Skip to content

The open alternative to Salesforce, designed for AI.

49.4 KB
Raw Blame
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),
        };
      });
    });
  }
}