@gadmin2n/schematics 0.0.144 → 0.0.146

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-event-catalog.spec.ts

@@ -0,0 +1,323 @@
+import { BadRequestException } from '@nestjs/common';
+import {
+  buildBusinessEventCatalog,
+  unknownBusinessEventNames,
+  validateBusinessEventTriggers,
+  WorkflowService,
+} from './workflow.service';
+
+const registration = {
+  id: BigInt(9),
+  code: 'eventRegistration01',
+  registrationKey: 'a'.repeat(64),
+  schemaName: 'public',
+  tableName: 't_hardware_asset',
+  operation: 'UPDATE',
+  watchedFields: ['status'],
+  primaryKeyFields: ['id'],
+  isEnabled: true,
+  creator: 'admin',
+  createdAt: new Date(),
+  updatedAt: new Date(),
+};
+
+const columns = [
+  {
+    schemaName: 'public',
+    tableName: 't_hardware_asset',
+    columnName: 'id',
+    dataType: 'bigint',
+    nullable: false,
+    primaryKey: true,
+  },
+  {
+    schemaName: 'public',
+    tableName: 't_hardware_asset',
+    columnName: 'status',
+    dataType: 'character varying(32)',
+    nullable: false,
+    primaryKey: false,
+  },
+];
+
+describe('PostgreSQL business event registration', () => {
+  it('derives stable Workflow fields from database metadata', () => {
+    const [event] = buildBusinessEventCatalog([registration], columns);
+
+    expect(event).toMatchObject({
+      registrationCode: registration.code,
+      label: 'public.t_hardware_asset · UPDATE',
+      watchedFields: ['status'],
+      defaultKeyPath: 'primaryKey.id',
+    });
+    expect(event.fields.map((field) => field.path)).toEqual([
+      'primaryKey.id',
+      'before.id',
+      'before.status',
+      'after.id',
+      'after.status',
+    ]);
+  });
+
+  it('matches event_trigger by registration code and validates serial keys', () => {
+    const catalog = buildBusinessEventCatalog([registration], columns);
+    const dsl = {
+      nodes: [
+        {
+          type: 'event_trigger',
+          config: {
+            registrationCode: registration.code,
+            processingMode: 'SERIAL_BY_KEY',
+            concurrencyKeyPath: 'primaryKey.id',
+          },
+        },
+      ],
+    };
+
+    expect(unknownBusinessEventNames(dsl, catalog)).toEqual([]);
+    expect(() => validateBusinessEventTriggers(dsl, catalog)).not.toThrow();
+    expect(
+      unknownBusinessEventNames(
+        {
+          nodes: [
+            {
+              type: 'event_trigger',
+              config: { registrationCode: 'missing' },
+            },
+          ],
+        },
+        catalog,
+      ),
+    ).toEqual(['missing']);
+
+    expect(() =>
+      validateBusinessEventTriggers(
+        {
+          nodes: [
+            {
+              type: 'event_trigger',
+              config: {
+                registrationCode: registration.code,
+                processingMode: 'SERIAL_BY_KEY',
+                concurrencyKeyPath: 'missing',
+              },
+            },
+          ],
+        },
+        catalog,
+      ),
+    ).toThrow(BadRequestException);
+  });
+
+  it('validates event trigger match fields and fixed value types', () => {
+    const catalog = buildBusinessEventCatalog([registration], columns);
+    const eventNode = (leftPath: string, valueType: string) => ({
+      type: 'event_trigger',
+      config: {
+        registrationCode: registration.code,
+        processingMode: 'PARALLEL',
+        match: {
+          combineOperation: 'AND',
+          conditions: [
+            {
+              id: 'condition-1',
+              left: { source: 'WORKFLOW', path: leftPath },
+              operator: 'EQ',
+              right: { source: 'FIXED', valueType, value: 'APPROVED' },
+            },
+          ],
+        },
+      },
+    });
+
+    expect(() =>
+      validateBusinessEventTriggers(
+        { nodes: [eventNode('after.status', 'STRING')] },
+        catalog,
+      ),
+    ).not.toThrow();
+    expect(() =>
+      validateBusinessEventTriggers(
+        { nodes: [eventNode('after.missing', 'STRING')] },
+        catalog,
+      ),
+    ).toThrow(BadRequestException);
+    expect(() =>
+      validateBusinessEventTriggers(
+        { nodes: [eventNode('after.status', 'NUMBER')] },
+        catalog,
+      ),
+    ).toThrow(BadRequestException);
+  });
+
+  it('installs a PG trigger that writes the standard Outbox row', async () => {
+    const executeRawUnsafe = jest.fn().mockResolvedValue(0);
+    const tx = {
+      $queryRaw: jest
+        .fn()
+        .mockResolvedValueOnce([{ lock: 'ok' }])
+        .mockResolvedValueOnce([{ schemaName: 'public' }]),
+      $executeRawUnsafe: executeRawUnsafe,
+      workflowBusinessEventRegistration: {
+        findUnique: jest.fn().mockResolvedValue(null),
+        create: jest.fn().mockResolvedValue(registration),
+      },
+    };
+    const prisma = {
+      $queryRaw: jest.fn().mockResolvedValue(columns),
+      $transaction: jest.fn(async (callback: any) => callback(tx)),
+    };
+    const service = new WorkflowService(
+      prisma as any,
+      {} as any,
+      {} as any,
+      {} as any,
+    );
+
+    await expect(
+      service.registerBusinessEvent(
+        {
+          schemaName: 'public',
+          tableName: 't_hardware_asset',
+          operation: 'UPDATE',
+          watchedFields: ['status'],
+        },
+        'admin',
+      ),
+    ).resolves.toMatchObject({ registrationCode: registration.code });
+    expect(executeRawUnsafe).toHaveBeenCalledTimes(3);
+    expect(executeRawUnsafe).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('CREATE OR REPLACE FUNCTION'),
+    );
+    expect(executeRawUnsafe).toHaveBeenNthCalledWith(
+      2,
+      expect.stringContaining('DROP TRIGGER IF EXISTS'),
+    );
+    expect(executeRawUnsafe).toHaveBeenNthCalledWith(
+      3,
+      expect.stringContaining('CREATE TRIGGER "gadmin_wf_event_9"'),
+    );
+    expect(executeRawUnsafe).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('t_workflow_event_outbox'),
+    );
+  });
+
+  it('rejects registering a table outside the current schema', async () => {
+    const prisma = {
+      $queryRaw: jest
+        .fn()
+        .mockResolvedValueOnce(columns)
+        .mockResolvedValueOnce([{ schemaName: 'public' }]),
+      $transaction: jest.fn(),
+    };
+    const service = new WorkflowService(
+      prisma as any,
+      {} as any,
+      {} as any,
+      {} as any,
+    );
+
+    await expect(
+      service.registerBusinessEvent(
+        {
+          schemaName: 'another_schema',
+          tableName: 't_hardware_asset',
+          operation: 'UPDATE',
+          watchedFields: ['status'],
+        },
+        'admin',
+      ),
+    ).rejects.toThrow('只能登记当前数据库 Schema（public）中的业务表');
+    expect(prisma.$transaction).not.toHaveBeenCalled();
+  });
+
+  it('registers INSERT for the whole row without requiring selected fields', async () => {
+    const insertRegistration = {
+      ...registration,
+      operation: 'INSERT',
+      watchedFields: ['id', 'status'],
+    };
+    const executeRawUnsafe = jest.fn().mockResolvedValue(0);
+    const tx = {
+      $queryRaw: jest.fn().mockResolvedValue([{ schemaName: 'public' }]),
+      $executeRawUnsafe: executeRawUnsafe,
+      workflowBusinessEventRegistration: {
+        findUnique: jest.fn().mockResolvedValue(null),
+        create: jest.fn().mockResolvedValue(insertRegistration),
+      },
+    };
+    const prisma = {
+      $queryRaw: jest
+        .fn()
+        .mockResolvedValueOnce(columns)
+        .mockResolvedValueOnce([{ schemaName: 'public' }]),
+      $transaction: jest.fn(async (callback: any) => callback(tx)),
+    };
+    const service = new WorkflowService(
+      prisma as any,
+      {} as any,
+      {} as any,
+      {} as any,
+    );
+
+    await service.registerBusinessEvent(
+      {
+        schemaName: 'public',
+        tableName: 't_hardware_asset',
+        operation: 'INSERT',
+        watchedFields: [],
+      },
+      'admin',
+    );
+
+    expect(tx.workflowBusinessEventRegistration.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({ watchedFields: ['id', 'status'] }),
+    });
+    expect(executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('AFTER INSERT ON'),
+    );
+    expect(executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('jsonb_object_keys'),
+    );
+  });
+
+  it('drops the PG trigger and function in separate statements', async () => {
+    const executeRawUnsafe = jest.fn().mockResolvedValue(0);
+    const tx = {
+      $queryRaw: jest.fn().mockResolvedValue([{ lock: 'ok' }]),
+      $executeRawUnsafe: executeRawUnsafe,
+      workflowBusinessEventRegistration: {
+        findUnique: jest.fn().mockResolvedValue(registration),
+        update: jest.fn().mockResolvedValue({
+          ...registration,
+          isEnabled: false,
+        }),
+      },
+      workflow: { findMany: jest.fn().mockResolvedValue([]) },
+    };
+    const prisma = {
+      $transaction: jest.fn(async (callback: any) => callback(tx)),
+    };
+    const service = new WorkflowService(
+      prisma as any,
+      {} as any,
+      {} as any,
+      {} as any,
+    );
+
+    await expect(
+      service.unregisterBusinessEvent(registration.code),
+    ).resolves.toEqual({ registrationCode: registration.code });
+    expect(executeRawUnsafe).toHaveBeenCalledTimes(2);
+    expect(executeRawUnsafe).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('DROP TRIGGER IF EXISTS'),
+    );
+    expect(executeRawUnsafe).toHaveBeenNthCalledWith(
+      2,
+      expect.stringContaining('DROP FUNCTION IF EXISTS'),
+    );
+  });
+});