@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -1,6 +1,6 @@
 import {
   IsBoolean,
-  IsInt,
+  IsNotEmpty,
   IsObject,
   IsOptional,
   IsString,
@@ -10,18 +10,6 @@ export class ExecuteWorkflowDto {
   @IsOptional()
   @IsObject()
   workflow?: Record<string, any>;
-
-  @IsOptional()
-  @IsInt()
-  versionId?: number;
-}
-
-export class SignalWorkflowDto {
-  @IsString()
-  signalName: string;
-
-  @IsObject()
-  payload: Record<string, any>;
 }
 
 export class ApproveInstanceDto {
@@ -35,3 +23,9 @@ export class ApproveInstanceDto {
   @IsString()
   comment?: string;
 }
+
+export class RetryFromNodeDto {
+  @IsString()
+  @IsNotEmpty()
+  nodeId: string;
+}

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

@@ -24,22 +24,6 @@ export interface ExportPayload {
     config: any;
     isEnabled: boolean;
   }>;
-  nodeTypes: Array<{
-    type: string;
-    category: string;
-    label: string;
-    icon: string;
-    description: string | null;
-    configSchema: any;
-    inputSchema: any;
-    outputSchema: any;
-    outputs: any;
-    isBuiltin: boolean;
-    runtimeKey?: string;
-    uiSchema?: any;
-    schemaVersion?: number;
-    instancePolicy?: 'REQUIRED' | 'OPTIONAL' | 'INLINE_ONLY';
-  }>;
 }
 
 export interface ImportPreviewResponse {

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

@@ -0,0 +1,184 @@
+import {
+  ConflictException,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import * as jwt from 'jsonwebtoken';
+import { WorkflowExportService } from './workflow-export.service';
+
+const payload = {
+  version: 4,
+  exportedAt: '2026-08-14T00:00:00.000Z',
+  workflow: {
+    code: 'approval-flow',
+    name: '审批流程',
+    description: null,
+    status: 'PUBLISHED',
+    dsl: {
+      nodes: [
+        {
+          id: 'request',
+          type: 'http_request',
+          source: { instanceId: '10' },
+          config: { method: 'GET', path: '/users' },
+        },
+      ],
+      edges: [],
+    },
+  },
+  nodeInstances: [
+    {
+      sourceId: '10',
+      code: 'GET_USERS',
+      name: '查询用户',
+      description: null,
+      nodeTypeKey: 'http_request',
+      config: { method: 'GET', path: '/users' },
+      isEnabled: true,
+    },
+  ],
+};
+
+describe('WorkflowExportService', () => {
+  const originalSecret = process.env.TAIHU_ODC_APP_TOKEN;
+
+  afterEach(() => {
+    if (originalSecret === undefined) delete process.env.TAIHU_ODC_APP_TOKEN;
+    else process.env.TAIHU_ODC_APP_TOKEN = originalSecret;
+  });
+
+  it('fails closed when the export token secret is not configured', async () => {
+    delete process.env.TAIHU_ODC_APP_TOKEN;
+    const service = new WorkflowExportService({
+      workflow: {
+        findUnique: jest.fn().mockResolvedValue({ code: 'approval-flow' }),
+      },
+    } as never);
+
+    await expect(
+      service.generateExportToken(BigInt(1), 'https://example.test/api'),
+    ).rejects.toBeInstanceOf(InternalServerErrorException);
+  });
+
+  it('exports only workflow data and referenced instances', async () => {
+    process.env.TAIHU_ODC_APP_TOKEN = 'test-secret';
+    const prisma = {
+      workflow: {
+        findUnique: jest.fn().mockResolvedValue({
+          ...payload.workflow,
+          versions: [{ dsl: payload.workflow.dsl }],
+          dsl: payload.workflow.dsl,
+        }),
+      },
+      workflowNodeInstance: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(10),
+            ...payload.nodeInstances[0],
+            config: { method: 'POST', path: '/stale' },
+            nodeType: { type: 'http_request' },
+          },
+        ]),
+      },
+    };
+    const service = new WorkflowExportService(prisma as never);
+    const token = jwt.sign(
+      { workflowCode: payload.workflow.code },
+      process.env.TAIHU_ODC_APP_TOKEN,
+    );
+
+    const result = await service.getExportPayload(payload.workflow.code, token);
+
+    expect(result).toMatchObject({
+      version: 4,
+      workflow: { code: payload.workflow.code },
+      nodeInstances: [
+        expect.objectContaining({
+          code: 'GET_USERS',
+          config: payload.nodeInstances[0].config,
+        }),
+      ],
+    });
+    expect(result).not.toHaveProperty('nodeTypes');
+  });
+
+  it('reuses an identical local node instance without updating it', async () => {
+    const tx = {
+      workflowNodeType: {
+        findUnique: jest.fn().mockResolvedValue({ id: BigInt(2) }),
+      },
+      workflowNodeInstance: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: BigInt(20),
+          code: 'GET_USERS',
+          nodeTypeId: BigInt(2),
+          config: payload.nodeInstances[0].config,
+        }),
+        create: jest.fn(),
+      },
+      workflow: {
+        upsert: jest.fn().mockResolvedValue({
+          id: BigInt(30),
+          name: payload.workflow.name,
+        }),
+      },
+    };
+    const service = new WorkflowExportService({
+      $transaction: (callback: (client: typeof tx) => unknown) => callback(tx),
+    } as never);
+
+    await expect(service.importConfirm(payload, 'tester')).resolves.toEqual({
+      success: true,
+      workflowId: '30',
+      workflowName: payload.workflow.name,
+    });
+    expect(tx.workflowNodeInstance.create).not.toHaveBeenCalled();
+    expect(tx.workflow.upsert).toHaveBeenCalledWith(
+      expect.objectContaining({
+        create: expect.objectContaining({
+          dsl: expect.objectContaining({
+            nodes: [
+              expect.objectContaining({
+                instanceRef: {
+                  instanceId: '20',
+                  instanceCode: 'GET_USERS',
+                },
+              }),
+            ],
+          }),
+        }),
+      }),
+    );
+  });
+
+  it('rejects a conflicting shared node instance instead of overwriting it', async () => {
+    const tx = {
+      workflowNodeType: {
+        findUnique: jest.fn().mockResolvedValue({ id: BigInt(2) }),
+      },
+      workflowNodeInstance: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: BigInt(20),
+          code: 'GET_USERS',
+          nodeTypeId: BigInt(2),
+          config: { method: 'DELETE', path: '/users' },
+        }),
+        create: jest.fn(),
+      },
+      workflow: { upsert: jest.fn() },
+    };
+    const service = new WorkflowExportService({
+      $transaction: (callback: (client: typeof tx) => unknown) => callback(tx),
+    } as never);
+
+    await expect(
+      service.importConfirm(payload, 'tester'),
+    ).rejects.toMatchObject({
+      constructor: ConflictException,
+      response: expect.objectContaining({
+        code: 'WORKFLOW_NODE_INSTANCE_CONFLICT',
+      }),
+    });
+    expect(tx.workflowNodeInstance.create).not.toHaveBeenCalled();
+    expect(tx.workflow.upsert).not.toHaveBeenCalled();
+  });
+});

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

@@ -1,17 +1,28 @@
 import {
   BadRequestException,
+  ConflictException,
   Injectable,
+  InternalServerErrorException,
   NotFoundException,
   UnauthorizedException,
 } from '@nestjs/common';
 import { Prisma } from '@prisma/client';
 import * as jwt from 'jsonwebtoken';
 import { PrismaService } from 'nestjs-prisma';
+import { isDeepStrictEqual } from 'node:util';
 import { ExportPayload, ImportPreviewResponse } from './workflow-export.dto';
 
-const EXPORT_TOKEN_SECRET =
-  process.env.TAIHU_ODC_APP_TOKEN || 'gadmin-default-secret';
 const EXPORT_TOKEN_EXPIRY = 30 * 60; // 30 minutes in seconds
+const EXPORT_PAYLOAD_VERSION = 4;
+
+function exportTokenSecret(): string {
+  const secret = process.env.TAIHU_ODC_APP_TOKEN?.trim();
+  if (!secret)
+    throw new InternalServerErrorException(
+      'Workflow export token secret is not configured',
+    );
+  return secret;
+}
 
 interface ExportTokenPayload {
   workflowCode: string;
@@ -34,7 +45,7 @@ export class WorkflowExportService {
 
     const token = jwt.sign(
       { workflowCode: workflow.code } as ExportTokenPayload,
-      EXPORT_TOKEN_SECRET,
+      exportTokenSecret(),
       { expiresIn: EXPORT_TOKEN_EXPIRY },
     );
 
@@ -45,8 +56,9 @@ export class WorkflowExportService {
   /** Verify export token and return the full export payload */
   async getExportPayload(code: string, token: string): Promise<ExportPayload> {
     let decoded: ExportTokenPayload;
+    const secret = exportTokenSecret();
     try {
-      decoded = jwt.verify(token, EXPORT_TOKEN_SECRET) as ExportTokenPayload;
+      decoded = jwt.verify(token, secret) as ExportTokenPayload;
     } catch {
       throw new UnauthorizedException('Export token is invalid or expired');
     }
@@ -87,27 +99,8 @@ export class WorkflowExportService {
           })
         : [];
 
-    // Collect NodeType keys from instances + DSL nodes
-    const nodeTypeKeys = new Set<string>();
-    for (const ni of nodeInstances) {
-      nodeTypeKeys.add(ni.nodeType.type);
-    }
-    if (dsl?.nodes) {
-      for (const node of dsl.nodes) {
-        if (node.type) nodeTypeKeys.add(node.type);
-      }
-    }
-
-    // Fetch NodeTypes
-    const nodeTypes =
-      nodeTypeKeys.size > 0
-        ? await this.prisma.workflowNodeType.findMany({
-            where: { type: { in: Array.from(nodeTypeKeys) } },
-          })
-        : [];
-
     return {
-      version: 3,
+      version: EXPORT_PAYLOAD_VERSION,
       exportedAt: new Date().toISOString(),
       workflow: {
         code: workflow.code,
@@ -125,30 +118,12 @@ export class WorkflowExportService {
         config: snapshotConfigByInstanceId.get(String(ni.id)) ?? ni.config,
         isEnabled: ni.isEnabled,
       })),
-      nodeTypes: nodeTypes.map((nt) => ({
-        type: nt.type,
-        category: nt.category,
-        label: nt.label,
-        icon: nt.icon,
-        description: nt.description,
-        configSchema: nt.configSchema as any,
-        inputSchema: nt.inputSchema as any,
-        outputSchema: nt.outputSchema as any,
-        outputs: nt.outputs as any,
-        isBuiltin: nt.isBuiltin,
-        runtimeKey: nt.runtimeKey,
-        uiSchema: nt.uiSchema as any,
-        schemaVersion: nt.schemaVersion,
-        instancePolicy: nt.instancePolicy,
-      })),
     };
   }
 
   /** Preview import — return current state vs incoming for diff */
   async importPreview(payload: ExportPayload): Promise<ImportPreviewResponse> {
-    if (!payload?.workflow?.code) {
-      throw new BadRequestException('Invalid payload: missing workflow code');
-    }
+    this.assertImportPayload(payload);
 
     // Look up current state by code
     const existingWorkflow = await this.prisma.workflow.findUnique({
@@ -166,15 +141,6 @@ export class WorkflowExportService {
           })
         : [];
 
-    // Look up existing node types by type key
-    const incomingTypes = payload.nodeTypes.map((nt) => nt.type);
-    const existingTypes =
-      incomingTypes.length > 0
-        ? await this.prisma.workflowNodeType.findMany({
-            where: { type: { in: incomingTypes } },
-          })
-        : [];
-
     const current: Partial<ExportPayload> | null = existingWorkflow
       ? {
           workflow: {
@@ -194,22 +160,6 @@ export class WorkflowExportService {
             config: ni.config as any,
             isEnabled: ni.isEnabled,
           })),
-          nodeTypes: existingTypes.map((nt) => ({
-            type: nt.type,
-            category: nt.category,
-            label: nt.label,
-            icon: nt.icon,
-            description: nt.description,
-            configSchema: nt.configSchema as any,
-            inputSchema: nt.inputSchema as any,
-            outputSchema: nt.outputSchema as any,
-            outputs: nt.outputs as any,
-            isBuiltin: nt.isBuiltin,
-            runtimeKey: nt.runtimeKey,
-            uiSchema: nt.uiSchema as any,
-            schemaVersion: nt.schemaVersion,
-            instancePolicy: nt.instancePolicy,
-          })),
         }
       : null;
 
@@ -221,50 +171,10 @@ export class WorkflowExportService {
     payload: ExportPayload,
     creator: string,
   ): Promise<{ success: boolean; workflowId: string; workflowName: string }> {
-    if (!payload?.workflow?.code) {
-      throw new BadRequestException('Invalid payload: missing workflow code');
-    }
+    this.assertImportPayload(payload);
 
     return this.prisma.$transaction(async (tx) => {
-      // 1. Upsert NodeTypes by `type`
-      for (const nt of payload.nodeTypes) {
-        await tx.workflowNodeType.upsert({
-          where: { type: nt.type },
-          create: {
-            type: nt.type,
-            category: nt.category as any,
-            label: nt.label,
-            icon: nt.icon,
-            description: nt.description,
-            configSchema: nt.configSchema,
-            inputSchema: nt.inputSchema,
-            outputSchema: nt.outputSchema,
-            outputs: nt.outputs,
-            isBuiltin: nt.isBuiltin,
-            runtimeKey: nt.runtimeKey ?? nt.type,
-            uiSchema: nt.uiSchema ?? {},
-            schemaVersion: nt.schemaVersion ?? 1,
-            instancePolicy: nt.instancePolicy ?? 'INLINE_ONLY',
-            creator,
-          },
-          update: {
-            category: nt.category as any,
-            label: nt.label,
-            icon: nt.icon,
-            description: nt.description,
-            configSchema: nt.configSchema,
-            inputSchema: nt.inputSchema,
-            outputSchema: nt.outputSchema,
-            outputs: nt.outputs,
-            runtimeKey: nt.runtimeKey ?? nt.type,
-            uiSchema: nt.uiSchema ?? {},
-            schemaVersion: nt.schemaVersion ?? 1,
-            instancePolicy: nt.instancePolicy ?? 'INLINE_ONLY',
-          },
-        });
-      }
-
-      // 2. Upsert NodeInstances by `code`, build sourceId → newId map
+      // 1. Reuse local node types and create only missing node instances.
       const idMap = new Map<string, string>();
       const codeMap = new Map<string, string>();
 
@@ -274,44 +184,42 @@ export class WorkflowExportService {
         });
         if (!nodeType) {
           throw new BadRequestException(
-            `NodeType "${ni.nodeTypeKey}" not found after upsert`,
+            `目标环境缺少节点类型：${ni.nodeTypeKey}`,
           );
         }
 
         let record = await tx.workflowNodeInstance.findUnique({
           where: { code: ni.code },
         });
-        if (record && record.nodeTypeId !== nodeType.id)
-          throw new BadRequestException(
-            `Node Instance "${ni.code}" has a different node type`,
-          );
-        record = record
-          ? await tx.workflowNodeInstance.update({
-              where: { id: record.id },
-              data: {
-                name: ni.name,
-                description: ni.description,
-                config: ni.config,
-                isEnabled: ni.isEnabled,
-              },
-            })
-          : await tx.workflowNodeInstance.create({
-              data: {
-                code: ni.code,
-                nodeTypeId: nodeType.id,
-                name: ni.name,
-                description: ni.description,
-                config: ni.config,
-                isEnabled: ni.isEnabled,
-                creator,
-              },
-            });
+        if (
+          record &&
+          (!isDeepStrictEqual(record.config, ni.config) ||
+            record.nodeTypeId !== nodeType.id)
+        )
+          throw new ConflictException({
+            code: 'WORKFLOW_NODE_INSTANCE_CONFLICT',
+            message: `节点实例编码“${ni.code}”已存在，但类型或配置不同`,
+            instanceCode: ni.code,
+          });
+        record =
+          record ??
+          (await tx.workflowNodeInstance.create({
+            data: {
+              code: ni.code,
+              nodeTypeId: nodeType.id,
+              name: ni.name,
+              description: ni.description,
+              config: ni.config,
+              isEnabled: ni.isEnabled,
+              creator,
+            },
+          }));
 
         idMap.set(ni.sourceId, String(record.id));
         codeMap.set(ni.sourceId, record.code);
       }
 
-      // 3. Turn the exported compiled snapshot back into an editable draft.
+      // 2. Turn the exported compiled snapshot back into an editable draft.
       const dsl = JSON.parse(JSON.stringify(payload.workflow.dsl));
       if (dsl?.nodes) {
         for (const node of dsl.nodes) {
@@ -334,7 +242,7 @@ export class WorkflowExportService {
         }
       }
 
-      // 4. Upsert Workflow by `code`, always set to DRAFT
+      // 3. Upsert Workflow by `code`, always set to DRAFT
       const workflow = await tx.workflow.upsert({
         where: { code: payload.workflow.code },
         create: {
@@ -360,4 +268,27 @@ export class WorkflowExportService {
       };
     });
   }
+
+  private assertImportPayload(payload: ExportPayload): void {
+    if (
+      payload?.version !== EXPORT_PAYLOAD_VERSION ||
+      !payload.workflow?.code?.trim() ||
+      !payload.workflow?.name?.trim() ||
+      !payload.workflow?.dsl ||
+      !Array.isArray(payload.nodeInstances)
+    )
+      throw new BadRequestException(
+        `导入文件无效，仅支持版本 ${EXPORT_PAYLOAD_VERSION} 的 Workflow 导出文件`,
+      );
+    const invalidInstance = payload.nodeInstances.find(
+      (item) =>
+        !item?.sourceId?.trim() ||
+        !item.code?.trim() ||
+        !item.name?.trim() ||
+        !item.nodeTypeKey?.trim() ||
+        item.config === undefined,
+    );
+    if (invalidInstance)
+      throw new BadRequestException('导入文件包含无效的节点实例');
+  }
 }

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

@@ -0,0 +1,113 @@
+import { validateWorkflowHandles } from './workflow-handle-validator';
+
+describe('validateWorkflowHandles', () => {
+  it('requires the canonical HTTP and Code IN/OUT handles', () => {
+    const nodes = [
+      { id: 'trigger', type: 'manual_trigger' },
+      { id: 'request', type: 'http_request' },
+      { id: 'transform', type: 'code' },
+    ];
+    const outputs = {
+      manual_trigger: [],
+      http_request: [],
+      code: [],
+    };
+
+    expect(
+      validateWorkflowHandles(
+        {
+          nodes,
+          edges: [
+            {
+              id: 'to-request',
+              source: 'trigger',
+              target: 'request',
+              targetHandle: 'request-in',
+            },
+            {
+              id: 'to-code',
+              source: 'request',
+              target: 'transform',
+              sourceHandle: 'response-out',
+              targetHandle: 'data-in',
+            },
+          ],
+        },
+        outputs,
+      ),
+    ).toEqual([]);
+
+    expect(
+      validateWorkflowHandles(
+        {
+          nodes,
+          edges: [
+            { id: 'to-request', source: 'trigger', target: 'request' },
+            {
+              id: 'to-code',
+              source: 'request',
+              target: 'transform',
+              sourceHandle: 'result-out',
+              targetHandle: 'request-in',
+            },
+          ],
+        },
+        outputs,
+      ),
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          edgeId: 'to-request',
+          code: 'MISSING_TARGET_HANDLE',
+        }),
+        expect.objectContaining({
+          edgeId: 'to-code',
+          code: 'UNKNOWN_HANDLE',
+        }),
+        expect.objectContaining({
+          edgeId: 'to-code',
+          code: 'UNKNOWN_TARGET_HANDLE',
+        }),
+      ]),
+    );
+  });
+
+  it('validates Switch edges against stable case ids and the default output', () => {
+    const nodes = [
+      {
+        id: 'switch-1',
+        type: 'switch',
+        config: {
+          cases: [{ id: 'case-paid', label: '已支付', value: 'PAID' }],
+        },
+      },
+      { id: 'paid', type: 'code' },
+      { id: 'other', type: 'code' },
+    ];
+
+    expect(
+      validateWorkflowHandles(
+        {
+          nodes,
+          edges: [
+            {
+              id: 'paid-edge',
+              source: 'switch-1',
+              target: 'paid',
+              sourceHandle: 'case-paid',
+              targetHandle: 'data-in',
+            },
+            {
+              id: 'default-edge',
+              source: 'switch-1',
+              target: 'other',
+              sourceHandle: 'default',
+              targetHandle: 'data-in',
+            },
+          ],
+        },
+        { switch: null },
+      ),
+    ).toEqual([]);
+  });
+});