@gadmin2n/schematics 0.0.144 → 0.0.145

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/node-config-validator.service.spec.ts

@@ -1,5 +1,7 @@
 import { BadRequestException } from '@nestjs/common';
+import { NODE_TYPES } from '../../../seed/workflow-node-types';
 import { NodeConfigValidatorService } from './node-config-validator.service';
+import type { JsonSchema } from './schema.types';
 
 describe('NodeConfigValidatorService', () => {
   const schema = {
@@ -32,6 +34,7 @@ describe('NodeConfigValidatorService', () => {
       expect(error).toBeInstanceOf(BadRequestException);
       expect((error as BadRequestException).getResponse()).toEqual({
         code: 'NODE_CONFIG_INVALID',
+        message: '节点配置不完整或有误',
         errors: expect.arrayContaining([
           { path: '/count', keyword: 'minimum', message: 'must be >= 1' },
           {
@@ -53,8 +56,9 @@ describe('NodeConfigValidatorService', () => {
     (config) => {
       expect(() => service.validateOrThrow('12:3', schema, config)).toThrow(
         expect.objectContaining({
-          response: {
+          response: expect.objectContaining({
             code: 'NODE_CONFIG_INVALID',
+            message: '节点配置不完整或有误',
             errors: [
               {
                 path: '/',
@@ -62,7 +66,7 @@ describe('NodeConfigValidatorService', () => {
                 message: 'must be object',
               },
             ],
-          },
+          }),
         }),
       );
     },
@@ -76,4 +80,277 @@ describe('NodeConfigValidatorService', () => {
 
     expect(compile).toHaveBeenCalledTimes(1);
   });
+
+  it('rejects an approval without any possible approver', () => {
+    const approval = NODE_TYPES.find((node) => node.type === 'approval')!;
+    const approvalSchema = approval.configSchema as JsonSchema;
+
+    expect(() =>
+      service.validateOrThrow('approval:10', approvalSchema, {
+        subjects: [],
+        approvalRule: { mode: 'ANY' },
+        rejectionRule: { mode: 'ANY' },
+        timeout: { durationSeconds: 0, action: 'REJECTED' },
+      }),
+    ).toThrow(BadRequestException);
+  });
+
+  it('accepts a complete approval and requires threshold values', () => {
+    const approval = NODE_TYPES.find((node) => node.type === 'approval')!;
+    const approvalSchema = approval.configSchema as JsonSchema;
+    const baseConfig = {
+      task: {
+        title: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '请审批',
+        },
+        description: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '',
+        },
+        details: [],
+      },
+      subjects: [{ source: 'STATIC', provider: 'USER', refs: ['reviewer'] }],
+      rejectionRule: { mode: 'ANY' },
+      timeout: { durationSeconds: 0, action: 'REJECTED' },
+    };
+
+    expect(() =>
+      service.validateOrThrow('approval:10-valid', approvalSchema, {
+        ...baseConfig,
+        approvalRule: { mode: 'COUNT', count: 1 },
+      }),
+    ).not.toThrow();
+    expect(() =>
+      service.validateOrThrow('approval:10-invalid', approvalSchema, {
+        ...baseConfig,
+        approvalRule: { mode: 'COUNT' },
+      }),
+    ).toThrow(BadRequestException);
+  });
+
+  it('requires a complete embedded external approval configuration when enabled', () => {
+    const approval = NODE_TYPES.find((node) => node.type === 'approval')!;
+    const approvalSchema = approval.configSchema as JsonSchema;
+    const config = {
+      task: {
+        title: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '请审批',
+        },
+        description: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '',
+        },
+        details: [],
+      },
+      subjects: [{ source: 'STATIC', provider: 'USER', refs: ['reviewer'] }],
+      approvalRule: { mode: 'ANY' },
+      rejectionRule: { mode: 'ANY' },
+      timeout: { durationSeconds: 0, action: 'REJECTED' },
+    };
+
+    expect(() =>
+      service.validateOrThrow('approval:external-missing', approvalSchema, {
+        ...config,
+        external: {
+          request: {
+            connectionRef: 'myoa',
+            method: 'POST',
+            path: '/approvals',
+            bodyMode: 'JSON',
+          },
+        },
+      }),
+    ).toThrow(BadRequestException);
+    expect(() =>
+      service.validateOrThrow('approval:external-valid', approvalSchema, {
+        ...config,
+        external: {
+          request: {
+            connectionRef: 'myoa',
+            method: 'POST',
+            path: '/approvals',
+            bodyMode: 'FIELDS',
+            bodyBindings: {
+              callbackToken: {
+                source: 'APPROVAL',
+                path: 'callbackToken',
+              },
+            },
+          },
+          creationResult: { script: 'return response;' },
+          callbackResult: { script: 'return callback.body;' },
+        },
+      }),
+    ).not.toThrow();
+  });
+
+  it('requires the HTTP and Code configuration for dynamic approvers', () => {
+    const approval = NODE_TYPES.find((node) => node.type === 'approval')!;
+    const approvalSchema = approval.configSchema as JsonSchema;
+    const config = {
+      task: {
+        title: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '请审批',
+        },
+        description: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '',
+        },
+        details: [],
+      },
+      subjects: [
+        {
+          source: 'DYNAMIC',
+          provider: 'USER',
+          inputKey: 'direct_manager',
+          label: '查询直属领导',
+        },
+      ],
+      approvalRule: { mode: 'ANY' },
+      rejectionRule: { mode: 'ANY' },
+      timeout: { durationSeconds: 0, action: 'REJECTED' },
+    };
+
+    expect(() =>
+      service.validateOrThrow(
+        'approval:lookup-missing',
+        approvalSchema,
+        config,
+      ),
+    ).toThrow(BadRequestException);
+    expect(() =>
+      service.validateOrThrow('approval:lookup-valid', approvalSchema, {
+        ...config,
+        subjects: [
+          {
+            ...config.subjects[0],
+            lookup: {
+              request: {
+                connectionRef: 'erp',
+                method: 'GET',
+                path: '/',
+                bodyMode: 'FIELDS',
+              },
+              result: { script: 'return response;' },
+            },
+          },
+        ],
+      }),
+    ).not.toThrow();
+  });
+
+  it.each(['', ' '])(
+    'rejects a blank HTTP request field name when publishing',
+    (fieldName) => {
+      const httpRequest = NODE_TYPES.find(
+        (node) => node.type === 'http_request',
+      )!;
+      const httpRequestSchema = httpRequest.configSchema as JsonSchema;
+
+      expect(() =>
+        service.validateOrThrow('http-request:empty-field', httpRequestSchema, {
+          connectionRef: 'erp',
+          method: 'GET',
+          path: '/',
+          queryBindings: {
+            [fieldName]: {
+              source: 'FIXED',
+              valueType: 'STRING',
+              value: '',
+            },
+          },
+          bodyMode: 'FIELDS',
+        }),
+      ).toThrow(BadRequestException);
+    },
+  );
+
+  it('requires the matching external wait timeout value', () => {
+    const externalWait = NODE_TYPES.find(
+      (node) => node.type === 'external_wait',
+    )!;
+    const externalWaitSchema = externalWait.configSchema as JsonSchema;
+    const callbackTokenBinding = { source: 'INPUT', path: 'callbackToken' };
+
+    expect(() =>
+      service.validateOrThrow(
+        'external-wait:duration-invalid',
+        externalWaitSchema,
+        {
+          callbackTokenBinding,
+          timeout: { mode: 'DURATION' },
+        },
+      ),
+    ).toThrow(BadRequestException);
+    expect(() =>
+      service.validateOrThrow(
+        'external-wait:deadline-invalid',
+        externalWaitSchema,
+        {
+          callbackTokenBinding,
+          timeout: { mode: 'DEADLINE' },
+        },
+      ),
+    ).toThrow(BadRequestException);
+    expect(() =>
+      service.validateOrThrow(
+        'external-wait:duration-valid',
+        externalWaitSchema,
+        {
+          callbackTokenBinding,
+          timeout: { mode: 'DURATION', durationSeconds: 60 },
+        },
+      ),
+    ).not.toThrow();
+    expect(() =>
+      service.validateOrThrow(
+        'external-wait:deadline-valid',
+        externalWaitSchema,
+        {
+          callbackTokenBinding,
+          timeout: {
+            mode: 'DEADLINE',
+            deadlineBinding: { source: 'WORKFLOW', path: 'deadline' },
+          },
+        },
+      ),
+    ).not.toThrow();
+  });
+
+  it('requires concurrency for parallel for-each execution', () => {
+    const forEach = NODE_TYPES.find((node) => node.type === 'for_each')!;
+    const forEachSchema = forEach.configSchema as JsonSchema;
+    const baseConfig = {
+      itemsBinding: { source: 'INPUT', path: 'items' },
+      errorPolicy: 'STOP',
+    };
+
+    expect(() =>
+      service.validateOrThrow('for-each:parallel-invalid', forEachSchema, {
+        ...baseConfig,
+        execution: { mode: 'PARALLEL' },
+      }),
+    ).toThrow(BadRequestException);
+    expect(() =>
+      service.validateOrThrow('for-each:parallel-valid', forEachSchema, {
+        ...baseConfig,
+        execution: { mode: 'PARALLEL', concurrency: 3 },
+      }),
+    ).not.toThrow();
+    expect(() =>
+      service.validateOrThrow('for-each:sequential-valid', forEachSchema, {
+        ...baseConfig,
+        execution: { mode: 'SEQUENTIAL' },
+      }),
+    ).not.toThrow();
+  });
 });

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/node-config-validator.service.ts

@@ -57,6 +57,10 @@ export class NodeConfigValidatorService {
   });
 
   private throwInvalid(errors: NodeConfigValidationError[]): never {
-    throw new BadRequestException({ code: 'NODE_CONFIG_INVALID', errors });
+    throw new BadRequestException({
+      code: 'NODE_CONFIG_INVALID',
+      message: '节点配置不完整或有误',
+      errors,
+    });
   }
 }

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/subject-config-validator.service.spec.ts

@@ -89,7 +89,10 @@ describe('SubjectConfigValidatorService', () => {
         actor,
       ),
     ).rejects.toMatchObject({
-      response: { code: 'SUBJECT_REF_INVALID' },
+      response: {
+        code: 'SUBJECT_REF_INVALID',
+        message: '审批人配置不完整或无效',
+      },
     });
   });
 

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/subject-config-validator.service.ts

@@ -212,7 +212,11 @@ export class SubjectConfigValidatorService {
   }
 
   private throwInvalid(issues: SubjectValidationIssue[]): never {
-    throw new BadRequestException({ code: 'SUBJECT_REF_INVALID', issues });
+    throw new BadRequestException({
+      code: 'SUBJECT_REF_INVALID',
+      message: '审批人配置不完整或无效',
+      issues,
+    });
   }
 }
 

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

@@ -11,7 +11,15 @@ describe('WidgetCatalogService', () => {
         externalWait: { widget: 'external-wait-config' },
         callableInputs: { widget: 'callable-input-parameters' },
         approvalRequest: { widget: 'approval-request-trigger-config' },
-        returnResult: { widget: 'return-result-config' },
+        manualTrigger: { widget: 'manual-trigger-config' },
+        forEach: { widget: 'for-each-config' },
+        subWorkflow: { widget: 'sub-workflow-config' },
+        eventTrigger: { widget: 'event-trigger-config' },
+        database: { widget: 'db-execute-config' },
+        delay: { widget: 'delay-config' },
+        parallel: { widget: 'parallel-config' },
+        ifElse: { widget: 'if-else-config' },
+        switch: { widget: 'switch-config' },
       }),
     ).not.toThrow();
   });
@@ -37,11 +45,12 @@ describe('WidgetCatalogService', () => {
       }),
     ).toThrow(
       expect.objectContaining({
-        response: {
+        response: expect.objectContaining({
           code: 'NODE_WIDGET_NOT_REGISTERED',
+          message: '服务端尚未启用当前节点所需的配置组件',
           widget: 'missing-widget',
           path: '/approval/subjects/widget',
-        },
+        }),
       }),
     );
   });

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/widget-catalog.service.ts

@@ -13,10 +13,18 @@ const PRIMITIVE_WIDGETS = [
 const WORKFLOW_WIDGETS = [
   'callable-input-parameters',
   'approval-request-trigger-config',
-  'return-result-config',
   'external-request-config',
   'submit-approval-result-config',
   'external-wait-config',
+  'manual-trigger-config',
+  'for-each-config',
+  'sub-workflow-config',
+  'event-trigger-config',
+  'db-execute-config',
+  'delay-config',
+  'parallel-config',
+  'if-else-config',
+  'switch-config',
 ] as const;
 
 @Injectable()
@@ -50,6 +58,7 @@ export class WidgetCatalogService {
         if (!this.widgets.has(child)) {
           throw new BadRequestException({
             code: 'NODE_WIDGET_NOT_REGISTERED',
+            message: '服务端尚未启用当前节点所需的配置组件',
             widget: child,
             path: toJsonPointer(childPath),
           });

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

@@ -26,18 +26,6 @@ const mockPrismaService = {
   },
 };
 
-const mockNodeConfigValidator = {
-  validateOrThrow: jest.fn(),
-};
-
-const mockWidgetCatalog = {
-  assertUiSchemaSupported: jest.fn(),
-};
-
-const mockSubjectConfigValidator = {
-  validateSubjects: jest.fn(),
-};
-
 describe('WorkflowNodeInstanceService', () => {
   let service: WorkflowNodeInstanceService;
   let prisma: typeof mockPrismaService;
@@ -46,12 +34,7 @@ describe('WorkflowNodeInstanceService', () => {
     // 每个测试前重置所有 mock
     jest.clearAllMocks();
 
-    service = new WorkflowNodeInstanceService(
-      mockPrismaService as any,
-      mockNodeConfigValidator as any,
-      mockWidgetCatalog as any,
-      mockSubjectConfigValidator as any,
-    );
+    service = new WorkflowNodeInstanceService(mockPrismaService as any);
     prisma = mockPrismaService;
   });
 
@@ -76,7 +59,7 @@ describe('WorkflowNodeInstanceService', () => {
     };
     const actor = { userId: 'user-1', username: 'tester' };
 
-    it('should validate and create a configured node instance', async () => {
+    it('should save an incomplete config without publish-time validation', async () => {
       const expectedResult = {
         id: BigInt(1),
         ...input,
@@ -90,11 +73,6 @@ describe('WorkflowNodeInstanceService', () => {
 
       const result = await service.createConfigured(input, actor);
 
-      expect(mockNodeConfigValidator.validateOrThrow).toHaveBeenCalledWith(
-        '1:1',
-        nodeType.configSchema,
-        input.config,
-      );
       expect(prisma.workflowNodeInstance.create).toHaveBeenCalledWith({
         data: {
           nodeTypeId: BigInt(1),

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

@@ -3,10 +3,6 @@ import { Prisma, WorkflowNodeInstance } from '@prisma/client';
 import { PrismaService } from 'nestjs-prisma';
 
 import { ActorContext } from '../subjectProvider/subject-provider.types';
-import { NodeConfigValidatorService } from '../workflowConfig/node-config-validator.service';
-import { JsonSchema } from '../workflowConfig/schema.types';
-import { SubjectConfigValidatorService } from '../workflowConfig/subject-config-validator.service';
-import { WidgetCatalogService } from '../workflowConfig/widget-catalog.service';
 import {
   CreateConfiguredNodeInstanceDto,
   UpdateConfiguredNodeInstanceDto,
@@ -14,12 +10,7 @@ import {
 
 @Injectable()
 export class WorkflowNodeInstanceService {
-  constructor(
-    private prisma: PrismaService,
-    private readonly nodeConfigValidator: NodeConfigValidatorService,
-    private readonly widgetCatalog: WidgetCatalogService,
-    private readonly subjectConfigValidator: SubjectConfigValidatorService,
-  ) {}
+  constructor(private prisma: PrismaService) {}
 
   async createConfigured(
     input: CreateConfiguredNodeInstanceDto,
@@ -27,18 +18,10 @@ export class WorkflowNodeInstanceService {
   ) {
     const nodeType = await this.prisma.workflowNodeType.findUnique({
       where: { id: BigInt(input.nodeTypeId) },
-      select: {
-        id: true,
-        runtimeKey: true,
-        schemaVersion: true,
-        configSchema: true,
-        uiSchema: true,
-      },
+      select: { id: true },
     });
     if (!nodeType) throw new NotFoundException('Node type not found');
 
-    await this.validateConfig(nodeType, input.config, actor);
-
     const config = input.config as Prisma.InputJsonValue;
     const creator = this.creatorFrom(actor);
     const instance = await this.prisma.workflowNodeInstance.create({
@@ -63,23 +46,10 @@ export class WorkflowNodeInstanceService {
     const id = BigInt(instanceId);
     const instance = await this.prisma.workflowNodeInstance.findUnique({
       where: { id },
-      select: {
-        id: true,
-        nodeType: {
-          select: {
-            id: true,
-            runtimeKey: true,
-            schemaVersion: true,
-            configSchema: true,
-            uiSchema: true,
-          },
-        },
-      },
+      select: { id: true },
     });
     if (!instance) throw new NotFoundException('Node instance not found');
 
-    if (input.config !== undefined)
-      await this.validateConfig(instance.nodeType, input.config, actor);
     const data = {
       ...(input.name !== undefined && { name: input.name }),
       ...(input.description !== undefined && {
@@ -102,43 +72,6 @@ export class WorkflowNodeInstanceService {
     return updated;
   }
 
-  private async validateConfig(
-    nodeType: {
-      id: bigint;
-      runtimeKey: string;
-      schemaVersion: number;
-      configSchema: Prisma.JsonValue;
-      uiSchema: Prisma.JsonValue;
-    },
-    config: unknown,
-    actor: ActorContext,
-  ): Promise<void> {
-    const schemaKey = `${nodeType.id}:${nodeType.schemaVersion}`;
-    const configSchema = nodeType.configSchema as JsonSchema;
-
-    this.nodeConfigValidator.validateOrThrow(schemaKey, configSchema, config);
-    this.widgetCatalog.assertUiSchemaSupported(nodeType.uiSchema);
-    await this.subjectConfigValidator.validateSubjects(
-      configSchema,
-      config,
-      actor,
-    );
-    if (nodeType.runtimeKey === 'http_request') {
-      const connectionRef = (config as Record<string, unknown>)?.connectionRef;
-      const connection =
-        typeof connectionRef === 'string'
-          ? await this.prisma.integrationConnection.findUnique({
-              where: { code: connectionRef },
-              select: { isEnabled: true },
-            })
-          : null;
-      if (!connection?.isEnabled)
-        throw new NotFoundException(
-          'HTTP Request Connection was not found or is disabled',
-        );
-    }
-  }
-
   private creatorFrom(actor: ActorContext): string {
     return actor.username ?? actor.userId;
   }

package/dist/lib/application/files/gadmin2-game-angle-demo/web/package.json

@@ -11,7 +11,7 @@
     "@dnd-kit/sortable": "^7.0.2",
     "@dnd-kit/utilities": "^3.2.2",
     "@gadmin2n/charts": "0.0.10",
-    "@gadmin2n/react-common": "^0.0.72",
+    "@gadmin2n/react-common": "^0.0.75",
     "@monaco-editor/react": "^4.7.0",
     "@refinedev/antd": "^6.0.3",
     "@refinedev/cli": "^2.16.52",
@@ -22,6 +22,8 @@
     "@tanstack/react-query": "^5.81.5",
     "@uiw/react-md-editor": "^3.19.5",
     "@xyflow/react": "^12.10.2",
+    "ajv": "^8.16.0",
+    "ajv-formats": "^2.1.1",
     "antd": "^5.24.6",
     "class-validator": "^0.14.0",
     "dayjs": "^1.11.19",

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/components/RowActions.tsx

@@ -49,7 +49,7 @@ export interface RowActionsProps<T = any> {
   showDetail?: boolean;
   showClone?: boolean;
   showDelete?: boolean;
-  /** History/Log button —— actions 数组里没有，需要通过 LogButton 或显式 showHistory 开启 */
+  /** History/Log button —— 强制显式覆盖；actions 未声明 HISTORY 时需显式 showHistory 或 LogButton 开启 */
   showHistory?: boolean;
   /** Custom children - if provided, replaces entire default UI */
   children?:
@@ -95,7 +95,7 @@ export function RowActions<T extends { id: number | string }>({
   showDetail,
   showClone,
   showDelete,
-  showHistory = false,
+  showHistory,
   children,
   renderEditButton,
   renderDetailButton,
@@ -132,6 +132,7 @@ export function RowActions<T extends { id: number | string }>({
   const resolvedShowDetail = showDetail ?? flags.showDetail;
   const resolvedShowClone = showClone ?? flags.showClone;
   const resolvedShowDelete = showDelete ?? flags.showDelete;
+  const resolvedShowHistory = showHistory ?? flags.showHistory;
 
   // ---------- 默认按钮渲染器 ----------
   const defaultEditButton = (id: number | string) => (
@@ -212,6 +213,22 @@ export function RowActions<T extends { id: number | string }>({
                 : defaultDetailButton(recordId),
             }
           : null;
+      case 'CLONE':
+        return resolvedShowClone
+          ? {
+              key,
+              node: renderCloneButton
+                ? renderCloneButton(recordId)
+                : defaultCloneButton(recordId),
+            }
+          : null;
+      case 'HISTORY': {
+        if (!resolvedShowHistory) return null;
+        const node = renderHistoryButton
+          ? renderHistoryButton(recordId)
+          : defaultHistoryButton(recordId);
+        return node != null ? { key, node } : null;
+      }
       case 'DELETE':
         return resolvedShowDelete
           ? {
@@ -281,8 +298,8 @@ export function RowActions<T extends { id: number | string }>({
     .map((a, i) => renderAction(a, i))
     .filter((x): x is Renderable => x != null);
 
-  // 隐式按钮（actions 数组里通常没有）：CLONE 由显式 showClone 控制；HISTORY 由 showHistory 或 LogButton 触发
-  if (resolvedShowClone) {
+  // 隐式按钮：CLONE/HISTORY 未在 actions 声明时，分别由显式 showClone、showHistory 或 LogButton 触发
+  if (resolvedShowClone && !actions.some((a) => a.action === 'CLONE')) {
     renderables.push({
       key: 'clone-implicit',
       node: renderCloneButton
@@ -290,7 +307,10 @@ export function RowActions<T extends { id: number | string }>({
         : defaultCloneButton(recordId),
     });
   }
-  if (showHistory || LogButton) {
+  if (
+    (showHistory || LogButton) &&
+    !actions.some((a) => a.action === 'HISTORY')
+  ) {
     const node = renderHistoryButton
       ? renderHistoryButton(recordId)
       : defaultHistoryButton(recordId);