Skip to content

The open alternative to Salesforce, designed for AI.

13.4 KB
Raw Blame
import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  ParseUUIDPipe,
  Patch,
  Post,
  Put,
  Req,
  UseFilters,
  UseGuards,
  UsePipes,
  ValidationPipe,
} from '@nestjs/common';
import { ApiPath, FeatureFlagKey } from 'twenty-shared/types';
import { In } from 'typeorm';

import { type RestCursorPageInfo } from 'src/engine/api/rest/metadata/types/rest-cursor-page-info.type';
import { paginateByIdCursor } from 'src/engine/api/rest/metadata/utils/paginate-by-id-cursor.util';
import { type AuthenticatedRequest } from 'src/engine/api/rest/types/authenticated-request.type';
import { ApplicationRestApiExceptionFilter } from 'src/engine/core-modules/application/application-rest-api-exception.filter';
import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { JwtAuthGuard } from 'src/engine/guards/jwt-auth.guard';
import { DerivedFieldMetadataIdsService } from 'src/engine/metadata-modules/derived-field-metadata-ids/services/derived-field-metadata-ids.service';
import { type DerivedFieldMetadataIds } from 'src/engine/metadata-modules/derived-field-metadata-ids/types/derived-field-metadata-ids.type';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { fromFieldMetadataEntityToFieldMetadataDto } from 'src/engine/metadata-modules/field-metadata/utils/from-field-metadata-entity-to-field-metadata-dto.util';
import { FlatEntityMapsRestApiExceptionFilter } from 'src/engine/metadata-modules/flat-entity/filters/flat-entity-maps-rest-api-exception.filter';
import { fromFlatObjectMetadataToObjectMetadataDto } from 'src/engine/metadata-modules/flat-object-metadata/utils/from-flat-object-metadata-to-object-metadata-dto.util';
import { CreateObjectInput } from 'src/engine/metadata-modules/object-metadata/dtos/create-object.input';
import { type ObjectMetadataWithFieldsDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata-with-fields.dto';
import { UpdateObjectPayload } from 'src/engine/metadata-modules/object-metadata/dtos/update-object.input';
import { ObjectMetadataRestApiExceptionFilter } from 'src/engine/metadata-modules/object-metadata/filters/object-metadata-rest-api-exception.filter';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import {
  ObjectMetadataException,
  ObjectMetadataExceptionCode,
} from 'src/engine/metadata-modules/object-metadata/object-metadata.exception';
import { ObjectMetadataService } from 'src/engine/metadata-modules/object-metadata/object-metadata.service';
import { fromObjectMetadataEntityToObjectMetadataDto } from 'src/engine/metadata-modules/object-metadata/utils/from-object-metadata-entity-to-object-metadata-dto.util';
import { ApplicationTranslationCatalogService } from 'src/engine/metadata-modules/application-translation-catalog/services/application-translation-catalog.service';
import { RequestLocale } from 'src/engine/decorators/locale/request-locale.decorator';
import { type APP_LOCALES } from 'twenty-shared/translations';
import {
  toLegacyObjectMetadataCreateResponse,
  toLegacyObjectMetadataDeleteResponse,
  toLegacyObjectMetadataFindOneResponse,
  toLegacyObjectMetadataListResponse,
  toLegacyObjectMetadataUpdateResponse,
} from 'src/engine/metadata-modules/object-metadata/utils/to-legacy-object-metadata-response.util';
import { PermissionsRestApiExceptionFilter } from 'src/engine/permissions/utils/permissions-rest-api-exception.filter';
import { AuthRestApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-rest-api-exception.filter';
import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
import { OBJECT_METADATA_READ_ACCESS_POLICY } from 'src/engine/metadata-modules/object-metadata/constants/object-metadata-read-access-policy.constant';
import { OBJECT_METADATA_WRITE_ACCESS_POLICY } from 'src/engine/metadata-modules/object-metadata/constants/object-metadata-write-access-policy.constant';
import { AccessPolicyGuard } from 'src/engine/guards/access-policy.guard';

@Controller(`${ApiPath.Rest}/metadata/objects`)
@UseGuards(JwtAuthGuard)
@UseFilters(
  PermissionsRestApiExceptionFilter,
  ObjectMetadataRestApiExceptionFilter,
  ApplicationRestApiExceptionFilter,
  FlatEntityMapsRestApiExceptionFilter,
  AuthRestApiExceptionFilter,
)
@UsePipes(new ValidationPipe())
export class ObjectMetadataController {
  constructor(
    @InjectWorkspaceScopedRepository(ObjectMetadataEntity)
    private readonly objectMetadataRepository: WorkspaceScopedRepository<ObjectMetadataEntity>,
    @InjectWorkspaceScopedRepository(FieldMetadataEntity)
    private readonly fieldMetadataRepository: WorkspaceScopedRepository<FieldMetadataEntity>,
    private readonly objectMetadataService: ObjectMetadataService,
    private readonly featureFlagService: FeatureFlagService,
    private readonly derivedFieldMetadataIdsService: DerivedFieldMetadataIdsService,
    private readonly applicationTranslationCatalogService: ApplicationTranslationCatalogService,
  ) {}

  @Get()
  @UseGuards(AccessPolicyGuard(OBJECT_METADATA_READ_ACCESS_POLICY))
  async findMany(
    @Req() request: AuthenticatedRequest,
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
    @RequestLocale() locale: keyof typeof APP_LOCALES | undefined,
  ) {
    const { items, pageInfo, totalCount } = await paginateByIdCursor({
      repository: this.objectMetadataRepository,
      workspaceId,
      request,
    });

    const [fields, derivedFieldMetadataIds] = await Promise.all([
      this.findFieldsForObjectIds(
        workspaceId,
        items.map((object) => object.id),
      ),
      this.derivedFieldMetadataIdsService.getForWorkspace(workspaceId),
    ]);

    const data = await this.toObjectWithFieldsDtos({
      objects: items,
      fieldsByObjectId: fields,
      derivedFieldMetadataIds,
      locale,
      workspaceId,
    });

    const result: {
      data: ObjectMetadataWithFieldsDTO[];
      pageInfo: RestCursorPageInfo;
      totalCount: number;
    } = { data, pageInfo, totalCount };

    return (await this.isNewMetadataFormat(workspaceId))
      ? result
      : toLegacyObjectMetadataListResponse(result);
  }

  @Get(':id')
  @UseGuards(AccessPolicyGuard(OBJECT_METADATA_READ_ACCESS_POLICY))
  async findOne(
    @Param('id', new ParseUUIDPipe()) id: string,
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
    @RequestLocale() locale: keyof typeof APP_LOCALES | undefined,
  ) {
    const object = await this.objectMetadataRepository.findOne(workspaceId, {
      where: { id },
    });

    if (!object) {
      throw new ObjectMetadataException(
        'Object metadata not found',
        ObjectMetadataExceptionCode.OBJECT_METADATA_NOT_FOUND,
      );
    }

    const [fields, derivedFieldMetadataIds] = await Promise.all([
      this.fieldMetadataRepository.find(workspaceId, {
        where: { objectMetadataId: object.id },
      }),
      this.derivedFieldMetadataIdsService.getForWorkspace(workspaceId),
    ]);

    const [result] = await this.toObjectWithFieldsDtos({
      objects: [object],
      fieldsByObjectId: new Map([[object.id, fields]]),
      derivedFieldMetadataIds,
      locale,
      workspaceId,
    });

    return (await this.isNewMetadataFormat(workspaceId))
      ? result
      : toLegacyObjectMetadataFindOneResponse(result);
  }

  @Post()
  @UseGuards(AccessPolicyGuard(OBJECT_METADATA_WRITE_ACCESS_POLICY))
  async createOne(
    @Body() input: CreateObjectInput,
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ) {
    const flatObject = await this.objectMetadataService.createOneObject({
      createObjectInput: input,
      workspaceId,
    });

    const [fields, derivedFieldMetadataIds] = await Promise.all([
      this.fieldMetadataRepository.find(workspaceId, {
        where: { objectMetadataId: flatObject.id },
      }),
      this.derivedFieldMetadataIdsService.getForWorkspace(workspaceId),
    ]);

    const result: ObjectMetadataWithFieldsDTO = {
      ...fromFlatObjectMetadataToObjectMetadataDto(flatObject),
      fields: fields.map((field) =>
        fromFieldMetadataEntityToFieldMetadataDto(
          field,
          derivedFieldMetadataIds,
        ),
      ),
    };

    return (await this.isNewMetadataFormat(workspaceId))
      ? result
      : toLegacyObjectMetadataCreateResponse(result);
  }

  @Patch(':id')
  @UseGuards(AccessPolicyGuard(OBJECT_METADATA_WRITE_ACCESS_POLICY))
  async updateOnePatch(
    @Param('id', new ParseUUIDPipe()) id: string,
    @Body() update: UpdateObjectPayload,
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ) {
    return this.handleUpdate({ id, update, workspaceId });
  }

  @Put(':id')
  @UseGuards(AccessPolicyGuard(OBJECT_METADATA_WRITE_ACCESS_POLICY))
  async updateOnePut(
    @Param('id', new ParseUUIDPipe()) id: string,
    @Body() update: UpdateObjectPayload,
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ) {
    return this.handleUpdate({ id, update, workspaceId });
  }

  @Delete(':id')
  @UseGuards(AccessPolicyGuard(OBJECT_METADATA_WRITE_ACCESS_POLICY))
  async deleteOne(
    @Param('id', new ParseUUIDPipe()) id: string,
    @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
  ) {
    const flatObject = await this.objectMetadataService.deleteOneObject({
      deleteObjectInput: { id },
      workspaceId,
    });

    const result = fromFlatObjectMetadataToObjectMetadataDto(flatObject);

    return (await this.isNewMetadataFormat(workspaceId))
      ? result
      : toLegacyObjectMetadataDeleteResponse(result);
  }

  private async handleUpdate({
    id,
    update,
    workspaceId,
  }: {
    id: string;
    update: UpdateObjectPayload;
    workspaceId: string;
  }) {
    const flatObject = await this.objectMetadataService.updateOneObject({
      updateObjectInput: { id, update },
      workspaceId,
    });

    const [fields, derivedFieldMetadataIds] = await Promise.all([
      this.fieldMetadataRepository.find(workspaceId, {
        where: { objectMetadataId: flatObject.id },
      }),
      this.derivedFieldMetadataIdsService.getForWorkspace(workspaceId),
    ]);

    const result: ObjectMetadataWithFieldsDTO = {
      ...fromFlatObjectMetadataToObjectMetadataDto(flatObject),
      fields: fields.map((field) =>
        fromFieldMetadataEntityToFieldMetadataDto(
          field,
          derivedFieldMetadataIds,
        ),
      ),
    };

    return (await this.isNewMetadataFormat(workspaceId))
      ? result
      : toLegacyObjectMetadataUpdateResponse(result);
  }

  private async isNewMetadataFormat(workspaceId: string): Promise<boolean> {
    return this.featureFlagService.isFeatureEnabled(
      FeatureFlagKey.IS_REST_METADATA_API_NEW_FORMAT_DIRECT,
      workspaceId,
    );
  }

  private async findFieldsForObjectIds(
    workspaceId: string,
    objectIds: string[],
  ): Promise<Map<string, FieldMetadataEntity[]>> {
    const grouped = new Map<string, FieldMetadataEntity[]>();

    if (objectIds.length === 0) {
      return grouped;
    }

    const fields = await this.fieldMetadataRepository.find(workspaceId, {
      where: { objectMetadataId: In(objectIds) },
    });

    for (const field of fields) {
      const list = grouped.get(field.objectMetadataId);

      if (list) {
        list.push(field);
      } else {
        grouped.set(field.objectMetadataId, [field]);
      }
    }

    return grouped;
  }

  // labels resolve for the caller's locale via the GraphQL read path's resolver, one call per kind so a page costs a fixed number of catalog reads
  private async toObjectWithFieldsDtos({
    objects,
    fieldsByObjectId,
    derivedFieldMetadataIds,
    locale,
    workspaceId,
  }: {
    objects: ObjectMetadataEntity[];
    fieldsByObjectId: Map<string, FieldMetadataEntity[]>;
    derivedFieldMetadataIds: DerivedFieldMetadataIds;
    locale: keyof typeof APP_LOCALES | undefined;
    workspaceId: string;
  }): Promise<ObjectMetadataWithFieldsDTO[]> {
    const [resolvedObjects, resolvedFields] = await Promise.all([
      this.applicationTranslationCatalogService.resolveTranslatablePropertiesForEntities(
        {
          metadataName: 'objectMetadata',
          entities: objects,
          locale,
          workspaceId,
        },
      ),
      this.applicationTranslationCatalogService.resolveTranslatablePropertiesForEntities(
        {
          metadataName: 'fieldMetadata',
          entities: objects.flatMap(
            (object) => fieldsByObjectId.get(object.id) ?? [],
          ),
          locale,
          workspaceId,
        },
      ),
    ]);
    const resolvedFieldsByObjectId = new Map<string, FieldMetadataEntity[]>();

    for (const field of resolvedFields) {
      const fieldsForObject =
        resolvedFieldsByObjectId.get(field.objectMetadataId) ?? [];

      fieldsForObject.push(field);
      resolvedFieldsByObjectId.set(field.objectMetadataId, fieldsForObject);
    }

    return resolvedObjects.map((object) => ({
      ...fromObjectMetadataEntityToObjectMetadataDto(object),
      fields: (resolvedFieldsByObjectId.get(object.id) ?? []).map((field) =>
        fromFieldMetadataEntityToFieldMetadataDto(
          field,
          derivedFieldMetadataIds,
        ),
      ),
    }));
  }
}