@wildo-ai/saas-backend-lib 1.0.1

package/src/__tests__/integration/postgresql-delete-best-effort-boundary.integration.test.ts

@@ -0,0 +1,604 @@
+import 'reflect-metadata';
+import { randomUUID } from 'node:crypto';
+import { Container } from 'inversify';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Kysely, PostgresDialect, sql } from 'kysely';
+import { newDb } from 'pg-mem';
+import { z } from 'zod';
+import { ensureZodDecoratorsLoaded, z_file } from '@wildo-ai/zod-decorators';
+import {
+  ChildLifecycleMode,
+  CoreResourceOperation,
+  CoreResourceType,
+  createResourceConfiguration_Initialization,
+  createResourcesRelationship,
+  ExecutionContext_ExecutionType,
+  FileUploaderEntityType,
+  FileStatus,
+  RelationshipNature,
+  ResourceOperationRiskLevel,
+  ResourceOperationVariantType,
+  ResourcePrimaryScope,
+  ResourceRelationshipCardinality,
+  type ResourceType,
+} from '@wildo-ai/saas-models';
+
+import { createTestContainer, getMocks, resetMocks } from '~wildo-backend-lib/__tests__/test-container';
+import { RepositoriesRegistryHandlerBackendService } from '~wildo-backend-lib/base-classes/services/repositories/repositories-registry-handler.backend.service';
+import { ResourceOperationHelperBackendService } from '~wildo-backend-lib/base-classes/services/resource-operations-helper.backend.service';
+import { ServiceResourceBackendService } from '~wildo-backend-lib/base-classes/services/services/services-registry-handler.backend.service';
+import { MockMongoDBService } from '~wildo-backend-lib/databases/services/__tests__/mock-mongodb.service';
+import { createTransactionContext } from '~wildo-backend-lib/databases/models/transaction.shared.schemas';
+import { PostgreSQLDatabaseBackendService } from '~wildo-backend-lib/databases/services/postgresql-database.backend.service';
+import { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';
+import { ResourcesRegistryBackendService } from '~wildo-backend-lib/resources/services/resources-registry.backend.service';
+import { ExecutionContext } from '~wildo-backend-lib/runtime/models/execution-context.backend.schemas';
+
+ensureZodDecoratorsLoaded(z);
+
+describe('PostgreSQL delete best-effort boundary integration', () => {
+  let container: Container;
+  let resourceRegistry: ResourcesRegistryBackendService;
+  let repositoriesRegistry: RepositoriesRegistryHandlerBackendService;
+  let closePostgreSQL: (() => Promise<void>) | null = null;
+
+  const projectsResourceType = 'postgres_projects' as ResourceType;
+  const membershipsResourceType = 'postgres_project_memberships' as ResourceType;
+  const organizationId = 'org-1';
+  const userId = 'user-1';
+  const parentFileId = '507f1f77bcf86cd799439501';
+  const childFileId = '507f1f77bcf86cd799439502';
+  const fileUpdatedAt = new Date('2026-03-31T00:00:00.000Z');
+
+  function createLifecycleRelationship() {
+    return createResourcesRelationship(
+      projectsResourceType,
+      membershipsResourceType,
+      ResourceRelationshipCardinality.ONE,
+      ResourceRelationshipCardinality.MANY,
+      {
+        nature: RelationshipNature.COMPOSITION,
+        foreignKeyField: 'projectId',
+        childOperations: {
+          lifecycle: {
+            onParentDelete: {
+              enabled: true,
+              mode: ChildLifecycleMode.IMMEDIATE,
+              maxDepth: 1,
+            },
+          },
+        },
+      }
+    );
+  }
+
+  function buildOperationsConfiguration(operations: CoreResourceOperation[]) {
+    return Object.fromEntries(
+      operations.map((operation) => [operation, {
+        variants: [{
+          variantType: ResourceOperationVariantType.API_CALL,
+          isDefault: true,
+          roles: ['APP_USER'],
+          riskLevel:
+            operation === CoreResourceOperation.DELETE
+            || operation === CoreResourceOperation.DELETE_MANY
+              ? ResourceOperationRiskLevel.HIGH
+              : ResourceOperationRiskLevel.MEDIUM,
+        }],
+      }])
+    );
+  }
+
+  function createProjectsFactory() {
+    const lifecycleRelationship = createLifecycleRelationship();
+    return () => createResourceConfiguration_Initialization({
+      mainSchema: z.object({
+        _id: z.string().optional(),
+        organizationId: z.string().optional(),
+        name: z.string().min(1),
+        attachment: z_file(),
+      }),
+      resourceIdentifier: projectsResourceType,
+      resourceFieldIdentifier: '_id',
+      persistenceAdapter: 'postgresql',
+      resourceRelationships: [lifecycleRelationship],
+      coreOperations: [
+        CoreResourceOperation.CREATE,
+        CoreResourceOperation.READ,
+        CoreResourceOperation.LIST,
+        CoreResourceOperation.DELETE,
+        CoreResourceOperation.DELETE_MANY,
+      ],
+      operationsConfiguration: buildOperationsConfiguration([
+        CoreResourceOperation.CREATE,
+        CoreResourceOperation.READ,
+        CoreResourceOperation.LIST,
+        CoreResourceOperation.DELETE,
+        CoreResourceOperation.DELETE_MANY,
+      ]) as any,
+    });
+  }
+
+  function createMembershipsFactory() {
+    const lifecycleRelationship = createLifecycleRelationship();
+    return () => createResourceConfiguration_Initialization({
+      mainSchema: z.object({
+        _id: z.string().optional(),
+        organizationId: z.string().optional(),
+        projectId: z.string(),
+        role: z.string(),
+        attachment: z_file(),
+      }),
+      resourceIdentifier: membershipsResourceType,
+      resourceFieldIdentifier: '_id',
+      persistenceAdapter: 'postgresql',
+      resourceRelationships: [lifecycleRelationship],
+      coreOperations: [
+        CoreResourceOperation.CREATE,
+        CoreResourceOperation.READ,
+        CoreResourceOperation.LIST,
+        CoreResourceOperation.DELETE_MANY,
+      ],
+      operationsConfiguration: buildOperationsConfiguration([
+        CoreResourceOperation.CREATE,
+        CoreResourceOperation.READ,
+        CoreResourceOperation.LIST,
+        CoreResourceOperation.DELETE_MANY,
+      ]) as any,
+    });
+  }
+
+  function createExecutionContext(operation: any) {
+    return new ExecutionContext(
+      operation,
+      ExecutionContext_ExecutionType.USER_REQUEST,
+      new Map([['organizationId', organizationId]]),
+      {
+        userId,
+        organizationId,
+        applicationId: 'app-1',
+      },
+      [],
+      [],
+      'request-postgres-delete-boundary-1',
+      0,
+      new Set(),
+      'APP_USER',
+    );
+  }
+
+  function getOperation(resourceType: ResourceType, operationIdentifier: CoreResourceOperation) {
+    const operation = resourceRegistry
+      .getResourceConfiguration(resourceType)
+      .operations
+      .find((candidate) => candidate.operationIdentifier === operationIdentifier);
+
+    expect(operation).toBeDefined();
+    return operation!;
+  }
+
+  function buildFileValue(fileId: string) {
+    return {
+      fileId,
+      updatedAt: fileUpdatedAt,
+    };
+  }
+
+  async function seedFileDocument(
+    fileId: string,
+    linkedResourceType: ResourceType,
+    linkedResourceId: string,
+  ) {
+    const { zodConverter } = getMocks(container);
+    const filesModel = zodConverter.getModel(CoreResourceType.FILES) as any;
+
+    expect(filesModel).toBeDefined();
+
+    await filesModel.create({
+      _id: fileId,
+      fileId,
+      filename: `${fileId}.bin`,
+      originalFilename: `${fileId}.bin`,
+      mimeType: 'application/octet-stream',
+      size: 128,
+      extension: 'bin',
+      storageKey: `org/${organizationId}/${fileId}`,
+      uploadedBy: userId,
+      uploadedByEntityType: FileUploaderEntityType.USER,
+      primaryScope: ResourcePrimaryScope.ORGANIZATIONS,
+      organizationId,
+      status: FileStatus.LINKED,
+      linkedResourceType,
+      linkedResourceId,
+      linkedFieldName: 'attachment',
+      uploadedAt: new Date('2026-03-31T00:00:00.000Z'),
+      updatedAt: new Date('2026-03-31T00:00:00.000Z'),
+    });
+  }
+
+  async function createInMemoryPostgreSQL() {
+    const database = newDb({
+      autoCreateForeignKeyIndices: true,
+    });
+    database.public.registerFunction({
+      name: 'gen_random_uuid',
+      returns: 'uuid',
+      implementation: () => randomUUID(),
+    });
+    const pg = database.adapters.createPg();
+    const pool = new pg.Pool();
+    const db = new Kysely<any>({
+      dialect: new PostgresDialect({ pool }),
+    });
+
+    await sql`
+      create table "postgres_projects" (
+        "_id" uuid primary key default gen_random_uuid(),
+        "organizationId" text,
+        "name" text not null,
+        "attachment" jsonb
+      )
+    `.execute(db);
+
+    await sql`
+      create table "postgres_project_memberships" (
+        "_id" uuid primary key default gen_random_uuid(),
+        "organizationId" text,
+        "projectId" uuid not null,
+        "role" text not null,
+        "attachment" jsonb
+      )
+    `.execute(db);
+
+    return {
+      database,
+      db,
+      async close() {
+        await db.destroy();
+        await pool.end();
+      },
+    };
+  }
+
+  async function createHarness(
+    fileIdsByResourceId: Map<string, string>,
+    options?: {
+      emulatePostgreSQLRollbackWithSnapshot?: boolean;
+    },
+  ) {
+    const { logger, errorBuilder, operationHelper, config } = getMocks(container);
+    const mongoDBService = new MockMongoDBService();
+    const postgreSQLDatabaseService = container.get(
+      SAAS_SERVICE_TYPES.PostgreSQLDatabaseService
+    ) as PostgreSQLDatabaseBackendService;
+    const inMemoryPostgreSQL = await createInMemoryPostgreSQL();
+    closePostgreSQL = inMemoryPostgreSQL.close;
+    vi.spyOn(postgreSQLDatabaseService, 'getDb').mockResolvedValue(inMemoryPostgreSQL.db);
+    if (options?.emulatePostgreSQLRollbackWithSnapshot) {
+      vi.spyOn(postgreSQLDatabaseService, 'executeTransaction').mockImplementation(async (callback: any) => {
+        const backup = inMemoryPostgreSQL.database.backup();
+
+        try {
+          return await callback(createTransactionContext(inMemoryPostgreSQL.db, 'postgresql'));
+        } catch (error) {
+          backup.restore();
+          throw error;
+        }
+      });
+    }
+    const filesRepository = repositoriesRegistry.getRepositoryOrThrow(CoreResourceType.FILES) as any;
+    const fileOperationHandler = {
+      processFileFieldsForDelete: vi.fn(async (
+        resourceType: ResourceType,
+        resourceId: string,
+        executionContext: ExecutionContext<any>,
+        options?: any,
+      ) => {
+        const fileId = fileIdsByResourceId.get(resourceId);
+        if (!fileId) {
+          return;
+        }
+
+        await filesRepository.update(
+          executionContext,
+          { fileId },
+          {
+            status: FileStatus.DELETED,
+            deletedAt: fileUpdatedAt,
+            updatedAt: fileUpdatedAt,
+          },
+          options,
+        );
+      }),
+      processFileFieldsForCreate: vi.fn(),
+      processFileFieldsForUpdate: vi.fn(),
+      validateFileFieldsForCreate: vi.fn(),
+    } as any;
+    const fileFieldDetection = {
+      hasFileFields: vi.fn((resourceType: ResourceType) =>
+        resourceType === projectsResourceType || resourceType === membershipsResourceType
+      ),
+    } as any;
+
+    const service = new ServiceResourceBackendService(
+      projectsResourceType,
+      resourceRegistry,
+      logger as any,
+      errorBuilder as any,
+      operationHelper as any,
+      {} as any,
+      repositoriesRegistry,
+      {
+        dispatchPostOperationHooks: vi.fn().mockResolvedValue(undefined),
+        getService: vi.fn((resourceType: ResourceType) =>
+          resourceType === membershipsResourceType ? {} : undefined
+        ),
+      } as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      mongoDBService as any,
+      fileOperationHandler,
+      fileFieldDetection,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      config as any,
+      undefined,
+      undefined,
+      undefined,
+      postgreSQLDatabaseService,
+    );
+
+    (service as any).validateAndTransformInput = vi.fn(async (_executionContext: unknown, data: any) => data);
+    (service as any).applyBusinessValidation = vi.fn(async (_operation: unknown, data: any) => data);
+    (service as any).executePreOperationLogic = vi.fn(async (_operation: unknown, data: any) => data);
+    (service as any).executeAdditionalPostOperationLogic = vi.fn(async () => undefined);
+
+    return {
+      db: inMemoryPostgreSQL.db,
+      childRepository: repositoriesRegistry.getRepositoryOrThrow(membershipsResourceType) as any,
+      fileOperationHandler,
+      filesRepository,
+      mongoDBService,
+      parentRepository: repositoriesRegistry.getRepositoryOrThrow(projectsResourceType) as any,
+      postgreSQLDatabaseService,
+      service,
+    };
+  }
+
+  beforeEach(async () => {
+    container = createTestContainer();
+    resourceRegistry = container.get(SAAS_SERVICE_TYPES.ResourceRegistryService);
+    repositoriesRegistry = container.get(SAAS_SERVICE_TYPES.RepositoriesRegistryHandlerService);
+
+    const { config, logger, errorBuilder, operationHelper } = getMocks(container);
+    config.config.database.postgresql = { enabled: true } as any;
+    const realHelper = new ResourceOperationHelperBackendService(
+      logger as any,
+      errorBuilder as any,
+      undefined,
+    );
+    Object.assign(operationHelper, {
+      cleanInputData: vi.fn(realHelper.cleanInputData.bind(realHelper)),
+      cleanInputDataArray: vi.fn(realHelper.cleanInputDataArray.bind(realHelper)),
+      enrichDataWithContext: vi.fn(realHelper.enrichDataWithContext.bind(realHelper)),
+      findNestedFieldPathsFromZodSchema: vi.fn(realHelper.findNestedFieldPathsFromZodSchema.bind(realHelper)),
+      findRequiredNestedFieldPathsFromZodSchema: vi.fn(realHelper.findRequiredNestedFieldPathsFromZodSchema.bind(realHelper)),
+      hasNestedPath: vi.fn(realHelper.hasNestedPath.bind(realHelper)),
+      injectNonDiscriminatorLiteralValues: vi.fn(realHelper.injectNonDiscriminatorLiteralValues.bind(realHelper)),
+      setNestedValue: vi.fn(realHelper.setNestedValue.bind(realHelper)),
+    });
+
+    await resourceRegistry.initialize(
+      {
+        [projectsResourceType]: createProjectsFactory(),
+        [membershipsResourceType]: createMembershipsFactory(),
+      } as any,
+      {
+        [projectsResourceType]: '_id',
+        [membershipsResourceType]: '_id',
+      },
+      [],
+      {},
+      {},
+      [],
+    );
+
+    const registry = resourceRegistry.getResourcesRegistry();
+    const resourceConfigs = new Map(Object.entries(registry.resourceConfigurations));
+    await repositoriesRegistry.initializeRepositories(resourceConfigs as any);
+  });
+
+  afterEach(async () => {
+    if (closePostgreSQL) {
+      await closePostgreSQL();
+      closePostgreSQL = null;
+    }
+    vi.restoreAllMocks();
+    resetMocks(container);
+  });
+
+  it('shows the PostgreSQL bulk best-effort boundary when Mongo file cleanup commits before the SQL delete stage fails', async () => {
+    const firstProjectId = randomUUID();
+    const secondProjectId = randomUUID();
+    const harness = await createHarness(new Map([
+      [firstProjectId, parentFileId],
+      [secondProjectId, childFileId],
+    ]));
+    const deleteManyOperation = getOperation(projectsResourceType, CoreResourceOperation.DELETE_MANY);
+    const listOperation = getOperation(projectsResourceType, CoreResourceOperation.LIST);
+
+    await sql`
+      insert into "postgres_projects" ("_id", "organizationId", "name", "attachment")
+      values
+        (${firstProjectId}, ${organizationId}, ${'Project A'}, ${JSON.stringify(buildFileValue(parentFileId))}::jsonb),
+        (${secondProjectId}, ${organizationId}, ${'Project B'}, ${JSON.stringify(buildFileValue(childFileId))}::jsonb)
+    `.execute(harness.db);
+
+    await seedFileDocument(parentFileId, projectsResourceType, firstProjectId);
+    await seedFileDocument(childFileId, projectsResourceType, secondProjectId);
+
+    vi.spyOn(harness.service as any, 'callRepository').mockRejectedValueOnce(
+      new Error('postgres bulk delete failed after file cleanup')
+    );
+
+    await expect(
+      harness.service.deleteMany(
+        deleteManyOperation,
+        createExecutionContext(deleteManyOperation),
+        [firstProjectId, secondProjectId],
+        undefined,
+      ),
+    ).rejects.toThrow('postgres bulk delete failed after file cleanup');
+
+    const persistedFirstProject = await harness.parentRepository.read(
+      createExecutionContext(listOperation),
+      firstProjectId,
+      undefined,
+    ) as any;
+    const persistedSecondProject = await harness.parentRepository.read(
+      createExecutionContext(listOperation),
+      secondProjectId,
+      undefined,
+    ) as any;
+    const persistedFirstFile = await harness.filesRepository.read(
+      createExecutionContext(listOperation),
+      { fileId: parentFileId },
+      undefined,
+    ) as any;
+    const persistedSecondFile = await harness.filesRepository.read(
+      createExecutionContext(listOperation),
+      { fileId: childFileId },
+      undefined,
+    ) as any;
+
+    expect(persistedFirstProject).toEqual(expect.objectContaining({ _id: firstProjectId }));
+    expect(persistedSecondProject).toEqual(expect.objectContaining({ _id: secondProjectId }));
+    expect(persistedFirstFile).toEqual(expect.objectContaining({
+      fileId: parentFileId,
+      status: FileStatus.DELETED,
+      linkedResourceId: firstProjectId,
+    }));
+    expect(persistedSecondFile).toEqual(expect.objectContaining({
+      fileId: childFileId,
+      status: FileStatus.DELETED,
+      linkedResourceId: secondProjectId,
+    }));
+    expect(harness.mongoDBService.executeTransaction).toHaveBeenCalledTimes(1);
+    expect(harness.fileOperationHandler.processFileFieldsForDelete).toHaveBeenNthCalledWith(
+      1,
+      projectsResourceType,
+      firstProjectId,
+      expect.anything(),
+      expect.objectContaining({ transaction: expect.objectContaining({ databaseType: 'mongodb' }) }),
+    );
+    expect(harness.fileOperationHandler.processFileFieldsForDelete).toHaveBeenNthCalledWith(
+      2,
+      projectsResourceType,
+      secondProjectId,
+      expect.anything(),
+      expect.objectContaining({ transaction: expect.objectContaining({ databaseType: 'mongodb' }) }),
+    );
+  });
+
+  it('shows the lifecycle best-effort boundary when a pg-mem snapshot restore replays SQL rollback after parent and child file cleanup commit', async () => {
+    const projectId = randomUUID();
+    const membershipId = randomUUID();
+    const parentLifecycleFileId = '507f1f77bcf86cd799439503';
+    const childLifecycleFileId = '507f1f77bcf86cd799439504';
+    const harness = await createHarness(
+      new Map([
+        [projectId, parentLifecycleFileId],
+        [membershipId, childLifecycleFileId],
+      ]),
+      {
+        emulatePostgreSQLRollbackWithSnapshot: true,
+      },
+    );
+    const deleteOperation = getOperation(projectsResourceType, CoreResourceOperation.DELETE);
+    const listOperation = getOperation(projectsResourceType, CoreResourceOperation.LIST);
+    const childListOperation = getOperation(membershipsResourceType, CoreResourceOperation.LIST);
+
+    await sql`
+      insert into "postgres_projects" ("_id", "organizationId", "name", "attachment")
+      values (${projectId}, ${organizationId}, ${'Lifecycle project'}, ${JSON.stringify(buildFileValue(parentLifecycleFileId))}::jsonb)
+    `.execute(harness.db);
+
+    await sql`
+      insert into "postgres_project_memberships" ("_id", "organizationId", "projectId", "role", "attachment")
+      values (${membershipId}, ${organizationId}, ${projectId}, ${'OWNER'}, ${JSON.stringify(buildFileValue(childLifecycleFileId))}::jsonb)
+    `.execute(harness.db);
+
+    await seedFileDocument(parentLifecycleFileId, projectsResourceType, projectId);
+    await seedFileDocument(childLifecycleFileId, membershipsResourceType, membershipId);
+
+    vi.spyOn(harness.childRepository, 'deleteMany').mockRejectedValueOnce(
+      new Error('postgres lifecycle child delete failed after file cleanup')
+    );
+
+    await expect(
+      harness.service.delete(
+        deleteOperation,
+        createExecutionContext(deleteOperation),
+        projectId,
+        undefined,
+      ),
+    ).rejects.toThrow('postgres lifecycle child delete failed after file cleanup');
+
+    const persistedProject = await harness.parentRepository.read(
+      createExecutionContext(listOperation),
+      projectId,
+      undefined,
+    ) as any;
+    const persistedMemberships = await harness.childRepository.list(
+      createExecutionContext(childListOperation),
+      { projectId: { $in: [projectId] } },
+      undefined,
+    ) as any[];
+    const persistedParentFile = await harness.filesRepository.read(
+      createExecutionContext(listOperation),
+      { fileId: parentLifecycleFileId },
+      undefined,
+    ) as any;
+    const persistedChildFile = await harness.filesRepository.read(
+      createExecutionContext(listOperation),
+      { fileId: childLifecycleFileId },
+      undefined,
+    ) as any;
+
+    expect(persistedProject).toEqual(expect.objectContaining({ _id: projectId }));
+    expect(persistedMemberships.map((item) => item._id)).toEqual([membershipId]);
+    expect(persistedParentFile).toEqual(expect.objectContaining({
+      fileId: parentLifecycleFileId,
+      status: FileStatus.DELETED,
+      linkedResourceId: projectId,
+      linkedResourceType: projectsResourceType,
+    }));
+    expect(persistedChildFile).toEqual(expect.objectContaining({
+      fileId: childLifecycleFileId,
+      status: FileStatus.DELETED,
+      linkedResourceId: membershipId,
+      linkedResourceType: membershipsResourceType,
+    }));
+    expect(harness.mongoDBService.executeTransaction).toHaveBeenCalledTimes(2);
+    expect(harness.fileOperationHandler.processFileFieldsForDelete).toHaveBeenNthCalledWith(
+      1,
+      projectsResourceType,
+      projectId,
+      expect.anything(),
+      expect.objectContaining({ transaction: expect.objectContaining({ databaseType: 'mongodb' }) }),
+    );
+    expect(harness.fileOperationHandler.processFileFieldsForDelete).toHaveBeenNthCalledWith(
+      2,
+      membershipsResourceType,
+      membershipId,
+      expect.anything(),
+      expect.objectContaining({ transaction: expect.objectContaining({ databaseType: 'mongodb' }) }),
+    );
+  });
+});