Paul RastoinandGitHub
6188c72f74
# Introduction This PR introduces a huge type refactor that will leverage dynamic intra entity optimistic flat maps update in the future and also a more granular cache invalidation enhancing performances close https://github.com/twentyhq/core-team-issues/issues/1717 close https://github.com/twentyhq/core-team-issues/issues/1716 close https://github.com/twentyhq/core-team-issues/issues/1643 ## What's done ### Comparators centralization Comparator is now done through global configuration as const for each metadata names Thanks to Note: Definition of standard is evolving, standard is now scoped to an app. Meaning that a manifest should be able to update its own standards objects but on other app standards ones ? Each synchronizable entities will have a standardOverrides ? ## Typing refactor ### `AllFlatEntityTypesByMetadataName` **Single source of truth for the complete type ecosystem**, mapping each metadata name to its entity types, flat entities, and migration actions: ```typescript export type AllFlatEntityTypesByMetadataName = { fieldMetadata: { actions: { created: CreateFieldAction; updated: UpdateFieldAction; deleted: DeleteFieldAction; }; flatEntity: FlatFieldMetadata; entity: FieldMetadataEntity; }; objectMetadata: { /* ... */ }; // ... all 10 metadata types }; ``` ### `ALL_METADATA_NAME_MANY_TO_ONE_RELATIONS` **Explicitly declares database relationships** between entities with compile-time validation: ```typescript export const ALL_METADATA_NAME_MANY_TO_ONE_RELATIONS = { viewField: { view: 'viewId', fieldMetadata: 'fieldMetadataId', }, cronTrigger: { serverlessFunction: 'serverlessFunctionId', }, // ... all relations } as const satisfies MetadataNameAndRelations; ``` ### `ALL_FLAT_ENTITY_CONFIGURATION` **Centralizes comparison and serialization logic** for each metadata type: ```typescript export const ALL_FLAT_ENTITY_CONFIGURATION = { fieldMetadata: { propertiesToCompare: ['name', 'type', 'label', 'defaultValue', /* ... */], propertiesToStringify: ['options', 'settings', 'defaultValue'], }, objectMetadata: { propertiesToCompare: ['nameSingular', 'namePlural', 'isActive', /* ... */], propertiesToStringify: [], }, // ... all metadata types } as const satisfies AllFlatEntityConfiguration; ``` ## Combined Impact These three configurations work together to create a **strongly-typed, centrally-managed metadata system**: 1. **`AllFlatEntityTypesByMetadataName`** defines *what exists* 2. **`ALL_METADATA_NAME_MANY_TO_ONE_RELATIONS`** defines *how they relate* 3. **`ALL_FLAT_ENTITY_CONFIGURATION`** defines *how to compare and serialize them* **Result:** Builders and validators become thin wrappers around type-safe, configuration-driven logic instead of containing scattered, error-prone manual implementations. ## What's next ### StandardOverrides standardization Every metadata entity can be a standard one for a workspace if it's an installed app, which means it might not expose the whole entity api to be editable through an import dynamically The standard overrides logic should not be applied to Fields and Objects but to every entities At the moment we have a logic of `EDITABLE_PROPERTIES` through the api, and also `STANDARD_OVERRIDEDABLE_PROPERTIES` This should be configuration centered like `propertiesToCompare` and `propertiesToStringify`. Scoping this PR to two last for the moment. As update dispatch to standardOverrides could be considered as a side effect prefer waiting to start the side effect refactor ### Granular Optimistic deprecation With this new grain at runtime we will be able to add a flat entity and dispatch its addition to related flat maps, so we don't have to describe an optimistic method for each flat entity operations See `addFlatEntityToFlatEntityAndRelatedEntityMapsOrThrow` Note: Still in wip and included in this PR but about to create a new one to integrate these utils and remove existing methods ### ValidateBuildAndRun dynamic args typed defintion We should restrain the devxp to send expected flat maps entity as at least from to or dependency as we now have the grain both a type lvl and runtime to do so It should not be possible in the devxp to forgot adding the views to the v2 builder when passing the view field anymore ( that would lead to permanent validation error in view field integrity checks ) ## Conclusion Thanks for reading and reviewing ! Any suggestions are more than welcomed ! ( same as for questions too ! )
507 lines
20 KiB
TypeScript
507 lines
20 KiB
TypeScript
import { Injectable } from '@nestjs/common';
|
|
|
|
import DataLoader from 'dataloader';
|
|
import { type APP_LOCALES, SOURCE_LOCALE } 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 { I18nService } from 'src/engine/core-modules/i18n/i18n.service';
|
|
import { type IDataloaders } from 'src/engine/dataloaders/dataloader.interface';
|
|
import { filterMorphRelationDuplicateFields } from 'src/engine/dataloaders/utils/filter-morph-relation-duplicate-fields.util';
|
|
import { FIELD_METADATA_STANDARD_OVERRIDES_PROPERTIES } from 'src/engine/metadata-modules/field-metadata/constants/field-metadata-standard-overrides-properties.constant';
|
|
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 { resolveFieldMetadataStandardOverride } from 'src/engine/metadata-modules/field-metadata/utils/resolve-field-metadata-standard-override.util';
|
|
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 { findManyFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
|
|
import { findAllOthersMorphRelationFlatFieldMetadatasOrThrow } from 'src/engine/metadata-modules/flat-field-metadata/utils/find-all-others-morph-relation-flat-field-metadatas-or-throw.util';
|
|
import { fromFlatFieldMetadataToFieldMetadataDto } from 'src/engine/metadata-modules/flat-field-metadata/utils/from-flat-field-metadata-to-field-metadata-dto.util';
|
|
import { fromMorphOrRelationFlatFieldMetadataToRelationDto } from 'src/engine/metadata-modules/flat-field-metadata/utils/from-morph-or-relation-flat-field-metadata-to-relation-dto.util';
|
|
import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
|
|
import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';
|
|
import { getMorphNameFromMorphFieldMetadataName } from 'src/engine/metadata-modules/flat-object-metadata/utils/get-morph-name-from-morph-field-metadata-name.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 { type ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
|
|
import { type ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
|
|
import { WorkspaceMetadataCacheService } from 'src/engine/metadata-modules/workspace-metadata-cache/services/workspace-metadata-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 ObjectMetadataLoaderPayload = {
|
|
workspaceId: string;
|
|
objectMetadataId: string;
|
|
};
|
|
|
|
@Injectable()
|
|
export class DataloaderService {
|
|
constructor(
|
|
private readonly i18nService: I18nService,
|
|
private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
|
|
private readonly workspaceMetadataCacheService: WorkspaceMetadataCacheService,
|
|
) {}
|
|
|
|
createLoaders(): IDataloaders {
|
|
const relationLoader = this.createRelationLoader();
|
|
const morphRelationLoader = this.createMorphRelationLoader();
|
|
const fieldMetadataLoader = this.createFieldMetadataLoader();
|
|
const indexMetadataLoader = this.createIndexMetadataLoader();
|
|
const indexFieldMetadataLoader = this.createIndexFieldMetadataLoader();
|
|
const objectMetadataLoader = this.createObjectMetadataLoader();
|
|
|
|
return {
|
|
relationLoader,
|
|
morphRelationLoader,
|
|
fieldMetadataLoader,
|
|
indexMetadataLoader,
|
|
indexFieldMetadataLoader,
|
|
objectMetadataLoader,
|
|
};
|
|
}
|
|
|
|
private createRelationLoader() {
|
|
return new DataLoader<RelationLoaderPayload, RelationDTO | null>(
|
|
async (dataLoaderParams: RelationLoaderPayload[]) => {
|
|
const relationDtos: Array<RelationDTO | null> = [];
|
|
const workspaceId = dataLoaderParams[0].workspaceId;
|
|
const { flatFieldMetadataMaps, flatObjectMetadataMaps } =
|
|
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
|
|
{
|
|
workspaceId,
|
|
flatMapsKeys: ['flatFieldMetadataMaps', 'flatObjectMetadataMaps'],
|
|
},
|
|
);
|
|
|
|
for (const { fieldMetadataId } of dataLoaderParams) {
|
|
const sourceFlatFieldMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId: fieldMetadataId,
|
|
flatEntityMaps: flatFieldMetadataMaps,
|
|
});
|
|
|
|
if (
|
|
!isFlatFieldMetadataOfType(
|
|
sourceFlatFieldMetadata,
|
|
FieldMetadataType.RELATION,
|
|
)
|
|
) {
|
|
relationDtos.push(null);
|
|
continue;
|
|
}
|
|
|
|
const sourceFlatObjectMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId: sourceFlatFieldMetadata.objectMetadataId,
|
|
flatEntityMaps: flatObjectMetadataMaps,
|
|
});
|
|
|
|
const targetFlatFieldMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId:
|
|
sourceFlatFieldMetadata.relationTargetFieldMetadataId,
|
|
flatEntityMaps: flatFieldMetadataMaps,
|
|
});
|
|
|
|
if (!isMorphOrRelationFlatFieldMetadata(targetFlatFieldMetadata)) {
|
|
relationDtos.push(null);
|
|
continue;
|
|
}
|
|
|
|
const targetFlatObjectMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId: targetFlatFieldMetadata.objectMetadataId,
|
|
flatEntityMaps: flatObjectMetadataMaps,
|
|
});
|
|
|
|
if (
|
|
isFlatFieldMetadataOfType(
|
|
targetFlatFieldMetadata,
|
|
FieldMetadataType.MORPH_RELATION,
|
|
)
|
|
) {
|
|
const morphNameFromMorphFieldMetadataName =
|
|
getMorphNameFromMorphFieldMetadataName({
|
|
morphRelationFlatFieldMetadata: targetFlatFieldMetadata,
|
|
nameSingular: sourceFlatObjectMetadata.nameSingular,
|
|
namePlural: sourceFlatObjectMetadata.namePlural,
|
|
});
|
|
|
|
const allMorphFlatFieldMetadatas = [
|
|
targetFlatFieldMetadata,
|
|
...findAllOthersMorphRelationFlatFieldMetadatasOrThrow({
|
|
flatFieldMetadata: targetFlatFieldMetadata,
|
|
flatFieldMetadataMaps,
|
|
flatObjectMetadata: targetFlatObjectMetadata,
|
|
}),
|
|
].sort((a, b) => (a.id > b.id ? 1 : -1));
|
|
|
|
relationDtos.push(
|
|
fromMorphOrRelationFlatFieldMetadataToRelationDto({
|
|
sourceFlatFieldMetadata,
|
|
sourceFlatObjectMetadata,
|
|
targetFlatFieldMetadata: {
|
|
...allMorphFlatFieldMetadatas[0],
|
|
name: morphNameFromMorphFieldMetadataName,
|
|
},
|
|
targetFlatObjectMetadata,
|
|
}),
|
|
);
|
|
continue;
|
|
}
|
|
|
|
relationDtos.push(
|
|
fromMorphOrRelationFlatFieldMetadataToRelationDto({
|
|
sourceFlatFieldMetadata,
|
|
targetFlatFieldMetadata,
|
|
targetFlatObjectMetadata,
|
|
sourceFlatObjectMetadata,
|
|
}),
|
|
);
|
|
}
|
|
|
|
return relationDtos;
|
|
},
|
|
);
|
|
}
|
|
|
|
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'],
|
|
},
|
|
);
|
|
const relationDtos: Array<RelationDTO[] | null> = [];
|
|
|
|
for (const { fieldMetadataId } of dataLoaderParams) {
|
|
const morphFlatFieldMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId: fieldMetadataId,
|
|
flatEntityMaps: flatFieldMetadataMaps,
|
|
});
|
|
|
|
if (
|
|
!isFlatFieldMetadataOfType(
|
|
morphFlatFieldMetadata,
|
|
FieldMetadataType.MORPH_RELATION,
|
|
)
|
|
) {
|
|
relationDtos.push(null);
|
|
continue;
|
|
}
|
|
|
|
const sourceFlatObjectMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityMaps: flatObjectMetadataMaps,
|
|
flatEntityId: morphFlatFieldMetadata.objectMetadataId,
|
|
});
|
|
|
|
const relatedMorphFlatFieldMetadatas =
|
|
findAllOthersMorphRelationFlatFieldMetadatasOrThrow({
|
|
flatFieldMetadata: morphFlatFieldMetadata,
|
|
flatFieldMetadataMaps,
|
|
flatObjectMetadata: sourceFlatObjectMetadata,
|
|
});
|
|
const allMorphFlatFieldMetadatas = [
|
|
morphFlatFieldMetadata,
|
|
...relatedMorphFlatFieldMetadatas,
|
|
];
|
|
|
|
relationDtos.push(
|
|
allMorphFlatFieldMetadatas.flatMap((sourceFlatFieldMetadata) => {
|
|
const targetFlatFieldMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId:
|
|
sourceFlatFieldMetadata.relationTargetFieldMetadataId,
|
|
flatEntityMaps: flatFieldMetadataMaps,
|
|
});
|
|
|
|
if (
|
|
!isMorphOrRelationFlatFieldMetadata(targetFlatFieldMetadata)
|
|
) {
|
|
return [];
|
|
}
|
|
|
|
const targetFlatObjectMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId:
|
|
sourceFlatFieldMetadata.relationTargetObjectMetadataId,
|
|
flatEntityMaps: flatObjectMetadataMaps,
|
|
});
|
|
|
|
const morphNameFromMorphFieldMetadataName =
|
|
getMorphNameFromMorphFieldMetadataName({
|
|
morphRelationFlatFieldMetadata: sourceFlatFieldMetadata,
|
|
nameSingular: targetFlatObjectMetadata.nameSingular,
|
|
namePlural: targetFlatObjectMetadata.namePlural,
|
|
});
|
|
|
|
return fromMorphOrRelationFlatFieldMetadataToRelationDto({
|
|
sourceFlatFieldMetadata: {
|
|
...sourceFlatFieldMetadata,
|
|
name: morphNameFromMorphFieldMetadataName,
|
|
},
|
|
targetFlatFieldMetadata,
|
|
targetFlatObjectMetadata,
|
|
sourceFlatObjectMetadata,
|
|
});
|
|
}),
|
|
);
|
|
}
|
|
|
|
return relationDtos;
|
|
},
|
|
);
|
|
}
|
|
|
|
private createIndexMetadataLoader() {
|
|
return new DataLoader<IndexMetadataLoaderPayload, IndexMetadataDTO[]>(
|
|
async (dataLoaderParams: IndexMetadataLoaderPayload[]) => {
|
|
const workspaceId = dataLoaderParams[0].workspaceId;
|
|
const objectMetadataIds = dataLoaderParams.map(
|
|
(dataLoaderParam) => dataLoaderParam.objectMetadata.id,
|
|
);
|
|
|
|
const { objectMetadataMaps } =
|
|
await this.workspaceMetadataCacheService.getExistingOrRecomputeMetadataMaps(
|
|
{ workspaceId },
|
|
);
|
|
|
|
const indexMetadataCollection = objectMetadataIds.map((id) => {
|
|
const objectMetadata = objectMetadataMaps.byId[id];
|
|
|
|
if (!isDefined(objectMetadata)) {
|
|
return [];
|
|
}
|
|
|
|
return Object.values(objectMetadata.indexMetadatas).map(
|
|
(indexMetadata) => {
|
|
return {
|
|
...indexMetadata,
|
|
createdAt: new Date(indexMetadata.createdAt),
|
|
updatedAt: new Date(indexMetadata.updatedAt),
|
|
id: indexMetadata.id,
|
|
indexWhereClause: indexMetadata.indexWhereClause ?? undefined,
|
|
objectMetadataId: id,
|
|
workspaceId: workspaceId,
|
|
};
|
|
},
|
|
);
|
|
});
|
|
|
|
return indexMetadataCollection;
|
|
},
|
|
);
|
|
}
|
|
|
|
private createFieldMetadataLoader() {
|
|
return new DataLoader<FieldMetadataLoaderPayload, FieldMetadataDTO[]>(
|
|
async (dataLoaderParams: FieldMetadataLoaderPayload[]) => {
|
|
const locale = dataLoaderParams[0].locale;
|
|
const i18nInstance = this.i18nService.getI18nInstance(
|
|
locale ?? SOURCE_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 fieldMetadataCollection = objectMetadataIds.map(
|
|
(objectMetadataId) => {
|
|
const flatObjectMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId: objectMetadataId,
|
|
flatEntityMaps: flatObjectMetadataMaps,
|
|
});
|
|
const objectFlatFieldMetadatas =
|
|
findManyFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityMaps: flatFieldMetadataMaps,
|
|
flatEntityIds: flatObjectMetadata.fieldMetadataIds,
|
|
});
|
|
|
|
const overriddenFieldMetadataEntities =
|
|
objectFlatFieldMetadatas.map((flatFieldMetadata) => {
|
|
return FIELD_METADATA_STANDARD_OVERRIDES_PROPERTIES.reduce(
|
|
(acc, property) => ({
|
|
...acc,
|
|
[property]: resolveFieldMetadataStandardOverride(
|
|
{
|
|
label: flatFieldMetadata.label,
|
|
description: flatFieldMetadata.description ?? undefined,
|
|
icon: flatFieldMetadata.icon ?? undefined,
|
|
isCustom: flatFieldMetadata.isCustom,
|
|
standardOverrides:
|
|
flatFieldMetadata.standardOverrides ?? undefined,
|
|
},
|
|
property,
|
|
dataLoaderParams[0].locale,
|
|
i18nInstance,
|
|
),
|
|
}),
|
|
flatFieldMetadata,
|
|
);
|
|
});
|
|
|
|
const filteredFieldMetadataEntities =
|
|
filterMorphRelationDuplicateFields(
|
|
overriddenFieldMetadataEntities,
|
|
);
|
|
|
|
const filteredFieldMetadataEntitiesWithMorphRenamed =
|
|
filteredFieldMetadataEntities.map((flatFieldMetadata) => {
|
|
if (
|
|
isFlatFieldMetadataOfType(
|
|
flatFieldMetadata,
|
|
FieldMetadataType.MORPH_RELATION,
|
|
)
|
|
) {
|
|
const relationTargetObjectMetadata =
|
|
findFlatEntityByIdInFlatEntityMapsOrThrow({
|
|
flatEntityId:
|
|
flatFieldMetadata.relationTargetObjectMetadataId,
|
|
flatEntityMaps: flatObjectMetadataMaps,
|
|
});
|
|
|
|
return {
|
|
...flatFieldMetadata,
|
|
name: getMorphNameFromMorphFieldMetadataName({
|
|
morphRelationFlatFieldMetadata: flatFieldMetadata,
|
|
nameSingular: relationTargetObjectMetadata.nameSingular,
|
|
namePlural: relationTargetObjectMetadata.namePlural,
|
|
}),
|
|
};
|
|
}
|
|
|
|
return flatFieldMetadata;
|
|
});
|
|
|
|
return filteredFieldMetadataEntitiesWithMorphRenamed.map(
|
|
fromFlatFieldMetadataToFieldMetadataDto,
|
|
);
|
|
},
|
|
);
|
|
|
|
return fieldMetadataCollection;
|
|
},
|
|
);
|
|
}
|
|
|
|
private createIndexFieldMetadataLoader() {
|
|
return new DataLoader<
|
|
IndexFieldMetadataLoaderPayload,
|
|
IndexFieldMetadataDTO[]
|
|
>(async (dataLoaderParams: IndexFieldMetadataLoaderPayload[]) => {
|
|
const workspaceId = dataLoaderParams[0].workspaceId;
|
|
|
|
const { objectMetadataMaps } =
|
|
await this.workspaceMetadataCacheService.getExistingOrRecomputeMetadataMaps(
|
|
{ workspaceId },
|
|
);
|
|
|
|
return dataLoaderParams.map(
|
|
({
|
|
objectMetadata: { id: objectMetadataId },
|
|
indexMetadata: { id: indexMetadataId },
|
|
}) => {
|
|
const objectMetadata = objectMetadataMaps.byId[objectMetadataId];
|
|
|
|
if (!isDefined(objectMetadata)) {
|
|
return [];
|
|
}
|
|
|
|
const indexMetadataEntity = objectMetadata.indexMetadatas.find(
|
|
(indexMetadata) => indexMetadata.id === indexMetadataId,
|
|
);
|
|
|
|
if (!isDefined(indexMetadataEntity)) {
|
|
return [];
|
|
}
|
|
|
|
return indexMetadataEntity.indexFieldMetadatas.map(
|
|
(indexFieldMetadata) => {
|
|
return {
|
|
id: indexFieldMetadata.id,
|
|
fieldMetadataId: indexFieldMetadata.fieldMetadataId,
|
|
order: indexFieldMetadata.order,
|
|
createdAt: new Date(indexFieldMetadata.createdAt),
|
|
updatedAt: new Date(indexFieldMetadata.updatedAt),
|
|
indexMetadataId,
|
|
workspaceId,
|
|
};
|
|
},
|
|
);
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
private createObjectMetadataLoader() {
|
|
return new DataLoader<
|
|
ObjectMetadataLoaderPayload,
|
|
ObjectMetadataItemWithFieldMaps | null
|
|
>(async (dataLoaderParams: ObjectMetadataLoaderPayload[]) => {
|
|
const workspaceId = dataLoaderParams[0].workspaceId;
|
|
const objectMetadataIds = dataLoaderParams.map(
|
|
(dataLoaderParam) => dataLoaderParam.objectMetadataId,
|
|
);
|
|
|
|
const { objectMetadataMaps } =
|
|
await this.workspaceMetadataCacheService.getExistingOrRecomputeMetadataMaps(
|
|
{ workspaceId },
|
|
);
|
|
|
|
return objectMetadataIds.map((objectMetadataId) => {
|
|
return objectMetadataMaps.byId[objectMetadataId] || null;
|
|
});
|
|
});
|
|
}
|
|
}
|