@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -1,6 +1,6 @@
 export type ParameterBinding =
   | {
-      source: 'INPUT' | 'WORKFLOW' | 'SYSTEM';
+      source: 'INPUT' | 'WORKFLOW' | 'APPROVAL';
       path: string;
     }
   | {
@@ -17,7 +17,7 @@ export function validateParameterBinding(
   if (
     binding.source === 'INPUT' ||
     binding.source === 'WORKFLOW' ||
-    binding.source === 'SYSTEM'
+    binding.source === 'APPROVAL'
   )
     return typeof binding.path === 'string' && Boolean(binding.path.trim());
   if (binding.source !== 'FIXED') return false;
@@ -49,7 +49,7 @@ export function resolveParameterBinding(
   binding: ParameterBinding,
   input: unknown,
   workflow: Record<string, unknown>,
-  system: Record<string, unknown> = {},
+  approval?: unknown,
 ): unknown {
   if (binding.source === 'FIXED') {
     if (binding.valueType === 'STRING') return binding.value;
@@ -63,13 +63,13 @@ export function resolveParameterBinding(
       ? 'input'
       : binding.source === 'WORKFLOW'
       ? 'workflow'
-      : 'system';
+      : 'approval';
   const root =
     binding.source === 'INPUT'
       ? input
       : binding.source === 'WORKFLOW'
       ? workflow
-      : system;
+      : approval;
   const value = readPath(root, binding.path);
   if (value === undefined)
     throw new Error(

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

@@ -1,5 +1,9 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import { ScheduleNotFoundError } from '@temporalio/client';
+import {
+  ScheduleNotFoundError,
+  WorkflowIdConflictPolicy,
+  WorkflowIdReusePolicy,
+} from '@temporalio/client';
 import { TemporalService } from './temporal.service';
 
 /**
@@ -16,6 +20,7 @@ const mockHandle = {
 const mockWorkflowHandle = {
   cancel: jest.fn(),
   result: jest.fn(),
+  describe: jest.fn(),
 };
 const mockClient = {
   schedule: {
@@ -39,6 +44,8 @@ jest.mock('@temporalio/client', () => {
     Client: jest.fn(() => mockClient),
     Connection: { connect: jest.fn(async () => ({ close: jest.fn() })) },
     ScheduleNotFoundError: FakeScheduleNotFoundError,
+    WorkflowIdConflictPolicy: { USE_EXISTING: 'USE_EXISTING' },
+    WorkflowIdReusePolicy: { REJECT_DUPLICATE: 'REJECT_DUPLICATE' },
   };
 });
 
@@ -54,33 +61,60 @@ describe('TemporalService — cron schedule methods', () => {
     await service.onModuleInit();
   });
 
-  describe('waitForWorkflowResult', () => {
-    it('returns the completed Workflow result', async () => {
-      const workflowResult = {
+  describe('inspectWorkflow', () => {
+    it('returns the Temporal execution state and completed result', async () => {
+      const startedAt = new Date('2026-08-13T00:00:00.000Z');
+      const finishedAt = new Date('2026-08-13T00:00:01.000Z');
+      mockWorkflowHandle.describe.mockResolvedValueOnce({
+        status: { name: 'COMPLETED' },
+        startTime: startedAt,
+        closeTime: finishedAt,
+      });
+      mockWorkflowHandle.result.mockResolvedValueOnce({ output: { id: 1 } });
+
+      await expect(service.inspectWorkflow('wf-42-99')).resolves.toEqual({
+        kind: 'FOUND',
         status: 'COMPLETED',
-        output: { ticketId: 'T-42' },
-      };
-      mockWorkflowHandle.result.mockResolvedValueOnce(workflowResult);
-
-      await expect(
-        service.waitForWorkflowResult('wf-42', 1000),
-      ).resolves.toEqual({
-        kind: 'COMPLETED',
-        result: workflowResult,
+        startedAt,
+        finishedAt,
+        result: { output: { id: 1 } },
       });
     });
 
-    it('stops waiting at the configured timeout without cancelling the Workflow', async () => {
-      jest.useFakeTimers();
-      mockWorkflowHandle.result.mockReturnValueOnce(new Promise(() => {}));
+    it('reports a missing Temporal execution', async () => {
+      const error = new Error('not found');
+      error.name = 'WorkflowNotFoundError';
+      mockWorkflowHandle.describe.mockRejectedValueOnce(error);
 
-      const result = service.waitForWorkflowResult('wf-42', 1000);
-      jest.advanceTimersByTime(1000);
+      await expect(service.inspectWorkflow('wf-42-99')).resolves.toEqual({
+        kind: 'MISSING',
+      });
+    });
+  });
 
-      await expect(result).resolves.toEqual({ kind: 'TIMED_OUT' });
-      expect(mockWorkflowHandle.cancel).not.toHaveBeenCalled();
-      jest.useRealTimers();
+  it('reuses the same open execution and rejects a completed duplicate', async () => {
+    mockClient.workflow.start.mockResolvedValueOnce({
+      workflowId: 'wf-42-99',
     });
+
+    await expect(
+      service.startWorkflow({
+        instanceId: 99,
+        workflowId: 42,
+        versionId: 7,
+        dsl: { nodes: [], edges: [] },
+        context: { workflow: {}, nodes: {} },
+      }),
+    ).resolves.toEqual({ temporalRunId: 'wf-42-99' });
+
+    expect(mockClient.workflow.start).toHaveBeenCalledWith(
+      'dslWorkflow',
+      expect.objectContaining({
+        workflowId: 'wf-42-99',
+        workflowIdConflictPolicy: WorkflowIdConflictPolicy.USE_EXISTING,
+        workflowIdReusePolicy: WorkflowIdReusePolicy.REJECT_DUPLICATE,
+      }),
+    );
   });
 
   describe('upsertCronSchedule', () => {
@@ -93,14 +127,14 @@ describe('TemporalService — cron schedule methods', () => {
         workflowId: 42,
         versionId: 7,
         dsl: { nodes: [], edges: [] },
-        cron: '0 * * * *',
+        cronExpressions: ['0 9 * * *', '30 18 * * *'],
         timezone: 'Asia/Shanghai',
       });
 
       expect(mockClient.schedule.create).toHaveBeenCalledTimes(1);
       const arg = mockClient.schedule.create.mock.calls[0][0];
       expect(arg.scheduleId).toBe('wf-42-cron');
-      expect(arg.spec.cronExpressions).toEqual(['0 * * * *']);
+      expect(arg.spec.cronExpressions).toEqual(['0 9 * * *', '30 18 * * *']);
       expect(arg.spec.timezoneName).toBe('Asia/Shanghai');
       expect(arg.action.workflowType).toBe('cronTriggerWorkflow');
       expect(arg.action.args[0]).toMatchObject({
@@ -117,7 +151,7 @@ describe('TemporalService — cron schedule methods', () => {
         workflowId: 42,
         versionId: 8,
         dsl: { nodes: [], edges: [] },
-        cron: '*/5 * * * *',
+        cronExpressions: ['*/5 * * * *'],
       });
 
       expect(mockClient.schedule.create).not.toHaveBeenCalled();
@@ -132,13 +166,29 @@ describe('TemporalService — cron schedule methods', () => {
         workflowId: 1,
         versionId: 1,
         dsl: {},
-        cron: '0 0 * * *',
+        cronExpressions: ['0 0 * * *'],
       });
       const spec = mockClient.schedule.create.mock.calls[0][0].spec;
       expect(spec.timezoneName).toBeUndefined();
     });
   });
 
+  describe('getCronScheduleStatus', () => {
+    it('returns the live paused state', async () => {
+      mockHandle.describe.mockResolvedValueOnce({
+        state: { paused: true },
+      });
+      await expect(service.getCronScheduleStatus(42)).resolves.toBe('PAUSED');
+    });
+
+    it('returns missing when the schedule does not exist', async () => {
+      mockHandle.describe.mockRejectedValueOnce(
+        new ScheduleNotFoundError('nf', 'wf-x-cron'),
+      );
+      await expect(service.getCronScheduleStatus(42)).resolves.toBe('MISSING');
+    });
+  });
+
   describe('pauseCronSchedule', () => {
     it('calls handle.pause for existing schedule', async () => {
       mockHandle.pause.mockResolvedValueOnce(undefined);
@@ -157,6 +207,13 @@ describe('TemporalService — cron schedule methods', () => {
       mockHandle.pause.mockRejectedValueOnce(new Error('boom'));
       await expect(service.pauseCronSchedule(42)).rejects.toThrow('boom');
     });
+
+    it('fails when the Temporal client is unavailable', async () => {
+      (service as any).client = undefined;
+      await expect(service.pauseCronSchedule(42)).rejects.toThrow(
+        'Temporal client not connected',
+      );
+    });
   });
 
   describe('unpauseCronSchedule', () => {
@@ -172,6 +229,13 @@ describe('TemporalService — cron schedule methods', () => {
       );
       await expect(service.unpauseCronSchedule(42)).resolves.toBeUndefined();
     });
+
+    it('fails when the Temporal client is unavailable', async () => {
+      (service as any).client = undefined;
+      await expect(service.unpauseCronSchedule(42)).rejects.toThrow(
+        'Temporal client not connected',
+      );
+    });
   });
 
   describe('deleteCronSchedule', () => {
@@ -187,5 +251,12 @@ describe('TemporalService — cron schedule methods', () => {
       );
       await expect(service.deleteCronSchedule(42)).resolves.toBeUndefined();
     });
+
+    it('fails when the Temporal client is unavailable', async () => {
+      (service as any).client = undefined;
+      await expect(service.deleteCronSchedule(42)).rejects.toThrow(
+        'Temporal client not connected',
+      );
+    });
   });
 });

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

@@ -4,17 +4,43 @@ import {
   OnModuleDestroy,
   OnModuleInit,
 } from '@nestjs/common';
-import { Client, Connection, ScheduleNotFoundError } from '@temporalio/client';
+import {
+  Client,
+  Connection,
+  ScheduleNotFoundError,
+  WorkflowIdConflictPolicy,
+  WorkflowIdReusePolicy,
+} from '@temporalio/client';
 
 const TEMPORAL_ADDRESS = process.env.TEMPORAL_ADDRESS || 'localhost:7233';
 const TEMPORAL_NAMESPACE = process.env.TEMPORAL_NAMESPACE || 'default';
 const TASK_QUEUE = process.env.TEMPORAL_TASK_QUEUE || 'workflow-execution';
 
 const cronScheduleId = (workflowId: number) => `wf-${workflowId}-cron`;
+export const workflowTemporalId = (workflowId: number, instanceId: number) =>
+  `wf-${workflowId}-${instanceId}`;
+
+export type WorkflowExecutionState =
+  | { kind: 'MISSING' }
+  | {
+      kind: 'FOUND';
+      status: string;
+      startedAt: Date;
+      finishedAt?: Date;
+      result?: unknown;
+    };
+
+export type CronScheduleStatus =
+  | 'ACTIVE'
+  | 'PAUSED'
+  | 'MISSING'
+  | 'UNAVAILABLE';
 
-export type WorkflowWaitResult =
-  | { kind: 'COMPLETED'; result: unknown }
-  | { kind: 'TIMED_OUT' };
+export interface WorkflowRetryCheckpoint {
+  startNodeId: string;
+  completedNodeIds: string[];
+  outputs: Record<string, unknown>;
+}
 
 @Injectable()
 export class TemporalService implements OnModuleInit, OnModuleDestroy {
@@ -56,44 +82,25 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
     versionId: number;
     dsl: any;
     context: Record<string, any>;
+    retryCheckpoint?: WorkflowRetryCheckpoint;
   }): Promise<{ temporalRunId: string }> {
     if (!this.client) {
       throw new Error('Temporal client not connected');
     }
 
-    const workflowId = `wf-${params.workflowId}-${params.instanceId}`;
+    const workflowId = workflowTemporalId(params.workflowId, params.instanceId);
 
     const handle = await this.client.workflow.start('dslWorkflow', {
       taskQueue: TASK_QUEUE,
       workflowId,
+      workflowIdConflictPolicy: WorkflowIdConflictPolicy.USE_EXISTING,
+      workflowIdReusePolicy: WorkflowIdReusePolicy.REJECT_DUPLICATE,
       args: [params],
     });
 
     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.
    */
@@ -103,6 +110,29 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
     await handle.cancel();
   }
 
+  async inspectWorkflow(
+    temporalRunId: string,
+  ): Promise<WorkflowExecutionState> {
+    if (!this.client) throw new Error('Temporal client not connected');
+    const handle = this.client.workflow.getHandle(temporalRunId);
+    try {
+      const description = await handle.describe();
+      return {
+        kind: 'FOUND',
+        status: description.status.name,
+        startedAt: description.startTime,
+        ...(description.closeTime && { finishedAt: description.closeTime }),
+        ...(description.status.name === 'COMPLETED' && {
+          result: await handle.result(),
+        }),
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === 'WorkflowNotFoundError')
+        return { kind: 'MISSING' };
+      throw error;
+    }
+  }
+
   /**
    * Send a signal to a running workflow (e.g., approval).
    */
@@ -142,7 +172,7 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
     workflowId: number;
     versionId: number;
     dsl: any;
-    cron: string;
+    cronExpressions: string[];
     timezone?: string;
   }): Promise<void> {
     if (!this.client) throw new Error('Temporal client not connected');
@@ -162,7 +192,7 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
       ],
     };
     const spec = {
-      cronExpressions: [input.cron],
+      cronExpressions: input.cronExpressions,
       ...(input.timezone ? { timezoneName: input.timezone } : {}),
     };
 
@@ -176,7 +206,7 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
         action,
       }));
       this.logger.log(
-        `Updated cron schedule ${scheduleId} (cron="${input.cron}")`,
+        `Updated cron schedule ${scheduleId} (${input.cronExpressions.length} expression(s))`,
       );
     } catch (err: any) {
       if (err instanceof ScheduleNotFoundError) {
@@ -186,7 +216,7 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
           action,
         });
         this.logger.log(
-          `Created cron schedule ${scheduleId} (cron="${input.cron}")`,
+          `Created cron schedule ${scheduleId} (${input.cronExpressions.length} expression(s))`,
         );
       } else {
         throw err;
@@ -194,11 +224,24 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
     }
   }
 
+  async getCronScheduleStatus(workflowId: number): Promise<CronScheduleStatus> {
+    if (!this.client) return 'UNAVAILABLE';
+    try {
+      const description = await this.client.schedule
+        .getHandle(cronScheduleId(workflowId))
+        .describe();
+      return description.state.paused ? 'PAUSED' : 'ACTIVE';
+    } catch (error) {
+      if (error instanceof ScheduleNotFoundError) return 'MISSING';
+      return 'UNAVAILABLE';
+    }
+  }
+
   /**
    * Pause a cron schedule. No-op if it doesn't exist.
    */
   async pauseCronSchedule(workflowId: number): Promise<void> {
-    if (!this.client) return;
+    if (!this.client) throw new Error('Temporal client not connected');
     const scheduleId = cronScheduleId(workflowId);
     try {
       await this.client.schedule.getHandle(scheduleId).pause();
@@ -213,7 +256,7 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
    * Resume a paused cron schedule. No-op if it doesn't exist.
    */
   async unpauseCronSchedule(workflowId: number): Promise<void> {
-    if (!this.client) return;
+    if (!this.client) throw new Error('Temporal client not connected');
     const scheduleId = cronScheduleId(workflowId);
     try {
       await this.client.schedule.getHandle(scheduleId).unpause();
@@ -228,7 +271,7 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
    * Delete a cron schedule. No-op if it doesn't exist.
    */
   async deleteCronSchedule(workflowId: number): Promise<void> {
-    if (!this.client) return;
+    if (!this.client) throw new Error('Temporal client not connected');
     const scheduleId = cronScheduleId(workflowId);
     try {
       await this.client.schedule.getHandle(scheduleId).delete();

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

@@ -15,13 +15,12 @@ const validDsl = {
       },
     },
     { id: 'http', type: 'http_request', config: {} },
-    { id: 'return', type: 'return_result', config: {} },
   ],
-  edges: [{ source: 'http', target: 'return', kind: 'FLOW' }],
+  edges: [{ source: 'input', target: 'http', kind: 'FLOW' }],
 };
 
 describe('callable Workflow contract', () => {
-  it('describes declared inputs and a returning workflow without a result type', () => {
+  it('describes declared inputs and returns the terminal node result', () => {
     expect(describeCallableWorkflow(validDsl)).toEqual({
       mode: 'RETURN',
       inputParameters: [
@@ -42,45 +41,35 @@ describe('callable Workflow contract', () => {
     ).toThrow('不能同时包含其他触发器');
   });
 
-  it('rejects a callable Workflow without a return node', () => {
-    expect(() =>
-      validateCallableWorkflow({
-        ...validDsl,
-        nodes: validDsl.nodes.filter((node) => node.type !== 'return_result'),
-      }),
-    ).toThrow('必须且只能包含一个“返回调用”节点');
+  it('accepts a callable Workflow without a separate return node', () => {
+    expect(() => validateCallableWorkflow(validDsl)).not.toThrow();
   });
 
-  it('rejects more than one return node', () => {
+  it('accepts conditional terminal branches', () => {
     expect(() =>
       validateCallableWorkflow({
-        ...validDsl,
         nodes: [
-          ...validDsl.nodes,
-          { id: 'return-2', type: 'return_result', config: {} },
+          validDsl.nodes[0],
+          { id: 'branch', type: 'if_else', config: {} },
+          { id: 'accepted', type: 'code', config: {} },
+          { id: 'rejected', type: 'code', config: {} },
         ],
-      }),
-    ).toThrow('必须且只能包含一个“返回调用”节点');
-  });
-
-  it('requires exactly one previous node', () => {
-    expect(() =>
-      validateCallableWorkflow({
-        ...validDsl,
-        edges: [],
-      }),
-    ).toThrow('“返回调用”前需要连接一个节点');
-  });
-
-  it('requires the return node to be terminal', () => {
-    expect(() =>
-      validateCallableWorkflow({
-        ...validDsl,
         edges: [
-          ...validDsl.edges,
-          { source: 'return', target: 'after', kind: 'FLOW' },
+          { source: 'input', target: 'branch', kind: 'FLOW' },
+          {
+            source: 'branch',
+            target: 'accepted',
+            sourceHandle: 'true',
+            kind: 'FLOW',
+          },
+          {
+            source: 'branch',
+            target: 'rejected',
+            sourceHandle: 'false',
+            kind: 'FLOW',
+          },
         ],
       }),
-    ).toThrow('“返回调用”必须是流程最后一个节点');
+    ).not.toThrow();
   });
 });

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

@@ -56,31 +56,10 @@ export function validateCallableWorkflow(
   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 !== 1)
-    throw new Error('可调用 Workflow 必须且只能包含一个“返回调用”节点');
-
-  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('“返回调用”前需要连接一个节点');
-  const successors = (asDsl(dsl).edges ?? []).filter(
-    (edge) =>
-      edge.source === returnNodeId &&
-      (!edge.kind || edge.kind === 'FLOW') &&
-      !edge.pairId,
-  );
-  if (successors.length > 0)
-    throw new Error('“返回调用”必须是流程最后一个节点');
 
   return {
     mode: 'RETURN',