@gadmin2n/schematics 0.0.140 → 0.0.142

package/dist/lib/application/files/gadmin2-game-angle-demo/config/ui/Event.ts

@@ -51,7 +51,7 @@ export const Event: ModelConfig = {
           action: "EDIT",
           desc: "Edit",
         },
-
+        { action: "DETAIL", desc: "详情" },
         { action: "DELETE", desc: "Delete" },
       ],
     },

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

@@ -94,7 +94,7 @@
   "devDependencies": {
     "@faker-js/faker": "^10.4.0",
     "@gadmin2n/prisma-nest-generator": "^0.0.49",
-    "@gadmin2n/prisma-react-generator": "^0.0.71",
+    "@gadmin2n/prisma-react-generator": "^0.0.73",
     "@nestjs/cli": "^11.0.21",
     "@nestjs/testing": "^10.4.15",
     "@swc/cli": "^0.8.1",

package/dist/lib/application/files/gadmin2-game-angle-demo/server/scripts/gen-jwt.ts

@@ -49,7 +49,14 @@ async function main() {
     process.exit(1);
   }
 
-  const ttl = expiresIn ? parseInt(expiresIn, 10) : 7 * 24 * 60 * 60; // 默认 7 天
+  const ttl = expiresIn ? parseInt(expiresIn, 10) : 3600; // 默认 1 小时（单位：秒）
+
+  if (Number.isNaN(ttl) || ttl <= 0) {
+    console.error(
+      `[gen-jwt] --expiresIn must be a positive integer (seconds), got "${expiresIn}".`,
+    );
+    process.exit(1);
+  }
 
   const token = await TaiHuId.sign(
     {

package/dist/lib/application/files/gadmin2-game-angle-demo/server/seed/workflow-node-types.ts

@@ -124,6 +124,21 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
           description:
             'HMAC-SHA256 secret. Caller must send X-Workflow-Signature: sha256=HEX(HMAC(secret, "{ts}.{rawBody}")) and X-Workflow-Timestamp.',
         },
+        responseMode: {
+          type: 'string',
+          enum: ['IMMEDIATE', 'WAIT_FOR_RESULT'],
+          default: 'IMMEDIATE',
+          description:
+            'Immediately acknowledge the request or wait for a Return Result node.',
+        },
+        responseTimeoutSeconds: {
+          type: 'integer',
+          minimum: 1,
+          maximum: 300,
+          default: 60,
+          description:
+            'Maximum time to keep the HTTP request open in WAIT_FOR_RESULT mode.',
+        },
       },
       required: ['path', 'method'],
       allOf: [
@@ -1007,8 +1022,8 @@ const returnResultNode: NodeTypeSeed = {
       resultType: {
         type: 'string',
         title: '结果类型',
-        enum: ['APPROVAL_SUBJECTS'],
-        default: 'APPROVAL_SUBJECTS',
+        enum: ['JSON', 'APPROVAL_SUBJECTS'],
+        default: 'JSON',
       },
       sourceMode: {
         type: 'string',
@@ -1021,6 +1036,19 @@ const returnResultNode: NodeTypeSeed = {
         title: 'Workflow 数据字段',
         description: '例如 approvers',
       },
+      httpStatusCode: {
+        type: 'integer',
+        title: 'HTTP 状态码',
+        minimum: 100,
+        maximum: 599,
+        default: 200,
+      },
+      httpHeaders: {
+        type: 'object',
+        title: 'HTTP 响应头',
+        additionalProperties: { type: 'string' },
+        default: {},
+      },
     },
     required: ['resultType', 'sourceMode'],
   },
@@ -1028,7 +1056,7 @@ const returnResultNode: NodeTypeSeed = {
   outputSchema: { type: 'object' },
   outputs: [],
   runtimeKey: 'return_result',
-  schemaVersion: 3,
+  schemaVersion: 4,
   instancePolicy: 'INLINE_ONLY',
   uiSchema: { widget: 'return-result-config' },
 };
@@ -1203,7 +1231,7 @@ const webhookDefinition = INLINE_NODE_DEFINITIONS.find(
 const webhookNode: NodeTypeSeed = {
   ...inlineNode(webhookDefinition),
   runtimeKey: 'webhook_trigger',
-  schemaVersion: 3,
+  schemaVersion: 4,
   uiSchema: { widget: 'external-request-config' },
 };
 

package/dist/lib/application/files/gadmin2-game-angle-demo/server/seed/workflow.seed.ts

@@ -12,7 +12,7 @@ import { seedNodeTypes } from './workflow-node-types';
  * Workflow 模块 seed
  *
  * 一站式负责 workflow 模块所有 seed：
- *   1. 菜单结构：workflow 父分组 + 2 个 leaf (workflow_list / workflow_node_instance)
+ *   1. 菜单结构：workflow 父分组及其管理、审批任务页面
  *   2. resource: workflow / workflowNodeInstance
  *   3. PageResource 绑定与 SYSTEM_ADMIN 授权
  *   4. 业务数据：node-types / workflows / event-trigger function & index
@@ -41,30 +41,6 @@ export async function seedWorkflowModule(prisma: PrismaClient): Promise<void> {
   });
   console.log(`[workflow] Page: ${workflowPage.code} (id=${workflowPage.id})`);
 
-  // Approval work belongs to the user's task inbox, not Workflow management.
-  const approvalTasksPage = await upsertPage(prisma, {
-    code: 'approval_tasks',
-    name: 'approval_tasks',
-    zhName: '审批任务',
-    enName: 'Approval Tasks',
-    sortOrder: 1040,
-    parentId: admin.id,
-  });
-  await bindResourceToPage(
-    prisma,
-    approvalTasksPage.id,
-    'humanApproval',
-    'Read and decide assigned Human Approval tasks',
-  );
-  for (const eligibleRole of await prisma.role.findMany()) {
-    await grantRoleAccess(
-      prisma,
-      eligibleRole.id,
-      approvalTasksPage.id,
-      await getPageResourceIds(prisma, approvalTasksPage.id),
-    );
-  }
-
   // ── leaf pages + resource 绑定 ─────────────────────────────────────────────
   const leafDefs: {
     code: string;
@@ -115,19 +91,33 @@ export async function seedWorkflowModule(prisma: PrismaClient): Promise<void> {
       resourceDescription:
         'Reusable dispatch and callback workflows for external approvals',
     },
+    {
+      code: 'approval_tasks',
+      zhName: '审批任务',
+      enName: 'Approval Tasks',
+      sortOrder: 6,
+      resourceCode: 'humanApproval',
+      resourceDescription: 'Read and decide assigned Human Approval tasks',
+    },
   ];
 
   const allPages = [{ id: workflowPage.id, code: workflowPage.code }];
 
   for (const def of leafDefs) {
-    const p = await upsertPage(prisma, {
-      code: def.code,
-      name: def.code,
-      zhName: def.zhName,
-      enName: def.enName,
-      sortOrder: def.sortOrder,
-      parentId: workflowPage.id,
-    });
+    const p = await upsertPage(
+      prisma,
+      {
+        code: def.code,
+        name: def.code,
+        zhName: def.zhName,
+        enName: def.enName,
+        sortOrder: def.sortOrder,
+        parentId: workflowPage.id,
+      },
+      def.code === 'approval_tasks'
+        ? { parentId: workflowPage.id, sortOrder: def.sortOrder }
+        : {},
+    );
     allPages.push({ id: p.id, code: p.code });
     console.log(`[workflow] Page: ${p.code} (id=${p.id})`);
 
@@ -169,6 +159,22 @@ export async function seedWorkflowModule(prisma: PrismaClient): Promise<void> {
     );
   }
 
+  // 审批任务是所有业务角色的个人待办入口；移动到 Workflow 下不改变权限。
+  const approvalTasksPage = allPages.find(
+    (page) => page.code === 'approval_tasks',
+  );
+  if (approvalTasksPage) {
+    const resourceIds = await getPageResourceIds(prisma, approvalTasksPage.id);
+    for (const eligibleRole of await prisma.role.findMany()) {
+      await grantRoleAccess(
+        prisma,
+        eligibleRole.id,
+        approvalTasksPage.id,
+        resourceIds,
+      );
+    }
+  }
+
   // Connection management is part of creating and maintaining reusable Node
   // Templates. Keep its page access aligned with the existing Node Template
   // page instead of limiting it to SYSTEM_ADMIN on installations that already

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-compiler.service.spec.ts

@@ -2,6 +2,155 @@ import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-co
 import { WorkflowCompilerService } from './workflow-compiler.service';
 
 describe('WorkflowCompilerService', () => {
+  it('compiles a webhook function that returns JSON to its HTTP caller', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(1),
+            type: 'webhook_trigger',
+            runtimeKey: 'webhook_trigger',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 4,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+          {
+            id: BigInt(2),
+            type: 'return_result',
+            runtimeKey: 'return_result',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 4,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: {
+        findMany: jest.fn().mockResolvedValue([]),
+      },
+    };
+    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: 'webhook',
+            type: 'webhook_trigger',
+            config: {
+              path: 'create-ticket',
+              method: 'POST',
+              verificationMode: 'NONE',
+              responseMode: 'WAIT_FOR_RESULT',
+              responseTimeoutSeconds: 60,
+            },
+          },
+          {
+            id: 'return',
+            type: 'return_result',
+            config: {
+              resultType: 'JSON',
+              sourceMode: 'WORKFLOW',
+              path: 'body',
+            },
+          },
+        ],
+        edges: [
+          {
+            id: 'webhook-return',
+            source: 'webhook',
+            target: 'return',
+            kind: 'FLOW',
+          },
+        ],
+      },
+      { userId: 'author' },
+    );
+
+    expect(compiled.nodes).toEqual([
+      expect.objectContaining({ type: 'webhook_trigger' }),
+      expect.objectContaining({
+        type: 'return_result',
+        config: expect.objectContaining({ resultType: 'JSON' }),
+      }),
+    ]);
+  });
+
+  it('rejects a webhook function whose flow can finish without returning', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(1),
+            type: 'webhook_trigger',
+            runtimeKey: 'webhook_trigger',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 4,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+          {
+            id: BigInt(2),
+            type: 'code',
+            runtimeKey: 'code',
+            instancePolicy: 'OPTIONAL',
+            schemaVersion: 4,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: {
+        findMany: jest.fn().mockResolvedValue([]),
+      },
+    };
+    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: 'webhook',
+              type: 'webhook_trigger',
+              config: {
+                path: 'create-ticket',
+                method: 'POST',
+                responseMode: 'WAIT_FOR_RESULT',
+              },
+            },
+            { id: 'code', type: 'code', config: {} },
+          ],
+          edges: [
+            {
+              id: 'webhook-code',
+              source: 'webhook',
+              target: 'code',
+              kind: 'FLOW',
+            },
+          ],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: '等待返回结果时，每个流程分支都必须以“返回结果”结束',
+        nodeId: 'webhook',
+      },
+    });
+  });
+
   it('snapshots the current Node Instance config into the compiled workflow', async () => {
     const instance = {
       id: BigInt(12),

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

@@ -20,6 +20,7 @@ import {
   DraftWorkflowNode,
   WorkflowCompilerErrorCode,
 } from './workflow-compiler.types';
+import { validateWebhookResponseWorkflow } from './workflow-http-response';
 
 @Injectable()
 export class WorkflowCompilerService {
@@ -307,12 +308,7 @@ export class WorkflowCompilerService {
     }
 
     const compiledDsl = { ...clone(draftDsl), nodes: compiledNodes };
-    if (
-      compiledNodes.some(
-        (node) =>
-          node.type === 'callable_trigger' || node.type === 'return_result',
-      )
-    ) {
+    if (compiledNodes.some((node) => node.type === 'callable_trigger')) {
       try {
         validateCallableWorkflow(compiledDsl);
       } catch (error) {
@@ -327,6 +323,24 @@ export class WorkflowCompilerService {
         );
       }
     }
+    try {
+      validateWebhookResponseWorkflow(compiledDsl);
+    } catch (error) {
+      const boundaryNode =
+        draftDsl.nodes.find(
+          (node) =>
+            node.type === 'webhook_trigger' &&
+            (node.config as Record<string, unknown> | undefined)
+              ?.responseMode === 'WAIT_FOR_RESULT',
+        ) ??
+        draftDsl.nodes.find((node) => node.type === 'return_result') ??
+        draftDsl.nodes[0];
+      this.fail(
+        'NODE_TYPE_MISMATCH',
+        boundaryNode,
+        error instanceof Error ? error.message : 'HTTP 返回配置无效',
+      );
+    }
     return compiledDsl;
   }
 

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

@@ -0,0 +1,85 @@
+import { validateWebhookResponseWorkflow } from './workflow-http-response';
+
+const trigger = {
+  id: 'webhook',
+  type: 'webhook_trigger',
+  config: {
+    responseMode: 'WAIT_FOR_RESULT',
+    responseTimeoutSeconds: 60,
+  },
+};
+
+const returnNode = (id: string) => ({
+  id,
+  type: 'return_result',
+  config: {
+    resultType: 'JSON',
+    sourceMode: 'INPUT',
+    httpStatusCode: 200,
+  },
+});
+
+describe('webhook function response contract', () => {
+  it('accepts conditional branches that each return their own result', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [
+          trigger,
+          { id: 'branch', type: 'if_else', config: {} },
+          returnNode('accepted'),
+          returnNode('rejected'),
+        ],
+        edges: [
+          { source: 'webhook', target: 'branch', kind: 'FLOW' },
+          { source: 'branch', target: 'accepted', kind: 'FLOW' },
+          { source: 'branch', target: 'rejected', kind: 'FLOW' },
+        ],
+      }),
+    ).not.toThrow();
+  });
+
+  it('rejects a function-mode webhook with a terminal branch that does not return', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [
+          trigger,
+          { id: 'branch', type: 'if_else', config: {} },
+          returnNode('accepted'),
+          { id: 'unfinished', type: 'code', config: {} },
+        ],
+        edges: [
+          { source: 'webhook', target: 'branch', kind: 'FLOW' },
+          { source: 'branch', target: 'accepted', kind: 'FLOW' },
+          { source: 'branch', target: 'unfinished', kind: 'FLOW' },
+        ],
+      }),
+    ).toThrow('等待返回结果时，每个流程分支都必须以“返回结果”结束');
+  });
+
+  it('rejects an approval-only return value for an HTTP response', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [
+          trigger,
+          {
+            ...returnNode('return'),
+            config: {
+              resultType: 'APPROVAL_SUBJECTS',
+              sourceMode: 'INPUT',
+            },
+          },
+        ],
+        edges: [{ source: 'webhook', target: 'return', kind: 'FLOW' }],
+      }),
+    ).toThrow('HTTP 调用只能返回普通数据');
+  });
+
+  it('rejects returning a previous result when only the trigger is connected', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [trigger, returnNode('return')],
+        edges: [{ source: 'webhook', target: 'return', kind: 'FLOW' }],
+      }),
+    ).toThrow('返回上一步结果时，“返回结果”前需要连接一个处理节点');
+  });
+});