@gadmin2n/schematics 0.0.139 → 0.0.141

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

@@ -0,0 +1,512 @@
+import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-config.util';
+import { WorkflowCompilerService } from './workflow-compiler.service';
+
+describe('WorkflowCompilerService', () => {
+  it('compiles a webhook function that returns JSON to its HTTP caller', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(1),
+            type: 'webhook_trigger',
+            runtimeKey: 'webhook_trigger',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 4,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+          {
+            id: BigInt(2),
+            type: 'return_result',
+            runtimeKey: 'return_result',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 4,
+            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() } as any,
+    );
+
+    const compiled = await service.compile(
+      {
+        nodes: [
+          {
+            id: 'webhook',
+            type: 'webhook_trigger',
+            config: {
+              path: 'create-ticket',
+              method: 'POST',
+              verificationMode: 'NONE',
+              responseMode: 'WAIT_FOR_RESULT',
+              responseTimeoutSeconds: 60,
+            },
+          },
+          {
+            id: 'return',
+            type: 'return_result',
+            config: {
+              resultType: 'JSON',
+              sourceMode: 'WORKFLOW',
+              path: 'body',
+            },
+          },
+        ],
+        edges: [
+          {
+            id: 'webhook-return',
+            source: 'webhook',
+            target: 'return',
+            kind: 'FLOW',
+          },
+        ],
+      },
+      { userId: 'author' },
+    );
+
+    expect(compiled.nodes).toEqual([
+      expect.objectContaining({ type: 'webhook_trigger' }),
+      expect.objectContaining({
+        type: 'return_result',
+        config: expect.objectContaining({ resultType: 'JSON' }),
+      }),
+    ]);
+  });
+
+  it('rejects a webhook function whose flow can finish without returning', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(1),
+            type: 'webhook_trigger',
+            runtimeKey: 'webhook_trigger',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 4,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+          {
+            id: BigInt(2),
+            type: 'code',
+            runtimeKey: 'code',
+            instancePolicy: 'OPTIONAL',
+            schemaVersion: 4,
+            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() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
+            {
+              id: 'webhook',
+              type: 'webhook_trigger',
+              config: {
+                path: 'create-ticket',
+                method: 'POST',
+                responseMode: 'WAIT_FOR_RESULT',
+              },
+            },
+            { id: 'code', type: 'code', config: {} },
+          ],
+          edges: [
+            {
+              id: 'webhook-code',
+              source: 'webhook',
+              target: 'code',
+              kind: 'FLOW',
+            },
+          ],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: '等待返回结果时，每个流程分支都必须以“返回结果”结束',
+        nodeId: 'webhook',
+      },
+    });
+  });
+
+  it('snapshots the current Node Instance config into the compiled workflow', async () => {
+    const instance = {
+      id: BigInt(12),
+      code: 'FINANCE_APPROVAL',
+      nodeTypeId: BigInt(7),
+      isEnabled: true,
+      config: { subjects: [{ provider: 'USER', refs: ['alice'] }] },
+    };
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(7),
+            type: 'approval',
+            runtimeKey: 'human_approval',
+            instancePolicy: 'REQUIRED',
+            schemaVersion: 3,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: {
+        findMany: jest.fn().mockResolvedValue([instance]),
+      },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    const compiled = await service.compile(
+      {
+        nodes: [
+          {
+            id: 'approval-1',
+            type: 'approval',
+            config: { stale: true },
+            instanceRef: {
+              instanceId: '12',
+              instanceCode: 'FINANCE_APPROVAL',
+            },
+          },
+        ],
+        edges: [],
+      },
+      { userId: 'author' },
+    );
+
+    expect(compiled.nodes[0]).toMatchObject({
+      runtimeKey: 'human_approval',
+      config: instance.config,
+      source: {
+        instanceId: '12',
+        instanceCode: 'FINANCE_APPROVAL',
+        schemaVersion: 3,
+        configHash: hashNodeInstanceConfig(instance.config),
+      },
+    });
+    instance.config.subjects[0].refs[0] = 'bob';
+    expect(compiled.nodes[0].config).toEqual({
+      subjects: [{ provider: 'USER', refs: ['alice'] }],
+    });
+  });
+
+  it('uses a workflow-local config override without changing the Node Instance', async () => {
+    const instance = {
+      id: BigInt(12),
+      code: 'FINANCE_APPROVAL',
+      nodeTypeId: BigInt(7),
+      isEnabled: true,
+      config: { timeoutSeconds: 0 },
+    };
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(7),
+            type: 'approval',
+            runtimeKey: 'human_approval',
+            instancePolicy: 'REQUIRED',
+            schemaVersion: 3,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: {
+        findMany: jest.fn().mockResolvedValue([instance]),
+      },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    const compiled = await service.compile(
+      {
+        nodes: [
+          {
+            id: 'approval-1',
+            type: 'approval',
+            config: instance.config,
+            configOverride: { timeoutSeconds: 3600 },
+            instanceRef: {
+              instanceId: '12',
+              instanceCode: 'FINANCE_APPROVAL',
+            },
+          },
+        ],
+        edges: [],
+      },
+      { userId: 'author' },
+    );
+
+    expect(compiled.nodes[0].config).toEqual({ timeoutSeconds: 3600 });
+    expect(compiled.nodes[0].source?.configHash).toBe(
+      hashNodeInstanceConfig({ timeoutSeconds: 3600 }),
+    );
+    expect(instance.config).toEqual({ timeoutSeconds: 0 });
+  });
+
+  it('rejects a Human Approval node that references a disabled channel', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(7),
+            type: 'approval',
+            runtimeKey: 'human_approval',
+            instancePolicy: 'REQUIRED',
+            schemaVersion: 4,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(12),
+            code: 'FINANCE_APPROVAL',
+            nodeTypeId: BigInt(7),
+            isEnabled: true,
+            config: { channelRef: 'external-main' },
+          },
+        ]),
+      },
+      approvalChannel: {
+        findUnique: jest.fn().mockResolvedValue({ isEnabled: false }),
+      },
+    };
+    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',
+              instanceRef: {
+                instanceId: '12',
+                instanceCode: 'FINANCE_APPROVAL',
+              },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: 'Approval Channel was not found or is disabled',
+        nodeId: 'approval-1',
+      },
+    });
+  });
+
+  it('rejects a Human Approval node missing a required channel argument', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(7),
+            type: 'approval',
+            runtimeKey: 'human_approval',
+            instancePolicy: 'REQUIRED',
+            schemaVersion: 6,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(12),
+            code: 'MYOA_APPROVAL',
+            nodeTypeId: BigInt(7),
+            isEnabled: true,
+            config: {
+              channelRef: 'myoa',
+              channelInputBindings: {
+                title: { source: 'WORKFLOW', path: 'requestTitle' },
+              },
+            },
+          },
+        ]),
+      },
+      approvalChannel: {
+        findUnique: jest.fn().mockResolvedValue({
+          isEnabled: true,
+          dispatchWorkflow: {
+            versions: [
+              {
+                dsl: {
+                  nodes: [
+                    {
+                      type: 'callable_trigger',
+                      config: {
+                        inputParameters: [
+                          { key: 'title', required: true },
+                          {
+                            key: 'content',
+                            label: '审批内容',
+                            required: 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: 'approval-1',
+              type: 'approval',
+              instanceRef: {
+                instanceId: '12',
+                instanceCode: 'MYOA_APPROVAL',
+              },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: '审批通道缺少必填参数：审批内容',
+        nodeId: 'approval-1',
+      },
+    });
+  });
+
+  it('rejects a Human Approval node that references a disabled automatic approver Workflow', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(7),
+            type: 'approval',
+            runtimeKey: 'human_approval',
+            instancePolicy: 'REQUIRED',
+            schemaVersion: 4,
+            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: [],
+        }),
+      },
+    };
+    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',
+              instanceRef: {
+                instanceId: '12',
+                instanceCode: 'FINANCE_APPROVAL',
+              },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: '自动找审批人的 Workflow 未发布或已停用',
+        nodeId: 'approval-1',
+      },
+    });
+  });
+});