@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -1,7 +1,10 @@
 export type DslHandleValidationCode =
   | 'EXTRA_HANDLE'
   | 'MISSING_HANDLE'
-  | 'UNKNOWN_HANDLE';
+  | 'UNKNOWN_HANDLE'
+  | 'EXTRA_TARGET_HANDLE'
+  | 'MISSING_TARGET_HANDLE'
+  | 'UNKNOWN_TARGET_HANDLE';
 
 export interface DslHandleValidationError {
   edgeId: string;
@@ -22,6 +25,8 @@ interface DslEdge {
   source: string;
   target: string;
   sourceHandle?: string;
+  targetHandle?: string;
+  pairId?: string;
 }
 
 interface WorkflowDsl {
@@ -31,6 +36,14 @@ interface WorkflowDsl {
 
 export type NodeOutputsMap = Record<string, string[] | null>;
 
+const RUNTIME_MAIN_FLOW_PORTS: Record<
+  string,
+  { input: string; output: string }
+> = {
+  http_request: { input: 'request-in', output: 'response-out' },
+  code: { input: 'data-in', output: 'result-out' },
+};
+
 export function validateWorkflowHandles(
   dsl: WorkflowDsl,
   outputsMap: NodeOutputsMap,
@@ -39,16 +52,52 @@ export function validateWorkflowHandles(
   const nodeMap = new Map(dsl.nodes.map((node) => [node.id, node]));
 
   for (const edge of dsl.edges) {
+    if (edge.pairId) continue;
     const sourceNode = nodeMap.get(edge.source);
     if (!sourceNode || !(sourceNode.type in outputsMap)) continue;
 
+    const targetNode = nodeMap.get(edge.target);
+    if (targetNode) {
+      const expectedTargetHandle =
+        RUNTIME_MAIN_FLOW_PORTS[targetNode.type]?.input;
+      if (expectedTargetHandle) {
+        if (edge.targetHandle == null || edge.targetHandle === '') {
+          errors.push({
+            edgeId: edge.id,
+            source: edge.source,
+            target: edge.target,
+            code: 'MISSING_TARGET_HANDLE',
+            reason: `Node "${targetNode.type}" requires targetHandle "${expectedTargetHandle}".`,
+          });
+        } else if (edge.targetHandle !== expectedTargetHandle) {
+          errors.push({
+            edgeId: edge.id,
+            source: edge.source,
+            target: edge.target,
+            code: 'UNKNOWN_TARGET_HANDLE',
+            reason: `Node "${targetNode.type}" targetHandle "${edge.targetHandle}" must be "${expectedTargetHandle}".`,
+          });
+        }
+      } else if (edge.targetHandle != null && edge.targetHandle !== '') {
+        errors.push({
+          edgeId: edge.id,
+          source: edge.source,
+          target: edge.target,
+          code: 'EXTRA_TARGET_HANDLE',
+          reason: `Node "${targetNode.type}" has no named main-flow input handle; edge must not set targetHandle (got "${edge.targetHandle}").`,
+        });
+      }
+    }
+
     const declaredOutputs = outputsMap[sourceNode.type];
-    const handles =
-      declaredOutputs === null
-        ? deriveDynamicOutputs(sourceNode)
-        : declaredOutputs;
+    const runtimeOutput = RUNTIME_MAIN_FLOW_PORTS[sourceNode.type]?.output;
+    const handles = runtimeOutput
+      ? [runtimeOutput]
+      : declaredOutputs === null
+      ? deriveDynamicOutputs(sourceNode)
+      : declaredOutputs;
 
-    if (declaredOutputs !== null && handles.length === 0) {
+    if (!runtimeOutput && declaredOutputs !== null && handles.length === 0) {
       if (edge.sourceHandle != null && edge.sourceHandle !== '') {
         errors.push({
           edgeId: edge.id,
@@ -95,13 +144,10 @@ export function validateWorkflowHandles(
 function deriveDynamicOutputs(node: DslNode): string[] {
   if (node.type === 'switch') {
     const cases = node.config?.cases;
-    if (!Array.isArray(cases)) return [];
-    return cases
-      .map((item) => item?.value)
-      .filter(
-        (value): value is string =>
-          typeof value === 'string' && value.length > 0,
-      );
+    const outputs = (Array.isArray(cases) ? cases : [])
+      .map((item) => item?.id)
+      .filter((id): id is string => typeof id === 'string' && id.length > 0);
+    return [...outputs, 'default'];
   }
 
   return [];

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

@@ -0,0 +1,86 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import { WorkflowService } from './workflow.service';
+
+export interface ExecuteManualWorkflowInput {
+  code: string;
+  workflow: Record<string, unknown>;
+  idempotencyKey?: string;
+  creator: string;
+}
+
+export interface WorkflowExecutionSummary {
+  instanceId: string;
+  status: string;
+}
+
+export interface WorkflowCancellationSummary {
+  instanceId: string;
+  status: 'CANCELLED';
+}
+
+export interface CancelWorkflowExecutionInput {
+  tx: Prisma.TransactionClient;
+  instanceId: bigint;
+  reason?: string;
+}
+
+export interface FindEventTriggeredExecutionInput {
+  tx: Prisma.TransactionClient;
+  workflowCode: string;
+  tableName: string;
+  operation: 'INSERT' | 'UPDATE' | 'DELETE';
+  primaryKey: Record<string, string | number | boolean>;
+}
+
+export interface EventTriggeredExecutionReference {
+  instanceId: bigint;
+  status: string;
+}
+
+@Injectable()
+export class WorkflowRuntimeFacade {
+  constructor(private readonly workflows: WorkflowService) {}
+
+  async executeManualWorkflowByCode(
+    input: ExecuteManualWorkflowInput,
+  ): Promise<WorkflowExecutionSummary> {
+    const result = await this.workflows.executeManualWorkflowByCode(
+      input.code,
+      input.workflow,
+      input.idempotencyKey,
+      input.creator,
+    );
+    return { instanceId: result.instanceId, status: result.status };
+  }
+
+  async cancelExecution(
+    input: CancelWorkflowExecutionInput,
+  ): Promise<WorkflowCancellationSummary> {
+    await this.workflows.cancelExecutionInTransaction(
+      input.tx,
+      input.instanceId,
+      input.reason,
+    );
+    return { instanceId: input.instanceId.toString(), status: 'CANCELLED' };
+  }
+
+  findEventTriggeredExecution(
+    input: FindEventTriggeredExecutionInput,
+  ): Promise<EventTriggeredExecutionReference | null> {
+    return this.workflows.findEventTriggeredExecutionInTransaction(input.tx, {
+      workflowCode: input.workflowCode,
+      tableName: input.tableName,
+      operation: input.operation,
+      primaryKey: input.primaryKey,
+    });
+  }
+
+  getExecutionStatus(instanceId: bigint) {
+    return this.workflows.getExecutionStatus(instanceId);
+  }
+
+  getWorkflowStatsByCode(code: string) {
+    return this.workflows.getWorkflowStatsByCode(code);
+  }
+}

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

@@ -0,0 +1,25 @@
+import { switchCaseValidationError } from './workflow-switch-config';
+
+describe('switchCaseValidationError', () => {
+  it('rejects numeric values that become equal at runtime', () => {
+    expect(
+      switchCaseValidationError([
+        { id: 'one', valueType: 'NUMBER', value: '1' },
+        { id: 'also-one', valueType: 'NUMBER', value: '1.0' },
+      ]),
+    ).toBe('多路分支不能配置运行时结果相同的重复匹配项');
+  });
+
+  it('rejects values the Worker cannot parse', () => {
+    expect(
+      switchCaseValidationError([
+        { id: 'invalid', valueType: 'NUMBER', value: 'not-a-number' },
+      ]),
+    ).toBe('多路分支的数字匹配值无效');
+    expect(
+      switchCaseValidationError([
+        { id: 'invalid', valueType: 'BOOLEAN', value: 'yes' },
+      ]),
+    ).toBe('多路分支的是/否匹配值无效');
+  });
+});

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

@@ -0,0 +1,45 @@
+export function switchCaseValidationError(value: unknown): string | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const ids = new Set<string>();
+  const matches = new Set<string>();
+
+  for (const rawItem of value) {
+    const item = asObject(rawItem);
+    const id = String(item.id ?? '');
+    if (id === 'default' || ids.has(id))
+      return '多路分支的分支标识重复或与“其他情况”冲突';
+    ids.add(id);
+
+    const matchKey = normalizedMatchKey(item);
+    if (typeof matchKey !== 'string') return matchKey.error;
+    if (matches.has(matchKey))
+      return '多路分支不能配置运行时结果相同的重复匹配项';
+    matches.add(matchKey);
+  }
+  return undefined;
+}
+
+function normalizedMatchKey(
+  item: Record<string, unknown>,
+): string | { error: string } {
+  const valueType = String(item.valueType ?? '');
+  const value = String(item.value ?? '');
+  if (valueType === 'STRING') return `STRING:${value}`;
+  if (valueType === 'BOOLEAN') {
+    if (value !== 'true' && value !== 'false')
+      return { error: '多路分支的是/否匹配值无效' };
+    return `BOOLEAN:${value}`;
+  }
+  if (valueType === 'NUMBER') {
+    if (!value.trim() || !Number.isFinite(Number(value)))
+      return { error: '多路分支的数字匹配值无效' };
+    return `NUMBER:${Number(value)}`;
+  }
+  return { error: '多路分支的匹配值类型无效' };
+}
+
+function asObject(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}

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

@@ -1,59 +1,94 @@
 import { WorkflowController } from './workflow.controller';
 
-describe('WorkflowController — webhook HTTP response', () => {
-  it('returns the Workflow body with its configured status and headers', async () => {
-    const workflowService = {
-      receiveWebhook: jest.fn().mockResolvedValue({
-        instanceIds: ['42'],
-        response: {
-          statusCode: 201,
-          headers: {
-            'x-workflow-result': 'created',
-          },
-          body: {
-            ticketId: 'T-42',
-          },
-        },
+describe('WorkflowController runtime contracts', () => {
+  it('starts manual Workflows only through the stable action code contract', async () => {
+    const runtime = {
+      executeManualWorkflowByCode: jest.fn().mockResolvedValue({
+        instanceId: '42',
+        status: 'PENDING',
       }),
     };
     const controller = new WorkflowController(
-      workflowService as never,
       {} as never,
       {} as never,
+      {} as never,
+      runtime as never,
+      {} as never,
     );
-    const response = {
-      statusCode: 200,
-      headers: {} as Record<string, string>,
-      status(code: number) {
-        this.statusCode = code;
-        return this;
-      },
-      set(headers: Record<string, string>) {
-        this.headers = headers;
-        return this;
-      },
+
+    await expect(
+      controller.executeAction(
+        'asset-disposal',
+        'request-1',
+        { user: { userid: 'tester' } },
+        { workflow: { assetId: 'A-1' } },
+      ),
+    ).resolves.toEqual({ instanceId: '42', status: 'PENDING' });
+    expect(runtime.executeManualWorkflowByCode).toHaveBeenCalledWith({
+      code: 'asset-disposal',
+      workflow: { assetId: 'A-1' },
+      idempotencyKey: 'request-1',
+      creator: 'tester',
+    });
+  });
+
+  it('always returns accepted webhook instance IDs without waiting for a result', async () => {
+    const workflowService = {
+      receiveWebhook: jest.fn().mockResolvedValue({ instanceIds: ['42'] }),
     };
+    const controller = new WorkflowController(
+      workflowService as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+    );
 
-    const body = await controller.receiveWebhook(
-      'create-ticket',
-      undefined as never,
-      undefined as never,
-      {
-        method: 'POST',
-        rawBody: Buffer.from('{}'),
-        headers: {},
-      } as never,
-      {},
-      {},
-      response as never,
+    await expect(
+      controller.receiveWebhook(
+        'create-ticket',
+        undefined as never,
+        undefined as never,
+        {
+          method: 'POST',
+          rawBody: Buffer.from('{}'),
+          headers: {},
+        } as never,
+        {},
+        {},
+      ),
+    ).resolves.toEqual({ instanceIds: ['42'] });
+  });
+
+  it('delegates management cancellation to the concurrency-safe runtime facade', async () => {
+    const tx = { transaction: true };
+    const prisma = {
+      $transaction: jest.fn((callback: (input: typeof tx) => unknown) =>
+        callback(tx),
+      ),
+    };
+    const runtime = {
+      cancelExecution: jest.fn().mockResolvedValue({
+        instanceId: '42',
+        status: 'CANCELLED',
+      }),
+    };
+    const controller = new WorkflowController(
+      {} as never,
+      {} as never,
+      {} as never,
+      runtime as never,
+      prisma as never,
     );
 
-    expect(response.statusCode).toBe(201);
-    expect(response.headers).toEqual({
-      'x-workflow-result': 'created',
+    await expect(controller.cancelInstance(42)).resolves.toEqual({
+      instanceId: '42',
+      status: 'CANCELLED',
     });
-    expect(body).toEqual({
-      ticketId: 'T-42',
+    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
+    expect(runtime.cancelExecution).toHaveBeenCalledWith({
+      tx,
+      instanceId: BigInt(42),
     });
   });
 });

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

@@ -1,3 +1,4 @@
+import { ACGuard } from '@gadmin2n/nest-common';
 import {
   Body,
   Controller,
@@ -12,39 +13,45 @@ import {
   Query,
   RawBodyRequest,
   Req,
-  Res,
   UnauthorizedException,
   UseGuards,
 } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
-import { Request, Response } from 'express';
-import AuthGuard, { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { Request } from 'express';
+import { UseRoles } from 'nest-access-control';
+import { PrismaService } from 'nestjs-prisma';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
 import { TemporalService } from './temporal.service';
 import {
   ApproveInstanceDto,
   ExecuteWorkflowDto,
-  SignalWorkflowDto,
+  RetryFromNodeDto,
 } from './workflow-execution.dto';
 import { ImportPayloadDto } from './workflow-export.dto';
 import { WorkflowExportService } from './workflow-export.service';
+import { WorkflowRuntimeFacade } from './workflow-runtime.facade';
 import {
   CreateWorkflowDto,
   PublishVersionDto,
+  RegisterBusinessEventDto,
   SaveDraftDto,
   ToggleEnabledDto,
+  UnregisterBusinessEventDto,
   UpdateWorkflowDto,
+  WorkflowInstanceListQueryDto,
   WorkflowListQueryDto,
 } from './workflow.dto';
 import { WorkflowService } from './workflow.service';
 
 @ApiTags('workflow')
-@UseGuards(AuthGuard)
 @Controller('workflow')
 export class WorkflowController {
   constructor(
     private readonly workflowService: WorkflowService,
     private readonly temporalService: TemporalService,
     private readonly workflowExportService: WorkflowExportService,
+    private readonly workflowRuntime: WorkflowRuntimeFacade,
+    private readonly prisma: PrismaService,
   ) {}
 
   @Get()
@@ -58,6 +65,17 @@ export class WorkflowController {
     });
   }
 
+  @Post('event-catalog/register')
+  @UseGuards(ACGuard)
+  @UseRoles({
+    resource: 'workflowEventRegistration',
+    action: 'create',
+    possession: 'any',
+  })
+  registerBusinessEvent(@Body() dto: RegisterBusinessEventDto, @Req() req) {
+    return this.workflowService.registerBusinessEvent(dto, req.user.userid);
+  }
+
   @Get('overview')
   getOverview() {
     return this.workflowService.getOverview();
@@ -73,6 +91,44 @@ export class WorkflowController {
     return this.workflowService.findExternalInteractionOptions();
   }
 
+  @Get('event-catalog/overview')
+  findBusinessEventCatalogOverview() {
+    return this.workflowService.findBusinessEventCatalogOverview();
+  }
+
+  @Get('event-catalog/sources')
+  findBusinessEventSources() {
+    return this.workflowService.findBusinessEventSources();
+  }
+
+  @Get('event-catalog/:registrationCode/instances')
+  findBusinessEventInstances(
+    @Param('registrationCode') registrationCode: string,
+    @Query() query: WorkflowInstanceListQueryDto,
+  ) {
+    return this.workflowService.findBusinessEventInstances(registrationCode, {
+      status: query.status,
+      skip: query.skip,
+      limit: query.limit,
+    });
+  }
+
+  @Post('event-catalog/unregister')
+  @UseGuards(ACGuard)
+  @UseRoles({
+    resource: 'workflowEventRegistration',
+    action: 'delete',
+    possession: 'any',
+  })
+  unregisterBusinessEvent(@Body() dto: UnregisterBusinessEventDto) {
+    return this.workflowService.unregisterBusinessEvent(dto.registrationCode);
+  }
+
+  @Get('event-catalog')
+  findBusinessEventCatalog() {
+    return this.workflowService.findBusinessEventCatalog();
+  }
+
   // ─── Export/Import Endpoints ──────────────────────────────────────────────────
 
   @Post(':id/export-token')
@@ -167,12 +223,12 @@ export class WorkflowController {
   @Get(':id/instances')
   getInstances(
     @Param('id', ParseIntPipe) id: number,
-    @Query() query: { status?: string; skip?: string; limit?: string },
+    @Query() query: WorkflowInstanceListQueryDto,
   ) {
     return this.workflowService.getInstances(BigInt(id), {
       status: query.status,
-      skip: query.skip ? Number(query.skip) : undefined,
-      limit: query.limit ? Number(query.limit) : undefined,
+      skip: query.skip,
+      limit: query.limit,
     });
   }
 
@@ -183,30 +239,45 @@ export class WorkflowController {
 
   // ─── Execution Endpoints ──────────────────────────────────────────────────────
 
-  @Post(':id/execute')
-  async execute(
-    @Param('id', ParseIntPipe) id: number,
+  @Post('actions/:code/execute')
+  @UseGuards(ACGuard)
+  @UseRoles({
+    resource: 'workflowExecution',
+    action: 'create',
+    possession: 'any',
+  })
+  async executeAction(
+    @Param('code') code: string,
+    @Headers('idempotency-key') idempotencyKey: string | undefined,
     @Req() req,
     @Body() dto: ExecuteWorkflowDto,
   ) {
-    return this.workflowService.executeWorkflow(
-      BigInt(id),
-      dto,
-      req.user.userid,
-      this.temporalService,
-    );
+    return this.workflowRuntime.executeManualWorkflowByCode({
+      code,
+      workflow: dto.workflow ?? {},
+      idempotencyKey,
+      creator: req.user.userid,
+    });
   }
 
   @Get('instance/:instanceId')
-  getInstanceDetail(@Param('instanceId', ParseIntPipe) instanceId: number) {
-    return this.workflowService.getInstanceDetail(BigInt(instanceId));
+  getInstanceDetail(
+    @Param('instanceId', ParseIntPipe) instanceId: number,
+    @Req() req,
+  ) {
+    return this.workflowService.getInstanceDetail(
+      BigInt(instanceId),
+      req.user.userid,
+    );
   }
 
   @Post('instance/:instanceId/cancel')
   async cancelInstance(@Param('instanceId', ParseIntPipe) instanceId: number) {
-    return this.workflowService.cancelInstance(
-      BigInt(instanceId),
-      this.temporalService,
+    return this.prisma.$transaction((tx) =>
+      this.workflowRuntime.cancelExecution({
+        tx,
+        instanceId: BigInt(instanceId),
+      }),
     );
   }
 
@@ -222,14 +293,16 @@ export class WorkflowController {
     );
   }
 
-  @Post('instance/:instanceId/signal')
-  async signalInstance(
+  @Post('instance/:instanceId/retry-from-node')
+  async retryInstanceFromNode(
     @Param('instanceId', ParseIntPipe) instanceId: number,
-    @Body() dto: SignalWorkflowDto,
+    @Body() dto: RetryFromNodeDto,
+    @Req() req,
   ) {
-    return this.workflowService.signalInstance(
+    return this.workflowService.retryInstanceFromNode(
       BigInt(instanceId),
-      dto,
+      dto.nodeId,
+      req.user.userid,
       this.temporalService,
     );
   }
@@ -254,8 +327,7 @@ export class WorkflowController {
    * Request verification is configured by the matching trigger. Existing triggers
    * require HMAC-SHA256; direct triggers accept callers that cannot sign requests.
    *
-   * By default returns 202 Accepted with the created instance IDs. A trigger in
-   * function mode keeps this request open and returns the Workflow result instead.
+   * Returns 202 Accepted with all created instance IDs.
    */
   @Post('webhook/:path')
   @HttpCode(202)
@@ -267,9 +339,8 @@ export class WorkflowController {
     @Req() req: RawBodyRequest<Request>,
     @Body() body: any,
     @Query() query: any,
-    @Res({ passthrough: true }) response: Response,
-  ): Promise<unknown> {
-    const result = await this.workflowService.receiveWebhook({
+  ): Promise<{ instanceIds: string[] }> {
+    return this.workflowService.receiveWebhook({
       path,
       method: req.method,
       signatureHeader: signature,
@@ -279,13 +350,5 @@ export class WorkflowController {
       headers: req.headers as Record<string, any>,
       query,
     });
-    if (!result.response) {
-      response.status(202);
-      return { instanceIds: result.instanceIds };
-    }
-
-    response.status(result.response.statusCode);
-    response.set(result.response.headers);
-    return result.response.body;
   }
 }