@gadmin2n/schematics 0.0.138 → 0.0.140

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

@@ -0,0 +1,354 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { Prisma } 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 { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-config.util';
+import { validateParameterBinding } from './parameter-binding';
+import {
+  describeApprovalChannelInputs,
+  describeCallableWorkflow,
+  validateCallableWorkflow,
+} from './workflow-callable';
+import {
+  CompiledWorkflowDsl,
+  CompiledWorkflowNode,
+  DraftWorkflowDsl,
+  DraftWorkflowNode,
+  WorkflowCompilerErrorCode,
+} from './workflow-compiler.types';
+
+@Injectable()
+export class WorkflowCompilerService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly configs: NodeConfigValidatorService,
+    private readonly widgets: WidgetCatalogService,
+    private readonly subjects: SubjectConfigValidatorService,
+  ) {}
+
+  async compile(
+    draftDsl: DraftWorkflowDsl,
+    actor: ActorContext,
+  ): Promise<CompiledWorkflowDsl> {
+    if (!draftDsl || !Array.isArray(draftDsl.nodes))
+      throw new BadRequestException({
+        code: 'NODE_TYPE_MISMATCH',
+        message: 'Workflow DSL must contain a nodes array',
+      });
+
+    const typeNames = [...new Set(draftDsl.nodes.map((node) => node.type))];
+    const instanceIds = [
+      ...new Set(
+        draftDsl.nodes.flatMap((node) =>
+          node.instanceRef?.instanceId
+            ? [parseId(node.instanceRef.instanceId, node)]
+            : [],
+        ),
+      ),
+    ];
+    const nodeTypesPromise = this.prisma.workflowNodeType.findMany({
+      where: { type: { in: typeNames } },
+      select: {
+        id: true,
+        type: true,
+        runtimeKey: true,
+        instancePolicy: true,
+        schemaVersion: true,
+        configSchema: true,
+        uiSchema: true,
+      },
+    });
+    const instancesPromise = this.prisma.workflowNodeInstance.findMany({
+      where: { id: { in: instanceIds } },
+      select: {
+        id: true,
+        code: true,
+        nodeTypeId: true,
+        isEnabled: true,
+        config: true,
+      },
+    });
+    const [nodeTypes, instances] = await Promise.all([
+      nodeTypesPromise,
+      instancesPromise,
+    ]);
+    const typeByName = new Map(nodeTypes.map((item) => [item.type, item]));
+    const instanceById = new Map(
+      instances.map((item) => [String(item.id), item]),
+    );
+
+    const compiledNodes: CompiledWorkflowNode[] = [];
+    for (const node of draftDsl.nodes) {
+      const nodeType = typeByName.get(node.type);
+      if (!nodeType)
+        this.fail(
+          'NODE_TYPE_MISMATCH',
+          node,
+          `Unknown node type: ${node.type}`,
+        );
+      const ref = node.instanceRef;
+      if (nodeType.instancePolicy === 'REQUIRED' && !ref)
+        this.fail(
+          'NODE_INSTANCE_REQUIRED',
+          node,
+          `Node type ${node.type} requires an instance`,
+        );
+      if (nodeType.instancePolicy === 'INLINE_ONLY' && ref)
+        this.fail(
+          'INLINE_NODE_INSTANCE_FORBIDDEN',
+          node,
+          `Node type ${node.type} does not accept an instance reference`,
+        );
+
+      let config = clone(node.config ?? {});
+      let source: CompiledWorkflowNode['source'];
+      if (ref) {
+        const instance = instanceById.get(String(ref.instanceId));
+        if (!instance)
+          this.fail(
+            'NODE_INSTANCE_NOT_FOUND',
+            node,
+            `Node Instance ${ref.instanceId} was not found`,
+          );
+        if (instance.code !== ref.instanceCode)
+          this.fail(
+            'NODE_INSTANCE_NOT_FOUND',
+            node,
+            'Node Instance does not match the workflow node reference',
+          );
+        if (!instance.isEnabled)
+          this.fail(
+            'NODE_INSTANCE_DISABLED',
+            node,
+            `Node Instance ${ref.instanceCode} is disabled`,
+          );
+        if (instance.nodeTypeId !== nodeType.id)
+          this.fail(
+            'NODE_TYPE_MISMATCH',
+            node,
+            'Node Instance type does not match the workflow node type',
+          );
+        config = clone(
+          node.configOverride ?? (instance.config as Record<string, unknown>),
+        );
+        source = {
+          instanceId: String(instance.id),
+          instanceCode: instance.code,
+          schemaVersion: nodeType.schemaVersion,
+          configHash: hashNodeInstanceConfig(config as Prisma.JsonValue),
+        };
+      }
+
+      const schemaKey = `${nodeType.id}:${nodeType.schemaVersion}`;
+      const schema = nodeType.configSchema as JsonSchema;
+      this.configs.validateOrThrow(schemaKey, schema, config);
+      this.widgets.assertUiSchemaSupported(nodeType.uiSchema);
+      await this.subjects.validateSubjects(schema, 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)
+          this.fail(
+            'NODE_TYPE_MISMATCH',
+            node,
+            'HTTP Request Connection was not found or is disabled',
+          );
+      }
+      if (nodeType.runtimeKey === 'human_approval') {
+        const channelRef = (config as Record<string, unknown>)?.channelRef;
+        if (typeof channelRef === 'string' && channelRef.trim()) {
+          const channel = await this.prisma.approvalChannel.findUnique({
+            where: { code: channelRef.trim() },
+            select: {
+              isEnabled: true,
+              dispatchWorkflow: {
+                select: {
+                  versions: {
+                    orderBy: { version: 'desc' },
+                    take: 1,
+                    select: { dsl: true },
+                  },
+                },
+              },
+            },
+          });
+          if (!channel?.isEnabled)
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              'Approval Channel was not found or is disabled',
+            );
+          const bindings =
+            (config as Record<string, unknown>).channelInputBindings &&
+            typeof (config as Record<string, unknown>).channelInputBindings ===
+              'object' &&
+            !Array.isArray(
+              (config as Record<string, unknown>).channelInputBindings,
+            )
+              ? ((config as Record<string, unknown>)
+                  .channelInputBindings as Record<string, unknown>)
+              : {};
+          const missing = describeApprovalChannelInputs(
+            channel.dispatchWorkflow.versions[0]?.dsl,
+          ).find((parameter) => parameter.required && !bindings[parameter.key]);
+          if (missing)
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              `审批通道缺少必填参数：${missing.label ?? missing.key}`,
+            );
+        }
+        const approverSources = Array.isArray(
+          (config as Record<string, unknown>)?.approverSources,
+        )
+          ? ((config as Record<string, unknown>).approverSources as Array<
+              Record<string, unknown>
+            >)
+          : [];
+        for (const source of approverSources) {
+          const workflowId = String(source.workflowId ?? '');
+          if (!/^[1-9]\d*$/.test(workflowId))
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              '自动找审批人的 Workflow ID 无效',
+            );
+          const workflow = await this.prisma.workflow.findUnique({
+            where: { id: BigInt(workflowId) },
+            include: {
+              versions: {
+                orderBy: { version: 'desc' },
+                take: 1,
+              },
+            },
+          });
+          if (
+            !workflow ||
+            workflow.status !== 'PUBLISHED' ||
+            !workflow.isEnabled
+          )
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              '自动找审批人的 Workflow 未发布或已停用',
+            );
+          let descriptor;
+          try {
+            descriptor = describeCallableWorkflow(workflow.versions[0]?.dsl);
+          } catch (error) {
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              error instanceof Error
+                ? error.message
+                : '自动找审批人的 Workflow 配置无效',
+            );
+          }
+          if (
+            descriptor?.mode !== 'RETURN' ||
+            descriptor.resultType !== 'APPROVAL_SUBJECTS'
+          )
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              '选择的 Workflow 不能返回审批人',
+            );
+          const inputBindings =
+            source.inputBindings &&
+            typeof source.inputBindings === 'object' &&
+            !Array.isArray(source.inputBindings)
+              ? (source.inputBindings as Record<string, unknown>)
+              : {};
+          const missingInput = descriptor.inputParameters.find(
+            (parameter) =>
+              parameter.required &&
+              !validateParameterBinding(inputBindings[parameter.key]),
+          );
+          if (missingInput)
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              `自动找审批人缺少参数映射：${
+                missingInput.label ?? missingInput.key
+              }`,
+            );
+          const invalidInput = descriptor.inputParameters.find(
+            (parameter) =>
+              inputBindings[parameter.key] !== undefined &&
+              !validateParameterBinding(inputBindings[parameter.key]),
+          );
+          if (invalidInput)
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              `自动找审批人的参数来源无效：${
+                invalidInput.label ?? invalidInput.key
+              }`,
+            );
+        }
+      }
+      compiledNodes.push({
+        ...clone(node),
+        config,
+        runtimeKey: nodeType.runtimeKey || nodeType.type,
+        ...(source && { source }),
+      });
+    }
+
+    const compiledDsl = { ...clone(draftDsl), nodes: compiledNodes };
+    if (
+      compiledNodes.some(
+        (node) =>
+          node.type === 'callable_trigger' || node.type === 'return_result',
+      )
+    ) {
+      try {
+        validateCallableWorkflow(compiledDsl);
+      } catch (error) {
+        const boundaryNode =
+          draftDsl.nodes.find((node) => node.type === 'callable_trigger') ??
+          draftDsl.nodes.find((node) => node.type === 'return_result') ??
+          draftDsl.nodes[0];
+        this.fail(
+          'NODE_TYPE_MISMATCH',
+          boundaryNode,
+          error instanceof Error ? error.message : '可调用 Workflow 配置无效',
+        );
+      }
+    }
+    return compiledDsl;
+  }
+
+  private fail(
+    code: WorkflowCompilerErrorCode,
+    node: DraftWorkflowNode,
+    message: string,
+  ): never {
+    throw new BadRequestException({ code, message, nodeId: node.id });
+  }
+}
+
+function parseId(value: string, node: DraftWorkflowNode): bigint {
+  if (!/^[1-9][0-9]*$/.test(String(value)))
+    throw new BadRequestException({
+      code: 'NODE_INSTANCE_NOT_FOUND',
+      message: `Invalid Node Instance id: ${value}`,
+      nodeId: node.id,
+    });
+  return BigInt(value);
+}
+
+function clone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}

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

@@ -0,0 +1,43 @@
+export interface InstanceRef {
+  instanceId: string;
+  instanceCode: string;
+}
+
+export interface CompiledNodeSource {
+  instanceId: string;
+  instanceCode: string;
+  schemaVersion: number;
+  configHash: string;
+}
+
+export interface DraftWorkflowNode {
+  id: string;
+  type: string;
+  config?: Record<string, unknown>;
+  configOverride?: Record<string, unknown>;
+  instanceRef?: InstanceRef;
+  [key: string]: unknown;
+}
+
+export interface DraftWorkflowDsl {
+  nodes: DraftWorkflowNode[];
+  edges: Array<Record<string, unknown>>;
+  [key: string]: unknown;
+}
+
+export interface CompiledWorkflowNode extends DraftWorkflowNode {
+  runtimeKey: string;
+  config: Record<string, unknown>;
+  source?: CompiledNodeSource;
+}
+
+export interface CompiledWorkflowDsl extends Omit<DraftWorkflowDsl, 'nodes'> {
+  nodes: CompiledWorkflowNode[];
+}
+
+export type WorkflowCompilerErrorCode =
+  | 'NODE_INSTANCE_REQUIRED'
+  | 'NODE_INSTANCE_NOT_FOUND'
+  | 'NODE_INSTANCE_DISABLED'
+  | 'NODE_TYPE_MISMATCH'
+  | 'INLINE_NODE_INSTANCE_FORBIDDEN';

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

@@ -0,0 +1,174 @@
+import { validateWorkflowDataEdges } from './workflow-data-edge.util';
+
+describe('validateWorkflowDataEdges', () => {
+  const nodes = [
+    { id: 'query-users', type: 'http_request', config: {} },
+    {
+      id: 'approval',
+      type: 'human_approval',
+      config: {
+        subjects: [
+          {
+            source: 'DYNAMIC',
+            provider: 'USER',
+            inputKey: 'dynamic_users',
+          },
+        ],
+      },
+    },
+  ];
+
+  it('accepts exactly one DATA edge for each dynamic approver input', () => {
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes,
+        edges: [
+          {
+            id: 'data-edge',
+            kind: 'DATA',
+            source: 'query-users',
+            target: 'approval',
+            targetHandle: 'dynamic_users',
+          },
+        ],
+      }),
+    ).not.toThrow();
+  });
+
+  it('rejects an unconnected dynamic approver input', () => {
+    expect(() => validateWorkflowDataEdges({ nodes, edges: [] })).toThrow(
+      'Dynamic input "dynamic_users" on node "approval" must have exactly one lookup connection',
+    );
+  });
+
+  it('accepts an AP call that returns through a Code node', () => {
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes: [
+          {
+            id: 'query-users',
+            type: 'http_request',
+            config: {},
+          },
+          { id: 'extract-users', type: 'code', config: {} },
+          nodes[1],
+        ],
+        edges: [
+          {
+            id: 'call',
+            pairId: 'pair-1',
+            kind: 'CALL',
+            source: 'approval',
+            target: 'query-users',
+            sourceHandle: 'lookup:dynamic_users',
+            targetHandle: 'request-in',
+          },
+          {
+            id: 'transform',
+            pairId: 'pair-1',
+            kind: 'FLOW',
+            source: 'query-users',
+            target: 'extract-users',
+            sourceHandle: 'response-out',
+            targetHandle: 'data-in',
+          },
+          {
+            id: 'return',
+            pairId: 'pair-1',
+            kind: 'RETURN',
+            source: 'extract-users',
+            target: 'approval',
+            sourceHandle: 'result-out',
+            targetHandle: 'approver:dynamic_users',
+          },
+        ],
+      }),
+    ).not.toThrow();
+  });
+
+  it('rejects a RETURN from a node outside the AP call chain', () => {
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes: [
+          { id: 'query-users', type: 'http_request', config: {} },
+          { id: 'unrelated-code', type: 'code', config: {} },
+          nodes[1],
+        ],
+        edges: [
+          {
+            pairId: 'pair-1',
+            kind: 'CALL',
+            source: 'approval',
+            target: 'query-users',
+            sourceHandle: 'lookup:dynamic_users',
+            targetHandle: 'request-in',
+          },
+          {
+            pairId: 'pair-1',
+            kind: 'RETURN',
+            source: 'unrelated-code',
+            target: 'approval',
+            sourceHandle: 'result-out',
+            targetHandle: 'approver:dynamic_users',
+          },
+        ],
+      }),
+    ).toThrow('must return from the CALL chain');
+  });
+
+  it('rejects multiple AP calls into the same HTTP Request', () => {
+    const approval2 = {
+      id: 'approval-2',
+      type: 'human_approval',
+      config: {
+        subjects: [
+          {
+            source: 'DYNAMIC',
+            provider: 'USER',
+            inputKey: 'dynamic_users_2',
+          },
+        ],
+      },
+    };
+
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes: [nodes[0], nodes[1], approval2],
+        edges: [
+          {
+            pairId: 'pair-1',
+            kind: 'CALL',
+            source: 'approval',
+            target: 'query-users',
+            sourceHandle: 'lookup:dynamic_users',
+            targetHandle: 'request-in',
+          },
+          {
+            pairId: 'pair-1',
+            kind: 'RETURN',
+            source: 'query-users',
+            target: 'approval',
+            sourceHandle: 'response-out',
+            targetHandle: 'approver:dynamic_users',
+          },
+          {
+            pairId: 'pair-2',
+            kind: 'CALL',
+            source: 'approval-2',
+            target: 'query-users',
+            sourceHandle: 'lookup:dynamic_users_2',
+            targetHandle: 'request-in',
+          },
+          {
+            pairId: 'pair-2',
+            kind: 'RETURN',
+            source: 'query-users',
+            target: 'approval-2',
+            sourceHandle: 'response-out',
+            targetHandle: 'approver:dynamic_users_2',
+          },
+        ],
+      }),
+    ).toThrow('HTTP Request "query-users" can only have one incoming CALL');
+  });
+});