@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -0,0 +1,49 @@
+import { PrismaClient } from '@prisma/client';
+
+/**
+ * Workflow Outbox 初始化与旧数据表事件清理。
+ *
+ * 业务代码在自身事务中显式写入 t_workflow_event_outbox。Workflow 不再通过
+ * PostgreSQL Trigger 把任意数据表变化转换成事件。
+ */
+export async function seedWorkflowOutbox(prisma: PrismaClient) {
+  console.log('Removing legacy workflow table-event triggers...');
+
+  await prisma.$executeRawUnsafe(`
+    DO $$
+    DECLARE
+      legacy_trigger record;
+    BEGIN
+      FOR legacy_trigger IN
+        SELECT
+          event_trigger.tgname AS trigger_name,
+          table_schema.nspname AS schema_name,
+          table_class.relname AS table_name
+        FROM pg_trigger event_trigger
+        JOIN pg_class table_class ON table_class.oid = event_trigger.tgrelid
+        JOIN pg_namespace table_schema ON table_schema.oid = table_class.relnamespace
+        JOIN pg_proc trigger_function ON trigger_function.oid = event_trigger.tgfoid
+        JOIN pg_namespace function_schema ON function_schema.oid = trigger_function.pronamespace
+        WHERE NOT event_trigger.tgisinternal
+          AND table_schema.nspname = current_schema()
+          AND function_schema.nspname = current_schema()
+          AND trigger_function.proname = 'notify_workflow_event'
+      LOOP
+        EXECUTE format(
+          'DROP TRIGGER %I ON %I.%I',
+          legacy_trigger.trigger_name,
+          legacy_trigger.schema_name,
+          legacy_trigger.table_name
+        );
+      END LOOP;
+
+      EXECUTE format(
+        'DROP FUNCTION IF EXISTS %I.notify_workflow_event()',
+        current_schema()
+      );
+    END
+    $$;
+  `);
+
+  console.log('Workflow outbox initialized.');
+}

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

@@ -5,8 +5,8 @@ import {
   grantRoleAccess,
   upsertPage,
 } from '../scripts/lib/page-helpers';
-import { seedWorkflowEventTrigger } from './workflow-event-trigger';
 import { seedNodeTypes } from './workflow-node-types';
+import { seedWorkflowOutbox } from './workflow-outbox';
 
 /**
  * Workflow 模块 seed
@@ -15,9 +15,9 @@ import { seedNodeTypes } from './workflow-node-types';
  *   1. 菜单结构：workflow 父分组及其管理、审批任务页面
  *   2. resource: workflow / workflowNodeInstance
  *   3. PageResource 绑定与 SYSTEM_ADMIN 授权
- *   4. 业务数据：node-types / workflows / event-trigger function & index
+ *   4. 业务数据：node-types / Outbox 旧触发器清理
  *
- * 业务数据 seed 函数仍来自 ./workflow-{node-types,workflows,event-trigger}.ts
+ * 业务数据 seed 函数仍来自 ./workflow-{node-types,outbox}.ts
  * （文件较大，保持独立但只被本入口 import，不再由 seed/index.ts 直接调用）。
  *
  * 前置：seedBootstrap 已建好 SYSTEM_ADMIN。
@@ -83,11 +83,19 @@ export async function seedWorkflowModule(prisma: PrismaClient): Promise<void> {
       resourceCode: 'temporalTenantConfig',
       resourceDescription: 'Temporal tenant config management',
     },
+    {
+      code: 'workflow_event_catalog',
+      zhName: '业务事件',
+      enName: 'Business Events',
+      sortOrder: 5,
+      resourceCode: 'workflow',
+      resourceDescription: 'Read registered Workflow business events',
+    },
     {
       code: 'approval_tasks',
       zhName: '审批任务',
       enName: 'Approval Tasks',
-      sortOrder: 5,
+      sortOrder: 6,
       resourceCode: 'humanApproval',
       resourceDescription: 'Read and decide assigned Human Approval tasks',
     },
@@ -121,6 +129,28 @@ export async function seedWorkflowModule(prisma: PrismaClient): Promise<void> {
     );
     console.log(`[workflow] PageResource: ${def.code} ↔ ${def.resourceCode}`);
 
+    if (def.code === 'workflow_event_catalog') {
+      await bindResourceToPage(
+        prisma,
+        p.id,
+        'workflowEventRegistration',
+        'Register database-backed Workflow business events',
+      );
+      console.log(
+        '[workflow] PageResource: workflow_event_catalog ↔ workflowEventRegistration',
+      );
+    }
+
+    if (def.code === 'workflow_list') {
+      await bindResourceToPage(
+        prisma,
+        p.id,
+        'workflowExecution',
+        'Execute published manual Workflows',
+      );
+      console.log('[workflow] PageResource: workflow_list ↔ workflowExecution');
+    }
+
     // Provider actions live inside the existing Node Instance page. Resolve is
     // seeded now for the later publish/runtime call path; it has no HTTP route yet.
     if (def.code === 'workflow_node_instance') {
@@ -201,5 +231,5 @@ export async function seedWorkflowModule(prisma: PrismaClient): Promise<void> {
 
   // ── 业务数据 ───────────────────────────────────────────────────────────────
   await seedNodeTypes(prisma);
-  await seedWorkflowEventTrigger(prisma);
+  await seedWorkflowOutbox(prisma);
 }

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

@@ -494,44 +494,34 @@ export class AgendaService
     };
   }
 
-  /** Requeue jobs — reschedule them to run immediately */
+  /**
+   * 重排任务 —— 将原实例的 nextRunAt 重置为现在，同一行重跑。
+   * 不用 cancel + now（会向队列插入新行，且销毁周期任务的 repeatInterval）。
+   */
   async requeueByIds(jobIds: string[]) {
     let affected = 0;
     for (const id of jobIds) {
       const result = await this.agenda.queryJobs({ id });
-      if (result.jobs.length > 0) {
-        const job = result.jobs[0];
-        const liveJobs = await this.agenda.queryJobs({ id } as any);
-        if (liveJobs.jobs.length > 0) {
-          await this.agenda.cancel({ _id: id } as any);
-          await this.agenda.now(job.name, job.data as Record<string, any>);
-          affected++;
-        }
-      }
+      if (result.jobs.length === 0) continue;
+      // 用完整 attrs 重建 Job 实例，save() 走 UPDATE 而非 INSERT
+      const job = new Job(this.agenda, { ...result.jobs[0] } as any);
+      job.schedule(new Date());
+      await job.save();
+      affected++;
     }
     return { affected };
   }
 
-  /** Retry failed jobs */
+  /** Retry failed jobs —— 同样重置原实例，不清除周期计划 */
   async retryByIds(jobIds: string[]) {
-    let affected = 0;
-    for (const id of jobIds) {
-      const result = await this.agenda.queryJobs({ id });
-      if (result.jobs.length > 0) {
-        const job = result.jobs[0];
-        await this.agenda.cancel({ _id: id } as any);
-        await this.agenda.now(job.name, job.data as Record<string, any>);
-        affected++;
-      }
-    }
-    return { affected };
+    return this.requeueByIds(jobIds);
   }
 
-  /** Delete jobs by IDs */
+  /** Delete jobs by IDs（postgres backend 的 cancel 只认 { id }，{_id} 会静默匹配 0 条） */
   async deleteByIds(jobIds: string[]) {
     let affected = 0;
     for (const id of jobIds) {
-      const count = await this.agenda.cancel({ _id: id } as any);
+      const count = await this.agenda.cancel({ id });
       affected += count ?? 0;
     }
     return { affected };

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/codeRuntime/code-executor.spec.ts

@@ -39,4 +39,27 @@ describe('executeCode', () => {
       applicant: 'alice',
     });
   });
+
+  it('exposes node-local scopes without replacing input', async () => {
+    await expect(
+      executeCode(
+        {
+          script:
+            'return { title: input.title, requestId: approval.requestId, status: response.status, eventId: callback.eventId };',
+        },
+        { title: '服务器权限申请' },
+        {},
+        {
+          approval: { requestId: '41' },
+          response: { status: 201 },
+          callback: { eventId: 'external:W-1' },
+        },
+      ),
+    ).resolves.toEqual({
+      title: '服务器权限申请',
+      requestId: '41',
+      status: 201,
+      eventId: 'external:W-1',
+    });
+  });
 });

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/codeRuntime/code-executor.ts

@@ -6,14 +6,23 @@ export interface CodeNodeConfig {
   timeout?: number;
 }
 
+export interface CodeNodeScopes {
+  approval?: unknown;
+  response?: unknown;
+  callback?: unknown;
+}
+
 const WORKER_SOURCE = String.raw`
 const { parentPort, workerData } = require('node:worker_threads');
 const vm = require('node:vm');
 
-function run(script, input, workflow, timeout) {
+function run(script, input, workflow, scopes, timeout) {
   const sandbox = Object.create(null);
   sandbox.input = input;
   sandbox.workflow = workflow;
+  sandbox.approval = scopes.approval;
+  sandbox.response = scopes.response;
+  sandbox.callback = scopes.callback;
   sandbox.data = input && typeof input === 'object' && 'data' in input
     ? input.data
     : input;
@@ -32,17 +41,17 @@ function run(script, input, workflow, timeout) {
 }
 
 try {
-  const { config, input, workflow } = workerData;
+  const { config, input, workflow, scopes } = workerData;
   let result;
   if (config.mode === 'runOnceForEach') {
     const items = Array.isArray(input)
       ? input
       : input && Array.isArray(input.items) ? input.items : [];
     result = items.map((item) =>
-      run(config.script, item, workflow, config.timeout)
+      run(config.script, item, workflow, scopes, config.timeout)
     );
   } else {
-    result = run(config.script, input, workflow, config.timeout);
+    result = run(config.script, input, workflow, scopes, config.timeout);
   }
   parentPort.postMessage({ ok: true, result });
 } catch (error) {
@@ -57,11 +66,12 @@ export async function executeCode(
   config: CodeNodeConfig,
   input: unknown,
   workflow: Record<string, unknown> = {},
+  scopes: CodeNodeScopes = {},
 ): Promise<unknown> {
   if (typeof config.script !== 'string' || !config.script.trim())
     throw new Error('CODE_SCRIPT_REQUIRED');
   const timeout = Math.min(
-    Math.max(Math.trunc(config.timeout ?? 1000), 1),
+    Math.max(Math.trunc(config.timeout ?? 5000), 1),
     5000,
   );
   const mode = config.mode ?? 'runOnceForAll';
@@ -75,6 +85,7 @@ export async function executeCode(
         config: { script: config.script, mode, timeout },
         input,
         workflow,
+        scopes,
       },
       resourceLimits: {
         maxOldGenerationSizeMb: 16,

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/codeRuntime/code-runtime.controller.spec.ts

@@ -0,0 +1,98 @@
+import { CodeRuntimeController } from './code-runtime.controller';
+
+describe('CodeRuntimeController', () => {
+  it('executes the embedded approval dispatch validator', async () => {
+    const prisma = {
+      workflowInstance: {
+        findUnique: jest.fn().mockResolvedValue({
+          workflowId: BigInt(30),
+          versionId: BigInt(20),
+          temporalRunId: 'run-1',
+        }),
+      },
+      workflowVersion: {
+        findUnique: jest.fn().mockResolvedValue({
+          workflowId: BigInt(30),
+          dsl: {
+            nodes: [
+              {
+                id: 'approval-1',
+                runtimeKey: 'human_approval',
+                config: {
+                  external: {
+                    creationResult: {
+                      script:
+                        'return { accepted: response.status === 201, title: input.title, requestId: approval.requestId };',
+                    },
+                  },
+                  subjects: [
+                    {
+                      source: 'DYNAMIC',
+                      provider: 'USER',
+                      inputKey: 'direct_manager',
+                      lookup: {
+                        result: {
+                          script:
+                            "return { subjects: [{ provider: 'USER', refs: [response.data.leader] }], requester: input.user_id };",
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        }),
+      },
+    };
+    const controller = new CodeRuntimeController(
+      prisma as any,
+      { assertTenant: jest.fn() } as any,
+    );
+
+    await expect(
+      controller.execute({
+        tenantNamespace: 'tenant-a',
+        workflowInstanceId: '10',
+        workflowVersionId: '20',
+        temporalRunId: 'run-1',
+        nodeId: 'approval-1',
+        configKey: 'creationResult',
+        input: { title: '服务器权限申请' },
+        response: { status: 201 },
+        approval: { requestId: '41' },
+        workflow: {},
+      }),
+    ).resolves.toEqual({
+      result: {
+        accepted: true,
+        title: '服务器权限申请',
+        requestId: '41',
+      },
+    });
+
+    await expect(
+      controller.execute({
+        tenantNamespace: 'tenant-a',
+        workflowInstanceId: '10',
+        workflowVersionId: '20',
+        temporalRunId: 'run-1',
+        nodeId: 'approval-1',
+        configKey: 'approverLookupResult',
+        lookupKey: 'direct_manager',
+        input: { user_id: 'applicant-a' },
+        response: {
+          status: 200,
+          data: { leader: 'leader-a' },
+          headers: {},
+        },
+        workflow: {},
+      }),
+    ).resolves.toEqual({
+      result: {
+        subjects: [{ provider: 'USER', refs: ['leader-a'] }],
+        requester: 'applicant-a',
+      },
+    });
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/codeRuntime/code-runtime.controller.ts

@@ -50,13 +50,29 @@ export class CodeRuntimeController {
     const node = (version?.dsl as any)?.nodes?.find(
       (item: any) => item.id === input.nodeId,
     );
+    const dynamicSubject = Array.isArray(node?.config?.subjects)
+      ? node.config.subjects.find(
+          (subject: any) =>
+            subject?.source === 'DYNAMIC' &&
+            subject.inputKey === input.lookupKey,
+        )
+      : undefined;
+    const codeConfig =
+      node?.runtimeKey === 'code' && !input.configKey
+        ? node.config
+        : node?.runtimeKey === 'human_approval' &&
+          input.configKey === 'creationResult'
+        ? node.config.external?.creationResult
+        : node?.runtimeKey === 'human_approval' &&
+          input.configKey === 'approverLookupResult'
+        ? dynamicSubject?.lookup?.result
+        : undefined;
     if (
       !version ||
       version.workflowId !== instance.workflowId ||
-      node?.runtimeKey !== 'code' ||
-      !node?.config ||
-      typeof node.config !== 'object' ||
-      typeof node.config.script !== 'string'
+      !codeConfig ||
+      typeof codeConfig !== 'object' ||
+      typeof codeConfig.script !== 'string'
     )
       throw runtimeError(
         'WORKFLOW_RUNTIME_COMPILED_INPUT_INVALID',
@@ -66,9 +82,13 @@ export class CodeRuntimeController {
     try {
       return {
         result: await executeCode(
-          node.config as CodeNodeConfig,
-          input.inputs,
+          codeConfig as CodeNodeConfig,
+          input.input,
           input.workflow,
+          {
+            response: input.response,
+            approval: input.approval,
+          },
         ),
       };
     } catch (error) {

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/codeRuntime/code-runtime.dto.ts

@@ -1,4 +1,4 @@
-import { Allow, IsNotEmpty, IsString } from 'class-validator';
+import { Allow, IsIn, IsNotEmpty, IsOptional, IsString } from 'class-validator';
 
 export class ExecuteCodeRuntimeDto {
   @IsString()
@@ -21,9 +21,24 @@ export class ExecuteCodeRuntimeDto {
   @IsNotEmpty()
   nodeId!: string;
 
+  @IsOptional()
+  @IsIn(['creationResult', 'approverLookupResult'])
+  configKey?: 'creationResult' | 'approverLookupResult';
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  lookupKey?: string;
+
   @Allow()
-  inputs!: unknown;
+  input!: unknown;
 
   @Allow()
   workflow!: Record<string, unknown>;
+
+  @Allow()
+  response?: unknown;
+
+  @Allow()
+  approval?: unknown;
 }

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-runtime.controller.spec.ts

@@ -3,6 +3,7 @@ import { ExternalInteractionRuntimeController } from './external-interaction-run
 describe('ExternalInteractionRuntimeController', () => {
   it('starts an external wait and resolves the selected callback Workflow', async () => {
     const service = {
+      assertRuntimeTarget: jest.fn().mockResolvedValue(undefined),
       createInteraction: jest.fn().mockResolvedValue({
         interactionId: '51',
         callbackToken: 'ext_cb_token',

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-runtime.controller.ts

@@ -22,6 +22,7 @@ export class ExternalInteractionRuntimeController {
   @AllowUnauthorizedRequest()
   async start(@Body() input: StartExternalInteractionRuntimeDto) {
     await this.runtimeConfig.assertTenant(input.tenantNamespace);
+    await this.interactions.assertRuntimeTarget(input);
     const callbackUrl = input.callbackWorkflowId
       ? await this.callbackUrls.resolve(input.callbackWorkflowId)
       : undefined;
@@ -43,6 +44,7 @@ export class ExternalInteractionRuntimeController {
   @AllowUnauthorizedRequest()
   async expire(@Body() input: CloseExternalInteractionRuntimeDto) {
     await this.runtimeConfig.assertTenant(input.tenantNamespace);
+    await this.interactions.assertInteractionRuntime(input);
     return this.interactions.expireInteraction(
       input.tenantNamespace,
       input.callbackToken,
@@ -53,6 +55,7 @@ export class ExternalInteractionRuntimeController {
   @AllowUnauthorizedRequest()
   async cancel(@Body() input: CloseExternalInteractionRuntimeDto) {
     await this.runtimeConfig.assertTenant(input.tenantNamespace);
+    await this.interactions.assertInteractionRuntime(input);
     return this.interactions.cancelInteraction(
       input.tenantNamespace,
       input.callbackToken,

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-runtime.dto.ts

@@ -1,5 +1,4 @@
 import {
-  ArrayMinSize,
   IsArray,
   IsISO8601,
   IsNotEmpty,
@@ -35,7 +34,6 @@ export class StartExternalInteractionRuntimeDto extends ExternalInteractionRunti
   callbackToken!: string;
 
   @IsArray()
-  @ArrayMinSize(1)
   @IsString({ each: true })
   allowedOutcomes!: string[];
 

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-signal-outbox.service.spec.ts

@@ -53,4 +53,34 @@ describe('ExternalInteractionSignalOutboxService', () => {
       }),
     });
   });
+
+  it('does not claim rows that exhausted their retry budget', async () => {
+    const findMany = jest.fn().mockResolvedValue([]);
+    const prisma = {
+      $transaction: jest.fn((callback) =>
+        callback({
+          externalInteractionSignalOutbox: {
+            findMany,
+            updateMany: jest.fn(),
+          },
+        }),
+      ),
+    };
+    const service = new ExternalInteractionSignalOutboxService(
+      prisma as any,
+      {} as any,
+    );
+
+    await service.poll();
+
+    expect(findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          OR: expect.arrayContaining([
+            expect.objectContaining({ retryCount: { lt: 10 } }),
+          ]),
+        }),
+      }),
+    );
+  });
 });

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-signal-outbox.service.ts

@@ -2,7 +2,11 @@ import { Injectable, Logger } from '@nestjs/common';
 import { Interval } from '@nestjs/schedule';
 import { randomUUID } from 'crypto';
 import { PrismaService } from 'nestjs-prisma';
-import { outboxError, outboxRetryAt } from '../humanApproval/outbox-retry.util';
+import {
+  OUTBOX_MAX_RETRY_COUNT,
+  outboxError,
+  outboxRetryAt,
+} from '../humanApproval/outbox-retry.util';
 import { TemporalService } from '../workflow/temporal.service';
 
 const BATCH_SIZE = 25;
@@ -35,8 +39,16 @@ export class ExternalInteractionSignalOutboxService {
         where: {
           nextAttemptAt: { lte: now },
           OR: [
-            { status: { in: ['PENDING', 'FAILED'] }, lockedAt: null },
-            { status: 'PROCESSING', lockedAt: { lt: staleAt } },
+            {
+              status: { in: ['PENDING', 'FAILED'] },
+              retryCount: { lt: OUTBOX_MAX_RETRY_COUNT },
+              lockedAt: null,
+            },
+            {
+              status: 'PROCESSING',
+              retryCount: { lt: OUTBOX_MAX_RETRY_COUNT },
+              lockedAt: { lt: staleAt },
+            },
           ],
         },
         include: {
@@ -51,8 +63,16 @@ export class ExternalInteractionSignalOutboxService {
         where: {
           id: { in: ids },
           OR: [
-            { status: { in: ['PENDING', 'FAILED'] }, lockedAt: null },
-            { status: 'PROCESSING', lockedAt: { lt: staleAt } },
+            {
+              status: { in: ['PENDING', 'FAILED'] },
+              retryCount: { lt: OUTBOX_MAX_RETRY_COUNT },
+              lockedAt: null,
+            },
+            {
+              status: 'PROCESSING',
+              retryCount: { lt: OUTBOX_MAX_RETRY_COUNT },
+              lockedAt: { lt: staleAt },
+            },
           ],
         },
         data: { status: 'PROCESSING', lockedAt: now, lockedBy: claimId },
@@ -104,7 +124,9 @@ export class ExternalInteractionSignalOutboxService {
         },
       });
       this.logger.warn(
-        `External interaction signal ${row.id} failed: ${outboxError(error)}`,
+        `External interaction signal ${row.id} failed${
+          retryCount >= OUTBOX_MAX_RETRY_COUNT ? ' permanently' : ''
+        }: ${outboxError(error)}`,
       );
     }
   }