@gadmin2n/schematics 0.0.150 → 0.0.151

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

@@ -20,6 +20,10 @@ import {
   DraftWorkflowNode,
   WorkflowCompilerErrorCode,
 } from './workflow-compiler.types';
+import {
+  listWorkflowDatabaseFunctions,
+  type WorkflowDatabaseFunctionOption,
+} from './workflow-database-function';
 import { switchCaseValidationError } from './workflow-switch-config';
 
 @Injectable()
@@ -85,6 +89,9 @@ export class WorkflowCompilerService {
     );
 
     const compiledNodes: CompiledWorkflowNode[] = [];
+    let databaseFunctionsPromise:
+      | Promise<WorkflowDatabaseFunctionOption[]>
+      | undefined;
     for (const node of draftDsl.nodes) {
       const nodeType = typeByName.get(node.type);
       if (!nodeType)
@@ -192,6 +199,15 @@ export class WorkflowCompilerService {
           'HTTP Request Connection',
         );
       }
+      if (nodeType.runtimeKey === 'event_trigger') {
+        const failureCallback = asObject(asObject(config).failureCallback);
+        if (Object.keys(failureCallback).length > 0)
+          await this.validateIntegrationConnection(
+            node,
+            failureCallback.connectionRef,
+            '业务失败通知连接',
+          );
+      }
       if (nodeType.runtimeKey === 'human_approval') {
         const approvalConfig = asObject(config);
         if (approvalConfig.external) {
@@ -224,15 +240,34 @@ export class WorkflowCompilerService {
       }
       if (nodeType.runtimeKey === 'db_execute') {
         const databaseConfig = config as Record<string, unknown>;
-        const allowWrite = databaseConfig.allowWrite === true;
-        const sql = String(databaseConfig.sql ?? '');
-        if (!isDatabaseSqlAllowed(sql, allowWrite))
+        if ('sql' in databaseConfig || 'allowWrite' in databaseConfig)
+          this.fail(
+            'NODE_TYPE_MISMATCH',
+            node,
+            '数据库节点不再支持 SQL，请选择 workflow_api 中的 Function',
+          );
+        const functionRef = asObject(databaseConfig.functionRef);
+        const argumentBindings = Array.isArray(databaseConfig.argumentBindings)
+          ? databaseConfig.argumentBindings
+          : [];
+        databaseFunctionsPromise ??= listWorkflowDatabaseFunctions(this.prisma);
+        const databaseFunction = (await databaseFunctionsPromise).find(
+          (item) =>
+            item.schema === functionRef.schema &&
+            item.name === functionRef.name &&
+            item.identityArguments === functionRef.identityArguments,
+        );
+        if (!databaseFunction)
+          this.fail(
+            'NODE_TYPE_MISMATCH',
+            node,
+            '选择的数据库 Function 不存在或已不再开放给 Workflow',
+          );
+        if (argumentBindings.length !== databaseFunction.arguments.length)
           this.fail(
             'NODE_TYPE_MISMATCH',
             node,
-            allowWrite
-              ? '数据库操作只允许单条查询、新增、更新或删除语句'
-              : '当前数据库操作节点只允许单条只读查询',
+            `数据库 Function 需要 ${databaseFunction.arguments.length} 个参数`,
           );
       }
       if (nodeType.runtimeKey === 'sub_workflow') {
@@ -468,41 +503,6 @@ function clone<T>(value: T): T {
   return JSON.parse(JSON.stringify(value)) as T;
 }
 
-function isSingleReadOnlySql(sql: string): boolean {
-  const normalized = normalizeSqlForPolicy(sql);
-  if (!/^(select|with)\b/i.test(normalized)) return false;
-  return !/\b(insert|update|delete|merge|call|copy|create|alter|drop|truncate|grant|revoke|vacuum|refresh)\b/i.test(
-    normalized,
-  );
-}
-
-function isDatabaseSqlAllowed(sql: string, allowWrite: boolean): boolean {
-  const normalized = normalizeSqlForPolicy(sql);
-  const writableCte =
-    /^with\b/i.test(normalized) &&
-    /\b(insert|update|delete)\b/i.test(normalized) &&
-    !/\b(merge|call|copy|create|alter|drop|truncate|grant|revoke|vacuum|refresh)\b/i.test(
-      normalized,
-    );
-  return (
-    isSingleReadOnlySql(sql) ||
-    (allowWrite &&
-      (/^(insert|update|delete)\b/i.test(normalized) || writableCte))
-  );
-}
-
-function normalizeSqlForPolicy(sql: string): string {
-  const withoutContent = sql
-    .replace(/\$(\w*)\$[\s\S]*?\$\1\$/g, ' ')
-    .replace(/'(?:''|[^'])*'/g, ' ')
-    .replace(/"(?:""|[^"])*"/g, ' ')
-    .replace(/\/\*[\s\S]*?\*\//g, ' ')
-    .replace(/--[^\r\n]*/g, ' ')
-    .trim();
-  const withoutTrailingSemicolon = withoutContent.replace(/;\s*$/, '').trim();
-  return withoutTrailingSemicolon.includes(';') ? '' : withoutTrailingSemicolon;
-}
-
 function asObject(value: unknown): Record<string, unknown> {
   return value && typeof value === 'object' && !Array.isArray(value)
     ? (value as Record<string, unknown>)

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

@@ -0,0 +1,36 @@
+import { listWorkflowDatabaseFunctions } from './workflow-database-function';
+
+describe('workflow database Function catalog', () => {
+  it('returns scalar workflow_api Functions with ordered input arguments', async () => {
+    const prisma = {
+      $queryRaw: jest.fn().mockResolvedValue([
+        {
+          schema: 'workflow_api',
+          name: 'approve_request',
+          identity_arguments: 'p_request_id bigint, p_approved boolean',
+          return_type: 'jsonb',
+          arguments: [
+            { position: 1, name: 'p_request_id', type: 'bigint' },
+            { position: 2, name: 'p_approved', type: 'boolean' },
+          ],
+        },
+      ]),
+    };
+
+    await expect(listWorkflowDatabaseFunctions(prisma as any)).resolves.toEqual(
+      [
+        {
+          schema: 'workflow_api',
+          name: 'approve_request',
+          identityArguments: 'p_request_id bigint, p_approved boolean',
+          returnType: 'jsonb',
+          arguments: [
+            { position: 1, name: 'p_request_id', type: 'bigint' },
+            { position: 2, name: 'p_approved', type: 'boolean' },
+          ],
+        },
+      ],
+    );
+    expect(prisma.$queryRaw).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,90 @@
+import { PrismaService } from 'nestjs-prisma';
+
+export const WORKFLOW_DATABASE_FUNCTION_SCHEMA = 'workflow_api';
+
+export interface WorkflowDatabaseFunctionArgument {
+  position: number;
+  name: string;
+  type: string;
+}
+
+export interface WorkflowDatabaseFunctionOption {
+  schema: string;
+  name: string;
+  identityArguments: string;
+  returnType: string;
+  arguments: WorkflowDatabaseFunctionArgument[];
+}
+
+interface WorkflowDatabaseFunctionRow {
+  schema: string;
+  name: string;
+  identity_arguments: string;
+  return_type: string;
+  arguments: unknown;
+}
+
+export async function listWorkflowDatabaseFunctions(
+  prisma: PrismaService,
+): Promise<WorkflowDatabaseFunctionOption[]> {
+  const rows = await prisma.$queryRaw<WorkflowDatabaseFunctionRow[]>`
+    SELECT namespace.nspname AS schema,
+           proc.proname AS name,
+           pg_get_function_identity_arguments(proc.oid) AS identity_arguments,
+           pg_get_function_result(proc.oid) AS return_type,
+           COALESCE(
+             (
+               SELECT jsonb_agg(
+                        jsonb_build_object(
+                          'position', argument.position,
+                          'name', COALESCE(
+                            proc.proargnames[argument.position],
+                            'arg_' || argument.position::text
+                          ),
+                          'type', format_type(
+                            proc.proargtypes[argument.position - 1],
+                            NULL
+                          )
+                        )
+                        ORDER BY argument.position
+                      )
+                 FROM generate_series(1, proc.pronargs) AS argument(position)
+             ),
+             '[]'::jsonb
+           ) AS arguments
+      FROM pg_proc proc
+      JOIN pg_namespace namespace ON namespace.oid = proc.pronamespace
+     WHERE namespace.nspname = 'workflow_api'
+       AND proc.prokind = 'f'
+       AND proc.proretset = FALSE
+     ORDER BY proc.proname, identity_arguments
+  `;
+
+  return rows.map((row) => ({
+    schema: row.schema,
+    name: row.name,
+    identityArguments: row.identity_arguments,
+    returnType: row.return_type,
+    arguments: normalizeArguments(row.arguments),
+  }));
+}
+
+function normalizeArguments(
+  value: unknown,
+): WorkflowDatabaseFunctionArgument[] {
+  if (!Array.isArray(value)) return [];
+  return value.map((item, index) => {
+    const argument = asObject(item);
+    return {
+      position: Number(argument.position ?? index + 1),
+      name: String(argument.name ?? `arg_${index + 1}`),
+      type: String(argument.type ?? ''),
+    };
+  });
+}
+
+function asObject(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}

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

@@ -179,6 +179,7 @@ describe('PostgreSQL business event registration', () => {
       {} as any,
       {} as any,
       {} as any,
+      {} as any,
     );
 
     await expect(
@@ -224,6 +225,7 @@ describe('PostgreSQL business event registration', () => {
       {} as any,
       {} as any,
       {} as any,
+      {} as any,
     );
 
     await expect(
@@ -267,6 +269,7 @@ describe('PostgreSQL business event registration', () => {
       {} as any,
       {} as any,
       {} as any,
+      {} as any,
     );
 
     await service.registerBusinessEvent(
@@ -312,6 +315,7 @@ describe('PostgreSQL business event registration', () => {
       {} as any,
       {} as any,
       {} as any,
+      {} as any,
     );
 
     await expect(

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

@@ -35,6 +35,7 @@ pgTest(
         {} as any,
         {} as any,
         {} as any,
+        {} as any,
       );
       await (service as any).installBusinessEventTrigger(tx, {
         id: BigInt(1),

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

@@ -32,6 +32,9 @@ describe('Workflow execution idempotency', () => {
         update: jest.fn(),
         updateMany: jest.fn().mockResolvedValue({ count: 0 }),
       },
+      workflowEventDelivery: {
+        updateMany: jest.fn().mockResolvedValue({ count: 0 }),
+      },
     };
     prisma.$transaction = jest.fn(async (callback: any) =>
       callback({
@@ -46,8 +49,17 @@ describe('Workflow execution idempotency', () => {
       cancelWorkflow: jest.fn().mockResolvedValue(undefined),
       inspectWorkflow: jest.fn(),
     };
-    const service = new WorkflowService(prisma, temporal, {} as any, {} as any);
-    return { prisma, temporal, service };
+    const lifecycle: any = {
+      markFailed: jest.fn().mockResolvedValue(true),
+    };
+    const service = new WorkflowService(
+      prisma,
+      temporal,
+      {} as any,
+      {} as any,
+      lifecycle,
+    );
+    return { prisma, temporal, lifecycle, service };
   }
 
   it('persists the key and starts one deterministic Temporal execution', async () => {
@@ -95,7 +107,7 @@ describe('Workflow execution idempotency', () => {
   });
 
   it('rechecks enabled state while holding the Workflow row lock', async () => {
-    const { prisma, temporal, service } = setup();
+    const { prisma, temporal, lifecycle, service } = setup();
     prisma.$transaction.mockImplementationOnce(async (callback: any) =>
       callback({
         $queryRaw: jest.fn().mockResolvedValue([{ isEnabled: false }]),
@@ -221,7 +233,7 @@ describe('Workflow execution idempotency', () => {
   });
 
   it('marks a reserved instance failed when Temporal cannot start it', async () => {
-    const { prisma, temporal, service } = setup();
+    const { prisma, temporal, lifecycle, service } = setup();
     const created = {
       id: BigInt(21),
       workflowId,
@@ -238,14 +250,12 @@ describe('Workflow execution idempotency', () => {
       service.executeWorkflow(workflowId, {}, 'manual', temporal),
     ).rejects.toThrow('Temporal unavailable');
 
-    expect(prisma.workflowInstance.updateMany).toHaveBeenLastCalledWith(
+    expect(lifecycle.markFailed).toHaveBeenCalledWith(
       expect.objectContaining({
-        where: expect.objectContaining({
-          id: BigInt(21),
-          status: 'PENDING',
-          temporalRunId: 'wf-7-21',
-        }),
-        data: expect.objectContaining({ status: 'FAILED' }),
+        instanceId: BigInt(21),
+        expectedStatuses: ['PENDING'],
+        temporalRunId: 'wf-7-21',
+        result: expect.objectContaining({ code: 'TEMPORAL_START_FAILED' }),
       }),
     );
   });
@@ -588,7 +598,9 @@ describe('Workflow execution idempotency', () => {
       context: { workflow: { orderId: 'O-1' }, nodes: {} },
       temporalRunId: 'wf-7-21',
     };
-    prisma.workflowInstance.findMany.mockResolvedValueOnce([reserved]);
+    prisma.workflowInstance.findMany
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([reserved]);
     prisma.workflowVersion.findUnique.mockResolvedValueOnce({
       dsl: version.dsl,
     });
@@ -622,6 +634,46 @@ describe('Workflow execution idempotency', () => {
         data: expect.objectContaining({ status: 'RUNNING' }),
       }),
     );
+    expect(prisma.workflowEventDelivery.updateMany).toHaveBeenCalledWith({
+      where: { workflowInstanceId: BigInt(21), status: 'FAILED' },
+      data: {
+        status: 'DISPATCHED',
+        dispatchedAt: expect.any(Date),
+        lastError: null,
+      },
+    });
+  });
+
+  it('fails through lifecycle handling when a missing Temporal execution cannot restart', async () => {
+    const { prisma, temporal, lifecycle, service } = setup();
+    const reserved = {
+      id: BigInt(21),
+      workflowId,
+      versionId: version.id,
+      status: 'PENDING',
+      context: { workflow: {}, nodes: {} },
+      temporalRunId: 'wf-7-21',
+    };
+    prisma.workflowInstance.findMany
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([reserved]);
+    prisma.workflowVersion.findUnique.mockResolvedValueOnce({
+      dsl: version.dsl,
+    });
+    temporal.inspectWorkflow.mockResolvedValueOnce({ kind: 'MISSING' });
+    temporal.startWorkflow.mockRejectedValueOnce(new Error('Temporal down'));
+
+    await service.reconcileUnstartedInstances();
+
+    expect(lifecycle.markFailed).toHaveBeenCalledWith({
+      instanceId: BigInt(21),
+      expectedStatuses: ['PENDING'],
+      temporalRunId: 'wf-7-21',
+      result: {
+        code: 'TEMPORAL_START_RECONCILIATION_FAILED',
+        message: 'Temporal down',
+      },
+    });
   });
 
   it('cancels a reconciled execution when cancellation wins the restart race', async () => {
@@ -634,7 +686,9 @@ describe('Workflow execution idempotency', () => {
       context: { workflow: {}, nodes: {} },
       temporalRunId: 'wf-7-21',
     };
-    prisma.workflowInstance.findMany.mockResolvedValueOnce([reserved]);
+    prisma.workflowInstance.findMany
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([reserved]);
     prisma.workflowVersion.findUnique.mockResolvedValueOnce({
       dsl: version.dsl,
     });
@@ -660,16 +714,18 @@ describe('Workflow execution idempotency', () => {
 
   it('recovers a completed Temporal result without exposing internal context', async () => {
     const { prisma, temporal, service } = setup();
-    prisma.workflowInstance.findMany.mockResolvedValueOnce([
-      {
-        id: BigInt(21),
-        workflowId,
-        versionId: version.id,
-        status: 'PENDING',
-        context: { workflow: { orderId: 'O-1' }, nodes: {} },
-        temporalRunId: 'wf-7-21',
-      },
-    ]);
+    prisma.workflowInstance.findMany
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([
+        {
+          id: BigInt(21),
+          workflowId,
+          versionId: version.id,
+          status: 'PENDING',
+          context: { workflow: { orderId: 'O-1' }, nodes: {} },
+          temporalRunId: 'wf-7-21',
+        },
+      ]);
     prisma.workflowInstance.updateMany
       .mockResolvedValueOnce({ count: 0 })
       .mockResolvedValueOnce({ count: 1 });
@@ -704,17 +760,19 @@ describe('Workflow execution idempotency', () => {
   });
 
   it('reconciles a stale RUNNING instance after Temporal reaches a terminal state', async () => {
-    const { prisma, temporal, service } = setup();
-    prisma.workflowInstance.findMany.mockResolvedValueOnce([
-      {
-        id: BigInt(21),
-        workflowId,
-        versionId: version.id,
-        status: 'RUNNING',
-        context: { workflow: { orderId: 'O-1' }, nodes: {} },
-        temporalRunId: 'wf-7-21',
-      },
-    ]);
+    const { prisma, temporal, lifecycle, service } = setup();
+    prisma.workflowInstance.findMany
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([
+        {
+          id: BigInt(21),
+          workflowId,
+          versionId: version.id,
+          status: 'RUNNING',
+          context: { workflow: { orderId: 'O-1' }, nodes: {} },
+          temporalRunId: 'wf-7-21',
+        },
+      ]);
     temporal.inspectWorkflow.mockResolvedValueOnce({
       kind: 'FOUND',
       status: 'FAILED',
@@ -724,47 +782,41 @@ describe('Workflow execution idempotency', () => {
 
     await service.reconcileUnstartedInstances();
 
-    expect(prisma.workflowInstance.updateMany).toHaveBeenLastCalledWith(
+    expect(lifecycle.markFailed).toHaveBeenCalledWith(
       expect.objectContaining({
-        where: {
-          id: BigInt(21),
-          status: { in: ['PENDING', 'RUNNING'] },
-          temporalRunId: 'wf-7-21',
-        },
-        data: expect.objectContaining({ status: 'FAILED' }),
+        instanceId: BigInt(21),
+        expectedStatuses: ['PENDING', 'RUNNING'],
+        temporalRunId: 'wf-7-21',
       }),
     );
     expect(temporal.startWorkflow).not.toHaveBeenCalled();
   });
 
   it('fails a stale RUNNING instance when its Temporal execution is missing', async () => {
-    const { prisma, temporal, service } = setup();
-    prisma.workflowInstance.findMany.mockResolvedValueOnce([
-      {
-        id: BigInt(21),
-        workflowId,
-        versionId: version.id,
-        status: 'RUNNING',
-        context: { workflow: {}, nodes: {} },
-        temporalRunId: 'wf-7-21',
-      },
-    ]);
+    const { prisma, temporal, lifecycle, service } = setup();
+    prisma.workflowInstance.findMany
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([
+        {
+          id: BigInt(21),
+          workflowId,
+          versionId: version.id,
+          status: 'RUNNING',
+          context: { workflow: {}, nodes: {} },
+          temporalRunId: 'wf-7-21',
+        },
+      ]);
     temporal.inspectWorkflow.mockResolvedValueOnce({ kind: 'MISSING' });
 
     await service.reconcileUnstartedInstances();
 
-    expect(prisma.workflowInstance.updateMany).toHaveBeenLastCalledWith(
+    expect(lifecycle.markFailed).toHaveBeenCalledWith(
       expect.objectContaining({
-        where: {
-          id: BigInt(21),
-          status: 'RUNNING',
-          temporalRunId: 'wf-7-21',
-        },
-        data: expect.objectContaining({
-          status: 'FAILED',
-          result: expect.objectContaining({
-            code: 'TEMPORAL_EXECUTION_MISSING',
-          }),
+        instanceId: BigInt(21),
+        expectedStatuses: ['RUNNING'],
+        temporalRunId: 'wf-7-21',
+        result: expect.objectContaining({
+          code: 'TEMPORAL_EXECUTION_MISSING',
         }),
       }),
     );