Skip to content

The open alternative to Salesforce, designed for AI.

6.3 KB
Raw Blame
import { FieldMetadataType, type ObjectPermissions } from 'twenty-shared/types';
import { isDefined, isMorphRelationHead } from 'twenty-shared/utils';

import { findManyFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
import {
  buildFieldSelection,
  type FieldSelectionFlatFieldMetadata,
} from 'src/engine/api/common/common-select-fields/utils/build-field-selection.util';
import { getIsFlatFieldAJoinColumn } from 'src/engine/api/common/common-select-fields/utils/get-is-flat-field-a-join-column.util';
import { getIsFlatFieldAJunctionRelationField } from 'src/engine/api/common/common-select-fields/utils/get-is-flat-field-a-junction-relation-field';
import { isRelationTargetExcludedFromSelection } from 'src/engine/api/common/common-select-fields/utils/is-relation-target-excluded-from-selection.util';
import { CommonSelectedFields } from 'src/engine/api/common/types/common-selected-fields-result.type';
import { MAX_SELECTION_DEPTH } from 'src/engine/api/common/common-select-fields/constants/max-selection-depth.constant';
import { SelectionDepth } from 'src/engine/api/common/common-select-fields/types/selection-depth.type';
import { FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
import { FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';

type RelationsSelectFlatObjectMetadata = Pick<
  FlatObjectMetadata,
  | 'id'
  | 'universalIdentifier'
  | 'applicationId'
  | 'workspaceId'
  | 'fieldIds'
  | 'nameSingular'
  | 'labelIdentifierFieldMetadataId'
  | 'imageIdentifierFieldMetadataId'
>;

type RelationsSelectFlatFieldMetadata = FieldSelectionFlatFieldMetadata &
  Pick<OrmFlatFieldMetadata, 'relationTargetObjectMetadataId'>;

type RelationsSelectObjectsPermissions = Record<
  string,
  Pick<ObjectPermissions, 'restrictedFields'>
>;

export const buildRelationSelectionFromDepth = ({
  flatObjectMetadataMaps,
  flatFieldMetadataMaps,
  flatObjectMetadata,
  flatFields,
  objectsPermissions,
  readableObjectMetadataIds,
  depth,
  onlyUseLabelIdentifierFieldsInRelations = false,
  currentDepthLevelIsAJunctionTable = false,
  recurseIntoJunctionTableRelations = false,
}: {
  flatObjectMetadataMaps: FlatEntityMaps<RelationsSelectFlatObjectMetadata>;
  flatFieldMetadataMaps: FlatEntityMaps<RelationsSelectFlatFieldMetadata>;
  flatObjectMetadata: RelationsSelectFlatObjectMetadata;
  flatFields: readonly RelationsSelectFlatFieldMetadata[];
  objectsPermissions: RelationsSelectObjectsPermissions;
  readableObjectMetadataIds: ReadonlySet<string>;
  depth: SelectionDepth | undefined;
  onlyUseLabelIdentifierFieldsInRelations?: boolean;
  currentDepthLevelIsAJunctionTable?: boolean;
  recurseIntoJunctionTableRelations?: boolean;
}): CommonSelectedFields => {
  if (!isDefined(depth) || depth === 0) return {};

  const relationsSelectFields: CommonSelectedFields = {};

  for (const flatField of flatFields) {
    if (
      !isFlatFieldMetadataOfType(flatField, FieldMetadataType.RELATION) &&
      !isFlatFieldMetadataOfType(flatField, FieldMetadataType.MORPH_RELATION)
    ) {
      continue;
    }

    if (
      objectsPermissions[flatObjectMetadata.id]?.restrictedFields[flatField.id]
        ?.canRead === false
    ) {
      continue;
    }

    if (currentDepthLevelIsAJunctionTable) {
      const fieldIsJunctionRelation = getIsFlatFieldAJunctionRelationField({
        flatField,
      });

      if (!fieldIsJunctionRelation) {
        continue;
      }
    }

    if (isMorphRelationHead(flatField)) {
      continue;
    }

    const relationTargetObjectMetadata =
      findFlatEntityByIdInFlatEntityMapsOrThrow({
        flatEntityMaps: flatObjectMetadataMaps,
        flatEntityId: flatField.relationTargetObjectMetadataId,
      });

    const relationTargetObjectPermissions =
      objectsPermissions[relationTargetObjectMetadata.id];

    if (
      !readableObjectMetadataIds.has(relationTargetObjectMetadata.id) ||
      !isDefined(relationTargetObjectPermissions)
    ) {
      continue;
    }

    if (isRelationTargetExcludedFromSelection(relationTargetObjectMetadata)) {
      continue;
    }

    const relationFlatFields = findManyFlatEntityByIdInFlatEntityMapsOrThrow({
      flatEntityIds: relationTargetObjectMetadata.fieldIds,
      flatEntityMaps: flatFieldMetadataMaps,
    });

    const relationFieldSelectFields = buildFieldSelection({
      restrictedFields: relationTargetObjectPermissions.restrictedFields,
      flatObjectMetadata: relationTargetObjectMetadata,
      flatFields: relationFlatFields,
      onlyUseLabelIdentifierFieldsInRelations,
    });

    if (Object.keys(relationFieldSelectFields).length === 0) continue;

    const flatFieldIsJoinColumn = getIsFlatFieldAJoinColumn({ flatField });

    const isFirstDepthLevel =
      depth === MAX_SELECTION_DEPTH &&
      isDefined(flatField.relationTargetObjectMetadataId);

    const shouldRecurseIntoRelation =
      isFirstDepthLevel ||
      (flatFieldIsJoinColumn && recurseIntoJunctionTableRelations);

    const nextLevelIsAJunctionTable = flatFieldIsJoinColumn;

    if (shouldRecurseIntoRelation) {
      const nestedRelationFieldSelectFields = buildRelationSelectionFromDepth({
        flatObjectMetadataMaps,
        flatFieldMetadataMaps,
        flatObjectMetadata: relationTargetObjectMetadata,
        flatFields: relationFlatFields,
        objectsPermissions,
        readableObjectMetadataIds,
        depth: 1,
        onlyUseLabelIdentifierFieldsInRelations,
        currentDepthLevelIsAJunctionTable: nextLevelIsAJunctionTable,
        recurseIntoJunctionTableRelations,
      });

      relationsSelectFields[flatField.name] = {
        ...relationFieldSelectFields,
        ...nestedRelationFieldSelectFields,
      };
    } else {
      relationsSelectFields[flatField.name] = relationFieldSelectFields;
    }
  }

  return relationsSelectFields;
};