@wildo-ai/saas-backend-lib 1.0.1

package/src/__tests__/integration/file-management-postgresql-persistence.integration.test.ts

@@ -0,0 +1,466 @@
+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 {
+  CoreResourceOperation,
+  ExecutionContext_ExecutionType,
+  FileStatus,
+  ResourceOperationRiskLevel,
+  ResourceOperationVariantType,
+  createResourceConfiguration_Initialization,
+  type ResourceType,
+} from '@wildo-ai/saas-models';
+
+import { createTestContainer, getMocks, resetMocks } from '~wildo-backend-lib/__tests__/test-container';
+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 { RepositoriesRegistryHandlerBackendService } from '~wildo-backend-lib/base-classes/services/repositories/repositories-registry-handler.backend.service';
+import { ServiceResourceBackendService } from '~wildo-backend-lib/base-classes/services/services/services-registry-handler.backend.service';
+import { FileFieldDetectionBackendService } from '~wildo-backend-lib/files/services/file-field-detection.backend.service';
+import { FileOperationHandlerBackendService } from '~wildo-backend-lib/files/services/file-operation-handler.backend.service';
+import { ExecutionContext } from '~wildo-backend-lib/runtime/models/execution-context.backend.schemas';
+import { MockMongoDBService } from '~wildo-backend-lib/databases/services/__tests__/mock-mongodb.service';
+import { ResourceOperationHelperBackendService } from '~wildo-backend-lib/base-classes/services/resource-operations-helper.backend.service';
+import { PostgreSQLDatabaseBackendService } from '~wildo-backend-lib/databases/services/postgresql-database.backend.service';
+
+ensureZodDecoratorsLoaded(z);
+
+describe('PostgreSQL file persistence integration', () => {
+  let container: Container;
+  let resourceRegistry: ResourcesRegistryBackendService;
+  let repositoriesRegistry: RepositoriesRegistryHandlerBackendService;
+  let closePostgreSQL: (() => Promise<void>) | null = null;
+
+  const resourceType = 'postgres_profiles' as ResourceType;
+  const originalFileId = '507f1f77bcf86cd799439201';
+  const replacementFileId = '507f1f77bcf86cd799439202';
+  const fileUpdatedAt = new Date('2026-03-31T00:00:00.000Z');
+
+  function createProfilesFactory() {
+    return () => createResourceConfiguration_Initialization({
+      mainSchema: z.object({
+        _id: z.string().optional(),
+        organizationId: z.string().optional(),
+        name: z.string().min(1),
+        attachment: z_file(),
+      }),
+      resourceIdentifier: resourceType,
+      resourceFieldIdentifier: '_id',
+      persistenceAdapter: 'postgresql',
+      resourceRelationships: [],
+      coreOperations: [
+        CoreResourceOperation.CREATE,
+        CoreResourceOperation.READ,
+        CoreResourceOperation.UPDATE,
+      ],
+      operationsConfiguration: {
+        [CoreResourceOperation.CREATE]: {
+          variants: [{
+            variantType: ResourceOperationVariantType.API_CALL,
+            isDefault: true,
+            roles: ['APP_USER'],
+            riskLevel: ResourceOperationRiskLevel.MEDIUM,
+          }],
+        },
+        [CoreResourceOperation.READ]: {
+          variants: [{
+            variantType: ResourceOperationVariantType.API_CALL,
+            isDefault: true,
+            roles: ['APP_USER'],
+            riskLevel: ResourceOperationRiskLevel.LOW,
+          }],
+        },
+        [CoreResourceOperation.UPDATE]: {
+          variants: [{
+            variantType: ResourceOperationVariantType.API_CALL,
+            isDefault: true,
+            roles: ['APP_USER'],
+            riskLevel: ResourceOperationRiskLevel.MEDIUM,
+          }],
+        },
+      },
+    });
+  }
+
+  function createExecutionContext(operation: any, overrides?: { organizationId?: string }) {
+    const organizationId = overrides?.organizationId ?? 'org-1';
+    return new ExecutionContext(
+      operation,
+      ExecutionContext_ExecutionType.USER_REQUEST,
+      new Map([['organizationId', organizationId]]),
+      {
+        userId: 'user-1',
+        organizationId,
+        applicationId: 'app-1',
+      },
+      [],
+      [],
+      'request-postgres-file-1',
+      0,
+      new Set(),
+      'APP_USER',
+    );
+  }
+
+  function getOperation(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,
+    };
+  }
+
+  function createFilesServiceStub() {
+    const files = new Map<string, any>();
+
+    const cloneFile = (file: any) => (file ? structuredClone(file) : null);
+
+    const filesService = {
+      getFile: vi.fn(async (fileId: string) => cloneFile(files.get(fileId))),
+      linkFileToResource: vi.fn(async (
+        fileId: string,
+        linkedResourceType: ResourceType,
+        linkedResourceId: string,
+        linkedFieldName: string,
+      ) => {
+        const currentFile = files.get(fileId);
+        const updatedFile = {
+          ...currentFile,
+          fileId,
+          status: FileStatus.LINKED,
+          linkedResourceType,
+          linkedResourceId,
+          linkedFieldName,
+        };
+        files.set(fileId, updatedFile);
+        return cloneFile(updatedFile);
+      }),
+      unlinkFileFromResource: vi.fn(async (fileId: string) => {
+        const currentFile = files.get(fileId);
+        const updatedFile = {
+          ...currentFile,
+          fileId,
+          status: FileStatus.ORPHANED,
+        };
+        files.set(fileId, updatedFile);
+        return cloneFile(updatedFile);
+      }),
+    } as any;
+
+    return {
+      files,
+      filesService,
+      seedUploadedFile(fileId: string) {
+        files.set(fileId, {
+          fileId,
+          status: FileStatus.UPLOADED,
+        });
+      },
+    };
+  }
+
+  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_profiles" (
+        "_id" uuid primary key default gen_random_uuid(),
+        "organizationId" text,
+        "name" text not null,
+        "attachment" jsonb
+      )
+    `.execute(db);
+
+    return {
+      db,
+      async close() {
+        await db.destroy();
+        await pool.end();
+      },
+    };
+  }
+
+  async function createHarness() {
+    const { logger, errorBuilder, operationHelper, config } = getMocks(container);
+    const fileStore = createFilesServiceStub();
+    const fileFieldDetection = new FileFieldDetectionBackendService(
+      logger as any,
+      resourceRegistry,
+      errorBuilder as any,
+    );
+    const fileOperationHandler = new FileOperationHandlerBackendService(
+      logger as any,
+      errorBuilder as any,
+      fileFieldDetection,
+      fileStore.filesService,
+    );
+    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);
+    const executeTransactionSpy = vi.spyOn(postgreSQLDatabaseService, 'executeTransaction');
+
+    const service = new ServiceResourceBackendService(
+      resourceType,
+      resourceRegistry,
+      logger as any,
+      errorBuilder as any,
+      operationHelper as any,
+      {} as any,
+      repositoriesRegistry,
+      {
+        dispatchPostOperationHooks: vi.fn().mockResolvedValue(undefined),
+        getService: vi.fn(),
+      } 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).executePostOperationLogic = vi.fn(async (_operation: unknown, result: any) => result);
+
+    return {
+      db: inMemoryPostgreSQL.db,
+      fileStore,
+      mongoDBService,
+      postgreSQLDatabaseService,
+      postgreSQLExecuteTransactionSpy: executeTransactionSpy,
+      repository: repositoriesRegistry.getRepositoryOrThrow(resourceType) as any,
+      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(
+      { [resourceType]: createProfilesFactory() } as any,
+      { [resourceType]: '_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('persists PostgreSQL-backed create and update rows while coordinating file metadata through Mongo', async () => {
+    const harness = await createHarness();
+    const createOperation = getOperation(CoreResourceOperation.CREATE);
+    const updateOperation = getOperation(CoreResourceOperation.UPDATE);
+
+    harness.fileStore.seedUploadedFile(originalFileId);
+    harness.fileStore.seedUploadedFile(replacementFileId);
+
+    const created = await (harness.service as any).create(
+      createOperation,
+      createExecutionContext(createOperation),
+      {
+        organizationId: 'org-1',
+        name: 'Postgres profile',
+        attachment: buildFileValue(originalFileId),
+      },
+      undefined,
+    );
+    const createdId = created._id;
+
+    expect(created).toEqual(expect.objectContaining({
+      _id: expect.any(String),
+      name: 'Postgres profile',
+    }));
+    expect(harness.postgreSQLExecuteTransactionSpy).toHaveBeenCalledTimes(1);
+    expect(harness.mongoDBService.executeTransaction).toHaveBeenCalledTimes(1);
+    expect(harness.fileStore.files.get(originalFileId)).toEqual(expect.objectContaining({
+      status: FileStatus.LINKED,
+      linkedResourceType: resourceType,
+      linkedResourceId: createdId,
+      linkedFieldName: 'attachment',
+    }));
+    expect(
+      await harness.db.selectFrom('postgres_profiles').selectAll().where('_id', '=', createdId).executeTakeFirst()
+    ).toEqual(expect.objectContaining({
+      _id: createdId,
+      organizationId: 'org-1',
+      name: 'Postgres profile',
+      attachment: {
+        fileId: originalFileId,
+        updatedAt: fileUpdatedAt.toISOString(),
+      },
+    }));
+
+    const updated = await (harness.service as any).update(
+      updateOperation,
+      createExecutionContext(updateOperation),
+      createdId,
+      {
+        name: 'Postgres profile updated',
+        attachment: buildFileValue(replacementFileId),
+      },
+      undefined,
+    );
+
+    expect(updated).toEqual(expect.objectContaining({
+      _id: createdId,
+      name: 'Postgres profile updated',
+    }));
+    expect(harness.postgreSQLExecuteTransactionSpy).toHaveBeenCalledTimes(2);
+    expect(harness.mongoDBService.executeTransaction).toHaveBeenCalledTimes(2);
+    expect(harness.fileStore.files.get(originalFileId)).toEqual(expect.objectContaining({
+      status: FileStatus.ORPHANED,
+    }));
+    expect(harness.fileStore.files.get(replacementFileId)).toEqual(expect.objectContaining({
+      status: FileStatus.LINKED,
+      linkedResourceType: resourceType,
+      linkedResourceId: createdId,
+      linkedFieldName: 'attachment',
+    }));
+    expect(
+      await harness.db.selectFrom('postgres_profiles').selectAll().where('_id', '=', createdId).executeTakeFirst()
+    ).toEqual(expect.objectContaining({
+      _id: createdId,
+      organizationId: 'org-1',
+      name: 'Postgres profile updated',
+      attachment: {
+        fileId: replacementFileId,
+        updatedAt: fileUpdatedAt.toISOString(),
+      },
+    }));
+  });
+
+  it('fails closed before file metadata changes when contextual PostgreSQL lookup cannot see the target row', async () => {
+    const harness = await createHarness();
+    const createOperation = getOperation(CoreResourceOperation.CREATE);
+    const updateOperation = getOperation(CoreResourceOperation.UPDATE);
+
+    harness.fileStore.seedUploadedFile(originalFileId);
+    harness.fileStore.seedUploadedFile(replacementFileId);
+
+    const created = await (harness.service as any).create(
+      createOperation,
+      createExecutionContext(createOperation),
+      {
+        organizationId: 'org-1',
+        name: 'Scoped Postgres profile',
+        attachment: buildFileValue(originalFileId),
+      },
+      undefined,
+    );
+    const createdId = created._id;
+
+    await expect(
+      (harness.service as any).update(
+        updateOperation,
+        createExecutionContext(updateOperation, { organizationId: 'org-2' }),
+        createdId,
+        {
+          name: 'Should not update',
+          attachment: buildFileValue(replacementFileId),
+        },
+        undefined,
+      )
+    ).rejects.toMatchObject({
+      customMessageReference: 'controller_resource_not_found',
+    });
+
+    expect(harness.postgreSQLExecuteTransactionSpy).toHaveBeenCalledTimes(1);
+    expect(harness.mongoDBService.executeTransaction).toHaveBeenCalledTimes(1);
+    expect(harness.fileStore.files.get(originalFileId)).toEqual(expect.objectContaining({
+      status: FileStatus.LINKED,
+      linkedResourceType: resourceType,
+      linkedResourceId: createdId,
+      linkedFieldName: 'attachment',
+    }));
+    expect(harness.fileStore.files.get(replacementFileId)).toEqual(expect.objectContaining({
+      status: FileStatus.UPLOADED,
+    }));
+    expect(
+      await harness.db.selectFrom('postgres_profiles').selectAll().where('_id', '=', createdId).executeTakeFirst()
+    ).toEqual(expect.objectContaining({
+      _id: createdId,
+      organizationId: 'org-1',
+      name: 'Scoped Postgres profile',
+      attachment: {
+        fileId: originalFileId,
+        updatedAt: fileUpdatedAt.toISOString(),
+      },
+    }));
+  });
+});