@gadmin2n/schematics 0.0.139 → 0.0.140

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

@@ -0,0 +1,158 @@
+import {
+  describeCallableWorkflow,
+  validateCallableWorkflow,
+} from './workflow-callable';
+
+const validDsl = {
+  nodes: [
+    {
+      id: 'input',
+      type: 'callable_trigger',
+      config: {
+        inputParameters: [
+          { key: 'employeeId', label: '员工 ID', required: true },
+        ],
+      },
+    },
+    { id: 'http', type: 'http_request', config: {} },
+    {
+      id: 'return',
+      type: 'return_result',
+      config: {
+        resultType: 'APPROVAL_SUBJECTS',
+        sourceMode: 'INPUT',
+      },
+    },
+  ],
+  edges: [{ source: 'http', target: 'return', kind: 'FLOW' }],
+};
+
+describe('callable Workflow contract', () => {
+  it('describes declared inputs and normalized result type', () => {
+    expect(describeCallableWorkflow(validDsl)).toEqual({
+      mode: 'RETURN',
+      inputParameters: [
+        { key: 'employeeId', label: '员工 ID', required: true },
+      ],
+      resultType: 'APPROVAL_SUBJECTS',
+      sourceMode: 'INPUT',
+    });
+  });
+
+  it('rejects a callable Workflow with an external trigger', () => {
+    expect(() =>
+      validateCallableWorkflow({
+        ...validDsl,
+        nodes: [
+          ...validDsl.nodes,
+          { id: 'manual', type: 'manual_trigger', config: {} },
+        ],
+      }),
+    ).toThrow('不能同时包含其他触发器');
+  });
+
+  it('describes a callable Workflow without a return node as one-way', () => {
+    expect(
+      validateCallableWorkflow({
+        ...validDsl,
+        nodes: validDsl.nodes.filter((node) => node.type !== 'return_result'),
+      }),
+    ).toEqual({
+      mode: 'ONE_WAY',
+      inputParameters: [
+        { key: 'employeeId', label: '员工 ID', required: true },
+      ],
+    });
+  });
+
+  it('rejects more than one return node', () => {
+    expect(() =>
+      validateCallableWorkflow({
+        ...validDsl,
+        nodes: [
+          ...validDsl.nodes,
+          {
+            id: 'return-2',
+            type: 'return_result',
+            config: {
+              resultType: 'APPROVAL_SUBJECTS',
+              sourceMode: 'WORKFLOW',
+              path: 'approvers',
+            },
+          },
+        ],
+      }),
+    ).toThrow('最多包含一个“返回结果”节点');
+  });
+
+  it('accepts returning the previous pipeline result as input', () => {
+    expect(
+      validateCallableWorkflow({
+        ...validDsl,
+        nodes: validDsl.nodes.map((node) =>
+          node.type === 'return_result'
+            ? {
+                ...node,
+                config: {
+                  resultType: 'APPROVAL_SUBJECTS',
+                  sourceMode: 'INPUT',
+                },
+              }
+            : node,
+        ),
+        edges: [{ source: 'http', target: 'return', kind: 'FLOW' }],
+      }),
+    ).toEqual({
+      mode: 'RETURN',
+      inputParameters: [
+        { key: 'employeeId', label: '员工 ID', required: true },
+      ],
+      resultType: 'APPROVAL_SUBJECTS',
+      sourceMode: 'INPUT',
+    });
+  });
+
+  it('rejects an input return node that is not connected', () => {
+    expect(() =>
+      validateCallableWorkflow({
+        ...validDsl,
+        nodes: validDsl.nodes.map((node) =>
+          node.type === 'return_result'
+            ? {
+                ...node,
+                config: {
+                  resultType: 'APPROVAL_SUBJECTS',
+                  sourceMode: 'INPUT',
+                },
+              }
+            : node,
+        ),
+        edges: [],
+      }),
+    ).toThrow('返回结果前需要连接一个节点');
+  });
+
+  it('accepts returning a field from Workflow data', () => {
+    expect(
+      validateCallableWorkflow({
+        ...validDsl,
+        nodes: validDsl.nodes.map((node) =>
+          node.type === 'return_result'
+            ? {
+                ...node,
+                config: {
+                  resultType: 'APPROVAL_SUBJECTS',
+                  sourceMode: 'WORKFLOW',
+                  path: 'approvers',
+                },
+              }
+            : node,
+        ),
+      }),
+    ).toMatchObject({
+      resultType: 'APPROVAL_SUBJECTS',
+      sourceMode: 'WORKFLOW',
+      path: 'approvers',
+    });
+  });
+});

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

@@ -0,0 +1,155 @@
+export type CallableResultType = 'APPROVAL_SUBJECTS';
+
+export interface CallableInputParameter {
+  key: string;
+  label?: string;
+  required?: boolean;
+}
+
+interface CallableWorkflowBaseDescriptor {
+  inputParameters: CallableInputParameter[];
+}
+
+export interface OneWayCallableWorkflowDescriptor
+  extends CallableWorkflowBaseDescriptor {
+  mode: 'ONE_WAY';
+}
+
+export interface ReturningCallableWorkflowDescriptor
+  extends CallableWorkflowBaseDescriptor {
+  mode: 'RETURN';
+  resultType: CallableResultType;
+  sourceMode: 'INPUT' | 'WORKFLOW';
+  path?: string;
+}
+
+export type CallableWorkflowDescriptor =
+  | OneWayCallableWorkflowDescriptor
+  | ReturningCallableWorkflowDescriptor;
+
+type DslLike = {
+  nodes?: Array<{
+    id?: unknown;
+    type?: unknown;
+    config?: unknown;
+  }>;
+  edges?: Array<{
+    source?: unknown;
+    target?: unknown;
+    kind?: unknown;
+    pairId?: unknown;
+  }>;
+};
+
+export function describeCallableWorkflow(
+  dsl: unknown,
+): CallableWorkflowDescriptor | null {
+  const nodes = asDsl(dsl).nodes ?? [];
+  if (!nodes.some((node) => node.type === 'callable_trigger')) return null;
+  return validateCallableWorkflow(dsl);
+}
+
+export function describeApprovalChannelInputs(
+  dsl: unknown,
+): CallableInputParameter[] {
+  const descriptor = describeCallableWorkflow(dsl);
+  if (!descriptor || descriptor.mode !== 'ONE_WAY') return [];
+  return descriptor.inputParameters;
+}
+
+export function validateCallableWorkflow(
+  dsl: unknown,
+): CallableWorkflowDescriptor {
+  const nodes = asDsl(dsl).nodes ?? [];
+  const triggers = nodes.filter((node) => node.type === 'callable_trigger');
+  if (triggers.length !== 1)
+    throw new Error('可调用 Workflow 必须包含一个“接收调用”节点');
+
+  const externalTriggers = nodes.filter(
+    (node) =>
+      typeof node.type === 'string' &&
+      node.type.endsWith('_trigger') &&
+      node.type !== 'callable_trigger',
+  );
+  if (externalTriggers.length)
+    throw new Error('可调用 Workflow 不能同时包含其他触发器');
+
+  const returns = nodes.filter((node) => node.type === 'return_result');
+  const triggerConfig = asObject(triggers[0].config);
+  const inputParameters = normalizeInputParameters(
+    triggerConfig.inputParameters,
+  );
+  if (returns.length === 0)
+    return {
+      mode: 'ONE_WAY',
+      inputParameters,
+    };
+  if (returns.length > 1)
+    throw new Error('可调用 Workflow 最多包含一个“返回结果”节点');
+
+  const returnConfig = asObject(returns[0].config);
+  if (returnConfig.resultType !== 'APPROVAL_SUBJECTS')
+    throw new Error('返回结果类型必须是审批人');
+
+  if (returnConfig.sourceMode === 'INPUT') {
+    const returnNodeId = returns[0].id;
+    const predecessors = (asDsl(dsl).edges ?? []).filter(
+      (edge) =>
+        edge.target === returnNodeId &&
+        (!edge.kind || edge.kind === 'FLOW') &&
+        !edge.pairId,
+    );
+    if (predecessors.length !== 1)
+      throw new Error('返回结果前需要连接一个节点');
+
+    return {
+      mode: 'RETURN',
+      inputParameters,
+      resultType: 'APPROVAL_SUBJECTS',
+      sourceMode: 'INPUT',
+    };
+  }
+
+  if (returnConfig.sourceMode !== 'WORKFLOW')
+    throw new Error('返回结果来源必须是上一个节点或 Workflow 数据');
+  if (typeof returnConfig.path !== 'string' || !returnConfig.path.trim())
+    throw new Error('返回 Workflow 数据时必须填写字段路径');
+
+  return {
+    mode: 'RETURN',
+    inputParameters,
+    resultType: 'APPROVAL_SUBJECTS',
+    sourceMode: 'WORKFLOW',
+    path: returnConfig.path.trim(),
+  };
+}
+
+function normalizeInputParameters(value: unknown): CallableInputParameter[] {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set<string>();
+  return value.map((item) => {
+    const input = asObject(item);
+    const key = typeof input.key === 'string' ? input.key.trim() : '';
+    if (!key) throw new Error('调用参数名称不能为空');
+    if (seen.has(key)) throw new Error(`调用参数名称不能重复：${key}`);
+    seen.add(key);
+    return {
+      key,
+      ...(typeof input.label === 'string' &&
+        input.label.trim() && { label: input.label.trim() }),
+      ...(input.required === true && { required: true }),
+    };
+  });
+}
+
+function asDsl(value: unknown): DslLike {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as DslLike)
+    : {};
+}
+
+function asObject(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}

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

@@ -0,0 +1,363 @@
+import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-config.util';
+import { WorkflowCompilerService } from './workflow-compiler.service';
+
+describe('WorkflowCompilerService', () => {
+  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',
+      },
+    });
+  });
+});