The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import { Injectable } from '@nestjs/common';
import { ViewType } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { ApplicationService } from 'src/engine/core-modules/application/application.service';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { findFlatEntityByUniversalIdentifierOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier-or-throw.util';
import { findManyFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps.util';
import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';
import { fromCreateViewInputToFlatViewToCreate } from 'src/engine/metadata-modules/flat-view/utils/from-create-view-input-to-flat-view-to-create.util';
import { fromDestroyViewInputToFlatViewOrThrow } from 'src/engine/metadata-modules/flat-view/utils/from-destroy-view-input-to-flat-view-or-throw.util';
import { fromUpdateViewInputToFlatViewToUpdateOrThrow } from 'src/engine/metadata-modules/flat-view/utils/from-update-view-input-to-flat-view-to-update-or-throw.util';
import { isCallerOverridingEntity } from 'src/engine/metadata-modules/overrides/utils/is-caller-overriding-entity.util';
import { fromFlatViewFieldGroupToViewFieldGroupDto } from 'src/engine/metadata-modules/view-field-group/utils/from-flat-view-field-group-to-view-field-group-dto.util';
import { fromFlatViewFieldToViewFieldDto } from 'src/engine/metadata-modules/view-field/utils/from-flat-view-field-to-view-field-dto.util';
import { fromFlatViewFilterGroupToViewFilterGroupDto } from 'src/engine/metadata-modules/view-filter-group/utils/from-flat-view-filter-group-to-view-filter-group-dto.util';
import { fromFlatViewFilterToViewFilterDto } from 'src/engine/metadata-modules/view-filter/utils/from-flat-view-filter-to-view-filter-dto.util';
import { fromFlatViewGroupToViewGroupDto } from 'src/engine/metadata-modules/view-group/utils/from-flat-view-group-to-view-group-dto.util';
import { fromFlatViewSortToViewSortDto } from 'src/engine/metadata-modules/view-sort/utils/from-flat-view-sort-to-view-sort-dto.util';
import { type MetadataCursorPage } from 'src/engine/metadata-modules/pagination/types/metadata-cursor-page.type';
import { type MetadataCursorPagination } from 'src/engine/metadata-modules/pagination/types/metadata-cursor-pagination.type';
import { paginateMetadataOrderedItems } from 'src/engine/metadata-modules/pagination/utils/paginate-metadata-ordered-items.util';
import { CreateViewInput } from 'src/engine/metadata-modules/view/dtos/inputs/create-view.input';
import { DeleteViewInput } from 'src/engine/metadata-modules/view/dtos/inputs/delete-view.input';
import { DestroyViewInput } from 'src/engine/metadata-modules/view/dtos/inputs/destroy-view.input';
import { UpdateViewInput } from 'src/engine/metadata-modules/view/dtos/inputs/update-view.input';
import { ViewDTO } from 'src/engine/metadata-modules/view/dtos/view.dto';
import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
import { fromFlatViewToViewDto } from 'src/engine/metadata-modules/view/utils/from-flat-view-to-view-dto.util';
import { isViewAvailableToUser } from 'src/engine/metadata-modules/view/utils/is-view-available-to-user.util';
import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
import { dispatchIsActiveUpdateToAuthoredOverride } from 'src/engine/metadata-modules/overrides/utils/dispatch-is-active-update-to-authored-override.util';
@Injectable()
export class ViewService {
constructor(
@InjectWorkspaceScopedRepository(ViewEntity)
private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
private readonly applicationService: ApplicationService,
) {}
async createOne({
createViewInput,
workspaceId,
createdByUserWorkspaceId,
}: {
createViewInput: CreateViewInput;
workspaceId: string;
createdByUserWorkspaceId?: string;
}): Promise<ViewDTO> {
const { workspaceCustomFlatApplication } =
await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
{
workspaceId,
},
);
const {
flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
flatObjectMetadataMaps: existingFlatObjectMetadataMaps,
} =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatFieldMetadataMaps', 'flatObjectMetadataMaps'],
},
);
const { flatViewToCreate, flatViewGroupsToCreate } =
fromCreateViewInputToFlatViewToCreate({
createViewInput,
createdByUserWorkspaceId,
flatApplication: workspaceCustomFlatApplication,
flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
flatObjectMetadataMaps: existingFlatObjectMetadataMaps,
});
const validateAndBuildResult =
await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
{
allFlatEntityOperationByMetadataName: {
view: {
flatEntityToCreate: [flatViewToCreate],
flatEntityToDelete: [],
flatEntityToUpdate: [],
},
viewGroup: {
flatEntityToCreate: flatViewGroupsToCreate,
flatEntityToDelete: [],
flatEntityToUpdate: [],
},
},
workspaceId,
isSystemBuild: false,
applicationUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
},
);
if (validateAndBuildResult.status === 'fail') {
throw new WorkspaceMigrationBuilderException(
validateAndBuildResult,
'Multiple validation errors occurred while creating view',
);
}
const { flatViewMaps: recomputedExistingFlatViewMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps'],
},
);
return fromFlatViewToViewDto(
findFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityId: flatViewToCreate.id,
flatEntityMaps: recomputedExistingFlatViewMaps,
}),
);
}
async updateOne({
updateViewInput,
workspaceId,
userWorkspaceId,
}: {
updateViewInput: UpdateViewInput;
workspaceId: string;
userWorkspaceId?: string;
}): Promise<ViewDTO> {
const { workspaceCustomFlatApplication } =
await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
{
workspaceId,
},
);
const {
flatViewMaps: existingFlatViewMaps,
flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
flatViewGroupMaps: existingFlatViewGroupMaps,
} = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: [
'flatViewMaps',
'flatFieldMetadataMaps',
'flatViewGroupMaps',
],
},
);
const { flatViewToUpdate, flatViewGroupsToDelete, flatViewGroupsToCreate } =
fromUpdateViewInputToFlatViewToUpdateOrThrow({
updateViewInput,
flatViewMaps: existingFlatViewMaps,
flatViewGroupMaps: existingFlatViewGroupMaps,
flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
userWorkspaceId,
callerApplicationUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
workspaceCustomApplicationUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
});
const validateAndBuildResult =
await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
{
allFlatEntityOperationByMetadataName: {
view: {
flatEntityToCreate: [],
flatEntityToDelete: [],
flatEntityToUpdate: [flatViewToUpdate],
},
viewGroup: {
flatEntityToCreate: flatViewGroupsToCreate,
flatEntityToDelete: flatViewGroupsToDelete,
flatEntityToUpdate: [],
},
},
workspaceId,
isSystemBuild: false,
applicationUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
},
);
if (validateAndBuildResult.status === 'fail') {
throw new WorkspaceMigrationBuilderException(
validateAndBuildResult,
'Multiple validation errors occurred while updating view',
);
}
const { flatViewMaps: recomputedExistingFlatViewMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps'],
},
);
return fromFlatViewToViewDto(
findFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityId: updateViewInput.id,
flatEntityMaps: recomputedExistingFlatViewMaps,
}),
);
}
async deleteOne({
deleteViewInput,
workspaceId,
}: {
deleteViewInput: DeleteViewInput;
workspaceId: string;
}): Promise<ViewDTO> {
return this.destroyOne({
destroyViewInput: deleteViewInput,
workspaceId,
});
}
async destroyOne({
destroyViewInput,
workspaceId,
}: {
destroyViewInput: DestroyViewInput;
workspaceId: string;
}): Promise<ViewDTO> {
const { workspaceCustomFlatApplication } =
await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
{
workspaceId,
},
);
const { flatViewMaps: existingFlatViewMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps'],
},
);
const flatViewFromDestroyInput = fromDestroyViewInputToFlatViewOrThrow({
destroyViewInput,
flatViewMaps: existingFlatViewMaps,
});
const existingFlatView = findFlatEntityByUniversalIdentifierOrThrow({
universalIdentifier: flatViewFromDestroyInput.universalIdentifier,
flatEntityMaps: existingFlatViewMaps,
});
const shouldDeactivate = isCallerOverridingEntity({
callerApplicationUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
entityApplicationUniversalIdentifier:
existingFlatView.applicationUniversalIdentifier,
workspaceCustomApplicationUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
isSystemSideEffect: existingFlatView.isSystemSideEffect,
});
const now = new Date().toISOString();
const deactivatedFlatView = {
...dispatchIsActiveUpdateToAuthoredOverride({
metadataName: 'view',
flatEntity: existingFlatView,
isActive: false,
authorUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
workspaceCustomApplicationUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
}),
updatedAt: now,
};
const validateAndBuildResult =
await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
{
allFlatEntityOperationByMetadataName: {
view: {
flatEntityToCreate: [],
flatEntityToDelete: shouldDeactivate
? []
: [flatViewFromDestroyInput],
flatEntityToUpdate: shouldDeactivate ? [deactivatedFlatView] : [],
},
},
workspaceId,
isSystemBuild: false,
applicationUniversalIdentifier:
workspaceCustomFlatApplication.universalIdentifier,
},
);
if (validateAndBuildResult.status === 'fail') {
throw new WorkspaceMigrationBuilderException(
validateAndBuildResult,
'Multiple validation errors occurred while destroying view',
);
}
if (shouldDeactivate) {
return fromFlatViewToViewDto(deactivatedFlatView);
}
return fromFlatViewToViewDto({
...existingFlatView,
deletedAt: now,
});
}
private async getFilteredFlatViews({
workspaceId,
objectMetadataId,
userWorkspaceId,
viewTypes,
}: {
workspaceId: string;
objectMetadataId?: string;
userWorkspaceId?: string;
viewTypes?: ViewType[];
}): Promise<FlatView[]> {
const { flatViewMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps'],
},
);
return Object.values(flatViewMaps.byUniversalIdentifier)
.filter(isDefined)
.filter((flatView) => flatView.workspaceId === workspaceId)
.filter(
(flatView) =>
!objectMetadataId || flatView.objectMetadataId === objectMetadataId,
)
.filter(
(flatView) =>
!viewTypes ||
viewTypes.length === 0 ||
viewTypes.includes(flatView.type),
)
.filter((flatView) =>
isViewAvailableToUser({ flatView, userWorkspaceId }),
)
.sort((a, b) => a.position - b.position || a.id.localeCompare(b.id));
}
async findByWorkspaceId(
workspaceId: string,
userWorkspaceId?: string,
viewTypes?: ViewType[],
): Promise<ViewDTO[]> {
const flatViews = await this.getFilteredFlatViews({
workspaceId,
userWorkspaceId,
viewTypes,
});
return flatViews.map(fromFlatViewToViewDto);
}
async findByObjectMetadataId(
workspaceId: string,
objectMetadataId: string,
userWorkspaceId?: string,
viewTypes?: ViewType[],
): Promise<ViewDTO[]> {
const flatViews = await this.getFilteredFlatViews({
workspaceId,
objectMetadataId,
userWorkspaceId,
viewTypes,
});
return flatViews.map(fromFlatViewToViewDto);
}
async findById(id: string, workspaceId: string): Promise<ViewDTO | null> {
const { flatViewMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps'],
},
);
const flatView = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: id,
flatEntityMaps: flatViewMaps,
});
if (!isDefined(flatView) || flatView.deletedAt !== null) {
return null;
}
return fromFlatViewToViewDto(flatView);
}
async findManyWithRelationsFromCache(
flatViews: FlatView[],
workspaceId: string,
): Promise<ViewDTO[]> {
const {
flatViewFieldMaps,
flatViewFieldGroupMaps,
flatViewFilterMaps,
flatViewFilterGroupMaps,
flatViewSortMaps,
flatViewGroupMaps,
} =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: [
'flatViewFieldMaps',
'flatViewFieldGroupMaps',
'flatViewFilterMaps',
'flatViewFilterGroupMaps',
'flatViewSortMaps',
'flatViewGroupMaps',
],
},
);
return flatViews.map((flatView) => {
const viewDto = fromFlatViewToViewDto(flatView);
viewDto.viewFields = findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewFieldIds,
flatEntityMaps: flatViewFieldMaps,
})
.filter((flatEntity) => flatEntity.deletedAt === null)
.map(fromFlatViewFieldToViewFieldDto);
viewDto.viewFieldGroups = findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewFieldGroupIds,
flatEntityMaps: flatViewFieldGroupMaps,
})
.filter((flatEntity) => flatEntity.deletedAt === null)
.map(fromFlatViewFieldGroupToViewFieldGroupDto);
viewDto.viewFilters = findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewFilterIds,
flatEntityMaps: flatViewFilterMaps,
})
.filter((flatEntity) => flatEntity.deletedAt === null)
.map(fromFlatViewFilterToViewFilterDto);
viewDto.viewFilterGroups = findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewFilterGroupIds,
flatEntityMaps: flatViewFilterGroupMaps,
})
.filter((flatEntity) => flatEntity.deletedAt === null)
.map(fromFlatViewFilterGroupToViewFilterGroupDto);
viewDto.viewSorts = findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewSortIds,
flatEntityMaps: flatViewSortMaps,
})
.filter((flatEntity) => flatEntity.deletedAt === null)
.map(fromFlatViewSortToViewSortDto);
viewDto.viewGroups = findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewGroupIds,
flatEntityMaps: flatViewGroupMaps,
})
.filter((flatEntity) => flatEntity.deletedAt === null)
.map(fromFlatViewGroupToViewGroupDto);
return viewDto;
});
}
async findByWorkspaceIdWithRelations(
workspaceId: string,
userWorkspaceId?: string,
viewTypes?: ViewType[],
): Promise<ViewDTO[]> {
const flatViews = await this.getFilteredFlatViews({
workspaceId,
userWorkspaceId,
viewTypes,
});
return this.findManyWithRelationsFromCache(flatViews, workspaceId);
}
async findManyWithRelationsPaginated({
workspaceId,
objectMetadataId,
userWorkspaceId,
pagination,
}: {
workspaceId: string;
objectMetadataId?: string;
userWorkspaceId?: string;
pagination: MetadataCursorPagination;
}): Promise<MetadataCursorPage<ViewDTO> & { totalCount: number }> {
const flatViews = await this.getFilteredFlatViews({
workspaceId,
objectMetadataId,
userWorkspaceId,
});
const page = paginateMetadataOrderedItems({
items: flatViews,
pagination,
});
return {
...page,
items: await this.findManyWithRelationsFromCache(page.items, workspaceId),
totalCount: flatViews.length,
};
}
async findByObjectMetadataIdWithRelations(
workspaceId: string,
objectMetadataId: string,
userWorkspaceId?: string,
viewTypes?: ViewType[],
): Promise<ViewDTO[]> {
const flatViews = await this.getFilteredFlatViews({
workspaceId,
objectMetadataId,
userWorkspaceId,
viewTypes,
});
return this.findManyWithRelationsFromCache(flatViews, workspaceId);
}
async findByIdWithRelations(
id: string,
workspaceId: string,
): Promise<ViewDTO | null> {
const { flatViewMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps'],
},
);
const flatView = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: id,
flatEntityMaps: flatViewMaps,
});
if (!isDefined(flatView) || flatView.deletedAt !== null) {
return null;
}
const results = await this.findManyWithRelationsFromCache(
[flatView],
workspaceId,
);
return results[0] ?? null;
}
async findByIdIncludingDeleted(
id: string,
workspaceId: string,
): Promise<ViewEntity | null> {
const view = await this.viewRepository.findOne(workspaceId, {
where: {
id,
},
relations: [
'workspace',
'viewFields',
'viewFilters',
'viewSorts',
'viewGroups',
'viewFilterGroups',
],
withDeleted: true,
});
return view || null;
}
}