@gadmin2n/schematics 0.0.148 → 0.0.149

package/dist/lib/application/files/gadmin2-game-angle-demo/config/prisma/workflow.prisma

@@ -378,7 +378,7 @@ model WorkflowBusinessEventRegistration {
   registrationKey  String                 @unique @map("registration_key") @db.Char(64)
   schemaName       String                 @map("schema_name") @db.VarChar(63)
   tableName        String                 @map("table_name") @db.VarChar(63)
-  operation        WorkflowEventOperation
+  operations       WorkflowEventOperation[]
   watchedFields    Json                   @map("watched_fields")
   primaryKeyFields Json                   @map("primary_key_fields")
   isEnabled        Boolean                @default(true) @map("is_enabled")

package/dist/lib/application/files/gadmin2-game-angle-demo/server/seed/workflow-node-types.ts

@@ -202,65 +202,82 @@ const NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
           minLength: 1,
           description: '前端登记的 PostgreSQL 表字段监听标识',
         },
-        match: {
-          type: 'object',
-          properties: {
-            combineOperation: {
-              type: 'string',
-              enum: ['AND', 'OR'],
-            },
-            conditions: {
-              type: 'array',
-              minItems: 1,
-              items: {
+        operationRules: {
+          type: 'array',
+          minItems: 1,
+          maxItems: 3,
+          description: '按数据操作配置启动规则；未启用的操作不启动',
+          items: {
+            type: 'object',
+            properties: {
+              operation: {
+                type: 'string',
+                enum: ['INSERT', 'UPDATE', 'DELETE'],
+              },
+              match: {
                 type: 'object',
                 properties: {
-                  id: { type: 'string', minLength: 1 },
-                  left: {
-                    type: 'object',
-                    properties: {
-                      source: { const: 'WORKFLOW' },
-                      path: { type: 'string', minLength: 1 },
-                    },
-                    required: ['source', 'path'],
-                    additionalProperties: false,
-                  },
-                  operator: {
+                  combineOperation: {
                     type: 'string',
-                    enum: ['EQ', 'NEQ', 'EMPTY', 'NOT_EMPTY'],
-                  },
-                  right: {
-                    type: 'object',
-                    properties: {
-                      source: { const: 'FIXED' },
-                      valueType: {
-                        type: 'string',
-                        enum: ['STRING', 'NUMBER', 'BOOLEAN'],
-                      },
-                      value: { type: 'string' },
-                    },
-                    required: ['source', 'valueType', 'value'],
-                    additionalProperties: false,
+                    enum: ['AND', 'OR'],
                   },
-                },
-                required: ['id', 'left', 'operator'],
-                allOf: [
-                  {
-                    if: {
+                  conditions: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                      type: 'object',
                       properties: {
-                        operator: { enum: ['EQ', 'NEQ'] },
+                        id: { type: 'string', minLength: 1 },
+                        left: {
+                          type: 'object',
+                          properties: {
+                            source: { const: 'WORKFLOW' },
+                            path: { type: 'string', minLength: 1 },
+                          },
+                          required: ['source', 'path'],
+                          additionalProperties: false,
+                        },
+                        operator: {
+                          type: 'string',
+                          enum: ['EQ', 'NEQ', 'IN', 'EMPTY', 'NOT_EMPTY'],
+                        },
+                        right: {
+                          type: 'object',
+                          properties: {
+                            source: { const: 'FIXED' },
+                            valueType: {
+                              type: 'string',
+                              enum: ['STRING', 'NUMBER', 'BOOLEAN'],
+                            },
+                            value: { type: 'string' },
+                          },
+                          required: ['source', 'valueType', 'value'],
+                          additionalProperties: false,
+                        },
                       },
-                      required: ['operator'],
+                      required: ['id', 'left', 'operator'],
+                      allOf: [
+                        {
+                          if: {
+                            properties: {
+                              operator: { enum: ['EQ', 'NEQ', 'IN'] },
+                            },
+                            required: ['operator'],
+                          },
+                          then: { required: ['right'] },
+                        },
+                      ],
+                      additionalProperties: false,
                     },
-                    then: { required: ['right'] },
                   },
-                ],
+                },
+                required: ['combineOperation', 'conditions'],
                 additionalProperties: false,
               },
             },
+            required: ['operation'],
+            additionalProperties: false,
           },
-          required: ['combineOperation', 'conditions'],
-          additionalProperties: false,
         },
         processingMode: {
           type: 'string',
@@ -281,7 +298,7 @@ const NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
           description: '顺序调度器最多同时处理的业务对象数量',
         },
       },
-      required: ['registrationCode', 'processingMode'],
+      required: ['registrationCode', 'operationRules', 'processingMode'],
       allOf: [
         {
           if: {
@@ -1327,7 +1344,7 @@ const dedicatedEditorNodes: NodeTypeSeed[] = [
   ),
   schemaVersion:
     type === 'event_trigger'
-      ? 4
+      ? 5
       : type === 'db_execute'
       ? 4
       : type === 'parallel'

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

@@ -22,6 +22,8 @@ class JobsQueryDto {
   toggle?: string;
   module?: string;
   q?: string;
+  dateFrom?: string;
+  dateTo?: string;
   skip?: number;
   limit?: number;
 }
@@ -55,6 +57,8 @@ export class AgendaController {
       toggle: query.toggle,
       module: query.module,
       q: query.q,
+      dateFrom: query.dateFrom,
+      dateTo: query.dateTo,
       skip: query.skip ? Number(query.skip) : 0,
       limit: query.limit ? Number(query.limit) : 20,
     });

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

@@ -16,6 +16,8 @@ interface GetJobsParams {
   toggle?: string; // 'active' | 'paused'
   module?: string;
   q?: string;
+  dateFrom?: string; // ISO：按 lastRunAt 过滤区间下界
+  dateTo?: string; // ISO：按 lastRunAt 过滤区间上界
   skip?: number;
   limit?: number;
 }
@@ -364,7 +366,17 @@ export class AgendaService
         totalPages: 0,
       };
     }
-    const { job, state, toggle, module, q, skip = 0, limit = 20 } = params;
+    const {
+      job,
+      state,
+      toggle,
+      module,
+      q,
+      dateFrom,
+      dateTo,
+      skip = 0,
+      limit = 20,
+    } = params;
 
     const allQuery: JobsQueryOptions = {};
     if (job) allQuery.name = job;
@@ -381,6 +393,21 @@ export class AgendaService
         )
       : allResult.jobs;
 
+    // 应用层过滤 lastRunAt 时间区间（Agenda queryJobs 同样不支持日期过滤）。
+    // 未执行过（lastRunAt 为空）的任务在设置了时间区间时不纳入。
+    const fromTs = dateFrom ? new Date(dateFrom).getTime() : null;
+    const toTs = dateTo ? new Date(dateTo).getTime() : null;
+    const dateFiltered =
+      fromTs !== null || toTs !== null
+        ? moduleFiltered.filter((j) => {
+            if (!j.lastRunAt) return false;
+            const t = new Date(j.lastRunAt).getTime();
+            if (fromTs !== null && t < fromTs) return false;
+            if (toTs !== null && t > toTs) return false;
+            return true;
+          })
+        : moduleFiltered;
+
     const overview: Record<string, number> = {
       running: 0,
       scheduled: 0,
@@ -392,15 +419,15 @@ export class AgendaService
       active: 0,
     };
 
-    for (const j of moduleFiltered) {
+    for (const j of dateFiltered) {
       const s = j.state;
       if (s in overview) overview[s]++;
     }
 
     // 第一步：按 job 原始状态过滤（running/queued 等）
     const stateFiltered = state
-      ? moduleFiltered.filter((j) => j.state === state)
-      : moduleFiltered;
+      ? dateFiltered.filter((j) => j.state === state)
+      : dateFiltered;
 
     // 从状态过滤后的数据计算 active/paused 数量
     for (const j of stateFiltered) {

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.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 })