@gadmin2n/schematics 0.0.147 → 0.0.149

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

@@ -12,7 +12,7 @@ const registration = {
   registrationKey: 'a'.repeat(64),
   schemaName: 'public',
   tableName: 't_hardware_asset',
-  operation: 'UPDATE',
+  operations: ['UPDATE'],
   watchedFields: ['status'],
   primaryKeyFields: ['id'],
   isEnabled: true,
@@ -67,6 +67,7 @@ describe('PostgreSQL business event registration', () => {
           type: 'event_trigger',
           config: {
             registrationCode: registration.code,
+            operationRules: [{ operation: 'UPDATE' }],
             processingMode: 'SERIAL_BY_KEY',
             concurrencyKeyPath: 'primaryKey.id',
           },
@@ -98,6 +99,7 @@ describe('PostgreSQL business event registration', () => {
               type: 'event_trigger',
               config: {
                 registrationCode: registration.code,
+                operationRules: [{ operation: 'UPDATE' }],
                 processingMode: 'SERIAL_BY_KEY',
                 concurrencyKeyPath: 'missing',
               },
@@ -116,17 +118,22 @@ describe('PostgreSQL business event registration', () => {
       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' },
+        operationRules: [
+          {
+            operation: 'UPDATE',
+            match: {
+              combineOperation: 'AND',
+              conditions: [
+                {
+                  id: 'condition-1',
+                  left: { source: 'WORKFLOW', path: leftPath },
+                  operator: 'EQ',
+                  right: { source: 'FIXED', valueType, value: 'APPROVED' },
+                },
+              ],
             },
-          ],
-        },
+          },
+        ],
       },
     });
 
@@ -179,7 +186,7 @@ describe('PostgreSQL business event registration', () => {
         {
           schemaName: 'public',
           tableName: 't_hardware_asset',
-          operation: 'UPDATE',
+          operations: ['UPDATE'],
           watchedFields: ['status'],
         },
         'admin',
@@ -224,7 +231,7 @@ describe('PostgreSQL business event registration', () => {
         {
           schemaName: 'another_schema',
           tableName: 't_hardware_asset',
-          operation: 'UPDATE',
+          operations: ['UPDATE'],
           watchedFields: ['status'],
         },
         'admin',
@@ -236,8 +243,8 @@ describe('PostgreSQL business event registration', () => {
   it('registers INSERT for the whole row without requiring selected fields', async () => {
     const insertRegistration = {
       ...registration,
-      operation: 'INSERT',
-      watchedFields: ['id', 'status'],
+      operations: ['INSERT'],
+      watchedFields: [],
     };
     const executeRawUnsafe = jest.fn().mockResolvedValue(0);
     const tx = {
@@ -266,14 +273,14 @@ describe('PostgreSQL business event registration', () => {
       {
         schemaName: 'public',
         tableName: 't_hardware_asset',
-        operation: 'INSERT',
+        operations: ['INSERT'],
         watchedFields: [],
       },
       'admin',
     );
 
     expect(tx.workflowBusinessEventRegistration.create).toHaveBeenCalledWith({
-      data: expect.objectContaining({ watchedFields: ['id', 'status'] }),
+      data: expect.objectContaining({ watchedFields: [] }),
     });
     expect(executeRawUnsafe).toHaveBeenCalledWith(
       expect.stringContaining('AFTER INSERT ON'),
@@ -321,3 +328,145 @@ describe('PostgreSQL business event registration', () => {
     );
   });
 });
+
+describe('multi-operation event rules', () => {
+  const [event] = buildBusinessEventCatalog(
+    [{ ...registration, operations: ['INSERT', 'UPDATE', 'DELETE'] }],
+    columns,
+  );
+  const condition = (path: string, values: string[]) => ({
+    id: path,
+    left: { source: 'WORKFLOW', path },
+    operator: 'IN',
+    right: {
+      source: 'FIXED',
+      valueType: 'STRING',
+      value: JSON.stringify(values),
+    },
+  });
+  const validate = (operationRules: unknown) =>
+    validateBusinessEventTriggers(
+      {
+        nodes: [
+          {
+            type: 'event_trigger',
+            config: {
+              registrationCode: event.registrationCode,
+              operationRules,
+            },
+          },
+        ],
+      },
+      [event],
+    );
+
+  it('requires stable primary keys for serial processing when before/after can be null', () => {
+    expect(
+      event.fields.find((field) => field.path === 'primaryKey.id')?.nullable,
+    ).toBe(false);
+    expect(
+      event.fields.find((field) => field.path === 'after.id')?.nullable,
+    ).toBe(true);
+    expect(
+      event.fields.find((field) => field.path === 'before.id')?.nullable,
+    ).toBe(true);
+    expect(() =>
+      validateBusinessEventTriggers(
+        {
+          nodes: [
+            {
+              type: 'event_trigger',
+              config: {
+                registrationCode: event.registrationCode,
+                operationRules: [{ operation: 'INSERT' }],
+                processingMode: 'SERIAL_BY_KEY',
+                concurrencyKeyPath: 'after.id',
+              },
+            },
+          ],
+        },
+        [event],
+      ),
+    ).toThrow(BadRequestException);
+  });
+
+  it('accepts independent insert and status transition rules', () => {
+    expect(() =>
+      validate([
+        {
+          operation: 'INSERT',
+          match: {
+            combineOperation: 'AND',
+            conditions: [
+              condition('after.status', ['PENDING', 'PENDING_SUPERIOR']),
+            ],
+          },
+        },
+        {
+          operation: 'UPDATE',
+          match: {
+            combineOperation: 'AND',
+            conditions: [
+              condition('before.status', ['DRAFT', 'REJECTED']),
+              condition('after.status', ['PENDING', 'PENDING_SUPERIOR']),
+            ],
+          },
+        },
+      ]),
+    ).not.toThrow();
+  });
+
+  it.each([
+    [],
+    [{ operation: 'UPSERT' }],
+    [{ operation: 'INSERT' }, { operation: 'INSERT' }],
+    [
+      {
+        operation: 'INSERT',
+        match: {
+          combineOperation: 'AND',
+          conditions: [condition('before.status', ['DRAFT'])],
+        },
+      },
+    ],
+    [
+      {
+        operation: 'DELETE',
+        match: {
+          combineOperation: 'AND',
+          conditions: [condition('after.status', ['DRAFT'])],
+        },
+      },
+    ],
+    [
+      {
+        operation: 'UPDATE',
+        match: {
+          combineOperation: 'AND',
+          conditions: [condition('after.status', [])],
+        },
+      },
+    ],
+  ])('rejects invalid or unavailable rules: %j', (...rules) => {
+    expect(() => validate(rules)).toThrow(BadRequestException);
+  });
+
+  it('rejects operations outside the registered set', () => {
+    expect(() =>
+      validateBusinessEventTriggers(
+        {
+          nodes: [
+            {
+              type: 'event_trigger',
+              config: {
+                registrationCode: event.registrationCode,
+                operationRules: [{ operation: 'DELETE' }],
+              },
+            },
+          ],
+        },
+        buildBusinessEventCatalog([registration], columns),
+      ),
+    ).toThrow(BadRequestException);
+  });
+});

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

@@ -0,0 +1,82 @@
+import { WorkflowService } from './workflow.service';
+
+// Opt-in, isolated database check. All fixtures and DDL are rolled back.
+const pgTest = process.env.WORKFLOW_EVENT_PG_TEST === '1' ? it : it.skip;
+
+pgTest(
+  'captures insert/delete rows and only real watched UPDATE changes, atomically',
+  async () => {
+    const { Client } = require('pg');
+    const client = new Client({ connectionString: process.env.DATABASE_URL });
+    const schemaName = `wf_event_test_${process.pid}`;
+    await client.connect();
+    try {
+      await client.query('BEGIN');
+      await client.query(`CREATE SCHEMA "${schemaName}"`);
+      await client.query(`SET LOCAL search_path TO "${schemaName}"`);
+      await client.query(
+        `CREATE TYPE "WorkflowEventOperation" AS ENUM ('INSERT', 'UPDATE', 'DELETE')`,
+      );
+      await client.query(
+        `CREATE TABLE request (id integer PRIMARY KEY, status text NOT NULL, title text)`,
+      );
+      await client.query(`CREATE TABLE t_workflow_event_outbox (
+      id serial PRIMARY KEY, registration_id bigint, operation "WorkflowEventOperation",
+      schema_name text, table_name text, primary_key jsonb, before jsonb, after jsonb,
+      changed_fields jsonb, status text, retry_count integer,
+      next_attempt_at timestamptz, created_at timestamptz, updated_at timestamptz
+    )`);
+      const tx = {
+        $queryRaw: async () => [{ schemaName }],
+        $executeRawUnsafe: (sql: string) => client.query(sql),
+      };
+      const service = new WorkflowService(
+        {} as any,
+        {} as any,
+        {} as any,
+        {} as any,
+      );
+      await (service as any).installBusinessEventTrigger(tx, {
+        id: BigInt(1),
+        schemaName,
+        tableName: 'request',
+        operations: ['INSERT', 'UPDATE', 'DELETE'],
+        watchedFields: ['status'],
+        primaryKeyFields: ['id'],
+      });
+      await client.query(`INSERT INTO request VALUES (1, 'DRAFT', 'original')`);
+      await client.query(`UPDATE request SET title = 'edited' WHERE id = 1`);
+      await client.query(`UPDATE request SET status = 'DRAFT' WHERE id = 1`);
+      await client.query(`UPDATE request SET status = 'PENDING' WHERE id = 1`);
+      await client.query('SAVEPOINT submission');
+      await client.query(`UPDATE request SET status = 'APPROVED' WHERE id = 1`);
+      await client.query('ROLLBACK TO SAVEPOINT submission');
+      await client.query(`DELETE FROM request WHERE id = 1`);
+      const { rows } = await client.query(
+        'SELECT * FROM t_workflow_event_outbox ORDER BY id',
+      );
+      expect(rows.map((row: any) => row.operation)).toEqual([
+        'INSERT',
+        'UPDATE',
+        'DELETE',
+      ]);
+      expect(rows[0]).toMatchObject({
+        before: null,
+        after: { status: 'DRAFT' },
+        primary_key: { id: 1 },
+      });
+      expect(rows[1]).toMatchObject({
+        before: { status: 'DRAFT' },
+        after: { status: 'PENDING' },
+        changed_fields: ['status'],
+      });
+      expect(rows[2]).toMatchObject({
+        before: { status: 'PENDING' },
+        after: null,
+      });
+    } finally {
+      await client.query('ROLLBACK');
+      await client.end();
+    }
+  },
+);

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-runtime.facade.ts

@@ -22,6 +22,7 @@ export interface WorkflowCancellationSummary {
 export interface CancelWorkflowExecutionInput {
   tx: Prisma.TransactionClient;
   instanceId: bigint;
+  requestedBy: string;
   reason?: string;
 }
 
@@ -60,6 +61,7 @@ export class WorkflowRuntimeFacade {
     await this.workflows.cancelExecutionInTransaction(
       input.tx,
       input.instanceId,
+      input.requestedBy,
       input.reason,
     );
     return { instanceId: input.instanceId.toString(), status: 'CANCELLED' };

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

@@ -81,7 +81,9 @@ describe('WorkflowController runtime contracts', () => {
       prisma as never,
     );
 
-    await expect(controller.cancelInstance(42)).resolves.toEqual({
+    await expect(
+      controller.cancelInstance(42, { user: { userid: 'admin-user' } }),
+    ).resolves.toEqual({
       instanceId: '42',
       status: 'CANCELLED',
     });
@@ -89,6 +91,7 @@ describe('WorkflowController runtime contracts', () => {
     expect(runtime.cancelExecution).toHaveBeenCalledWith({
       tx,
       instanceId: BigInt(42),
+      requestedBy: 'admin-user',
     });
   });
 });

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

@@ -272,11 +272,15 @@ export class WorkflowController {
   }
 
   @Post('instance/:instanceId/cancel')
-  async cancelInstance(@Param('instanceId', ParseIntPipe) instanceId: number) {
+  async cancelInstance(
+    @Param('instanceId', ParseIntPipe) instanceId: number,
+    @Req() req,
+  ) {
     return this.prisma.$transaction((tx) =>
       this.workflowRuntime.cancelExecution({
         tx,
         instanceId: BigInt(instanceId),
+        requestedBy: req.user.userid,
       }),
     );
   }

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

@@ -1,5 +1,7 @@
 import { Prisma } from '@prisma/client';
 import {
+  ArrayMinSize,
+  ArrayUnique,
   IsArray,
   IsBoolean,
   IsEnum,
@@ -32,8 +34,11 @@ export class RegisterBusinessEventDto {
   @Matches(/^[A-Za-z_][A-Za-z0-9_$]*$/)
   tableName: string;
 
-  @IsEnum(WorkflowEventOperationEnum)
-  operation: WorkflowEventOperationEnum;
+  @IsArray()
+  @ArrayMinSize(1)
+  @ArrayUnique()
+  @IsEnum(WorkflowEventOperationEnum, { each: true })
+  operations: WorkflowEventOperationEnum[];
 
   @IsArray()
   @IsString({ each: true })

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

@@ -7,6 +7,50 @@ import { signWebhookPayload } from './webhook-signature.util';
 import { WorkflowCompilerService } from './workflow-compiler.service';
 import { WorkflowService } from './workflow.service';
 
+describe('WorkflowService — workflow list run counts', () => {
+  it('includes cancelled instances in the run summary', async () => {
+    const prisma = {
+      workflow: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(42),
+            dsl: null,
+            versions: [],
+            _count: { instances: 2 },
+          },
+        ]),
+        count: jest.fn().mockResolvedValue(1),
+      },
+      workflowInstance: {
+        groupBy: jest.fn().mockResolvedValue([
+          {
+            workflowId: BigInt(42),
+            status: 'CANCELLED',
+            _count: 2,
+          },
+        ]),
+        findMany: jest.fn().mockResolvedValue([]),
+      },
+    };
+    const service = new WorkflowService(
+      prisma as any,
+      {} as any,
+      {} as any,
+      {} as any,
+    );
+
+    const result = await service.findMany({});
+
+    expect(result.items[0].runs).toEqual({
+      pending: 0,
+      running: 0,
+      completed: 0,
+      failed: 0,
+      cancelled: 2,
+    });
+  });
+});
+
 describe('WorkflowService — cron lifecycle hooks', () => {
   let service: WorkflowService;
   let prisma: any;