The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import { Injectable } from '@nestjs/common';
import DataLoader from 'dataloader';
import { type APP_LOCALES } from 'twenty-shared/translations';
import { FieldMetadataType } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { type IndexMetadataInterface } from 'src/engine/metadata-modules/index-metadata/interfaces/index-metadata.interface';
import { ApplicationRegistrationVariableService } from 'src/engine/core-modules/application/application-registration-variable/application-registration-variable.service';
import { ApplicationRegistrationService } from 'src/engine/core-modules/application/application-registration/application-registration.service';
import { type ApplicationRegistrationConfigurationIssue } from 'src/engine/core-modules/application/application-registration/enums/application-registration-configuration-issue.enum';
import { ApplicationTranslationCatalogService } from 'src/engine/metadata-modules/application-translation-catalog/services/application-translation-catalog.service';
import { type FlatWorkspaceMember } from 'src/engine/core-modules/user/types/flat-workspace-member.type';
import { type IDataloaders } from 'src/engine/dataloaders/dataloader.interface';
import { FieldMetadataConnectionLoaderFactory } from 'src/engine/dataloaders/factories/field-metadata-connection-loader.factory';
import { IndexMetadataConnectionLoaderFactory } from 'src/engine/dataloaders/factories/index-metadata-connection-loader.factory';
import { type FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
import { RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
import { type FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { fromFlatCommandMenuItemToCommandMenuItemDto } from 'src/engine/metadata-modules/flat-command-menu-item/utils/from-flat-command-menu-item-to-command-menu-item-dto.util';
import { type SyncableFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-from.type';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { findFlatEntitiesByApplicationId } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entities-by-application-id.util';
import { fromFlatFrontComponentToFrontComponentDto } from 'src/engine/metadata-modules/flat-front-component/utils/from-flat-front-component-to-front-component-dto.util';
import { fromFlatSettingsMenuItemToSettingsMenuItemDto } from 'src/engine/metadata-modules/flat-settings-menu-item/utils/from-flat-settings-menu-item-to-settings-menu-item-dto.util';
import { fromFlatLogicFunctionToLogicFunctionDto } from 'src/engine/metadata-modules/logic-function/utils/from-flat-logic-function-to-logic-function-dto.util';
import { type FlatAgent } from 'src/engine/metadata-modules/flat-agent/types/flat-agent.type';
import { type FlatApplicationVariable } from 'src/engine/metadata-modules/flat-application-variable/types/flat-application-variable.type';
import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-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 { findManyFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
import { fromFlatFieldMetadataToFieldMetadataDto } from 'src/engine/metadata-modules/flat-field-metadata/utils/from-flat-field-metadata-to-field-metadata-dto.util';
import { type ApplicationAuthorIdentifiers } from 'src/engine/metadata-modules/application-translation-catalog/types/application-author-identifiers.type';
import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
import { isMorphRelationTargetFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-relation-target-flat-field-metadata.util';
import { resolveMorphRelationsFromFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/resolve-morph-relations-from-flat-field-metadata.util';
import { resolveRelationFromFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/resolve-relation-from-flat-field-metadata.util';
import { fromFlatObjectMetadataToObjectMetadataDto } from 'src/engine/metadata-modules/flat-object-metadata/utils/from-flat-object-metadata-to-object-metadata-dto.util';
import { fromFlatSearchFieldMetadataToSearchFieldMetadataDto } from 'src/engine/metadata-modules/flat-search-field-metadata/utils/from-flat-search-field-metadata-to-search-field-metadata-dto.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 { fromFlatViewFilterToViewFilterDto } from 'src/engine/metadata-modules/view-filter/utils/from-flat-view-filter-to-view-filter-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 { 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 IndexFieldMetadataDTO } from 'src/engine/metadata-modules/index-metadata/dtos/index-field-metadata.dto';
import { type IndexMetadataDTO } from 'src/engine/metadata-modules/index-metadata/dtos/index-metadata.dto';
import { ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
import { type ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { type SearchFieldMetadataDTO } from 'src/engine/metadata-modules/search-field-metadata/dtos/search-field-metadata.dto';
import { resolveEffectiveFlatEntityProperty } from 'src/engine/metadata-modules/overrides/utils/resolve-effective-flat-entity-property.util';
import { resolveEffectiveTranslatedFlatEntity } from 'src/engine/metadata-modules/overrides/utils/resolve-effective-translated-flat-entity.util';
import { type AgentDTO } from 'src/engine/metadata-modules/ai/ai-agent/dtos/agent.dto';
import { fromFlatAgentWithRoleIdToAgentDto } from 'src/engine/metadata-modules/flat-agent/utils/from-agent-entity-to-agent-dto.util';
import { fromFlatRowLevelPermissionPredicateGroupToDto } from 'src/engine/metadata-modules/flat-row-level-permission-predicate/utils/from-flat-row-level-permission-predicate-group-to-dto.util';
import { fromFlatRowLevelPermissionPredicateToDto } from 'src/engine/metadata-modules/flat-row-level-permission-predicate/utils/from-flat-row-level-permission-predicate-to-dto.util';
import {
type ApiKeyForRoleDTO,
type RoleDTO,
} from 'src/engine/metadata-modules/role/dtos/role.dto';
import { RowLevelPermissionPredicateService } from 'src/engine/metadata-modules/row-level-permission-predicate/services/row-level-permission-predicate.service';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
export type RelationMetadataLoaderPayload = {
workspaceId: string;
fieldMetadata: Pick<FieldMetadataEntity, 'type' | 'id' | 'objectMetadataId'>;
};
export type RelationLoaderPayload = {
workspaceId: string;
fieldMetadataId: string;
objectMetadataId: string;
};
export type MorphRelationLoaderPayload = {
workspaceId: string;
fieldMetadataId: string;
objectMetadataId: string;
};
export type FieldMetadataLoaderPayload = {
workspaceId: string;
objectMetadata: Pick<ObjectMetadataEntity, 'id'>;
locale?: keyof typeof APP_LOCALES;
};
export type IndexMetadataLoaderPayload = {
workspaceId: string;
objectMetadata: Pick<ObjectMetadataEntity, 'id'>;
};
export type IndexFieldMetadataLoaderPayload = {
workspaceId: string;
objectMetadata: Pick<ObjectMetadataEntity, 'id'>;
indexMetadata: Pick<IndexMetadataInterface, 'id'>;
};
export type SearchFieldMetadataLoaderPayload = {
workspaceId: string;
objectMetadata: Pick<ObjectMetadataEntity, 'id'>;
};
export type ObjectMetadataLoaderPayload = {
workspaceId: string;
objectMetadataId: string;
};
export type ViewFieldGroupsByViewIdLoaderPayload = {
workspaceId: string;
viewId: string;
};
export type ViewFieldsByViewFieldGroupIdLoaderPayload = {
workspaceId: string;
viewFieldGroupId: string;
};
export type ViewFieldsByViewIdLoaderPayload = {
workspaceId: string;
viewId: string;
};
export type ViewFiltersByViewIdLoaderPayload = {
workspaceId: string;
viewId: string;
};
export type ViewSortsByViewIdLoaderPayload = {
workspaceId: string;
viewId: string;
};
export type ViewGroupsByViewIdLoaderPayload = {
workspaceId: string;
viewId: string;
};
export type ViewFilterGroupsByViewIdLoaderPayload = {
workspaceId: string;
viewId: string;
};
export type WorkspaceMembersByRoleIdLoaderPayload = {
workspaceId: string;
roleId: string;
};
export type AgentsByRoleIdLoaderPayload = {
workspaceId: string;
roleId: string;
};
export type ApiKeysByRoleIdLoaderPayload = {
workspaceId: string;
roleId: string;
};
export type RowLevelPermissionsByRoleIdLoaderPayload = {
workspaceId: string;
roleId: string;
};
export type FlatEntitiesByApplicationIdLoaderPayload = {
workspaceId: string;
applicationId: string;
};
export type ApplicationRegistrationConfigurationIssuesLoaderPayload = {
applicationRegistrationId: string;
};
export type ApplicationRegistrationInstallCountLoaderPayload = {
applicationRegistrationId: string;
};
export type ApplicationAuthorIdentifiersLoaderPayload = {
workspaceId: string;
};
export type ApplicationTranslationCatalogLoaderPayload = {
applicationId: string;
workspaceId: string;
locale: keyof typeof APP_LOCALES;
};
@Injectable()
export class DataloaderService {
constructor(
private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
private readonly applicationRegistrationVariableService: ApplicationRegistrationVariableService,
private readonly applicationRegistrationService: ApplicationRegistrationService,
private readonly applicationTranslationCatalogService: ApplicationTranslationCatalogService,
private readonly fieldMetadataConnectionLoaderFactory: FieldMetadataConnectionLoaderFactory,
private readonly indexMetadataConnectionLoaderFactory: IndexMetadataConnectionLoaderFactory,
private readonly workspaceCacheService: WorkspaceCacheService,
private readonly rowLevelPermissionPredicateService: RowLevelPermissionPredicateService,
) {}
createLoaders(): IDataloaders {
const relationLoader = this.createRelationLoader();
const morphRelationLoader = this.createMorphRelationLoader();
const fieldMetadataLoader = this.createFieldMetadataLoader();
const fieldMetadataConnectionLoader =
this.fieldMetadataConnectionLoaderFactory.create();
const indexMetadataLoader = this.createIndexMetadataLoader();
const indexMetadataConnectionLoader =
this.indexMetadataConnectionLoaderFactory.create();
const indexFieldMetadataLoader = this.createIndexFieldMetadataLoader();
const searchFieldMetadataLoader = this.createSearchFieldMetadataLoader();
const objectMetadataLoader = this.createObjectMetadataLoader();
const viewFieldGroupsByViewIdLoader =
this.createViewFieldGroupsByViewIdLoader();
const viewFieldsByViewFieldGroupIdLoader =
this.createViewFieldsByViewFieldGroupIdLoader();
const viewFieldsByViewIdLoader = this.createViewFieldsByViewIdLoader();
const viewFiltersByViewIdLoader = this.createViewFiltersByViewIdLoader();
const viewSortsByViewIdLoader = this.createViewSortsByViewIdLoader();
const viewGroupsByViewIdLoader = this.createViewGroupsByViewIdLoader();
const viewFilterGroupsByViewIdLoader =
this.createViewFilterGroupsByViewIdLoader();
const agentsByApplicationIdLoader =
this.createFlatEntitiesByApplicationIdLoader({
loadFlatEntityMaps: async (workspaceId) => {
const { flatAgentMaps, flatRoleTargetByAgentIdMaps } =
await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatAgentMaps',
'flatRoleTargetByAgentIdMaps',
]);
return {
flatEntityMaps: flatAgentMaps,
toDtos: (flatAgents: FlatAgent[]) =>
flatAgents.map((flatAgent) =>
fromFlatAgentWithRoleIdToAgentDto({
...flatAgent,
roleId:
flatRoleTargetByAgentIdMaps[flatAgent.id]?.roleId ?? null,
}),
),
};
},
});
const frontComponentsByApplicationIdLoader =
this.createFlatEntitiesByApplicationIdLoader({
loadFlatEntityMaps: async (workspaceId) => ({
flatEntityMaps: (
await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatFrontComponentMaps',
])
).flatFrontComponentMaps,
toDtos: (flatFrontComponents) =>
flatFrontComponents.map(fromFlatFrontComponentToFrontComponentDto),
}),
});
const commandMenuItemsByApplicationIdLoader =
this.createFlatEntitiesByApplicationIdLoader({
loadFlatEntityMaps: async (workspaceId) => ({
flatEntityMaps: (
await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatCommandMenuItemMaps',
])
).flatCommandMenuItemMaps,
toDtos: (flatCommandMenuItems) =>
flatCommandMenuItems.map(
fromFlatCommandMenuItemToCommandMenuItemDto,
),
}),
});
const settingsMenuItemsByApplicationIdLoader =
this.createFlatEntitiesByApplicationIdLoader({
loadFlatEntityMaps: async (workspaceId) => ({
flatEntityMaps: (
await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatSettingsMenuItemMaps',
])
).flatSettingsMenuItemMaps,
toDtos: (flatSettingsMenuItems) =>
flatSettingsMenuItems.map(
fromFlatSettingsMenuItemToSettingsMenuItemDto,
),
}),
});
const logicFunctionsByApplicationIdLoader =
this.createFlatEntitiesByApplicationIdLoader({
loadFlatEntityMaps: async (workspaceId) => ({
flatEntityMaps: (
await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatLogicFunctionMaps',
])
).flatLogicFunctionMaps,
toDtos: (flatLogicFunctions: FlatLogicFunction[]) =>
flatLogicFunctions
.filter(
(flatLogicFunction) => !isDefined(flatLogicFunction.deletedAt),
)
.map((flatLogicFunction) =>
fromFlatLogicFunctionToLogicFunctionDto({ flatLogicFunction }),
),
}),
});
const objectMetadataByApplicationIdLoader =
this.createFlatEntitiesByApplicationIdLoader({
loadFlatEntityMaps: async (workspaceId) => ({
flatEntityMaps: (
await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatObjectMetadataMaps',
])
).flatObjectMetadataMaps,
toDtos: (flatObjectMetadataItems) =>
flatObjectMetadataItems.map(
fromFlatObjectMetadataToObjectMetadataDto,
),
}),
});
const applicationVariablesByApplicationIdLoader =
this.createFlatEntitiesByApplicationIdLoader({
loadFlatEntityMaps: async (workspaceId) => ({
flatEntityMaps: (
await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatApplicationVariableMaps',
])
).flatApplicationVariableMaps,
toDtos: (flatApplicationVariables: FlatApplicationVariable[]) =>
flatApplicationVariables,
}),
});
const applicationRegistrationConfigurationIssuesLoader =
this.createApplicationRegistrationConfigurationIssuesLoader();
const applicationRegistrationInstallCountLoader =
this.createApplicationRegistrationInstallCountLoader();
const applicationAuthorIdentifiersLoader =
this.createApplicationAuthorIdentifiersLoader();
const applicationTranslationCatalogLoader =
this.createApplicationTranslationCatalogLoader();
const workspaceMembersByRoleIdLoader =
this.createWorkspaceMembersByRoleIdLoader();
const agentsByRoleIdLoader = this.createAgentsByRoleIdLoader();
const apiKeysByRoleIdLoader = this.createApiKeysByRoleIdLoader();
const rowLevelPermissionsByRoleIdLoader =
this.createRowLevelPermissionsByRoleIdLoader();
return {
relationLoader,
morphRelationLoader,
fieldMetadataLoader,
fieldMetadataConnectionLoader,
indexMetadataLoader,
indexMetadataConnectionLoader,
indexFieldMetadataLoader,
searchFieldMetadataLoader,
objectMetadataLoader,
viewFieldGroupsByViewIdLoader,
viewFieldsByViewFieldGroupIdLoader,
viewFieldsByViewIdLoader,
viewFiltersByViewIdLoader,
viewSortsByViewIdLoader,
viewGroupsByViewIdLoader,
viewFilterGroupsByViewIdLoader,
agentsByApplicationIdLoader,
frontComponentsByApplicationIdLoader,
commandMenuItemsByApplicationIdLoader,
settingsMenuItemsByApplicationIdLoader,
logicFunctionsByApplicationIdLoader,
objectMetadataByApplicationIdLoader,
applicationVariablesByApplicationIdLoader,
applicationRegistrationConfigurationIssuesLoader,
applicationRegistrationInstallCountLoader,
applicationAuthorIdentifiersLoader,
applicationTranslationCatalogLoader,
workspaceMembersByRoleIdLoader,
agentsByRoleIdLoader,
apiKeysByRoleIdLoader,
rowLevelPermissionsByRoleIdLoader,
};
}
private createRelationLoader() {
return new DataLoader<RelationLoaderPayload, RelationDTO | null>(
async (dataLoaderParams: RelationLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatFieldMetadataMaps, flatObjectMetadataMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatFieldMetadataMaps', 'flatObjectMetadataMaps'],
},
);
return dataLoaderParams.map(({ fieldMetadataId }) => {
const sourceFlatFieldMetadata =
findFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityId: fieldMetadataId,
flatEntityMaps: flatFieldMetadataMaps,
});
if (
!isFlatFieldMetadataOfType(
sourceFlatFieldMetadata,
FieldMetadataType.RELATION,
)
) {
return null;
}
return resolveRelationFromFlatFieldMetadata({
sourceFlatFieldMetadata,
flatFieldMetadataMaps,
flatObjectMetadataMaps,
});
});
},
);
}
private createMorphRelationLoader() {
return new DataLoader<MorphRelationLoaderPayload, RelationDTO[] | null>(
async (dataLoaderParams: MorphRelationLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatFieldMetadataMaps, flatObjectMetadataMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatFieldMetadataMaps', 'flatObjectMetadataMaps'],
},
);
return dataLoaderParams.map(({ fieldMetadataId }) => {
const morphFlatFieldMetadata =
findFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityId: fieldMetadataId,
flatEntityMaps: flatFieldMetadataMaps,
});
if (
!isFlatFieldMetadataOfType(
morphFlatFieldMetadata,
FieldMetadataType.MORPH_RELATION,
)
) {
return null;
}
return resolveMorphRelationsFromFlatFieldMetadata({
morphFlatFieldMetadata,
flatFieldMetadataMaps,
flatObjectMetadataMaps,
});
});
},
);
}
private createIndexMetadataLoader() {
return new DataLoader<IndexMetadataLoaderPayload, IndexMetadataDTO[]>(
async (dataLoaderParams: IndexMetadataLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const objectMetadataIds = dataLoaderParams.map(
(dataLoaderParam) => dataLoaderParam.objectMetadata.id,
);
const { flatIndexMaps, flatObjectMetadataMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatIndexMaps', 'flatObjectMetadataMaps'],
},
);
const indexMetadataCollection = objectMetadataIds.map(
(objectMetadataId) => {
const flatObjectMetadata =
findFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityId: objectMetadataId,
flatEntityMaps: flatObjectMetadataMaps,
});
const indexMetadatas =
findManyFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityIds: flatObjectMetadata.indexMetadataIds,
flatEntityMaps: flatIndexMaps,
});
return indexMetadatas.map((indexMetadata) => ({
...indexMetadata,
indexFieldMetadatas: indexMetadata.flatIndexFieldMetadatas,
createdAt: new Date(indexMetadata.createdAt),
updatedAt: new Date(indexMetadata.updatedAt),
id: indexMetadata.id,
indexWhereClause: indexMetadata.indexWhereClause ?? undefined,
objectMetadataId,
workspaceId,
}));
},
);
return indexMetadataCollection;
},
);
}
private createSearchFieldMetadataLoader() {
return new DataLoader<
SearchFieldMetadataLoaderPayload,
SearchFieldMetadataDTO[]
>(async (dataLoaderParams: SearchFieldMetadataLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const objectMetadataIds = dataLoaderParams.map(
(dataLoaderParam) => dataLoaderParam.objectMetadata.id,
);
const { flatSearchFieldMetadataMaps, flatObjectMetadataMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: [
'flatSearchFieldMetadataMaps',
'flatObjectMetadataMaps',
],
},
);
return objectMetadataIds.map((objectMetadataId) => {
const flatObjectMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityId: objectMetadataId,
flatEntityMaps: flatObjectMetadataMaps,
});
const searchFieldMetadatas =
findManyFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityIds: flatObjectMetadata.searchFieldMetadataIds,
flatEntityMaps: flatSearchFieldMetadataMaps,
});
return searchFieldMetadatas.map(
fromFlatSearchFieldMetadataToSearchFieldMetadataDto,
);
});
});
}
private createFieldMetadataLoader() {
return new DataLoader<FieldMetadataLoaderPayload, FieldMetadataDTO[]>(
async (dataLoaderParams: FieldMetadataLoaderPayload[]) => {
const locale = dataLoaderParams[0].locale;
const workspaceId = dataLoaderParams[0].workspaceId;
const objectMetadataIds = dataLoaderParams.map(
(dataLoaderParam) => dataLoaderParam.objectMetadata.id,
);
const { flatFieldMetadataMaps, flatObjectMetadataMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatFieldMetadataMaps', 'flatObjectMetadataMaps'],
},
);
const objectFlatFieldMetadatasList = objectMetadataIds.map(
(objectMetadataId) => {
const flatObjectMetadata =
findFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityId: objectMetadataId,
flatEntityMaps: flatObjectMetadataMaps,
});
return findManyFlatEntityByIdInFlatEntityMapsOrThrow({
flatEntityIds: flatObjectMetadata.fieldIds,
flatEntityMaps: flatFieldMetadataMaps,
});
},
);
const getI18nContext =
await this.applicationTranslationCatalogService.getI18nContextByApplicationId(
{
applicationIds: objectFlatFieldMetadatasList
.flat()
.map((flatFieldMetadata) => flatFieldMetadata.applicationId),
locale,
workspaceId,
},
);
const fieldMetadataCollection = objectFlatFieldMetadatasList.map(
(objectFlatFieldMetadatas) => {
const overriddenFieldMetadataEntities =
objectFlatFieldMetadatas.map((flatFieldMetadata) =>
resolveEffectiveTranslatedFlatEntity({
metadataName: 'fieldMetadata',
flatEntity: flatFieldMetadata,
i18nContext: getI18nContext(flatFieldMetadata.applicationId),
}),
);
return overriddenFieldMetadataEntities
.filter(
(flatFieldMetadata) =>
!isMorphRelationTargetFlatFieldMetadata(flatFieldMetadata),
)
.map(fromFlatFieldMetadataToFieldMetadataDto);
},
);
return fieldMetadataCollection;
},
);
}
private createIndexFieldMetadataLoader() {
return new DataLoader<
IndexFieldMetadataLoaderPayload,
IndexFieldMetadataDTO[]
>(async (dataLoaderParams: IndexFieldMetadataLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatIndexMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatIndexMaps'],
},
);
return dataLoaderParams.map(
({ indexMetadata: { id: indexMetadataId } }) => {
const indexMetadataEntity = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: indexMetadataId,
flatEntityMaps: flatIndexMaps,
});
if (!isDefined(indexMetadataEntity)) {
return [];
}
return [...indexMetadataEntity.flatIndexFieldMetadatas]
.sort((a, b) => a.order - b.order)
.map((indexFieldMetadata) => {
return {
id: indexFieldMetadata.id,
fieldMetadataId: indexFieldMetadata.fieldMetadataId,
subFieldName: indexFieldMetadata.subFieldName ?? undefined,
order: indexFieldMetadata.order,
createdAt: new Date(indexFieldMetadata.createdAt),
updatedAt: new Date(indexFieldMetadata.updatedAt),
indexMetadataId,
workspaceId,
};
});
},
);
});
}
private createObjectMetadataLoader() {
return new DataLoader<
ObjectMetadataLoaderPayload,
ObjectMetadataDTO | null
>(async (dataLoaderParams: ObjectMetadataLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatObjectMetadataMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatObjectMetadataMaps'],
},
);
return dataLoaderParams.map((dataLoaderParam) => {
const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: dataLoaderParam.objectMetadataId,
flatEntityMaps: flatObjectMetadataMaps,
});
if (!isDefined(flatObjectMetadata)) {
return null;
}
return fromFlatObjectMetadataToObjectMetadataDto(flatObjectMetadata);
});
});
}
private createViewFieldGroupsByViewIdLoader() {
return new DataLoader<
ViewFieldGroupsByViewIdLoaderPayload,
ReturnType<typeof fromFlatViewFieldGroupToViewFieldGroupDto>[]
>(async (dataLoaderParams: ViewFieldGroupsByViewIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatViewMaps, flatViewFieldGroupMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps', 'flatViewFieldGroupMaps'],
},
);
return dataLoaderParams.map(({ viewId }) => {
const flatView = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: viewId,
flatEntityMaps: flatViewMaps,
});
if (!isDefined(flatView)) {
return [];
}
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewFieldGroupIds,
flatEntityMaps: flatViewFieldGroupMaps,
})
.filter(
(flatViewFieldGroup) =>
flatViewFieldGroup.deletedAt === null &&
resolveEffectiveFlatEntityProperty({
metadataName: 'viewFieldGroup',
flatEntity: flatViewFieldGroup,
property: 'isActive',
}),
)
.map(fromFlatViewFieldGroupToViewFieldGroupDto);
});
});
}
private createViewFieldsByViewFieldGroupIdLoader() {
return new DataLoader<
ViewFieldsByViewFieldGroupIdLoaderPayload,
ReturnType<typeof fromFlatViewFieldToViewFieldDto>[]
>(async (dataLoaderParams: ViewFieldsByViewFieldGroupIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatViewFieldGroupMaps, flatViewFieldMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewFieldGroupMaps', 'flatViewFieldMaps'],
},
);
const viewFieldsByResolvedGroupId = new Map<
string,
ReturnType<typeof fromFlatViewFieldToViewFieldDto>[]
>();
for (const flatViewField of Object.values(
flatViewFieldMaps.byUniversalIdentifier,
)) {
if (
!isDefined(flatViewField) ||
flatViewField.deletedAt !== null ||
!resolveEffectiveFlatEntityProperty({
metadataName: 'viewField',
flatEntity: flatViewField,
property: 'isActive',
})
) {
continue;
}
const resolvedGroupId = resolveEffectiveFlatEntityProperty({
metadataName: 'viewField',
flatEntity: flatViewField,
property: 'viewFieldGroupId',
});
if (!isDefined(resolvedGroupId)) {
continue;
}
if (!viewFieldsByResolvedGroupId.has(resolvedGroupId)) {
viewFieldsByResolvedGroupId.set(resolvedGroupId, []);
}
viewFieldsByResolvedGroupId
.get(resolvedGroupId)!
.push(fromFlatViewFieldToViewFieldDto(flatViewField));
}
return dataLoaderParams.map(({ viewFieldGroupId }) => {
const flatViewFieldGroup = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: viewFieldGroupId,
flatEntityMaps: flatViewFieldGroupMaps,
});
if (!isDefined(flatViewFieldGroup)) {
return [];
}
return viewFieldsByResolvedGroupId.get(viewFieldGroupId) ?? [];
});
});
}
private createViewFieldsByViewIdLoader() {
return new DataLoader<
ViewFieldsByViewIdLoaderPayload,
ReturnType<typeof fromFlatViewFieldToViewFieldDto>[]
>(async (dataLoaderParams: ViewFieldsByViewIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatViewMaps, flatViewFieldMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps', 'flatViewFieldMaps'],
},
);
return dataLoaderParams.map(({ viewId }) => {
const flatView = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: viewId,
flatEntityMaps: flatViewMaps,
});
if (!isDefined(flatView)) {
return [];
}
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewFieldIds,
flatEntityMaps: flatViewFieldMaps,
})
.filter(
(flatViewField) =>
flatViewField.deletedAt === null &&
resolveEffectiveFlatEntityProperty({
metadataName: 'viewField',
flatEntity: flatViewField,
property: 'isActive',
}),
)
.map(fromFlatViewFieldToViewFieldDto);
});
});
}
private createViewFiltersByViewIdLoader() {
return new DataLoader<
ViewFiltersByViewIdLoaderPayload,
ReturnType<typeof fromFlatViewFilterToViewFilterDto>[]
>(async (dataLoaderParams: ViewFiltersByViewIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatViewMaps, flatViewFilterMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps', 'flatViewFilterMaps'],
},
);
return dataLoaderParams.map(({ viewId }) => {
const flatView = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: viewId,
flatEntityMaps: flatViewMaps,
});
if (!isDefined(flatView)) {
return [];
}
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewFilterIds,
flatEntityMaps: flatViewFilterMaps,
})
.filter((flatViewFilter) => flatViewFilter.deletedAt === null)
.map(fromFlatViewFilterToViewFilterDto);
});
});
}
private createViewSortsByViewIdLoader() {
return new DataLoader<
ViewSortsByViewIdLoaderPayload,
ReturnType<typeof fromFlatViewSortToViewSortDto>[]
>(async (dataLoaderParams: ViewSortsByViewIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatViewMaps, flatViewSortMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps', 'flatViewSortMaps'],
},
);
return dataLoaderParams.map(({ viewId }) => {
const flatView = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: viewId,
flatEntityMaps: flatViewMaps,
});
if (!isDefined(flatView)) {
return [];
}
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewSortIds,
flatEntityMaps: flatViewSortMaps,
})
.filter((flatViewSort) => flatViewSort.deletedAt === null)
.map(fromFlatViewSortToViewSortDto);
});
});
}
private createViewGroupsByViewIdLoader() {
return new DataLoader<
ViewGroupsByViewIdLoaderPayload,
ReturnType<typeof fromFlatViewGroupToViewGroupDto>[]
>(async (dataLoaderParams: ViewGroupsByViewIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatViewMaps, flatViewGroupMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps', 'flatViewGroupMaps'],
},
);
return dataLoaderParams.map(({ viewId }) => {
const flatView = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: viewId,
flatEntityMaps: flatViewMaps,
});
if (!isDefined(flatView)) {
return [];
}
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewGroupIds,
flatEntityMaps: flatViewGroupMaps,
})
.filter((flatViewGroup) => flatViewGroup.deletedAt === null)
.map(fromFlatViewGroupToViewGroupDto);
});
});
}
private createViewFilterGroupsByViewIdLoader() {
return new DataLoader<
ViewFilterGroupsByViewIdLoaderPayload,
ReturnType<typeof fromFlatViewFilterGroupToViewFilterGroupDto>[]
>(async (dataLoaderParams: ViewFilterGroupsByViewIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const { flatViewMaps, flatViewFilterGroupMaps } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatViewMaps', 'flatViewFilterGroupMaps'],
},
);
return dataLoaderParams.map(({ viewId }) => {
const flatView = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: viewId,
flatEntityMaps: flatViewMaps,
});
if (!isDefined(flatView)) {
return [];
}
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatView.viewFilterGroupIds,
flatEntityMaps: flatViewFilterGroupMaps,
})
.filter(
(flatViewFilterGroup) => flatViewFilterGroup.deletedAt === null,
)
.map(fromFlatViewFilterGroupToViewFilterGroupDto);
});
});
}
private createFlatEntitiesByApplicationIdLoader<
TFlatEntity extends SyncableFlatEntity,
TDto,
>({
loadFlatEntityMaps,
}: {
loadFlatEntityMaps: (workspaceId: string) => Promise<{
flatEntityMaps: FlatEntityMaps<TFlatEntity>;
toDtos: (flatEntities: TFlatEntity[]) => TDto[];
}>;
}) {
return new DataLoader<FlatEntitiesByApplicationIdLoaderPayload, TDto[]>(
async (dataLoaderParams: FlatEntitiesByApplicationIdLoaderPayload[]) => {
const { flatEntityMaps, toDtos } = await loadFlatEntityMaps(
dataLoaderParams[0].workspaceId,
);
return dataLoaderParams.map(({ applicationId }) =>
toDtos(
findFlatEntitiesByApplicationId({ flatEntityMaps, applicationId }),
),
);
},
);
}
private createApplicationRegistrationConfigurationIssuesLoader() {
return new DataLoader<
ApplicationRegistrationConfigurationIssuesLoaderPayload,
ApplicationRegistrationConfigurationIssue[]
>(
async (
params: ApplicationRegistrationConfigurationIssuesLoaderPayload[],
) => {
const configurationIssuesByRegistrationId =
await this.applicationRegistrationVariableService.findConfigurationIssuesBatch(
params.map((param) => param.applicationRegistrationId),
);
return params.map(
(param) =>
configurationIssuesByRegistrationId.get(
param.applicationRegistrationId,
) ?? [],
);
},
);
}
private createApplicationRegistrationInstallCountLoader() {
return new DataLoader<
ApplicationRegistrationInstallCountLoaderPayload,
number
>(async (params: ApplicationRegistrationInstallCountLoaderPayload[]) => {
const installCountByRegistrationId =
await this.applicationRegistrationService.countInstalledWorkspacesByApplicationRegistrationIds(
params.map((param) => param.applicationRegistrationId),
);
return params.map(
(param) =>
installCountByRegistrationId.get(param.applicationRegistrationId) ??
0,
);
});
}
private createApplicationAuthorIdentifiersLoader() {
return new DataLoader<
ApplicationAuthorIdentifiersLoaderPayload,
ApplicationAuthorIdentifiers
>(async (params: ApplicationAuthorIdentifiersLoaderPayload[]) => {
const applicationAuthorIdentifiers =
await this.applicationTranslationCatalogService.getApplicationAuthorIdentifiers(
{ workspaceId: params[0].workspaceId },
);
return params.map(() => applicationAuthorIdentifiers);
});
}
private createApplicationTranslationCatalogLoader() {
return new DataLoader<
ApplicationTranslationCatalogLoaderPayload,
Record<string, string> | undefined
>(async (params: ApplicationTranslationCatalogLoaderPayload[]) => {
const { catalogByApplicationId } =
await this.applicationTranslationCatalogService.getCatalogs({
applicationIds: params.map((param) => param.applicationId),
locale: params[0].locale,
workspaceId: params[0].workspaceId,
});
return params.map((param) =>
catalogByApplicationId.get(param.applicationId),
);
});
}
private createWorkspaceMembersByRoleIdLoader() {
return new DataLoader<
WorkspaceMembersByRoleIdLoaderPayload,
FlatWorkspaceMember[]
>(async (dataLoaderParams: WorkspaceMembersByRoleIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const [
{ flatRoleMaps, flatRoleTargetMaps },
{ flatWorkspaceMemberMaps },
] = await Promise.all([
this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps({
workspaceId,
flatMapsKeys: ['flatRoleMaps', 'flatRoleTargetMaps'],
}),
this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatWorkspaceMemberMaps',
]),
]);
const userWorkspaceIdsByRoleId = dataLoaderParams.map(({ roleId }) => {
const flatRole = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: roleId,
flatEntityMaps: flatRoleMaps,
});
if (!isDefined(flatRole)) {
return [];
}
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatRole.roleTargetIds,
flatEntityMaps: flatRoleTargetMaps,
})
.map((flatRoleTarget) => flatRoleTarget.userWorkspaceId)
.filter(isDefined);
});
return userWorkspaceIdsByRoleId.map((userWorkspaceIds) =>
userWorkspaceIds
.map((userWorkspaceId) => {
const workspaceMemberId =
flatWorkspaceMemberMaps.idByUserWorkspaceId[userWorkspaceId];
return isDefined(workspaceMemberId)
? flatWorkspaceMemberMaps.byId[workspaceMemberId]
: undefined;
})
.filter(isDefined),
);
});
}
private createAgentsByRoleIdLoader() {
return new DataLoader<AgentsByRoleIdLoaderPayload, AgentDTO[]>(
async (dataLoaderParams: AgentsByRoleIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const {
flatRoleMaps,
flatRoleTargetMaps,
flatAgentMaps,
flatApplicationMaps,
} =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: [
'flatRoleMaps',
'flatRoleTargetMaps',
'flatAgentMaps',
'flatApplicationMaps',
],
},
);
return dataLoaderParams.map(({ roleId }) => {
const flatRole = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: roleId,
flatEntityMaps: flatRoleMaps,
});
if (!isDefined(flatRole)) {
return [];
}
const agentIds = findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatRole.roleTargetIds,
flatEntityMaps: flatRoleTargetMaps,
})
.map((flatRoleTarget) => flatRoleTarget.agentId)
.filter(isDefined);
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: agentIds,
flatEntityMaps: flatAgentMaps,
})
.filter((flatAgent) =>
isDefined(flatApplicationMaps.byId[flatAgent.applicationId]),
)
.map((flatAgent) =>
fromFlatAgentWithRoleIdToAgentDto({ ...flatAgent, roleId }),
);
});
},
);
}
private createApiKeysByRoleIdLoader() {
return new DataLoader<ApiKeysByRoleIdLoaderPayload, ApiKeyForRoleDTO[]>(
async (dataLoaderParams: ApiKeysByRoleIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const [{ flatRoleMaps, flatRoleTargetMaps }, { apiKeyMap }] =
await Promise.all([
this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: ['flatRoleMaps', 'flatRoleTargetMaps'],
},
),
this.workspaceCacheService.getOrRecompute(workspaceId, [
'apiKeyMap',
]),
]);
return dataLoaderParams.map(({ roleId }) => {
const flatRole = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: roleId,
flatEntityMaps: flatRoleMaps,
});
if (!isDefined(flatRole)) {
return [];
}
return findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatRole.roleTargetIds,
flatEntityMaps: flatRoleTargetMaps,
})
.map((flatRoleTarget) =>
isDefined(flatRoleTarget.apiKeyId)
? apiKeyMap[flatRoleTarget.apiKeyId]
: undefined,
)
.filter(isDefined)
.filter((flatApiKey) => !isDefined(flatApiKey.revokedAt))
.map((flatApiKey) => ({
id: flatApiKey.id,
name: flatApiKey.name,
expiresAt: new Date(flatApiKey.expiresAt),
revokedAt: null,
}));
});
},
);
}
private createRowLevelPermissionsByRoleIdLoader() {
return new DataLoader<
RowLevelPermissionsByRoleIdLoaderPayload,
Required<
Pick<
RoleDTO,
'rowLevelPermissionPredicates' | 'rowLevelPermissionPredicateGroups'
>
>
>(async (dataLoaderParams: RowLevelPermissionsByRoleIdLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const hasRowLevelPermissionFeature =
await this.rowLevelPermissionPredicateService.hasRowLevelPermissionFeature(
workspaceId,
);
if (!hasRowLevelPermissionFeature) {
return dataLoaderParams.map(() => ({
rowLevelPermissionPredicates: [],
rowLevelPermissionPredicateGroups: [],
}));
}
const {
flatRoleMaps,
flatRowLevelPermissionPredicateMaps,
flatRowLevelPermissionPredicateGroupMaps,
} =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
flatMapsKeys: [
'flatRoleMaps',
'flatRowLevelPermissionPredicateMaps',
'flatRowLevelPermissionPredicateGroupMaps',
],
},
);
return dataLoaderParams.map(({ roleId }) => {
const flatRole = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: roleId,
flatEntityMaps: flatRoleMaps,
});
if (!isDefined(flatRole)) {
return {
rowLevelPermissionPredicates: [],
rowLevelPermissionPredicateGroups: [],
};
}
return {
rowLevelPermissionPredicates: findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatRole.rowLevelPermissionPredicateIds,
flatEntityMaps: flatRowLevelPermissionPredicateMaps,
})
.filter((flatPredicate) => !isDefined(flatPredicate.deletedAt))
.sort(
(flatPredicateA, flatPredicateB) =>
(flatPredicateA.positionInRowLevelPermissionPredicateGroup ??
0) -
(flatPredicateB.positionInRowLevelPermissionPredicateGroup ??
0),
)
.map(fromFlatRowLevelPermissionPredicateToDto),
rowLevelPermissionPredicateGroups:
findManyFlatEntityByIdInFlatEntityMaps({
flatEntityIds: flatRole.rowLevelPermissionPredicateGroupIds,
flatEntityMaps: flatRowLevelPermissionPredicateGroupMaps,
})
.filter(
(flatPredicateGroup) =>
!isDefined(flatPredicateGroup.deletedAt),
)
.sort(
(flatPredicateGroupA, flatPredicateGroupB) =>
(flatPredicateGroupA.positionInRowLevelPermissionPredicateGroup ??
0) -
(flatPredicateGroupB.positionInRowLevelPermissionPredicateGroup ??
0),
)
.map(fromFlatRowLevelPermissionPredicateGroupToDto),
};
});
});
}
}