@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -1,25 +1,317 @@
+import { BadRequestException } from '@nestjs/common';
 import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-config.util';
 import { WorkflowCompilerService } from './workflow-compiler.service';
 
 describe('WorkflowCompilerService', () => {
-  it('compiles a webhook function that returns its previous result', async () => {
+  it('allows an incomplete manual parameter draft to fail only at publication', async () => {
+    const validateOrThrow = jest.fn();
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
           {
             id: BigInt(1),
-            type: 'webhook_trigger',
-            runtimeKey: 'webhook_trigger',
+            type: 'manual_trigger',
+            runtimeKey: 'manual_trigger',
             instancePolicy: 'INLINE_ONLY',
-            schemaVersion: 4,
+            schemaVersion: 1,
             configSchema: { type: 'object' },
             uiSchema: {},
           },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
+            {
+              id: 'manual',
+              type: 'manual_trigger',
+              label: '手动触发',
+              config: {
+                inputParameters: [{ key: '', type: 'string' }],
+              },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: '启动参数 1 的参数名不能为空',
+        nodeLabel: '手动触发',
+        nodeId: 'manual',
+      },
+    });
+    expect(validateOrThrow).not.toHaveBeenCalled();
+  });
+
+  it('explains that an approval node needs at least one approver', async () => {
+    const validateOrThrow = jest.fn();
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
           {
-            id: BigInt(2),
-            type: 'return_result',
-            runtimeKey: 'return_result',
+            id: BigInt(1),
+            type: 'approval',
+            runtimeKey: 'human_approval',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 1,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
+            {
+              id: 'approval',
+              type: 'approval',
+              label: '人工审批',
+              config: { subjects: [] },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: '必须至少设置一位固定审批人或动态审批人',
+        nodeLabel: '人工审批',
+        nodeId: 'approval',
+      },
+    });
+    expect(validateOrThrow).not.toHaveBeenCalled();
+  });
+
+  it('rejects an invalid fixed binding before publication', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(1),
+            type: 'http_request',
+            runtimeKey: 'http_request',
             instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 1,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+      integrationConnection: {
+        findUnique: jest.fn().mockResolvedValue({ isEnabled: true }),
+      },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
+            {
+              id: 'request',
+              type: 'http_request',
+              config: {
+                connectionRef: 'erp',
+                bodyBindings: {
+                  payload: {
+                    source: 'FIXED',
+                    valueType: 'JSON',
+                    value: '{invalid',
+                  },
+                },
+              },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: '参数来源或固定值无效：config.bodyBindings.payload',
+        nodeId: 'request',
+      },
+    });
+  });
+
+  it('reports the node name and every schema error during publication', async () => {
+    const errors = [
+      {
+        path: '/script',
+        keyword: 'minLength',
+        message: 'must NOT have fewer than 1 characters',
+      },
+      {
+        path: '/',
+        keyword: 'required',
+        message: "must have required property 'mode'",
+      },
+    ];
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(1),
+            type: 'code',
+            label: '代码处理',
+            runtimeKey: 'code',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 1,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      {
+        validateOrThrow: jest.fn(() => {
+          throw new BadRequestException({
+            code: 'NODE_CONFIG_INVALID',
+            errors,
+          });
+        }),
+      } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
+            {
+              id: 'internal-node-id',
+              type: 'code',
+              label: '整理发布结果',
+              config: {},
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        code: 'NODE_CONFIG_INVALID',
+        message: '节点“整理发布结果”的配置不完整或有误',
+        nodeLabel: '整理发布结果',
+        errors,
+      },
+    });
+  });
+
+  it('reports every invalid approver with its node name', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(1),
+            type: 'approval',
+            label: '人工审批',
+            runtimeKey: 'human_approval',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 1,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      {
+        validateSubjects: jest.fn(() => {
+          throw new BadRequestException({
+            code: 'SUBJECT_REF_INVALID',
+            issues: [
+              {
+                path: '/subjects/0/refs/0',
+                code: 'INVALID_REF',
+                message: 'ref must be a nonblank string',
+              },
+            ],
+          });
+        }),
+      } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
+            {
+              id: 'internal-node-id',
+              type: 'approval',
+              label: '部门负责人审批',
+              config: {
+                subjects: [{ source: 'STATIC', provider: 'USER', refs: [' '] }],
+              },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        code: 'SUBJECT_REF_INVALID',
+        message: '节点“部门负责人审批”的审批人配置不完整或无效',
+        nodeLabel: '部门负责人审批',
+        errors: [
+          {
+            path: '/subjects/0/refs/0',
+            keyword: 'INVALID_REF',
+            message: 'ref must be a nonblank string',
+          },
+        ],
+      },
+    });
+  });
+
+  it('compiles an asynchronous webhook trigger', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(1),
+            type: 'webhook_trigger',
+            runtimeKey: 'webhook_trigger',
+            instancePolicy: 'REQUIRED',
             schemaVersion: 4,
             configSchema: { type: 'object' },
             uiSchema: {},
@@ -47,38 +339,20 @@ describe('WorkflowCompilerService', () => {
               path: 'create-ticket',
               method: 'POST',
               verificationMode: 'NONE',
-              responseMode: 'WAIT_FOR_RESULT',
-              responseTimeoutSeconds: 60,
             },
           },
-          {
-            id: 'return',
-            type: 'return_result',
-            config: {},
-          },
-        ],
-        edges: [
-          {
-            id: 'webhook-return',
-            source: 'webhook',
-            target: 'return',
-            kind: 'FLOW',
-          },
         ],
+        edges: [],
       },
       { userId: 'author' },
     );
 
     expect(compiled.nodes).toEqual([
       expect.objectContaining({ type: 'webhook_trigger' }),
-      expect.objectContaining({
-        type: 'return_result',
-        config: {},
-      }),
     ]);
   });
 
-  it('rejects a webhook function whose flow can finish without returning', async () => {
+  it('accepts a webhook flow that ends at a business node', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -123,7 +397,6 @@ describe('WorkflowCompilerService', () => {
               config: {
                 path: 'create-ticket',
                 method: 'POST',
-                responseMode: 'WAIT_FOR_RESULT',
               },
             },
             { id: 'code', type: 'code', config: {} },
@@ -139,15 +412,15 @@ describe('WorkflowCompilerService', () => {
         },
         { userId: 'author' },
       ),
-    ).rejects.toMatchObject({
-      response: {
-        message: '等待返回结果时，每个流程分支都必须以“返回调用”结束',
-        nodeId: 'webhook',
-      },
+    ).resolves.toMatchObject({
+      nodes: [
+        expect.objectContaining({ type: 'webhook_trigger' }),
+        expect.objectContaining({ type: 'code' }),
+      ],
     });
   });
 
-  it('snapshots the current Node Instance config into the compiled workflow', async () => {
+  it('snapshots a Node Instance config regardless of the legacy instance policy', async () => {
     const instance = {
       id: BigInt(12),
       code: 'FINANCE_APPROVAL',
@@ -162,7 +435,7 @@ describe('WorkflowCompilerService', () => {
             id: BigInt(7),
             type: 'approval',
             runtimeKey: 'human_approval',
-            instancePolicy: 'REQUIRED',
+            instancePolicy: 'INLINE_ONLY',
             schemaVersion: 3,
             configSchema: { type: 'object' },
             uiSchema: {},
@@ -254,7 +527,12 @@ describe('WorkflowCompilerService', () => {
             id: 'approval-1',
             type: 'approval',
             config: instance.config,
-            configOverride: { timeoutSeconds: 3600 },
+            configOverride: {
+              timeoutSeconds: 3600,
+              subjects: [
+                { source: 'STATIC', provider: 'USER', refs: ['alice'] },
+              ],
+            },
             instanceRef: {
               instanceId: '12',
               instanceCode: 'FINANCE_APPROVAL',
@@ -266,14 +544,38 @@ describe('WorkflowCompilerService', () => {
       { userId: 'author' },
     );
 
-    expect(compiled.nodes[0].config).toEqual({ timeoutSeconds: 3600 });
+    const expectedOverride = {
+      timeoutSeconds: 3600,
+      subjects: [{ source: 'STATIC', provider: 'USER', refs: ['alice'] }],
+    };
+    expect(compiled.nodes[0].config).toEqual(expectedOverride);
     expect(compiled.nodes[0].source?.configHash).toBe(
-      hashNodeInstanceConfig({ timeoutSeconds: 3600 }),
+      hashNodeInstanceConfig(expectedOverride),
     );
     expect(instance.config).toEqual({ timeoutSeconds: 0 });
   });
 
-  it('rejects a Human Approval node that references a disabled Workflow', async () => {
+  it('compiles a self-contained Human Approval node without loading another Workflow', async () => {
+    const findWorkflow = jest.fn();
+    const config = {
+      task: {
+        title: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '采购申请审批',
+        },
+        description: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '',
+        },
+        details: [],
+      },
+      subjects: [{ source: 'STATIC', provider: 'USER', refs: ['alice'] }],
+      approvalRule: { mode: 'ANY' },
+      rejectionRule: { mode: 'ANY' },
+      timeout: { durationSeconds: 0, action: 'REJECTED' },
+    };
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -281,29 +583,144 @@ describe('WorkflowCompilerService', () => {
             id: BigInt(7),
             type: 'approval',
             runtimeKey: 'human_approval',
-            instancePolicy: 'REQUIRED',
-            schemaVersion: 4,
+            instancePolicy: 'OPTIONAL',
+            schemaVersion: 12,
             configSchema: { type: 'object' },
             uiSchema: {},
           },
         ]),
       },
-      workflowNodeInstance: {
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+      workflow: { findUnique: findWorkflow },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [{ id: 'approval-1', type: 'approval', config }],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).resolves.toMatchObject({
+      nodes: [expect.objectContaining({ type: 'approval', config })],
+    });
+    expect(findWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('validates the connections embedded in a Human Approval node', async () => {
+    const findConnection = jest.fn().mockImplementation(({ where }) =>
+      Promise.resolve({
+        isEnabled: where.code === 'myoa' || where.code === 'erp',
+      }),
+    );
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(7),
+            type: 'approval',
+            runtimeKey: 'human_approval',
+            instancePolicy: 'OPTIONAL',
+            schemaVersion: 16,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+      integrationConnection: { findUnique: findConnection },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await service.compile(
+      {
+        nodes: [
+          {
+            id: 'approval-1',
+            type: 'approval',
+            config: {
+              external: { request: { connectionRef: 'myoa' } },
+              subjects: [
+                {
+                  source: 'DYNAMIC',
+                  provider: 'USER',
+                  inputKey: 'direct_manager',
+                  label: '查询直属领导',
+                  lookup: { request: { connectionRef: 'erp' } },
+                },
+              ],
+            },
+          },
+        ],
+        edges: [],
+      },
+      { userId: 'author' },
+    );
+
+    expect(findConnection).toHaveBeenCalledTimes(2);
+    expect(findConnection).toHaveBeenCalledWith({
+      where: { code: 'myoa' },
+      select: { isEnabled: true },
+    });
+    expect(findConnection).toHaveBeenCalledWith({
+      where: { code: 'erp' },
+      select: { isEnabled: true },
+    });
+  });
+
+  it('validates required inputs from the selected published version', async () => {
+    const findWorkflow = jest.fn().mockResolvedValue({
+      status: 'PUBLISHED',
+      isEnabled: true,
+      versions: [
+        {
+          dsl: {
+            nodes: [
+              {
+                id: 'input',
+                type: 'callable_trigger',
+                config: {
+                  inputParameters: [
+                    { key: 'orderId', label: '订单 ID', required: true },
+                  ],
+                },
+              },
+              { id: 'work', type: 'code', config: {} },
+            ],
+            edges: [{ source: 'input', target: 'work', kind: 'FLOW' }],
+          },
+        },
+      ],
+    });
+    const prisma = {
+      workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
           {
-            id: BigInt(12),
-            code: 'FINANCE_APPROVAL',
-            nodeTypeId: BigInt(7),
-            isEnabled: true,
-            config: { approvalWorkflowId: '11' },
+            id: BigInt(8),
+            type: 'sub_workflow',
+            runtimeKey: 'sub_workflow',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 2,
+            configSchema: { type: 'object' },
+            uiSchema: {},
           },
         ]),
       },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
       workflow: {
-        findUnique: jest.fn().mockResolvedValue({
-          isEnabled: false,
-          status: 'PUBLISHED',
-        }),
+        findUnique: findWorkflow,
       },
     };
     const service = new WorkflowCompilerService(
@@ -318,11 +735,12 @@ describe('WorkflowCompilerService', () => {
         {
           nodes: [
             {
-              id: 'approval-1',
-              type: 'approval',
-              instanceRef: {
-                instanceId: '12',
-                instanceCode: 'FINANCE_APPROVAL',
+              id: 'call-1',
+              type: 'sub_workflow',
+              config: {
+                workflowId: '42',
+                workflowVersionId: '420',
+                inputBindings: {},
               },
             },
           ],
@@ -332,77 +750,60 @@ describe('WorkflowCompilerService', () => {
       ),
     ).rejects.toMatchObject({
       response: {
-        message: 'Approval Workflow was not found, published, or enabled',
-        nodeId: 'approval-1',
+        message: '调用 Workflow 的参数来源无效：订单 ID',
+        nodeId: 'call-1',
       },
     });
+    expect(findWorkflow).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { id: BigInt(42) },
+        select: expect.objectContaining({
+          versions: expect.objectContaining({
+            where: { id: BigInt(420) },
+          }),
+        }),
+      }),
+    );
+    expect(findWorkflow.mock.calls[0][0].select).not.toHaveProperty('status');
   });
 
-  it('rejects a Human Approval node missing a required Workflow argument', async () => {
+  it('rejects an indirect Workflow invocation cycle', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
           {
-            id: BigInt(7),
-            type: 'approval',
-            runtimeKey: 'human_approval',
-            instancePolicy: 'REQUIRED',
-            schemaVersion: 6,
+            id: BigInt(8),
+            type: 'sub_workflow',
+            runtimeKey: 'sub_workflow',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 4,
             configSchema: { type: 'object' },
             uiSchema: {},
           },
         ]),
       },
-      workflowNodeInstance: {
-        findMany: jest.fn().mockResolvedValue([
-          {
-            id: BigInt(12),
-            code: 'MYOA_APPROVAL',
-            nodeTypeId: BigInt(7),
-            isEnabled: true,
-            config: {
-              approvalWorkflowId: '11',
-              approvalWorkflowInputBindings: {
-                title: { source: 'WORKFLOW', path: 'requestTitle' },
-              },
-            },
-          },
-        ]),
-      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
       workflow: {
         findUnique: jest.fn().mockResolvedValue({
-          isEnabled: true,
           status: 'PUBLISHED',
+          isEnabled: true,
           versions: [
             {
               dsl: {
                 nodes: [
+                  { id: 'input', type: 'callable_trigger', config: {} },
                   {
-                    id: 'input',
-                    type: 'callable_trigger',
+                    id: 'call-current',
+                    type: 'sub_workflow',
                     config: {
-                      inputParameters: [
-                        { key: 'title', required: true },
-                        {
-                          key: 'content',
-                          label: '审批内容',
-                          required: true,
-                        },
-                      ],
+                      workflowId: '7',
+                      workflowVersionId: '70',
+                      inputBindings: {},
                     },
                   },
-                  {
-                    id: 'return',
-                    type: 'return_result',
-                    config: {},
-                  },
                 ],
                 edges: [
-                  {
-                    source: 'input',
-                    target: 'return',
-                    kind: 'FLOW',
-                  },
+                  { source: 'input', target: 'call-current', kind: 'FLOW' },
                 ],
               },
             },
@@ -422,72 +823,100 @@ describe('WorkflowCompilerService', () => {
         {
           nodes: [
             {
-              id: 'approval-1',
-              type: 'approval',
-              instanceRef: {
-                instanceId: '12',
-                instanceCode: 'MYOA_APPROVAL',
+              id: 'call-1',
+              type: 'sub_workflow',
+              config: {
+                workflowId: '42',
+                workflowVersionId: '420',
+                inputBindings: {},
               },
             },
           ],
           edges: [],
         },
         { userId: 'author' },
+        { workflowId: BigInt(7) },
       ),
     ).rejects.toMatchObject({
       response: {
-        message: '审批 Workflow 缺少必填参数：审批内容',
-        nodeId: 'approval-1',
+        message: '调用 Workflow 的固定版本调用链存在循环',
+        nodeId: 'call-1',
       },
     });
   });
 
-  it('rejects a Human Approval node that references a disabled automatic approver Workflow', async () => {
+  it('allows a new version to call a historical version of the same Workflow when the fixed version graph terminates', async () => {
+    const prisma = {
+      workflow: {
+        findUnique: jest.fn().mockResolvedValue({
+          versions: [
+            {
+              dsl: {
+                nodes: [
+                  { id: 'input', type: 'callable_trigger', config: {} },
+                  {
+                    id: 'done',
+                    type: 'code',
+                    config: { script: 'return input;' },
+                  },
+                ],
+                edges: [
+                  {
+                    id: 'input-done',
+                    source: 'input',
+                    target: 'done',
+                    kind: 'FLOW',
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+      },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      {} as any,
+      {} as any,
+      {} as any,
+    );
+
+    await expect(
+      (service as any).assertNoInvocationCycle(
+        BigInt(42),
+        BigInt(420),
+        {
+          nodes: [
+            {
+              id: 'call-a-v1',
+              type: 'sub_workflow',
+              config: { workflowId: '7', workflowVersionId: '70' },
+            },
+          ],
+          edges: [],
+        },
+        { id: 'call-b-v1' },
+        '调用 Workflow',
+      ),
+    ).resolves.toBeUndefined();
+  });
+
+  it('rejects a data-modifying statement when database writes are disabled', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
           {
-            id: BigInt(7),
-            type: 'approval',
-            runtimeKey: 'human_approval',
-            instancePolicy: 'REQUIRED',
-            schemaVersion: 4,
+            id: BigInt(10),
+            type: 'db_execute',
+            runtimeKey: 'db_execute',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 2,
             configSchema: { type: 'object' },
             uiSchema: {},
           },
         ]),
       },
-      workflowNodeInstance: {
-        findMany: jest.fn().mockResolvedValue([
-          {
-            id: BigInt(12),
-            code: 'FINANCE_APPROVAL',
-            nodeTypeId: BigInt(7),
-            isEnabled: true,
-            config: {
-              approverSources: [
-                {
-                  workflowId: '99',
-                  inputBindings: {
-                    employeeId: {
-                      source: 'WORKFLOW',
-                      path: 'applicantId',
-                    },
-                  },
-                },
-              ],
-            },
-          },
-        ]),
-      },
-      workflow: {
-        findUnique: jest.fn().mockResolvedValue({
-          id: BigInt(99),
-          status: 'PUBLISHED',
-          isEnabled: false,
-          versions: [],
-        }),
-      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
     };
     const service = new WorkflowCompilerService(
       prisma as any,
@@ -501,11 +930,11 @@ describe('WorkflowCompilerService', () => {
         {
           nodes: [
             {
-              id: 'approval-1',
-              type: 'approval',
-              instanceRef: {
-                instanceId: '12',
-                instanceCode: 'FINANCE_APPROVAL',
+              id: 'database-1',
+              type: 'db_execute',
+              config: {
+                allowWrite: false,
+                sql: 'WITH removed AS (DELETE FROM users RETURNING id) SELECT * FROM removed',
               },
             },
           ],
@@ -515,57 +944,79 @@ describe('WorkflowCompilerService', () => {
       ),
     ).rejects.toMatchObject({
       response: {
-        message: '自动找审批人的 Workflow 未发布或已停用',
-        nodeId: 'approval-1',
+        message: '当前数据库操作节点只允许单条只读查询',
+        nodeId: 'database-1',
       },
     });
   });
 
-  it('validates required inputs when calling another Workflow', async () => {
+  it('accepts a single data write when database writes are enabled', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
           {
-            id: BigInt(8),
-            type: 'sub_workflow',
-            runtimeKey: 'sub_workflow',
+            id: BigInt(10),
+            type: 'db_execute',
+            runtimeKey: 'db_execute',
             instancePolicy: 'INLINE_ONLY',
-            schemaVersion: 2,
+            schemaVersion: 4,
             configSchema: { type: 'object' },
             uiSchema: {},
           },
         ]),
       },
       workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
-      workflow: {
-        findUnique: jest.fn().mockResolvedValue({
-          status: 'PUBLISHED',
-          isEnabled: true,
-          versions: [
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
             {
-              dsl: {
-                nodes: [
-                  {
-                    id: 'input',
-                    type: 'callable_trigger',
-                    config: {
-                      inputParameters: [
-                        { key: 'orderId', label: '订单 ID', required: true },
-                      ],
-                    },
-                  },
-                  { id: 'work', type: 'code', config: {} },
-                  { id: 'return', type: 'return_result', config: {} },
-                ],
-                edges: [
-                  { source: 'input', target: 'work', kind: 'FLOW' },
-                  { source: 'work', target: 'return', kind: 'FLOW' },
-                ],
+              id: 'database-1',
+              type: 'db_execute',
+              config: {
+                allowWrite: true,
+                sql: 'UPDATE users SET active = $1 WHERE id = $2',
               },
             },
           ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).resolves.toMatchObject({
+      nodes: [
+        expect.objectContaining({
+          id: 'database-1',
+          config: expect.objectContaining({ allowWrite: true }),
         }),
+      ],
+    });
+  });
+
+  it('accepts one writable CTE when database writes are enabled', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(10),
+            type: 'db_execute',
+            runtimeKey: 'db_execute',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 4,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
       },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
     };
     const service = new WorkflowCompilerService(
       prisma as any,
@@ -579,20 +1030,20 @@ describe('WorkflowCompilerService', () => {
         {
           nodes: [
             {
-              id: 'call-1',
-              type: 'sub_workflow',
-              config: { workflowId: '42', inputBindings: {} },
+              id: 'database-1',
+              type: 'db_execute',
+              config: {
+                allowWrite: true,
+                sql: 'WITH changed AS (UPDATE requests SET status = $1 RETURNING id) UPDATE assets SET state = $2 WHERE request_id IN (SELECT id FROM changed)',
+              },
             },
           ],
           edges: [],
         },
         { userId: 'author' },
       ),
-    ).rejects.toMatchObject({
-      response: {
-        message: '调用 Workflow 的参数来源无效：订单 ID',
-        nodeId: 'call-1',
-      },
+    ).resolves.toMatchObject({
+      nodes: [expect.objectContaining({ id: 'database-1' })],
     });
   });
 });