@gadmin2n/schematics 0.0.139 → 0.0.141

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

@@ -13,6 +13,10 @@ const mockHandle = {
   unpause: jest.fn(),
   delete: jest.fn(),
 };
+const mockWorkflowHandle = {
+  cancel: jest.fn(),
+  result: jest.fn(),
+};
 const mockClient = {
   schedule: {
     getHandle: jest.fn(() => mockHandle),
@@ -20,7 +24,7 @@ const mockClient = {
   },
   workflow: {
     start: jest.fn(),
-    getHandle: jest.fn(() => ({ cancel: jest.fn() })),
+    getHandle: jest.fn(() => mockWorkflowHandle),
   },
 };
 
@@ -50,6 +54,35 @@ describe('TemporalService — cron schedule methods', () => {
     await service.onModuleInit();
   });
 
+  describe('waitForWorkflowResult', () => {
+    it('returns the completed Workflow result', async () => {
+      const workflowResult = {
+        status: 'COMPLETED',
+        output: { ticketId: 'T-42' },
+      };
+      mockWorkflowHandle.result.mockResolvedValueOnce(workflowResult);
+
+      await expect(
+        service.waitForWorkflowResult('wf-42', 1000),
+      ).resolves.toEqual({
+        kind: 'COMPLETED',
+        result: workflowResult,
+      });
+    });
+
+    it('stops waiting at the configured timeout without cancelling the Workflow', async () => {
+      jest.useFakeTimers();
+      mockWorkflowHandle.result.mockReturnValueOnce(new Promise(() => {}));
+
+      const result = service.waitForWorkflowResult('wf-42', 1000);
+      jest.advanceTimersByTime(1000);
+
+      await expect(result).resolves.toEqual({ kind: 'TIMED_OUT' });
+      expect(mockWorkflowHandle.cancel).not.toHaveBeenCalled();
+      jest.useRealTimers();
+    });
+  });
+
   describe('upsertCronSchedule', () => {
     it('creates a new schedule when none exists', async () => {
       mockHandle.describe.mockRejectedValueOnce(

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

@@ -12,6 +12,10 @@ const TASK_QUEUE = process.env.TEMPORAL_TASK_QUEUE || 'workflow-execution';
 
 const cronScheduleId = (workflowId: number) => `wf-${workflowId}-cron`;
 
+export type WorkflowWaitResult =
+  | { kind: 'COMPLETED'; result: unknown }
+  | { kind: 'TIMED_OUT' };
+
 @Injectable()
 export class TemporalService implements OnModuleInit, OnModuleDestroy {
   private connection: Connection;
@@ -68,6 +72,28 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
     return { temporalRunId: handle.workflowId };
   }
 
+  async waitForWorkflowResult(
+    temporalRunId: string,
+    timeoutMs: number,
+  ): Promise<WorkflowWaitResult> {
+    if (!this.client) throw new Error('Temporal client not connected');
+    const handle = this.client.workflow.getHandle(temporalRunId);
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+
+    try {
+      return await Promise.race([
+        handle
+          .result()
+          .then((result) => ({ kind: 'COMPLETED', result } as const)),
+        new Promise<{ kind: 'TIMED_OUT' }>((resolve) => {
+          timeout = setTimeout(() => resolve({ kind: 'TIMED_OUT' }), timeoutMs);
+        }),
+      ]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+
   /**
    * Cancel a running workflow.
    */

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>)
+    : {};
+}