Revert "refactor: Simplify CRUD services to leverage Common API (#157… (#15875)

This reverts commit 11e07f90d2.

packages/twenty-server/src/engine/core-modules/actor/services/created-by-from-auth-context.service.ts

@@ -68,19 +68,6 @@ export class CreatedByFromAuthContextService {
 
     const clonedRecords = structuredClone(records);
 
-    // Check if all records already have createdBy with name populated
-    // If so, skip building from auth context (e.g., workflows provide explicit createdBy)
-    const recordsArray = Array.isArray(clonedRecords)
-      ? clonedRecords
-      : [clonedRecords];
-    const allRecordsHaveCreatedBy = recordsArray.every(
-      (record) => record.createdBy?.name,
-    );
-
-    if (allRecordsHaveCreatedBy) {
-      return clonedRecords;
-    }
-
     const createdBy = await this.buildCreatedBy(authContext);
 
     if (Array.isArray(clonedRecords)) {

packages/twenty-server/src/engine/core-modules/ai/services/tool.service.ts

@@ -12,6 +12,7 @@ import { generateUpdateRecordInputSchema } from 'src/engine/core-modules/record-
 import { BulkDeleteToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/bulk-delete-tool.zod-schema';
 import { generateFindToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/find-tool.zod-schema';
 import { SoftDeleteToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/soft-delete-tool.zod-schema';
+import { FindOneToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/find-one-tool.zod-schema';
 import { isWorkflowRelatedObject } from 'src/engine/metadata-modules/agent/utils/is-workflow-related-object.util';
 import {
   type ToolHints,
@@ -44,7 +45,6 @@ export class ToolService {
     rolePermissionConfig: RolePermissionConfig,
     workspaceId: string,
     actorContext?: ActorMetadata,
-    userWorkspaceId?: string,
     toolHints?: ToolHints,
   ): Promise<ToolSet> {
     const tools: ToolSet = {};
@@ -150,7 +150,20 @@ export class ToolService {
               offset,
               workspaceId,
               rolePermissionConfig,
-              userWorkspaceId,
+            });
+          },
+        };
+
+        tools[`find_one_${objectMetadata.nameSingular}`] = {
+          description: `Retrieve a single ${objectMetadata.labelSingular} record by its unique ID. Use this when you know the exact record ID and need the complete record data. Returns the full record or an error if not found.`,
+          inputSchema: FindOneToolInputSchema,
+          execute: async (parameters) => {
+            return this.findRecordsService.execute({
+              objectName: objectMetadata.nameSingular,
+              filter: { id: { eq: parameters.input.id } },
+              limit: 1,
+              workspaceId,
+              rolePermissionConfig,
             });
           },
         };
@@ -171,7 +184,6 @@ export class ToolService {
                 workspaceId,
                 rolePermissionConfig,
                 createdBy: actorContext,
-                userWorkspaceId,
               });
             },
           };
@@ -199,7 +211,6 @@ export class ToolService {
                 objectRecord,
                 workspaceId,
                 rolePermissionConfig,
-                userWorkspaceId,
               });
             },
           };
@@ -217,7 +228,6 @@ export class ToolService {
               workspaceId,
               rolePermissionConfig,
               soft: true,
-              userWorkspaceId,
             });
           },
         };

packages/twenty-server/src/engine/core-modules/record-crud/record-crud.module.ts

@@ -1,21 +1,23 @@
-import { forwardRef, Module } from '@nestjs/common';
+import { Module } from '@nestjs/common';
 
-import { CoreCommonApiModule } from 'src/engine/api/common/core-common-api.module';
 import { CreateRecordService } from 'src/engine/core-modules/record-crud/services/create-record.service';
 import { DeleteRecordService } from 'src/engine/core-modules/record-crud/services/delete-record.service';
 import { FindRecordsService } from 'src/engine/core-modules/record-crud/services/find-records.service';
 import { UpdateRecordService } from 'src/engine/core-modules/record-crud/services/update-record.service';
 import { UpsertRecordService } from 'src/engine/core-modules/record-crud/services/upsert-record.service';
-import { CommonApiContextBuilder } from 'src/engine/core-modules/record-crud/utils/common-api-context-builder.util';
-import { WorkspaceMetadataCacheModule } from 'src/engine/metadata-modules/workspace-metadata-cache/workspace-metadata-cache.module';
+import { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
+import { RecordTransformerModule } from 'src/engine/core-modules/record-transformer/record-transformer.module';
+import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
+import { WorkflowCommonModule } from 'src/modules/workflow/common/workflow-common.module';
 
 @Module({
   imports: [
-    forwardRef(() => CoreCommonApiModule),
-    WorkspaceMetadataCacheModule,
+    TwentyORMModule,
+    RecordPositionModule,
+    RecordTransformerModule,
+    WorkflowCommonModule,
   ],
   providers: [
-    CommonApiContextBuilder,
     CreateRecordService,
     UpdateRecordService,
     DeleteRecordService,

packages/twenty-server/src/engine/core-modules/record-crud/services/create-record.service.ts

@@ -1,60 +1,134 @@
 import { Injectable, Logger } from '@nestjs/common';
 
-import { CommonCreateOneQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-create-one-query-runner.service';
+import { isDefined } from 'class-validator';
+import { canObjectBeManagedByWorkflow } from 'twenty-shared/workflow';
+import { FieldActorSource } from 'twenty-shared/types';
+
+import {
+  RecordCrudException,
+  RecordCrudExceptionCode,
+} from 'src/engine/core-modules/record-crud/exceptions/record-crud.exception';
 import { type CreateRecordParams } from 'src/engine/core-modules/record-crud/types/create-record-params.type';
-import { CommonApiContextBuilder } from 'src/engine/core-modules/record-crud/utils/common-api-context-builder.util';
+import { getSelectedColumnsFromRestrictedFields } from 'src/engine/core-modules/record-crud/utils/get-selected-columns-from-restricted-fields.util';
+import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
+import { RecordInputTransformerService } from 'src/engine/core-modules/record-transformer/services/record-input-transformer.service';
 import { type ToolOutput } from 'src/engine/core-modules/tool/types/tool-output.type';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 
 @Injectable()
+// eslint-disable-next-line @nx/workspace-inject-workspace-repository
 export class CreateRecordService {
   private readonly logger = new Logger(CreateRecordService.name);
 
   constructor(
-    private readonly commonCreateOneRunner: CommonCreateOneQueryRunnerService,
-    private readonly commonApiContextBuilder: CommonApiContextBuilder,
+    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly recordPositionService: RecordPositionService,
+    private readonly recordInputTransformerService: RecordInputTransformerService,
+    private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
   ) {}
 
   async execute(params: CreateRecordParams): Promise<ToolOutput> {
-    const {
-      objectName,
-      objectRecord,
-      workspaceId,
-      rolePermissionConfig,
-      createdBy,
-      userWorkspaceId,
-      apiKey,
-    } = params;
+    const { objectName, objectRecord, workspaceId, rolePermissionConfig } =
+      params;
+
+    if (!workspaceId) {
+      return {
+        success: false,
+        message: 'Failed to create record: Workspace ID is required',
+        error: 'Workspace ID not found',
+      };
+    }
 
     try {
-      const { queryRunnerContext, selectedFields } =
-        await this.commonApiContextBuilder.build({
+      const repository =
+        await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+          workspaceId,
+          objectName,
+          rolePermissionConfig,
+        );
+
+      const { objectMetadataItemWithFieldsMaps } =
+        await this.workflowCommonWorkspaceService.getObjectMetadataItemWithFieldsMaps(
           objectName,
           workspaceId,
-          rolePermissionConfig,
-          userWorkspaceId,
-          apiKey,
-          actorContext: createdBy,
+        );
+
+      if (
+        !canObjectBeManagedByWorkflow({
+          nameSingular: objectMetadataItemWithFieldsMaps.nameSingular,
+          isSystem: objectMetadataItemWithFieldsMaps.isSystem,
+        })
+      ) {
+        throw new RecordCrudException(
+          'Failed to create: Object cannot be created by workflow',
+          RecordCrudExceptionCode.INVALID_REQUEST,
+        );
+      }
+
+      const position = await this.recordPositionService.buildRecordPosition({
+        value: 'first',
+        objectMetadata: objectMetadataItemWithFieldsMaps,
+        workspaceId,
+      });
+
+      const validObjectRecord = Object.fromEntries(
+        Object.entries(objectRecord).filter(
+          ([key]) =>
+            isDefined(objectMetadataItemWithFieldsMaps.fieldIdByName[key]) ||
+            isDefined(
+              objectMetadataItemWithFieldsMaps.fieldIdByJoinColumnName[key],
+            ),
+        ),
+      );
+
+      const transformedObjectRecord =
+        await this.recordInputTransformerService.process({
+          recordInput: validObjectRecord,
+          objectMetadataMapItem: objectMetadataItemWithFieldsMaps,
         });
 
-      // Pass createdBy explicitly if provided (for workflows)
-      // Common API hook will also inject createdBy from authContext if available
-      const dataWithActor = createdBy
-        ? { ...objectRecord, createdBy }
-        : objectRecord;
+      const restrictedFields =
+        repository.objectRecordsPermissions?.[
+          objectMetadataItemWithFieldsMaps.id
+        ]?.restrictedFields;
 
-      const result = await this.commonCreateOneRunner.execute(
-        { data: dataWithActor, selectedFields },
-        queryRunnerContext,
+      const selectedColumns = getSelectedColumnsFromRestrictedFields(
+        restrictedFields,
+        objectMetadataItemWithFieldsMaps,
       );
 
+      const insertResult = await repository.insert(
+        {
+          ...transformedObjectRecord,
+          position,
+          createdBy: params.createdBy ?? {
+            source: FieldActorSource.WORKFLOW,
+            name: 'Workflow',
+          },
+        },
+        undefined,
+        selectedColumns,
+      );
+
+      const [createdRecord] = insertResult.generatedMaps;
+
       this.logger.log(`Record created successfully in ${objectName}`);
 
       return {
         success: true,
         message: `Record created successfully in ${objectName}`,
-        result,
+        result: createdRecord,
       };
     } catch (error) {
+      if (error instanceof RecordCrudException) {
+        return {
+          success: false,
+          message: `Failed to create record in ${objectName}`,
+          error: error.message,
+        };
+      }
+
       this.logger.error(`Failed to create record: ${error}`);
 
       return {

packages/twenty-server/src/engine/core-modules/record-crud/services/delete-record.service.ts

@@ -1,17 +1,25 @@
 import { Injectable, Logger } from '@nestjs/common';
 
-import { CommonDeleteOneQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-delete-one-query-runner.service';
+import { isDefined, isValidUuid } from 'twenty-shared/utils';
+import { canObjectBeManagedByWorkflow } from 'twenty-shared/workflow';
+
+import {
+  RecordCrudException,
+  RecordCrudExceptionCode,
+} from 'src/engine/core-modules/record-crud/exceptions/record-crud.exception';
 import { type DeleteRecordParams } from 'src/engine/core-modules/record-crud/types/delete-record-params.type';
-import { CommonApiContextBuilder } from 'src/engine/core-modules/record-crud/utils/common-api-context-builder.util';
 import { type ToolOutput } from 'src/engine/core-modules/tool/types/tool-output.type';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 
 @Injectable()
+// eslint-disable-next-line @nx/workspace-inject-workspace-repository
 export class DeleteRecordService {
   private readonly logger = new Logger(DeleteRecordService.name);
 
   constructor(
-    private readonly commonDeleteOneRunner: CommonDeleteOneQueryRunnerService,
-    private readonly commonApiContextBuilder: CommonApiContextBuilder,
+    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
   ) {}
 
   async execute(params: DeleteRecordParams): Promise<ToolOutput> {
@@ -20,40 +28,107 @@ export class DeleteRecordService {
       objectRecordId,
       workspaceId,
       rolePermissionConfig,
-      userWorkspaceId,
-      apiKey,
-      createdBy,
+      soft = true,
     } = params;
 
+    if (!workspaceId) {
+      return {
+        success: false,
+        message: 'Failed to delete record: Workspace ID is required',
+        error: 'Workspace ID not found',
+      };
+    }
+
+    if (!isDefined(objectRecordId) || !isValidUuid(objectRecordId)) {
+      return {
+        success: false,
+        message: 'Failed to delete: Object record ID must be a valid UUID',
+        error: 'Invalid object record ID',
+      };
+    }
+
     try {
-      const { queryRunnerContext, selectedFields } =
-        await this.commonApiContextBuilder.build({
+      const repository =
+        await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+          workspaceId,
+          objectName,
+          rolePermissionConfig,
+        );
+
+      const { objectMetadataItemWithFieldsMaps } =
+        await this.workflowCommonWorkspaceService.getObjectMetadataItemWithFieldsMaps(
           objectName,
           workspaceId,
-          rolePermissionConfig,
-          userWorkspaceId,
-          apiKey,
-          actorContext: createdBy,
-        });
+        );
 
-      const result = await this.commonDeleteOneRunner.execute(
-        { id: objectRecordId, selectedFields },
-        queryRunnerContext,
-      );
+      if (
+        !canObjectBeManagedByWorkflow({
+          nameSingular: objectMetadataItemWithFieldsMaps.nameSingular,
+          isSystem: objectMetadataItemWithFieldsMaps.isSystem,
+        })
+      ) {
+        throw new RecordCrudException(
+          'Failed to delete: Object cannot be deleted by workflow',
+          RecordCrudExceptionCode.INVALID_REQUEST,
+        );
+      }
 
-      this.logger.log(`Record deleted successfully in ${objectName}`);
+      const objectRecord = await repository.findOne({
+        where: {
+          id: objectRecordId,
+        },
+      });
 
-      return {
-        success: true,
-        message: `Record deleted successfully in ${objectName}`,
-        result,
-      };
+      if (!objectRecord) {
+        throw new RecordCrudException(
+          `Failed to delete: Record ${objectName} with id ${objectRecordId} not found`,
+          RecordCrudExceptionCode.RECORD_NOT_FOUND,
+        );
+      }
+
+      if (soft) {
+        const columnsToReturnForSoftDelete: string[] = [];
+
+        await repository.softDelete(
+          objectRecordId,
+          undefined,
+          columnsToReturnForSoftDelete,
+        );
+
+        this.logger.log(`Record soft deleted successfully from ${objectName}`);
+
+        return {
+          success: true,
+          message: `Record soft deleted successfully from ${objectName}`,
+          result: objectRecord,
+        };
+      } else {
+        await repository.remove(objectRecord);
+
+        this.logger.log(
+          `Record permanently deleted successfully from ${objectName}`,
+        );
+
+        return {
+          success: true,
+          message: `Record permanently deleted successfully from ${objectName}`,
+          result: { id: objectRecordId },
+        };
+      }
     } catch (error) {
+      if (error instanceof RecordCrudException) {
+        return {
+          success: false,
+          message: `Failed to delete record from ${objectName}`,
+          error: error.message,
+        };
+      }
+
       this.logger.error(`Failed to delete record: ${error}`);
 
       return {
         success: false,
-        message: `Failed to delete record in ${objectName}`,
+        message: `Failed to delete record from ${objectName}`,
         error:
           error instanceof Error ? error.message : 'Failed to delete record',
       };

packages/twenty-server/src/engine/core-modules/record-crud/services/find-records.service.ts

@@ -1,63 +1,103 @@
 import { Injectable, Logger } from '@nestjs/common';
 
-import { CommonFindManyQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-find-many-query-runner.service';
+import isEmpty from 'lodash.isempty';
+import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';
+import { OrderByDirection } from 'twenty-shared/types';
+import { type ObjectLiteral } from 'typeorm';
+
+import {
+  type ObjectRecordFilter,
+  type ObjectRecordOrderBy,
+} from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
+
+import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
+import { getAllSelectableColumnNames } from 'src/engine/api/utils/get-all-selectable-column-names.utils';
 import { type FindRecordsParams } from 'src/engine/core-modules/record-crud/types/find-records-params.type';
-import { CommonApiContextBuilder } from 'src/engine/core-modules/record-crud/utils/common-api-context-builder.util';
+import { FindRecordsResult } from 'src/engine/core-modules/record-crud/types/find-records-result.type';
 import { type ToolOutput } from 'src/engine/core-modules/tool/types/tool-output.type';
+import { type ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
+import { type WorkspaceSelectQueryBuilder } from 'src/engine/twenty-orm/repository/workspace-select-query-builder';
+import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 
 @Injectable()
+// eslint-disable-next-line @nx/workspace-inject-workspace-repository
 export class FindRecordsService {
   private readonly logger = new Logger(FindRecordsService.name);
 
   constructor(
-    private readonly commonFindManyRunner: CommonFindManyQueryRunnerService,
-    private readonly commonApiContextBuilder: CommonApiContextBuilder,
+    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
   ) {}
 
   async execute(
     params: FindRecordsParams,
-  ): Promise<ToolOutput<{ records: unknown[]; totalCount: number }>> {
+  ): Promise<ToolOutput<FindRecordsResult>> {
     const {
       objectName,
       filter,
       orderBy,
       limit,
-      offset,
+      offset = 0,
       workspaceId,
       rolePermissionConfig,
-      userWorkspaceId,
-      apiKey,
-      createdBy,
     } = params;
 
+    if (!workspaceId) {
+      return {
+        success: false,
+        message: 'Failed to find records: Workspace ID is required',
+        error: 'Workspace ID not found',
+      };
+    }
+
     try {
-      const { queryRunnerContext, selectedFields } =
-        await this.commonApiContextBuilder.build({
+      const repository =
+        await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+          workspaceId,
+          objectName,
+          rolePermissionConfig,
+        );
+
+      const { objectMetadataItemWithFieldsMaps, objectMetadataMaps } =
+        await this.workflowCommonWorkspaceService.getObjectMetadataItemWithFieldsMaps(
           objectName,
           workspaceId,
-          rolePermissionConfig,
-          userWorkspaceId,
-          apiKey,
-          actorContext: createdBy,
-        });
+        );
 
-      const result = await this.commonFindManyRunner.execute(
-        {
-          filter: filter || {},
-          orderBy,
-          first: limit ?? 50,
-          offset: offset ?? 0,
-          selectedFields,
-        },
-        queryRunnerContext,
+      const graphqlQueryParser = new GraphqlQueryParser(
+        objectMetadataItemWithFieldsMaps,
+        objectMetadataMaps,
       );
 
+      const records = await this.getObjectRecords({
+        objectName,
+        filter,
+        orderBy,
+        limit,
+        offset,
+        repository,
+        graphqlQueryParser,
+        objectMetadataItemWithFieldsMaps,
+      });
+
+      const totalCount = await this.getTotalCount({
+        objectName,
+        filter,
+        repository,
+        graphqlQueryParser,
+        objectMetadataItemWithFieldsMaps,
+      });
+
+      this.logger.log(`Found ${records.length} records in ${objectName}`);
+
       return {
         success: true,
-        message: `Found ${result.records.length} records in ${objectName}`,
+        message: `Found ${records.length} ${objectName} records`,
         result: {
-          records: result.records,
-          totalCount: result.totalCount,
+          records,
+          count: totalCount,
         },
       };
     } catch (error) {
@@ -65,10 +105,129 @@ export class FindRecordsService {
 
       return {
         success: false,
-        message: `Failed to find records in ${objectName}`,
+        message: `Failed to find ${objectName} records`,
         error:
           error instanceof Error ? error.message : 'Failed to find records',
       };
     }
   }
+
+  private applyRestrictedFieldsToQueryBuilder<T extends ObjectLiteral>(
+    queryBuilder: WorkspaceSelectQueryBuilder<T>,
+    repository: WorkspaceRepository<T>,
+    objectMetadataItemWithFieldsMaps: ObjectMetadataItemWithFieldMaps,
+  ): WorkspaceSelectQueryBuilder<T> {
+    const restrictedFields =
+      repository.objectRecordsPermissions?.[objectMetadataItemWithFieldsMaps.id]
+        ?.restrictedFields;
+
+    if (!restrictedFields || isEmpty(restrictedFields)) {
+      return queryBuilder;
+    }
+
+    const selectableFields = getAllSelectableColumnNames({
+      restrictedFields,
+      objectMetadata: {
+        objectMetadataMapItem: objectMetadataItemWithFieldsMaps,
+      },
+    });
+
+    return queryBuilder.setFindOptions({
+      // @ts-expect-error - TypeORM typing limitation with dynamic select fields
+      select: selectableFields,
+    });
+  }
+
+  private async getObjectRecords<T extends ObjectLiteral>({
+    objectName,
+    filter,
+    orderBy,
+    limit,
+    offset,
+    repository,
+    graphqlQueryParser,
+    objectMetadataItemWithFieldsMaps,
+  }: {
+    objectName: string;
+    filter:
+      | Partial<ObjectRecordFilter>
+      | Partial<ObjectRecordFilter>[]
+      | undefined;
+    orderBy: Partial<ObjectRecordOrderBy> | undefined;
+    limit: number | undefined;
+    offset: number;
+    repository: WorkspaceRepository<T>;
+    graphqlQueryParser: GraphqlQueryParser;
+    objectMetadataItemWithFieldsMaps: ObjectMetadataItemWithFieldMaps;
+  }): Promise<T[]> {
+    const queryBuilder = repository.createQueryBuilder(objectName);
+
+    const withFilterQueryBuilder = graphqlQueryParser.applyFilterToBuilder(
+      queryBuilder,
+      objectName,
+      filter ?? {},
+    );
+
+    const orderByWithIdCondition: ObjectRecordOrderBy = [
+      ...(orderBy ?? []).filter((item) => item !== undefined),
+      { id: OrderByDirection.AscNullsFirst },
+    ];
+
+    const withOrderByQueryBuilder = graphqlQueryParser.applyOrderToBuilder(
+      withFilterQueryBuilder,
+      orderByWithIdCondition,
+      objectName,
+      true,
+    );
+
+    const queryBuilderWithSelect = this.applyRestrictedFieldsToQueryBuilder(
+      withOrderByQueryBuilder,
+      repository,
+      objectMetadataItemWithFieldsMaps,
+    );
+
+    return queryBuilderWithSelect
+      .skip(offset)
+      .take(limit ? Math.min(limit, QUERY_MAX_RECORDS) : QUERY_MAX_RECORDS)
+      .getMany();
+  }
+
+  private async getTotalCount({
+    objectName,
+    filter,
+    repository,
+    graphqlQueryParser,
+    objectMetadataItemWithFieldsMaps,
+  }: {
+    objectName: string;
+    filter:
+      | Partial<ObjectRecordFilter>
+      | Partial<ObjectRecordFilter>[]
+      | undefined;
+    repository: WorkspaceRepository<ObjectLiteral>;
+    graphqlQueryParser: GraphqlQueryParser;
+    objectMetadataItemWithFieldsMaps: ObjectMetadataItemWithFieldMaps;
+  }): Promise<number> {
+    const countQueryBuilder = repository.createQueryBuilder(objectName);
+
+    const withFilterCountQueryBuilder = graphqlQueryParser.applyFilterToBuilder(
+      countQueryBuilder,
+      objectName,
+      filter ?? {},
+    );
+
+    const withDeletedCountQueryBuilder =
+      graphqlQueryParser.applyDeletedAtToBuilder(
+        withFilterCountQueryBuilder,
+        filter ?? {},
+      );
+
+    const queryBuilderWithSelect = this.applyRestrictedFieldsToQueryBuilder(
+      withDeletedCountQueryBuilder,
+      repository,
+      objectMetadataItemWithFieldsMaps,
+    );
+
+    return queryBuilderWithSelect.getCount();
+  }
 }

packages/twenty-server/src/engine/core-modules/record-crud/services/update-record.service.ts

@@ -1,17 +1,29 @@
 import { Injectable, Logger } from '@nestjs/common';
 
-import { CommonUpdateOneQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-update-one-query-runner.service';
+import deepEqual from 'deep-equal';
+import { isDefined, isValidUuid } from 'twenty-shared/utils';
+import { canObjectBeManagedByWorkflow } from 'twenty-shared/workflow';
+
+import {
+  RecordCrudException,
+  RecordCrudExceptionCode,
+} from 'src/engine/core-modules/record-crud/exceptions/record-crud.exception';
 import { type UpdateRecordParams } from 'src/engine/core-modules/record-crud/types/update-record-params.type';
-import { CommonApiContextBuilder } from 'src/engine/core-modules/record-crud/utils/common-api-context-builder.util';
+import { getSelectedColumnsFromRestrictedFields } from 'src/engine/core-modules/record-crud/utils/get-selected-columns-from-restricted-fields.util';
+import { RecordInputTransformerService } from 'src/engine/core-modules/record-transformer/services/record-input-transformer.service';
 import { type ToolOutput } from 'src/engine/core-modules/tool/types/tool-output.type';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 
 @Injectable()
+// eslint-disable-next-line @nx/workspace-inject-workspace-repository
 export class UpdateRecordService {
   private readonly logger = new Logger(UpdateRecordService.name);
 
   constructor(
-    private readonly commonUpdateOneRunner: CommonUpdateOneQueryRunnerService,
-    private readonly commonApiContextBuilder: CommonApiContextBuilder,
+    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly recordInputTransformerService: RecordInputTransformerService,
+    private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
   ) {}
 
   async execute(params: UpdateRecordParams): Promise<ToolOutput> {
@@ -19,37 +31,139 @@ export class UpdateRecordService {
       objectName,
       objectRecordId,
       objectRecord,
+      fieldsToUpdate,
       workspaceId,
       rolePermissionConfig,
-      userWorkspaceId,
-      apiKey,
-      createdBy,
     } = params;
 
+    if (!workspaceId) {
+      return {
+        success: false,
+        message: 'Failed to update record: Workspace ID is required',
+        error: 'Workspace ID not found',
+      };
+    }
+
+    if (!isDefined(objectRecordId) || !isValidUuid(objectRecordId)) {
+      return {
+        success: false,
+        message: 'Failed to update: Object record ID must be a valid UUID',
+        error: 'Invalid object record ID',
+      };
+    }
+
     try {
-      const { queryRunnerContext, selectedFields } =
-        await this.commonApiContextBuilder.build({
+      const repository =
+        await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+          workspaceId,
+          objectName,
+          rolePermissionConfig,
+        );
+
+      const { objectMetadataItemWithFieldsMaps } =
+        await this.workflowCommonWorkspaceService.getObjectMetadataItemWithFieldsMaps(
           objectName,
           workspaceId,
-          rolePermissionConfig,
-          userWorkspaceId,
-          apiKey,
-          actorContext: createdBy,
+        );
+
+      const restrictedFields =
+        repository.objectRecordsPermissions?.[
+          objectMetadataItemWithFieldsMaps.id
+        ]?.restrictedFields;
+
+      const selectedColumns = getSelectedColumnsFromRestrictedFields(
+        restrictedFields,
+        objectMetadataItemWithFieldsMaps,
+      );
+
+      const previousObjectRecord = await repository.findOne({
+        where: {
+          id: objectRecordId,
+        },
+        select: selectedColumns,
+      });
+
+      if (!previousObjectRecord) {
+        throw new RecordCrudException(
+          `Failed to update: Record ${objectName} with id ${objectRecordId} not found`,
+          RecordCrudExceptionCode.RECORD_NOT_FOUND,
+        );
+      }
+
+      const fieldsToUpdateArray = fieldsToUpdate || Object.keys(objectRecord);
+
+      if (fieldsToUpdateArray.length === 0) {
+        return {
+          success: true,
+          message: 'No fields to update',
+          result: previousObjectRecord,
+        };
+      }
+
+      if (
+        !canObjectBeManagedByWorkflow({
+          nameSingular: objectMetadataItemWithFieldsMaps.nameSingular,
+          isSystem: objectMetadataItemWithFieldsMaps.isSystem,
+        })
+      ) {
+        throw new RecordCrudException(
+          'Failed to update: Object cannot be updated by workflow',
+          RecordCrudExceptionCode.INVALID_REQUEST,
+        );
+      }
+
+      const objectRecordWithFilteredFields = Object.keys(objectRecord).reduce(
+        (acc, key) => {
+          if (fieldsToUpdateArray.includes(key)) {
+            return {
+              ...acc,
+              [key]: objectRecord[key],
+            };
+          }
+
+          return acc;
+        },
+        {},
+      );
+
+      const transformedObjectRecord =
+        await this.recordInputTransformerService.process({
+          recordInput: objectRecordWithFilteredFields,
+          objectMetadataMapItem: objectMetadataItemWithFieldsMaps,
         });
 
-      const result = await this.commonUpdateOneRunner.execute(
-        { id: objectRecordId, data: objectRecord, selectedFields },
-        queryRunnerContext,
-      );
+      const updatedObjectRecord = {
+        ...previousObjectRecord,
+        ...objectRecordWithFilteredFields,
+      };
+
+      if (!deepEqual(updatedObjectRecord, previousObjectRecord)) {
+        await repository.update(
+          objectRecordId,
+          {
+            ...transformedObjectRecord,
+          },
+          undefined,
+          selectedColumns,
+        );
+      }
 
       this.logger.log(`Record updated successfully in ${objectName}`);
 
       return {
         success: true,
         message: `Record updated successfully in ${objectName}`,
-        result,
+        result: updatedObjectRecord,
       };
     } catch (error) {
+      if (error instanceof RecordCrudException) {
+        return {
+          success: false,
+          message: `Failed to update record in ${objectName}`,
+          error: error.message,
+        };
+      }
+
       this.logger.error(`Failed to update record: ${error}`);
 
       return {

packages/twenty-server/src/engine/core-modules/record-crud/services/upsert-record.service.ts

@@ -1,56 +1,204 @@
 import { Injectable, Logger } from '@nestjs/common';
 
-import { CommonCreateOneQueryRunnerService } from 'src/engine/api/common/common-query-runners/common-create-one-query-runner.service';
-import { type UpsertRecordParams } from 'src/engine/core-modules/record-crud/types/upsert-record-params.type';
-import { CommonApiContextBuilder } from 'src/engine/core-modules/record-crud/utils/common-api-context-builder.util';
+import { isDefined } from 'twenty-shared/utils';
+import { canObjectBeManagedByWorkflow } from 'twenty-shared/workflow';
+
+import {
+  RecordCrudException,
+  RecordCrudExceptionCode,
+} from 'src/engine/core-modules/record-crud/exceptions/record-crud.exception';
+import { UpsertRecordParams } from 'src/engine/core-modules/record-crud/types/upsert-record-params.type';
+import { getSelectedColumnsFromRestrictedFields } from 'src/engine/core-modules/record-crud/utils/get-selected-columns-from-restricted-fields.util';
+import { RecordInputTransformerService } from 'src/engine/core-modules/record-transformer/services/record-input-transformer.service';
 import { type ToolOutput } from 'src/engine/core-modules/tool/types/tool-output.type';
+import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
+import { getCompositeTypeOrThrow } from 'src/engine/metadata-modules/field-metadata/utils/get-composite-type-or-throw.util';
+import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
+import { computeUniqueIndexWhereClause } from 'src/engine/metadata-modules/index-metadata/utils/compute-unique-index-where-clause.util';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 
 @Injectable()
+// eslint-disable-next-line @nx/workspace-inject-workspace-repository
 export class UpsertRecordService {
   private readonly logger = new Logger(UpsertRecordService.name);
 
   constructor(
-    private readonly commonCreateOneRunner: CommonCreateOneQueryRunnerService,
-    private readonly commonApiContextBuilder: CommonApiContextBuilder,
+    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly recordInputTransformerService: RecordInputTransformerService,
+    private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
   ) {}
 
   async execute(params: UpsertRecordParams): Promise<ToolOutput> {
-    const {
-      objectName,
-      objectRecord,
-      workspaceId,
-      rolePermissionConfig,
-      userWorkspaceId,
-      apiKey,
-      createdBy,
-    } = params;
+    const { objectName, objectRecord, workspaceId, rolePermissionConfig } =
+      params;
+
+    if (!workspaceId) {
+      return {
+        success: false,
+        message: 'Failed to upsert record: Workspace ID is required',
+        error: 'Workspace ID not found',
+      };
+    }
 
     try {
-      const { queryRunnerContext, selectedFields } =
-        await this.commonApiContextBuilder.build({
+      const repository =
+        await this.twentyORMGlobalManager.getRepositoryForWorkspace(
+          workspaceId,
+          objectName,
+          rolePermissionConfig,
+        );
+
+      const fieldsToUpdateArray = Object.keys(objectRecord).filter((field) =>
+        isDefined(objectRecord[field]),
+      );
+
+      const { objectMetadataItemWithFieldsMaps } =
+        await this.workflowCommonWorkspaceService.getObjectMetadataItemWithFieldsMaps(
           objectName,
           workspaceId,
-          rolePermissionConfig,
-          userWorkspaceId,
-          apiKey,
-          actorContext: createdBy,
+        );
+
+      if (
+        !canObjectBeManagedByWorkflow({
+          nameSingular: objectMetadataItemWithFieldsMaps.nameSingular,
+          isSystem: objectMetadataItemWithFieldsMaps.isSystem,
+        })
+      ) {
+        throw new RecordCrudException(
+          'Failed to update: Object cannot be updated by workflow',
+          RecordCrudExceptionCode.INVALID_REQUEST,
+        );
+      }
+
+      const objectRecordWithFilteredFields = Object.keys(objectRecord).reduce(
+        (acc, key) => {
+          if (fieldsToUpdateArray.includes(key)) {
+            return {
+              ...acc,
+              [key]: objectRecord[key],
+            };
+          }
+
+          return acc;
+        },
+        {},
+      );
+
+      const transformedObjectRecord =
+        await this.recordInputTransformerService.process({
+          recordInput: objectRecordWithFilteredFields,
+          objectMetadataMapItem: objectMetadataItemWithFieldsMaps,
         });
 
-      // Use Common API's built-in upsert functionality
-      // This handles finding existing records by unique fields and updating or inserting
-      const result = await this.commonCreateOneRunner.execute(
-        { data: objectRecord, selectedFields, upsert: true },
-        queryRunnerContext,
+      const uniqueFieldsToUpdate = fieldsToUpdateArray
+        .map(
+          (field) =>
+            objectMetadataItemWithFieldsMaps.fieldIdByName[field] ||
+            objectMetadataItemWithFieldsMaps.fieldIdByJoinColumnName[field],
+        )
+        .map((fieldId) => objectMetadataItemWithFieldsMaps.fieldsById[fieldId])
+        .filter((field) => field && (field.isUnique || field.name === 'id'));
+
+      const conflictPathsUniqueFieldsToUpdate = uniqueFieldsToUpdate.flatMap(
+        (field) => {
+          if (isCompositeFieldMetadataType(field.type)) {
+            const compositeType = getCompositeTypeOrThrow(field.type);
+
+            const uniqueProperties = compositeType.properties.filter(
+              (prop) => prop.isIncludedInUniqueConstraint,
+            );
+
+            const propertiesToUse =
+              uniqueProperties.length > 0
+                ? uniqueProperties
+                : [compositeType.properties[0]];
+
+            return propertiesToUse.map((prop) =>
+              computeCompositeColumnName(field, prop),
+            );
+          }
+
+          return [field.name];
+        },
       );
 
+      const conflictPaths =
+        conflictPathsUniqueFieldsToUpdate.length > 0
+          ? conflictPathsUniqueFieldsToUpdate
+          : ['id'];
+
+      const indexPredicate = uniqueFieldsToUpdate
+        .map((field) =>
+          computeUniqueIndexWhereClause({
+            type: field.type,
+            name: field.name,
+          }),
+        )
+        .filter(isDefined);
+
+      const restrictedFields =
+        repository.objectRecordsPermissions?.[
+          objectMetadataItemWithFieldsMaps.id
+        ]?.restrictedFields;
+
+      const selectedColumns = getSelectedColumnsFromRestrictedFields(
+        restrictedFields,
+        objectMetadataItemWithFieldsMaps,
+      );
+
+      const upsertResult = await repository.upsert(
+        transformedObjectRecord,
+        {
+          conflictPaths: conflictPaths,
+          indexPredicate:
+            indexPredicate.length > 0
+              ? `${indexPredicate.join(' AND ')}`
+              : undefined,
+        },
+        undefined,
+        selectedColumns,
+      );
+
+      const upsertedRecordId = upsertResult.identifiers?.[0].id;
+
+      if (!isDefined(upsertedRecordId)) {
+        throw new RecordCrudException(
+          `Failed to upsert record in ${objectName}`,
+          RecordCrudExceptionCode.RECORD_UPSERT_FAILED,
+        );
+      }
+
+      const upsertedRecord = await repository.findOne({
+        where: {
+          id: upsertedRecordId,
+        },
+        select: selectedColumns,
+      });
+
+      if (!upsertedRecord) {
+        throw new RecordCrudException(
+          `Record not found after upsert with id ${upsertedRecordId} in ${objectName}`,
+          RecordCrudExceptionCode.RECORD_UPSERT_FAILED,
+        );
+      }
+
       this.logger.log(`Record upserted successfully in ${objectName}`);
 
       return {
         success: true,
         message: `Record upserted successfully in ${objectName}`,
-        result,
+        result: upsertedRecord,
       };
     } catch (error) {
+      if (error instanceof RecordCrudException) {
+        return {
+          success: false,
+          message: `Failed to upsert record in ${objectName}`,
+          error: error.message,
+        };
+      }
+
       this.logger.error(`Failed to upsert record: ${error}`);
 
       return {

packages/twenty-server/src/engine/core-modules/record-crud/types/execution-context.type.ts

@@ -1,14 +1,10 @@
 import { type ActorMetadata } from 'twenty-shared/types';
 
-import { type ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
 import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
 
 export type RecordCrudExecutionContext = {
   workspaceId: string;
   rolePermissionConfig?: RolePermissionConfig;
-  userWorkspaceId?: string;
-  apiKey?: ApiKeyEntity;
-  createdBy?: ActorMetadata;
 };
 
 export type CreateRecordExecutionContext = RecordCrudExecutionContext & {

packages/twenty-server/src/engine/core-modules/record-crud/types/find-records-params.type.ts

@@ -13,6 +13,6 @@ export type FindRecordsParams = FindRecordsInput &
       | Record<string, unknown>[]
       | Partial<ObjectRecordFilter>
       | Partial<ObjectRecordFilter>[];
-    orderBy?: ObjectRecordOrderBy;
+    orderBy?: Partial<ObjectRecordOrderBy>;
     offset?: number;
   };

packages/twenty-server/src/engine/core-modules/record-crud/types/record-crud-input.type.ts

@@ -35,7 +35,7 @@ export type FindRecordsInput = {
   orderBy?: {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     recordSorts?: any;
-    gqlOperationOrderBy?: ObjectRecordOrderBy;
+    gqlOperationOrderBy?: Partial<ObjectRecordOrderBy>;
   };
   limit?: number;
 };

packages/twenty-server/src/engine/core-modules/record-crud/utils/common-api-context-builder.util.ts

@@ -1,114 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { type ActorMetadata } from 'twenty-shared/types';
-
-import { type ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
-import { type ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
-import { WorkspaceMetadataCacheService } from 'src/engine/metadata-modules/workspace-metadata-cache/services/workspace-metadata-cache.service';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
-import { type CommonBaseQueryRunnerContext } from 'src/engine/api/common/types/common-base-query-runner-context.type';
-import { type AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
-
-@Injectable()
-export class CommonApiContextBuilder {
-  constructor(
-    private readonly workspaceMetadataCache: WorkspaceMetadataCacheService,
-  ) {}
-
-  async build(params: {
-    objectName: string;
-    workspaceId: string;
-    userWorkspaceId?: string;
-    apiKey?: ApiKeyEntity;
-    rolePermissionConfig?: RolePermissionConfig;
-    actorContext?: ActorMetadata;
-  }): Promise<{
-    queryRunnerContext: CommonBaseQueryRunnerContext;
-    selectedFields: Record<string, boolean>;
-  }> {
-    if (!params.userWorkspaceId && !params.apiKey) {
-      throw new Error(
-        'Either userWorkspaceId or apiKey is required for Common API operations',
-      );
-    }
-
-    const { objectMetadataMaps } =
-      await this.workspaceMetadataCache.getExistingOrRecomputeMetadataMaps({
-        workspaceId: params.workspaceId,
-      });
-
-    const objectMetadata = this.getObjectMetadataOrThrow(
-      params.objectName,
-      objectMetadataMaps,
-    );
-
-    const authContext = this.buildAuthContext(
-      params.workspaceId,
-      params.userWorkspaceId,
-      params.apiKey,
-      params.actorContext,
-    );
-
-    const selectedFields = this.buildSelectedFields(objectMetadata);
-
-    return {
-      queryRunnerContext: {
-        authContext,
-        objectMetadataItemWithFieldMaps: objectMetadata,
-        objectMetadataMaps,
-      },
-      selectedFields,
-    };
-  }
-
-  private getObjectMetadataOrThrow(
-    objectName: string,
-    objectMetadataMaps: {
-      byId: Partial<Record<string, ObjectMetadataItemWithFieldMaps>>;
-      idByNameSingular: Partial<Record<string, string>>;
-    },
-  ): ObjectMetadataItemWithFieldMaps {
-    const objectMetadataId = objectMetadataMaps.idByNameSingular[objectName];
-
-    if (!objectMetadataId) {
-      throw new Error(`Object ${objectName} not found in workspace`);
-    }
-
-    const objectMetadata = objectMetadataMaps.byId[objectMetadataId];
-
-    if (!objectMetadata) {
-      throw new Error(`Object metadata not found for ${objectName}`);
-    }
-
-    return objectMetadata;
-  }
-
-  private buildAuthContext(
-    workspaceId: string,
-    userWorkspaceId?: string,
-    apiKey?: ApiKeyEntity,
-    actorContext?: ActorMetadata,
-  ): AuthContext {
-    // Workspace object is intentionally minimal - the Common API validates
-    // and enriches the auth context internally
-    return {
-      workspace: { id: workspaceId } as unknown as AuthContext['workspace'],
-      workspaceMemberId: actorContext?.workspaceMemberId ?? undefined,
-      userWorkspaceId,
-      apiKey,
-      user: null,
-    };
-  }
-
-  private buildSelectedFields(
-    objectMetadata: ObjectMetadataItemWithFieldMaps,
-  ): Record<string, boolean> {
-    const selectedFields: Record<string, boolean> = { id: true };
-
-    for (const fieldName of Object.keys(objectMetadata.fieldIdByName)) {
-      selectedFields[fieldName] = true;
-    }
-
-    return selectedFields;
-  }
-}

packages/twenty-server/src/engine/core-modules/workspace/workspace.module.ts

@@ -28,6 +28,7 @@ import { WorkspaceWorkspaceMemberListener } from 'src/engine/core-modules/worksp
 import { workspaceAutoResolverOpts } from 'src/engine/core-modules/workspace/workspace.auto-resolver-opts';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { WorkspaceResolver } from 'src/engine/core-modules/workspace/workspace.resolver';
+import { AgentModule } from 'src/engine/metadata-modules/agent/agent.module';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
 import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
 import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
@@ -64,6 +65,7 @@ import { WorkspaceManagerModule } from 'src/engine/workspace-manager/workspace-m
         PermissionsModule,
         WorkspaceCacheStorageModule,
         RoleModule,
+        AgentModule,
         DnsManagerModule,
         WorkspaceDomainsModule,
         SubdomainManagerModule,