[4/n]: migrate the RESTAPI GET /rest/* to use TwentyORM directly (#10372)

# This PR

- Addressing #3644
- Migrates the `findOne` and the `findMany` Rest API to use TwentyORM
directly
- Adds integration tests to the migrated methods

---------

Co-authored-by: prastoin <paul@twenty.com>
Co-authored-by: martmull <martmull@hotmail.fr>

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser.ts

@@ -6,7 +6,6 @@ import {
 } from 'typeorm';
 
 import { ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 
 import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metadata-map';
 
@@ -16,14 +15,10 @@ export class GraphqlQueryFilterConditionParser {
   private fieldMetadataMapByName: FieldMetadataMap;
   private queryFilterFieldParser: GraphqlQueryFilterFieldParser;
 
-  constructor(
-    fieldMetadataMapByName: FieldMetadataMap,
-    featureFlagsMap: FeatureFlagMap,
-  ) {
+  constructor(fieldMetadataMapByName: FieldMetadataMap) {
     this.fieldMetadataMapByName = fieldMetadataMapByName;
     this.queryFilterFieldParser = new GraphqlQueryFilterFieldParser(
       this.fieldMetadataMapByName,
-      featureFlagsMap,
     );
   }
 

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts

@@ -1,7 +1,6 @@
 import { WhereExpressionBuilder } from 'typeorm';
 import { capitalize } from 'twenty-shared/utils';
 
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
 import {
@@ -18,14 +17,9 @@ const ARRAY_OPERATORS = ['in', 'contains', 'notContains'];
 
 export class GraphqlQueryFilterFieldParser {
   private fieldMetadataMapByName: FieldMetadataMap;
-  private featureFlagsMap: FeatureFlagMap;
 
-  constructor(
-    fieldMetadataMapByName: FieldMetadataMap,
-    featureFlagsMap: FeatureFlagMap,
-  ) {
+  constructor(fieldMetadataMapByName: FieldMetadataMap) {
     this.fieldMetadataMapByName = fieldMetadataMapByName;
-    this.featureFlagsMap = featureFlagsMap;
   }
 
   public parse(

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser.ts

@@ -4,7 +4,6 @@ import {
   ObjectRecordOrderBy,
   OrderByDirection,
 } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
-import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
 import {
@@ -18,14 +17,9 @@ import { CompositeFieldMetadataType } from 'src/engine/metadata-modules/workspac
 
 export class GraphqlQueryOrderFieldParser {
   private fieldMetadataMapByName: FieldMetadataMap;
-  private featureFlagsMap: FeatureFlagMap;
 
-  constructor(
-    fieldMetadataMapByName: FieldMetadataMap,
-    featureFlagsMap: FeatureFlagMap,
-  ) {
+  constructor(fieldMetadataMapByName: FieldMetadataMap) {
     this.fieldMetadataMapByName = fieldMetadataMapByName;
-    this.featureFlagsMap = featureFlagsMap;
   }
 
   parse(

packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts

@@ -39,11 +39,9 @@ export class GraphqlQueryParser {
     this.featureFlagsMap = featureFlagsMap;
     this.filterConditionParser = new GraphqlQueryFilterConditionParser(
       this.fieldMetadataMapByName,
-      featureFlagsMap,
     );
     this.orderFieldParser = new GraphqlQueryOrderFieldParser(
       this.fieldMetadataMapByName,
-      featureFlagsMap,
     );
   }
 

packages/twenty-server/src/engine/api/rest/core/controllers/rest-api-core.controller.ts

@@ -22,6 +22,7 @@ import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
 
 @Controller('rest/*')
 @UseGuards(JwtAuthGuard, WorkspaceAuthGuard)
+@UseFilters(RestApiExceptionFilter)
 export class RestApiCoreController {
   constructor(
     private readonly restApiCoreService: RestApiCoreService,
@@ -29,7 +30,6 @@ export class RestApiCoreController {
   ) {}
 
   @Post('/duplicates')
-  @UseFilters(RestApiExceptionFilter)
   async handleApiFindDuplicates(@Req() request: Request, @Res() res: Response) {
     const result = await this.restApiCoreService.findDuplicates(request);
 
@@ -37,17 +37,13 @@ export class RestApiCoreController {
   }
 
   @Get()
-  @UseFilters(RestApiExceptionFilter)
   async handleApiGet(@Req() request: Request, @Res() res: Response) {
-    const result = await this.restApiCoreService.get(request);
+    const result = await this.restApiCoreServiceV2.get(request);
 
-    res.status(200).send(cleanGraphQLResponse(result.data.data));
+    res.status(200).send(result);
   }
 
   @Delete()
-  // We should move this exception filter to RestApiCoreController class level
-  // when all endpoints are migrated to v2
-  @UseFilters(RestApiExceptionFilter)
   async handleApiDelete(@Req() request: Request, @Res() res: Response) {
     const result = await this.restApiCoreServiceV2.delete(request);
 
@@ -55,7 +51,6 @@ export class RestApiCoreController {
   }
 
   @Post()
-  @UseFilters(RestApiExceptionFilter)
   async handleApiPost(@Req() request: Request, @Res() res: Response) {
     const result = await this.restApiCoreServiceV2.createOne(request);
 
@@ -74,7 +69,6 @@ export class RestApiCoreController {
   // We keep it to avoid a breaking change since it initially used PUT instead of PATCH,
   // and because the PUT verb is often used as a PATCH.
   @Put()
-  @UseFilters(RestApiExceptionFilter)
   async handleApiPut(@Req() request: Request, @Res() res: Response) {
     const result = await this.restApiCoreServiceV2.update(request);
 

packages/twenty-server/src/engine/api/rest/core/rest-api-core-v2.service.ts

@@ -2,16 +2,52 @@ import { BadRequestException, Injectable } from '@nestjs/common';
 
 import { Request } from 'express';
 import { capitalize } from 'twenty-shared/utils';
+import { ObjectLiteral, OrderByCondition, SelectQueryBuilder } from 'typeorm';
 
+import { GraphqlQueryFilterConditionParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser';
+import { GraphqlQueryOrderFieldParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-order/graphql-query-order.parser';
 import { CoreQueryBuilderFactory } from 'src/engine/api/rest/core/query-builder/core-query-builder.factory';
 import { parseCorePath } from 'src/engine/api/rest/core/query-builder/utils/path-parsers/parse-core-path.utils';
+import { FieldValue } from 'src/engine/api/rest/core/types/field-value.type';
+import { EndingBeforeInputFactory } from 'src/engine/api/rest/input-factories/ending-before-input.factory';
+import { FilterInputFactory } from 'src/engine/api/rest/input-factories/filter-input.factory';
+import { LimitInputFactory } from 'src/engine/api/rest/input-factories/limit-input.factory';
+import { OrderByInputFactory } from 'src/engine/api/rest/input-factories/order-by-input.factory';
+import { StartingAfterInputFactory } from 'src/engine/api/rest/input-factories/starting-after-input.factory';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metadata-map';
+import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
+import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
+import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { formatResult as formatGetManyData } from 'src/engine/twenty-orm/utils/format-result.util';
 
+interface FindManyMeta {
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+  startCursor: string | null;
+  endCursor: string | null;
+  totalCount: number;
+}
+
+interface FormatResultParams<T> {
+  operation: 'delete' | 'create' | 'update' | 'findOne' | 'findMany';
+  objectNameSingular?: string;
+  objectNamePlural?: string;
+  data: T;
+  meta?: FindManyMeta;
+}
 @Injectable()
 export class RestApiCoreServiceV2 {
   constructor(
     private readonly coreQueryBuilderFactory: CoreQueryBuilderFactory,
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly limitInputFactory: LimitInputFactory,
+    private readonly filterInputFactory: FilterInputFactory,
+    private readonly featureFlagService: FeatureFlagService,
+    private readonly orderByInputFactory: OrderByInputFactory,
+    private readonly startingAfterInputFactory: StartingAfterInputFactory,
+    private readonly endingBeforeInputFactory: EndingBeforeInputFactory,
   ) {}
 
   async delete(request: Request) {
@@ -29,8 +65,12 @@ export class RestApiCoreServiceV2 {
 
     await repository.delete(recordId);
 
-    return this.formatResult('delete', objectMetadataNameSingular, {
-      id: recordToDelete.id,
+    return this.formatResult({
+      operation: 'delete',
+      objectNameSingular: objectMetadataNameSingular,
+      data: {
+        id: recordToDelete.id,
+      },
     });
   }
 
@@ -41,11 +81,11 @@ export class RestApiCoreServiceV2 {
       await this.getRepositoryAndMetadataOrFail(request);
     const createdRecord = await repository.save(body);
 
-    return this.formatResult(
-      'create',
-      objectMetadataNameSingular,
-      createdRecord,
-    );
+    return this.formatResult({
+      operation: 'create',
+      objectNameSingular: objectMetadataNameSingular,
+      data: createdRecord,
+    });
   }
 
   async update(request: Request) {
@@ -67,24 +107,310 @@ export class RestApiCoreServiceV2 {
       ...request.body,
     });
 
-    return this.formatResult(
-      'update',
+    return this.formatResult({
+      operation: 'update',
+      objectNameSingular: objectMetadataNameSingular,
+      data: updatedRecord,
+    });
+  }
+
+  async get(request: Request) {
+    const { id: recordId } = parseCorePath(request);
+    const {
       objectMetadataNameSingular,
-      updatedRecord,
+      repository,
+      objectMetadata,
+      objectMetadataItemWithFieldsMaps,
+    } = await this.getRepositoryAndMetadataOrFail(request);
+
+    if (recordId) {
+      return await this.findOne(
+        repository,
+        recordId,
+        objectMetadataNameSingular,
+      );
+    } else {
+      return await this.findMany(
+        request,
+        repository,
+        objectMetadata,
+        objectMetadataNameSingular,
+        objectMetadataItemWithFieldsMaps,
+      );
+    }
+  }
+
+  private async findOne(
+    repository: any,
+    recordId: string,
+    objectMetadataNameSingular: string,
+  ) {
+    const record = await repository.findOne({
+      where: { id: recordId },
+    });
+
+    return this.formatResult({
+      operation: 'findOne',
+      objectNameSingular: objectMetadataNameSingular,
+      data: record,
+    });
+  }
+
+  private async findMany(
+    request: Request,
+    repository: WorkspaceRepository<ObjectLiteral>,
+    objectMetadata: any,
+    objectMetadataNameSingular: string,
+    objectMetadataItemWithFieldsMaps:
+      | ObjectMetadataItemWithFieldMaps
+      | undefined,
+  ) {
+    // Get input parameters
+    const inputs = this.getPaginationInputs(request, objectMetadata);
+
+    // Create query builder
+    const qb = repository.createQueryBuilder(objectMetadataNameSingular);
+
+    // Apply filters with cursor
+    const { finalQuery } = await this.applyFiltersWithCursor(
+      qb,
+      objectMetadataNameSingular,
+      objectMetadataItemWithFieldsMaps,
+      inputs,
+    );
+
+    // Get total count
+    const totalCount = await this.getTotalCount(finalQuery);
+
+    // Get records with pagination
+    const { finalRecords, hasMoreRecords } =
+      await this.getRecordsWithPagination(
+        finalQuery,
+        objectMetadataNameSingular,
+        objectMetadataItemWithFieldsMaps,
+        inputs,
+      );
+
+    // Format and return result
+    return this.formatPaginatedResult(
+      finalRecords,
+      objectMetadataNameSingular,
+      objectMetadataItemWithFieldsMaps,
+      objectMetadata,
+      inputs.isForwardPagination,
+      hasMoreRecords,
+      totalCount,
     );
   }
 
-  private formatResult<T>(
-    operation: 'delete' | 'create' | 'update' | 'find',
-    objectNameSingular: string,
-    data: T,
+  private getPaginationInputs(request: Request, objectMetadata: any) {
+    const limit = this.limitInputFactory.create(request);
+    const filter = this.filterInputFactory.create(request, objectMetadata);
+    const orderBy = this.orderByInputFactory.create(request, objectMetadata);
+    const endingBefore = this.endingBeforeInputFactory.create(request);
+    const startingAfter = this.startingAfterInputFactory.create(request);
+    const isForwardPagination = !endingBefore;
+
+    return {
+      limit,
+      filter,
+      orderBy,
+      endingBefore,
+      startingAfter,
+      isForwardPagination,
+    };
+  }
+
+  private async applyFiltersWithCursor(
+    qb: SelectQueryBuilder<ObjectLiteral>,
+    objectMetadataNameSingular: string,
+    objectMetadataItemWithFieldsMaps:
+      | ObjectMetadataItemWithFieldMaps
+      | undefined,
+    inputs: {
+      filter: Record<string, FieldValue>;
+      orderBy: any;
+      startingAfter: string | undefined;
+      endingBefore: string | undefined;
+      isForwardPagination: boolean;
+    },
   ) {
+    const fieldMetadataMapByName =
+      objectMetadataItemWithFieldsMaps?.fieldsByName || {};
+
+    let appliedFilters = inputs.filter;
+
+    // Handle cursor-based filtering
+    if (inputs.startingAfter || inputs.endingBefore) {
+      const cursor = inputs.startingAfter || inputs.endingBefore;
+
+      try {
+        const cursorData = JSON.parse(
+          Buffer.from(cursor ?? '', 'base64').toString(),
+        );
+
+        // We always include ID in the ordering to ensure consistent pagination results
+        // Even if two records have identical values for the user-specified sort fields, their IDs ensures a deterministic order
+        const orderByWithIdCondition = [
+          ...(inputs.orderBy || []),
+          { id: 'ASC' },
+        ];
+
+        const cursorFilter = await this.computeCursorFilter(
+          cursorData,
+          orderByWithIdCondition,
+          fieldMetadataMapByName,
+          inputs.isForwardPagination,
+        );
+
+        // Combine cursor filter with any user-provided filters
+        appliedFilters = inputs.filter
+          ? { and: [inputs.filter, cursorFilter] }
+          : cursorFilter;
+      } catch (error) {
+        throw new BadRequestException(`Invalid cursor: ${cursor}`);
+      }
+    }
+
+    // Apply filters to query builder
+    const finalQuery = new GraphqlQueryFilterConditionParser(
+      fieldMetadataMapByName,
+    ).parse(qb, objectMetadataNameSingular, appliedFilters);
+
+    return { finalQuery, appliedFilters };
+  }
+
+  private async getTotalCount(
+    query: SelectQueryBuilder<ObjectLiteral>,
+  ): Promise<number> {
+    // Clone the query to avoid modifying the original query that will fetch records
+    const countQuery = query.clone();
+
+    return await countQuery.getCount();
+  }
+
+  private async getRecordsWithPagination(
+    query: SelectQueryBuilder<ObjectLiteral>,
+    objectMetadataNameSingular: string,
+    objectMetadataItemWithFieldsMaps:
+      | ObjectMetadataItemWithFieldMaps
+      | undefined,
+    inputs: {
+      orderBy: any;
+      limit: number;
+      isForwardPagination: boolean;
+    },
+  ) {
+    const fieldMetadataMapByName =
+      objectMetadataItemWithFieldsMaps?.fieldsByName || {};
+
+    // Get parsed order by
+    const parsedOrderBy = new GraphqlQueryOrderFieldParser(
+      fieldMetadataMapByName,
+    ).parse(inputs.orderBy, objectMetadataNameSingular);
+
+    // For backward pagination (endingBefore), we need to reverse the sort order
+    const finalOrderBy = inputs.isForwardPagination
+      ? parsedOrderBy
+      : Object.entries(parsedOrderBy).reduce((acc, [key, direction]) => {
+          acc[key] = direction === 'ASC' ? 'DESC' : 'ASC';
+
+          return acc;
+        }, {});
+
+    // Fetch one extra record beyond the requested limit
+    // We'll remove it from the results before returning to the client
+    const records = await query
+      .orderBy(finalOrderBy as OrderByCondition)
+      .take(inputs.limit + 1)
+      .getMany();
+
+    // If we got more records than the limit, it means there are more pages
+    const hasMoreRecords = records.length > inputs.limit;
+
+    // Remove the extra record if we fetched more than requested
+    if (hasMoreRecords) {
+      records.pop();
+    }
+
+    // For backward pagination, we reversed the order to get the correct records
+    // Now we need to reverse them back to maintain the expected order for the client
+    const finalRecords = !inputs.isForwardPagination
+      ? records.reverse()
+      : records;
+
+    return { finalRecords, hasMoreRecords };
+  }
+
+  private formatPaginatedResult(
+    finalRecords: any[],
+    objectMetadataNameSingular: string,
+    objectMetadataItemWithFieldsMaps: any,
+    objectMetadata: any,
+    isForwardPagination: boolean,
+    hasMoreRecords: boolean,
+    totalCount: number,
+  ) {
+    return this.formatResult({
+      operation: 'findMany',
+      objectNamePlural: objectMetadataNameSingular,
+      data: formatGetManyData(
+        finalRecords,
+        objectMetadataItemWithFieldsMaps as any,
+        objectMetadata.objectMetadataMaps,
+      ),
+      meta: {
+        hasNextPage: isForwardPagination && hasMoreRecords,
+        hasPreviousPage: !isForwardPagination && hasMoreRecords,
+        startCursor:
+          finalRecords.length > 0
+            ? Buffer.from(JSON.stringify({ id: finalRecords[0].id })).toString(
+                'base64',
+              )
+            : null,
+        endCursor:
+          finalRecords.length > 0
+            ? Buffer.from(
+                JSON.stringify({
+                  id: finalRecords[finalRecords.length - 1].id,
+                }),
+              ).toString('base64')
+            : null,
+        totalCount,
+      },
+    });
+  }
+
+  private formatResult<T>({
+    operation,
+    objectNameSingular,
+    objectNamePlural,
+    data,
+    meta,
+  }: FormatResultParams<T>) {
+    let prefix: string;
+
+    if (operation === 'findOne') {
+      prefix = objectNameSingular || '';
+    } else if (operation === 'findMany') {
+      prefix = objectNamePlural || '';
+    } else {
+      prefix = operation + capitalize(objectNameSingular || '');
+    }
     const result = {
       data: {
-        [operation + capitalize(objectNameSingular)]: data,
+        [prefix]: data,
       },
     };
 
+    if (meta) {
+      const { totalCount, ...rest } = meta;
+
+      (result.data as any).pageInfo = { ...rest };
+
+      (result.data as any).totalCount = totalCount;
+    }
+
     return result;
   }
 
@@ -107,12 +433,36 @@ export class RestApiCoreServiceV2 {
 
     const objectMetadataNameSingular =
       objectMetadata.objectMetadataMapItem.nameSingular;
+
+    const objectMetadataItemWithFieldsMaps =
+      getObjectMetadataMapItemByNameSingular(
+        objectMetadata.objectMetadataMaps,
+        objectMetadataNameSingular,
+      );
+
     const repository =
       await this.twentyORMGlobalManager.getRepositoryForWorkspace(
         workspace.id,
         objectMetadataNameSingular,
       );
 
-    return { objectMetadataNameSingular, repository };
+    return {
+      objectMetadataNameSingular,
+      objectMetadata,
+      repository,
+      objectMetadataItemWithFieldsMaps,
+    };
+  }
+
+  // Helper method to compute cursor filter
+  private async computeCursorFilter(
+    cursorData: Record<string, any>,
+    orderByWithIdCondition: any[],
+    fieldMetadataMapByName: FieldMetadataMap,
+    isForwardPagination: boolean,
+  ): Promise<any> {
+    return {
+      id: isForwardPagination ? { gt: cursorData.id } : { lt: cursorData.id },
+    };
   }
 }

packages/twenty-server/src/engine/api/rest/input-factories/__tests__/order-by-input.factory.spec.ts

@@ -6,7 +6,10 @@ import { objectMetadataItemMock } from 'src/engine/api/__mocks__/object-metadata
 import { OrderByInputFactory } from 'src/engine/api/rest/input-factories/order-by-input.factory';
 
 describe('OrderByInputFactory', () => {
-  const objectMetadata = { objectMetadataItem: objectMetadataItemMock };
+  const objectMetadata = {
+    objectMetadataItem: objectMetadataItemMock,
+    objectMetadataMapItem: objectMetadataItemMock,
+  };
 
   let service: OrderByInputFactory;
 

packages/twenty-server/src/engine/api/rest/input-factories/order-by-input.factory.ts

@@ -72,7 +72,7 @@ export class OrderByInputFactory {
       result = [...result, ...resultFields];
     }
 
-    checkArrayFields(objectMetadata.objectMetadataItem, result);
+    checkArrayFields(objectMetadata.objectMetadataMapItem, result);
 
     return result;
   }

packages/twenty-server/src/engine/api/rest/rest-api.module.ts

@@ -1,5 +1,6 @@
 import { HttpModule } from '@nestjs/axios';
 import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { RestApiCoreBatchController } from 'src/engine/api/rest/core/controllers/rest-api-core-batch.controller';
 import { RestApiCoreController } from 'src/engine/api/rest/core/controllers/rest-api-core.controller';
@@ -7,13 +8,18 @@ import { CoreQueryBuilderModule } from 'src/engine/api/rest/core/query-builder/c
 import { RestApiCoreServiceV2 } from 'src/engine/api/rest/core/rest-api-core-v2.service';
 import { RestApiCoreService } from 'src/engine/api/rest/core/rest-api-core.service';
 import { EndingBeforeInputFactory } from 'src/engine/api/rest/input-factories/ending-before-input.factory';
+import { FilterInputFactory } from 'src/engine/api/rest/input-factories/filter-input.factory';
 import { LimitInputFactory } from 'src/engine/api/rest/input-factories/limit-input.factory';
+import { OrderByInputFactory } from 'src/engine/api/rest/input-factories/order-by-input.factory';
 import { StartingAfterInputFactory } from 'src/engine/api/rest/input-factories/starting-after-input.factory';
 import { MetadataQueryBuilderModule } from 'src/engine/api/rest/metadata/query-builder/metadata-query-builder.module';
 import { RestApiMetadataController } from 'src/engine/api/rest/metadata/rest-api-metadata.controller';
 import { RestApiMetadataService } from 'src/engine/api/rest/metadata/rest-api-metadata.service';
 import { RestApiService } from 'src/engine/api/rest/rest-api.service';
 import { AuthModule } from 'src/engine/core-modules/auth/auth.module';
+import { FeatureFlag } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 
@@ -25,6 +31,8 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/
     AuthModule,
     HttpModule,
     TwentyORMModule,
+    TypeOrmModule.forFeature([FeatureFlag], 'core'),
+    FeatureFlagModule,
   ],
   controllers: [
     RestApiMetadataController,
@@ -36,9 +44,12 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/
     RestApiCoreService,
     RestApiCoreServiceV2,
     RestApiService,
+    FeatureFlagService,
     StartingAfterInputFactory,
     EndingBeforeInputFactory,
     LimitInputFactory,
+    FilterInputFactory,
+    OrderByInputFactory,
   ],
   exports: [RestApiMetadataService],
 })