@gadmin2n/schematics 0.0.139 → 0.0.141

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

@@ -1,8 +1,10 @@
 import { NotFoundException, UnauthorizedException } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { PrismaService } from 'nestjs-prisma';
+import { HumanApprovalService } from '../humanApproval/human-approval.service';
 import { TemporalService } from './temporal.service';
 import { signWebhookPayload } from './webhook-signature.util';
+import { WorkflowCompilerService } from './workflow-compiler.service';
 import { WorkflowService } from './workflow.service';
 
 describe('WorkflowService — cron lifecycle hooks', () => {
@@ -30,15 +32,34 @@ describe('WorkflowService — cron lifecycle hooks', () => {
           { type: 'http_request', outputs: [] },
           { type: 'if_else', outputs: ['true', 'false'] },
           { type: 'switch', outputs: null },
+          { type: 'approval', outputs: ['true', 'false'] },
+          { type: 'custom_branch', outputs: ['success', 'failure'] },
         ]),
       },
+      externalInteraction: {
+        findMany: jest.fn().mockResolvedValue([]),
+        deleteMany: jest.fn(),
+      },
+      externalInteractionEvent: { deleteMany: jest.fn() },
+      externalInteractionSignalOutbox: { deleteMany: jest.fn() },
       $transaction: jest.fn(async (cb: any) =>
         cb({
           workflowVersion: {
             findFirst: prisma.workflowVersion.findFirst,
-            create: prisma.workflowVersion.create,
+            create: async (args: any) => ({
+              ...(await prisma.workflowVersion.create(args)),
+              dsl: args.data.dsl,
+            }),
           },
-          workflow: { update: prisma.workflow.update },
+          workflow: {
+            update: prisma.workflow.update,
+            delete: prisma.workflow.delete,
+          },
+          externalInteraction: prisma.externalInteraction,
+          externalInteractionEvent: prisma.externalInteractionEvent,
+          externalInteractionSignalOutbox:
+            prisma.externalInteractionSignalOutbox,
+          audit: { create: jest.fn() },
         }),
       ),
     };
@@ -54,12 +75,116 @@ describe('WorkflowService — cron lifecycle hooks', () => {
         WorkflowService,
         { provide: PrismaService, useValue: prisma },
         { provide: TemporalService, useValue: temporal },
+        { provide: HumanApprovalService, useValue: {} },
+        {
+          provide: WorkflowCompilerService,
+          useValue: { compile: jest.fn(async (dsl: any) => dsl) },
+        },
       ],
     }).compile();
 
     service = module.get<WorkflowService>(WorkflowService);
   });
 
+  describe('draft publication state', () => {
+    const savedDsl = {
+      nodes: [
+        {
+          id: 'start',
+          type: 'manual_trigger',
+          label: '开始',
+          position: { x: 120, y: 80 },
+          config: { inputSchema: {} },
+        },
+      ],
+      edges: [],
+    };
+    const publishedDsl = {
+      nodes: [
+        {
+          id: 'start',
+          type: 'manual_trigger',
+          label: '开始',
+          position: { y: 80, x: 120 },
+          config: { inputSchema: {} },
+          runtimeKey: 'manual_trigger',
+          source: {
+            instanceId: '9',
+            instanceCode: 'START_TEMPLATE',
+            schemaVersion: 1,
+            configHash: 'published-hash',
+          },
+        },
+      ],
+      edges: [],
+    };
+
+    it('keeps a saved workflow published when its DSL matches the latest version', async () => {
+      prisma.workflow.findUnique.mockResolvedValueOnce({
+        id: BigInt(42),
+        versions: [{ dsl: publishedDsl }],
+      });
+      prisma.workflow.update.mockImplementationOnce(({ data }: any) =>
+        Promise.resolve(data),
+      );
+
+      const result = await service.saveDraft(BigInt(42), savedDsl);
+
+      expect(result).toMatchObject({ dsl: savedDsl, status: 'PUBLISHED' });
+    });
+
+    it('marks a saved workflow as draft when a node configuration changed', async () => {
+      prisma.workflow.findUnique.mockResolvedValueOnce({
+        id: BigInt(42),
+        versions: [{ dsl: publishedDsl }],
+      });
+      prisma.workflow.update.mockImplementationOnce(({ data }: any) =>
+        Promise.resolve(data),
+      );
+      const changedDsl = {
+        ...savedDsl,
+        nodes: [
+          {
+            ...savedDsl.nodes[0],
+            label: '新的开始节点',
+          },
+        ],
+      };
+
+      const result = await service.saveDraft(BigInt(42), changedDsl);
+
+      expect(result).toMatchObject({ dsl: changedDsl, status: 'DRAFT' });
+    });
+
+    it('does not create a version when the saved DSL is already published', async () => {
+      prisma.workflow.findUnique.mockResolvedValueOnce({
+        id: BigInt(42),
+        dsl: savedDsl,
+        status: 'DRAFT',
+        versions: [{ version: 1, dsl: publishedDsl }],
+      });
+      prisma.workflowVersion.findFirst.mockResolvedValue({
+        version: 1,
+        dsl: publishedDsl,
+      });
+      prisma.workflowVersion.create.mockResolvedValueOnce({
+        id: BigInt(2),
+        version: 2,
+        dsl: savedDsl,
+      });
+      prisma.workflow.update.mockResolvedValueOnce({});
+
+      await expect(
+        service.publish(BigInt(42), { changeSummary: 'duplicate' }, 'tester'),
+      ).rejects.toMatchObject({
+        response: expect.objectContaining({
+          code: 'WORKFLOW_DSL_UNCHANGED',
+        }),
+      });
+      expect(prisma.workflowVersion.create).not.toHaveBeenCalled();
+    });
+  });
+
   describe('publish — cron schedule sync', () => {
     const ID = BigInt(42);
     const mkWorkflow = (dsl: any) => ({ id: ID, dsl, status: 'DRAFT' });
@@ -136,6 +261,35 @@ describe('WorkflowService — cron lifecycle hooks', () => {
       ).rejects.toThrow(/requires a secret/);
     });
 
+    it('allows a direct webhook trigger to publish without an HMAC secret', async () => {
+      const dsl = {
+        nodes: [
+          {
+            id: 't1',
+            type: 'webhook_trigger',
+            config: {
+              path: 'myoa-callback',
+              method: 'POST',
+              verificationMode: 'NONE',
+            },
+          },
+        ],
+        edges: [],
+      };
+      prisma.workflow.findUnique.mockResolvedValueOnce(mkWorkflow(dsl));
+      prisma.workflow.findMany.mockResolvedValueOnce([]);
+      prisma.workflowVersion.findFirst.mockResolvedValueOnce(null);
+      prisma.workflowVersion.create.mockResolvedValueOnce({
+        id: BigInt(1),
+        version: 1,
+      });
+      prisma.workflow.update.mockResolvedValueOnce({});
+
+      await expect(
+        service.publish(ID, { changeSummary: 'init' }, 'tester'),
+      ).resolves.toBeDefined();
+    });
+
     it('rejects webhook path collision with another published workflow', async () => {
       const dsl = {
         nodes: [
@@ -152,15 +306,23 @@ describe('WorkflowService — cron lifecycle hooks', () => {
         {
           id: BigInt(999),
           name: 'other',
-          dsl: {
-            nodes: [
-              {
-                id: 't1',
-                type: 'webhook_trigger',
-                config: { path: 'order-paid', method: 'POST', secret: 'x' },
+          versions: [
+            {
+              dsl: {
+                nodes: [
+                  {
+                    id: 't1',
+                    type: 'webhook_trigger',
+                    config: {
+                      path: 'order-paid',
+                      method: 'POST',
+                      secret: 'x',
+                    },
+                  },
+                ],
               },
-            ],
-          },
+            },
+          ],
         },
       ]);
 
@@ -185,15 +347,23 @@ describe('WorkflowService — cron lifecycle hooks', () => {
         {
           id: BigInt(999),
           name: 'other',
-          dsl: {
-            nodes: [
-              {
-                id: 't1',
-                type: 'webhook_trigger',
-                config: { path: 'order-paid', method: 'POST', secret: 'x' },
+          versions: [
+            {
+              dsl: {
+                nodes: [
+                  {
+                    id: 't1',
+                    type: 'webhook_trigger',
+                    config: {
+                      path: 'order-paid',
+                      method: 'POST',
+                      secret: 'x',
+                    },
+                  },
+                ],
               },
-            ],
-          },
+            },
+          ],
         },
       ]);
       prisma.workflowVersion.findFirst.mockResolvedValueOnce(null);
@@ -208,6 +378,84 @@ describe('WorkflowService — cron lifecycle hooks', () => {
       ).resolves.toBeDefined();
     });
 
+    it('accepts approval branches declared by Workflow node metadata', async () => {
+      const dsl = {
+        nodes: [
+          { id: 't1', type: 'manual_trigger', config: {} },
+          { id: 'approval1', type: 'approval', config: {} },
+          { id: 'approved', type: 'code', config: {} },
+          { id: 'rejected', type: 'code', config: {} },
+        ],
+        edges: [
+          { id: 'e1', source: 't1', target: 'approval1' },
+          {
+            id: 'e2',
+            source: 'approval1',
+            target: 'approved',
+            sourceHandle: 'true',
+          },
+          {
+            id: 'e3',
+            source: 'approval1',
+            target: 'rejected',
+            sourceHandle: 'false',
+          },
+        ],
+      };
+      prisma.workflow.findUnique.mockResolvedValueOnce(mkWorkflow(dsl));
+      prisma.workflowVersion.findFirst.mockResolvedValueOnce(null);
+      prisma.workflowVersion.create.mockResolvedValueOnce({
+        id: BigInt(1),
+        version: 1,
+      });
+      prisma.workflow.update.mockResolvedValueOnce({});
+
+      await expect(
+        service.publish(ID, { changeSummary: 'init' }, 'tester'),
+      ).resolves.toBeDefined();
+    });
+
+    it('rejects an output handle not declared by Workflow node metadata', async () => {
+      const dsl = {
+        nodes: [
+          { id: 't1', type: 'manual_trigger', config: {} },
+          { id: 'branch1', type: 'custom_branch', config: {} },
+          { id: 'next', type: 'code', config: {} },
+        ],
+        edges: [
+          { id: 'e1', source: 't1', target: 'branch1' },
+          {
+            id: 'e2',
+            source: 'branch1',
+            target: 'next',
+            sourceHandle: 'unknown',
+          },
+        ],
+      };
+      prisma.workflow.findUnique.mockResolvedValueOnce(mkWorkflow(dsl));
+      prisma.workflowVersion.findFirst.mockResolvedValueOnce(null);
+      prisma.workflowVersion.create.mockResolvedValueOnce({
+        id: BigInt(1),
+        version: 1,
+      });
+      prisma.workflow.update.mockResolvedValueOnce({});
+
+      await expect(
+        service.publish(ID, { changeSummary: 'init' }, 'tester'),
+      ).rejects.toMatchObject({
+        status: 400,
+        response: expect.objectContaining({
+          code: 'DSL_HANDLE_VALIDATION',
+          errors: expect.arrayContaining([
+            expect.objectContaining({
+              edgeId: 'e2',
+              code: 'UNKNOWN_HANDLE',
+            }),
+          ]),
+        }),
+      });
+    });
+
     it('rejects with 400 BadRequestException when DSL has invalid sourceHandle', async () => {
       // if_else node has enumerated outputs ['true','false']; sending 'maybe'
       // must trigger the new sourceHandle validator and produce a 400 with a
@@ -280,6 +528,54 @@ describe('WorkflowService — cron lifecycle hooks', () => {
   describe('remove', () => {
     const ID = BigInt(42);
 
+    it('deletes external interaction history before deleting the workflow', async () => {
+      const rows = {
+        interactionEvents: 1,
+        signalOutboxes: 1,
+        interactions: 1,
+        workflowExists: true,
+      };
+      const deleteWorkflow = jest.fn(async () => {
+        if (rows.interactions > 0)
+          throw new Error('Foreign key constraint failed');
+        rows.workflowExists = false;
+        return { id: ID };
+      });
+      prisma.workflow.findUnique.mockResolvedValueOnce({ id: ID });
+      prisma.workflow.delete.mockImplementationOnce(deleteWorkflow);
+      prisma.$transaction.mockImplementationOnce(async (callback: any) =>
+        callback({
+          externalInteraction: {
+            findMany: jest.fn(async () => [{ id: BigInt(100) }]),
+            deleteMany: jest.fn(async () => {
+              if (rows.interactionEvents > 0 || rows.signalOutboxes > 0)
+                throw new Error('Foreign key constraint failed');
+              rows.interactions = 0;
+            }),
+          },
+          externalInteractionEvent: {
+            deleteMany: jest.fn(async () => {
+              rows.interactionEvents = 0;
+            }),
+          },
+          externalInteractionSignalOutbox: {
+            deleteMany: jest.fn(async () => {
+              rows.signalOutboxes = 0;
+            }),
+          },
+          workflow: { delete: deleteWorkflow },
+        }),
+      );
+
+      await expect(service.remove(ID)).resolves.toEqual({ id: ID });
+      expect(rows).toEqual({
+        interactionEvents: 0,
+        signalOutboxes: 0,
+        interactions: 0,
+        workflowExists: false,
+      });
+    });
+
     it('deletes cron schedule before deleting workflow', async () => {
       prisma.workflow.findUnique.mockResolvedValueOnce({ id: ID });
       prisma.workflow.delete.mockResolvedValueOnce({});
@@ -321,6 +617,7 @@ describe('WorkflowService — receiveWebhook', () => {
     };
     temporal = {
       startWorkflow: jest.fn(async () => ({ temporalRunId: 'run-1' })),
+      waitForWorkflowResult: jest.fn(),
     };
 
     const module: TestingModule = await Test.createTestingModule({
@@ -328,6 +625,11 @@ describe('WorkflowService — receiveWebhook', () => {
         WorkflowService,
         { provide: PrismaService, useValue: prisma },
         { provide: TemporalService, useValue: temporal },
+        { provide: HumanApprovalService, useValue: {} },
+        {
+          provide: WorkflowCompilerService,
+          useValue: { compile: jest.fn(async (dsl: any) => dsl) },
+        },
       ],
     }).compile();
 
@@ -342,7 +644,14 @@ describe('WorkflowService — receiveWebhook', () => {
 
   const nowSec = () => Math.floor(Date.now() / 1000).toString();
 
-  const mkPublishedWorkflow = (id: number, secret = SECRET, path = PATH) => ({
+  const mkPublishedWorkflow = (
+    id: number,
+    secret = SECRET,
+    path = PATH,
+    verificationMode?: 'HMAC' | 'NONE',
+    responseMode?: 'IMMEDIATE' | 'WAIT_FOR_RESULT',
+    responseTimeoutSeconds?: number,
+  ) => ({
     id: BigInt(id),
     status: 'PUBLISHED',
     isEnabled: true,
@@ -356,7 +665,14 @@ describe('WorkflowService — receiveWebhook', () => {
             {
               id: 't1',
               type: 'webhook_trigger',
-              config: { path, method: METHOD, secret },
+              config: {
+                path,
+                method: METHOD,
+                secret,
+                ...(verificationMode && { verificationMode }),
+                ...(responseMode && { responseMode }),
+                ...(responseTimeoutSeconds && { responseTimeoutSeconds }),
+              },
             },
           ],
           edges: [],
@@ -379,11 +695,17 @@ describe('WorkflowService — receiveWebhook', () => {
         },
       ],
     }));
+    prisma.workflowVersion.findFirst.mockImplementation(({ where }: any) => ({
+      id: where.id,
+      version: 1,
+      dsl: { nodes: [], edges: [] },
+    }));
     prisma.workflowInstance.create.mockResolvedValueOnce({ id: BigInt(7777) });
     prisma.workflowInstance.update.mockResolvedValueOnce({});
   };
 
   it('returns 401 (UnauthorizedException) when timestamp is missing', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([mkPublishedWorkflow(1)]);
     const sig = signWebhookPayload(SECRET, nowSec(), RAW);
     await expect(
       service.receiveWebhook({
@@ -400,6 +722,7 @@ describe('WorkflowService — receiveWebhook', () => {
   });
 
   it('returns 401 when timestamp is older than 5 minutes', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([mkPublishedWorkflow(1)]);
     const oldTs = String(Math.floor(Date.now() / 1000) - 6 * 60);
     const sig = signWebhookPayload(SECRET, oldTs, RAW);
     await expect(
@@ -473,8 +796,157 @@ describe('WorkflowService — receiveWebhook', () => {
     expect(temporal.startWorkflow).toHaveBeenCalledTimes(1);
     const startArg = temporal.startWorkflow.mock.calls[0][0];
     expect(startArg.context).toMatchObject({
+      workflow: {
+        body: { orderId: 42 },
+        query: { foo: 'bar' },
+      },
+      nodes: {},
+    });
+  });
+
+  it('starts a direct webhook without signature headers', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([
+      mkPublishedWorkflow(1, '', PATH, 'NONE'),
+    ]);
+    mkExecuteSetup();
+
+    const result = await service.receiveWebhook({
+      path: PATH,
+      method: METHOD,
+      signatureHeader: undefined,
+      timestampHeader: undefined,
+      rawBody: RAW,
+      body: { id: 'myoa-work-item-1' },
+      headers: { 'content-type': 'text/json' },
+      query: {},
+    });
+
+    expect(result.instanceIds).toEqual(['7777']);
+    expect(temporal.startWorkflow).toHaveBeenCalledTimes(1);
+    expect(temporal.startWorkflow.mock.calls[0][0].context).toMatchObject({
+      workflow: {
+        body: { id: 'myoa-work-item-1' },
+      },
+    });
+  });
+
+  it('waits for the Workflow return result when the trigger uses function mode', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([
+      mkPublishedWorkflow(1, '', PATH, 'NONE', 'WAIT_FOR_RESULT', 45),
+    ]);
+    mkExecuteSetup();
+    temporal.waitForWorkflowResult.mockResolvedValueOnce({
+      kind: 'COMPLETED',
+      result: {
+        status: 'COMPLETED',
+        output: {
+          ticketId: 'T-42',
+          accepted: true,
+        },
+        httpResponse: {
+          statusCode: 201,
+          headers: {
+            'x-workflow-result': 'created',
+          },
+        },
+      },
+    });
+
+    const result = await service.receiveWebhook({
+      path: PATH,
+      method: METHOD,
+      signatureHeader: undefined,
+      timestampHeader: undefined,
+      rawBody: RAW,
       body: { orderId: 42 },
-      query: { foo: 'bar' },
+      headers: {},
+      query: {},
+    });
+
+    expect(result).toEqual({
+      instanceIds: ['7777'],
+      response: {
+        statusCode: 201,
+        headers: {
+          'x-workflow-result': 'created',
+        },
+        body: {
+          ticketId: 'T-42',
+          accepted: true,
+        },
+      },
+    });
+    expect(temporal.waitForWorkflowResult).toHaveBeenCalledWith(
+      'run-1',
+      45_000,
+    );
+  });
+
+  it('returns a gateway timeout without cancelling a still-running Workflow', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([
+      mkPublishedWorkflow(1, '', PATH, 'NONE', 'WAIT_FOR_RESULT', 60),
+    ]);
+    mkExecuteSetup();
+    temporal.waitForWorkflowResult.mockResolvedValueOnce({
+      kind: 'TIMED_OUT',
+    });
+
+    const result = await service.receiveWebhook({
+      path: PATH,
+      method: METHOD,
+      signatureHeader: undefined,
+      timestampHeader: undefined,
+      rawBody: RAW,
+      body: {},
+      headers: {},
+      query: {},
+    });
+
+    expect(result).toEqual({
+      instanceIds: ['7777'],
+      response: {
+        statusCode: 504,
+        headers: {},
+        body: {
+          code: 'WORKFLOW_RESPONSE_TIMEOUT',
+          message: 'Workflow did not return a result within 60 seconds',
+          instanceId: '7777',
+        },
+      },
+    });
+  });
+
+  it('returns an internal error response when the Workflow execution fails', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([
+      mkPublishedWorkflow(1, '', PATH, 'NONE', 'WAIT_FOR_RESULT'),
+    ]);
+    mkExecuteSetup();
+    temporal.waitForWorkflowResult.mockRejectedValueOnce(
+      new Error('private Temporal failure'),
+    );
+
+    const result = await service.receiveWebhook({
+      path: PATH,
+      method: METHOD,
+      signatureHeader: undefined,
+      timestampHeader: undefined,
+      rawBody: RAW,
+      body: {},
+      headers: {},
+      query: {},
+    });
+
+    expect(result).toEqual({
+      instanceIds: ['7777'],
+      response: {
+        statusCode: 500,
+        headers: {},
+        body: {
+          code: 'WORKFLOW_EXECUTION_FAILED',
+          message: 'Workflow execution failed',
+          instanceId: '7777',
+        },
+      },
     });
   });