@gadmin2n/schematics 0.0.87 → 0.0.89

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

@@ -1,10 +1,56 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  Injectable,
+  Logger,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
 import { Prisma } from '@prisma/client';
 import { PrismaService } from 'nestjs-prisma';
+import { validateDslGraph } from './dsl-validate.util';
+import { TemporalService } from './temporal.service';
+import { verifyWebhookSignature } from './webhook-signature.util';
 
 @Injectable()
 export class WorkflowService {
-  constructor(private prisma: PrismaService) {}
+  private readonly logger = new Logger(WorkflowService.name);
+
+  constructor(
+    private prisma: PrismaService,
+    private temporalService: TemporalService,
+  ) {}
+
+  /**
+   * Find the cron_trigger node config in a DSL, if any.
+   * Returns null when no cron_trigger node or when its `cron` field is missing.
+   */
+  private extractCronConfig(
+    dsl: any,
+  ): { cron: string; timezone?: string } | null {
+    const node = dsl?.nodes?.find((n: any) => n?.type === 'cron_trigger');
+    if (!node?.config?.cron) return null;
+    return { cron: node.config.cron, timezone: node.config.timezone };
+  }
+
+  /**
+   * Find all webhook_trigger configs in a DSL.
+   * Each entry includes path + method; used for collision detection on publish.
+   */
+  private extractWebhookConfigs(
+    dsl: any,
+  ): Array<{ path: string; method: string; secret?: string }> {
+    if (!Array.isArray(dsl?.nodes)) return [];
+    return dsl.nodes
+      .filter(
+        (n: any) =>
+          n?.type === 'webhook_trigger' && n?.config?.path && n?.config?.method,
+      )
+      .map((n: any) => ({
+        path: n.config.path,
+        method: n.config.method,
+        secret: n.config.secret,
+      }));
+  }
 
   async findMany(params: {
     status?: string;
@@ -143,15 +189,44 @@ export class WorkflowService {
   async toggleEnabled(id: bigint, enabled: boolean) {
     const workflow = await this.prisma.workflow.findUnique({ where: { id } });
     if (!workflow) throw new NotFoundException('Workflow not found');
-    return this.prisma.workflow.update({
+    const updated = await this.prisma.workflow.update({
       where: { id },
       data: { isEnabled: enabled },
     });
+
+    // Cron schedule lifecycle: pause when disabled, resume when re-enabled
+    try {
+      if (enabled) {
+        await this.temporalService.unpauseCronSchedule(Number(id));
+      } else {
+        await this.temporalService.pauseCronSchedule(Number(id));
+      }
+    } catch (err: any) {
+      this.logger.warn(
+        `Failed to ${
+          enabled ? 'unpause' : 'pause'
+        } cron schedule for workflow ${id}: ${err?.message ?? err}`,
+      );
+    }
+
+    return updated;
   }
 
   async remove(id: bigint) {
     const workflow = await this.prisma.workflow.findUnique({ where: { id } });
     if (!workflow) throw new NotFoundException('Workflow not found');
+
+    // Best-effort: delete cron schedule before removing the workflow row
+    try {
+      await this.temporalService.deleteCronSchedule(Number(id));
+    } catch (err: any) {
+      this.logger.warn(
+        `Failed to delete cron schedule for workflow ${id}: ${
+          err?.message ?? err
+        }`,
+      );
+    }
+
     return this.prisma.workflow.delete({ where: { id } });
   }
 
@@ -202,7 +277,41 @@ export class WorkflowService {
       throw new NotFoundException('No draft DSL to publish');
     }
 
-    return this.prisma.$transaction(async (tx) => {
+    // Structural + cycle validation. Reject malformed/cyclic DSL up-front so the
+    // worker's executeGraph never has to deal with them at runtime.
+    try {
+      validateDslGraph(dslToPublish);
+    } catch (err: any) {
+      throw new BadRequestException(`Invalid DSL: ${err?.message ?? err}`);
+    }
+
+    // Validate webhook path collisions across other published workflows
+    const webhookConfigs = this.extractWebhookConfigs(dslToPublish);
+    if (webhookConfigs.length > 0) {
+      const otherPublished = await this.prisma.workflow.findMany({
+        where: { status: 'PUBLISHED', id: { not: workflowId } },
+        select: { id: true, name: true, dsl: true },
+      });
+      for (const cfg of webhookConfigs) {
+        if (!cfg.secret) {
+          throw new Error(
+            `webhook_trigger path="${cfg.method} ${cfg.path}" requires a secret (HMAC strict mode)`,
+          );
+        }
+        const conflict = otherPublished.find((w) =>
+          this.extractWebhookConfigs(w.dsl).some(
+            (other) => other.path === cfg.path && other.method === cfg.method,
+          ),
+        );
+        if (conflict) {
+          throw new Error(
+            `webhook path "${cfg.method} ${cfg.path}" already used by workflow #${conflict.id} (${conflict.name})`,
+          );
+        }
+      }
+    }
+
+    const result = await this.prisma.$transaction(async (tx) => {
       const lastVersion = await tx.workflowVersion.findFirst({
         where: { workflowId },
         orderBy: { version: 'desc' },
@@ -228,6 +337,31 @@ export class WorkflowService {
 
       return version;
     });
+
+    // Cron schedule lifecycle: register/update if cron_trigger present, delete otherwise
+    const cronConfig = this.extractCronConfig(dslToPublish);
+    try {
+      if (cronConfig) {
+        await this.temporalService.upsertCronSchedule({
+          workflowId: Number(workflowId),
+          versionId: Number(result.id),
+          dsl: dslToPublish,
+          cron: cronConfig.cron,
+          timezone: cronConfig.timezone,
+        });
+      } else {
+        // No cron_trigger in this version → clean up any leftover schedule
+        await this.temporalService.deleteCronSchedule(Number(workflowId));
+      }
+    } catch (err: any) {
+      this.logger.warn(
+        `Cron schedule sync failed for workflow ${workflowId}: ${
+          err?.message ?? err
+        }`,
+      );
+    }
+
+    return result;
   }
 
   async getStats(workflowId: bigint) {
@@ -418,6 +552,109 @@ export class WorkflowService {
     };
   }
 
+  /**
+   * Webhook trigger entry point. Looks up published workflows whose DSL contains a
+   * webhook_trigger node matching (path, method), verifies HMAC signature against
+   * each match's secret, and starts a workflow instance per verified match.
+   *
+   * Returns the list of created instance IDs. Throws:
+   * - NotFoundException when no published workflow listens on this path/method
+   * - UnauthorizedException on bad signature or stale timestamp
+   */
+  async receiveWebhook(input: {
+    path: string;
+    method: string;
+    signatureHeader: string | undefined;
+    timestampHeader: string | undefined;
+    rawBody: Buffer;
+    body: any;
+    headers: Record<string, any>;
+    query: Record<string, any>;
+  }): Promise<{ instanceIds: string[] }> {
+    // 1) Timestamp window — reject stale requests (±5 min)
+    const tsMs = Number(input.timestampHeader) * 1000;
+    if (
+      !input.timestampHeader ||
+      !Number.isFinite(tsMs) ||
+      Math.abs(Date.now() - tsMs) > 5 * 60 * 1000
+    ) {
+      throw new UnauthorizedException(
+        'Invalid or expired X-Workflow-Timestamp',
+      );
+    }
+
+    // 2) Lookup matching published + enabled workflows
+    const published = await this.prisma.workflow.findMany({
+      where: { status: 'PUBLISHED', isEnabled: true },
+      include: {
+        versions: { orderBy: { version: 'desc' }, take: 1 },
+      },
+    });
+
+    type Match = {
+      workflowId: bigint;
+      versionId: bigint;
+      dsl: any;
+      secret: string;
+    };
+    const matches: Match[] = [];
+    for (const wf of published) {
+      const version = wf.versions[0];
+      const dsl = version?.dsl ?? wf.dsl;
+      if (!dsl) continue;
+      const cfgs = this.extractWebhookConfigs(dsl);
+      const cfg = cfgs.find(
+        (c) => c.path === input.path && c.method === input.method,
+      );
+      if (!cfg || !cfg.secret) continue;
+      matches.push({
+        workflowId: wf.id,
+        versionId: version?.id ?? wf.id,
+        dsl,
+        secret: cfg.secret,
+      });
+    }
+
+    if (matches.length === 0) {
+      throw new NotFoundException(
+        `No published workflow listens on ${input.method} /${input.path}`,
+      );
+    }
+
+    // 3) Verify HMAC against each match's secret. Strict mode: every match must verify.
+    for (const m of matches) {
+      const ok = verifyWebhookSignature(
+        m.secret,
+        input.timestampHeader!,
+        input.rawBody,
+        input.signatureHeader,
+      );
+      if (!ok) {
+        throw new UnauthorizedException('Invalid X-Workflow-Signature');
+      }
+    }
+
+    // 4) Trigger executions in parallel
+    const context = {
+      headers: input.headers,
+      query: input.query,
+      body: input.body,
+      receivedAt: new Date().toISOString(),
+    };
+    const results = await Promise.all(
+      matches.map((m) =>
+        this.executeWorkflow(
+          m.workflowId,
+          { context },
+          'webhook',
+          this.temporalService,
+        ),
+      ),
+    );
+
+    return { instanceIds: results.map((r) => r.instanceId) };
+  }
+
   async getInstanceDetail(instanceId: bigint) {
     const instance = await this.prisma.workflowInstance.findUnique({
       where: { id: instanceId },

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

@@ -1,15 +1,47 @@
+/// <reference types="jest" />
+import { ConfigService } from '@nestjs/config';
 import { Test, TestingModule } from '@nestjs/testing';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import { WorkflowEventOutboxController } from './workflowEventOutbox.controller';
 import { WorkflowEventOutboxService } from './workflowEventOutbox.service';
 
+// Mock WorkflowEventOutboxService：用空对象屏蔽真实 Service 的依赖（PrismaService 等），
+// 避免 NestJS 在测试模块编译时去解析 Service 的构造参数。
+const mockWorkflowEventOutboxService = {};
+
+// Mock ConfigService
+const mockConfigService = {
+  get: jest.fn(),
+};
+
+// Mock Logger
+const mockLogger = {
+  child: jest.fn().mockReturnThis(),
+  info: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+};
+
 describe('WorkflowEventOutboxController', () => {
   let controller: WorkflowEventOutboxController;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [WorkflowEventOutboxController],
-      providers: [WorkflowEventOutboxService],
-    }).compile();
+      providers: [
+        {
+          provide: WorkflowEventOutboxService,
+          useValue: mockWorkflowEventOutboxService,
+        },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    })
+      // 兜底：自动 mock 任何未显式提供的依赖
+      // （例如 ACGuard 内部的 __roles_builder__ token）
+      .useMocker(() => ({}))
+      .compile();
 
     controller = module.get<WorkflowEventOutboxController>(
       WorkflowEventOutboxController,

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

@@ -77,10 +77,9 @@ describe('WorkflowEventOutboxService', () => {
           payload: {},
           processed: false,
           processedAt: new Date(),
-          retryCount: 0,
         },
-      };
-      const expectedResult = { id: BigInt(1), ...createArgs.data };
+      } as any;
+      const expectedResult = { id: 1, ...createArgs.data };
 
       prisma.workflowEventOutbox.create.mockResolvedValue(expectedResult);
 
@@ -100,9 +99,8 @@ describe('WorkflowEventOutboxService', () => {
           payload: {},
           processed: false,
           processedAt: new Date(),
-          retryCount: 0,
         },
-      };
+      } as any;
       const error = new Error('Database connection failed');
 
       prisma.workflowEventOutbox.create.mockRejectedValue(error);
@@ -121,16 +119,14 @@ describe('WorkflowEventOutboxService', () => {
           payload: {},
           processed: false,
           processedAt: new Date(),
-          retryCount: 0,
         },
         {
           eventName: 'test_eventName',
           payload: {},
           processed: false,
           processedAt: new Date(),
-          retryCount: 0,
         },
-      ];
+      ] as any;
       const expectedResult = { count: 2 };
 
       prisma.workflowEventOutbox.createMany.mockResolvedValue(expectedResult);
@@ -151,8 +147,8 @@ describe('WorkflowEventOutboxService', () => {
         where: {},
         take: 10,
         skip: 0,
-      };
-      const mockEntities = [{ id: BigInt(1) }, { id: BigInt(1) }];
+      } as any;
+      const mockEntities = [{ id: 1 }, { id: 2 }];
 
       prisma.workflowEventOutbox.count.mockResolvedValue(2);
       prisma.workflowEventOutbox.findMany.mockResolvedValue(mockEntities);
@@ -172,7 +168,7 @@ describe('WorkflowEventOutboxService', () => {
     });
 
     it('should return empty result when no records found', async () => {
-      const findArgs = { where: {} };
+      const findArgs = { where: {} } as any;
 
       prisma.workflowEventOutbox.count.mockResolvedValue(0);
       prisma.workflowEventOutbox.findMany.mockResolvedValue([]);
@@ -185,9 +181,9 @@ describe('WorkflowEventOutboxService', () => {
 
   describe('findUnique', () => {
     it('should find a single workflowEventOutbox record by id', async () => {
-      const id = BigInt(1);
+      const id = 1;
       const select = { id: true };
-      const expectedResult = { id: BigInt(1) };
+      const expectedResult = { id: 1 };
 
       prisma.workflowEventOutbox.findUnique.mockResolvedValue(expectedResult);
 
@@ -203,7 +199,7 @@ describe('WorkflowEventOutboxService', () => {
     it('should return null when record not found', async () => {
       prisma.workflowEventOutbox.findUnique.mockResolvedValue(null);
 
-      const result = await service.findUnique(BigInt(1), { id: true });
+      const result = await service.findUnique(1, { id: true });
 
       expect(result).toBeNull();
     });
@@ -211,15 +207,14 @@ describe('WorkflowEventOutboxService', () => {
 
   describe('updateUnique', () => {
     it('should update a single workflowEventOutbox record', async () => {
-      const id = BigInt(1);
+      const id = 1;
       const data = {
         eventName: 'test_eventName',
         payload: {},
         processed: false,
         processedAt: new Date(),
-        retryCount: 0,
-      };
-      const expectedResult = { id: BigInt(1), ...data };
+      } as any;
+      const expectedResult = { id: 1, ...data };
 
       prisma.workflowEventOutbox.update.mockResolvedValue(expectedResult);
 
@@ -242,9 +237,8 @@ describe('WorkflowEventOutboxService', () => {
           payload: {},
           processed: false,
           processedAt: new Date(),
-          retryCount: 0,
         },
-      };
+      } as any;
       const expectedResult = { count: 5 };
 
       prisma.workflowEventOutbox.updateMany.mockResolvedValue(expectedResult);
@@ -260,9 +254,9 @@ describe('WorkflowEventOutboxService', () => {
 
   describe('deleteUnique', () => {
     it('should delete a single workflowEventOutbox record and return count', async () => {
-      const id = BigInt(1);
+      const id = 1;
 
-      prisma.workflowEventOutbox.delete.mockResolvedValue({ id: BigInt(1) });
+      prisma.workflowEventOutbox.delete.mockResolvedValue({ id: 1 });
 
       const result = await service.deleteUnique(id);
 
@@ -275,7 +269,7 @@ describe('WorkflowEventOutboxService', () => {
 
   describe('deleteMany', () => {
     it('should delete multiple workflowEventOutbox records', async () => {
-      const deleteArgs = { where: {} };
+      const deleteArgs = { where: {} } as any;
       const expectedResult = { count: 3 };
 
       prisma.workflowEventOutbox.deleteMany.mockResolvedValue(expectedResult);
@@ -291,7 +285,7 @@ describe('WorkflowEventOutboxService', () => {
 
   describe('count', () => {
     it('should count workflowEventOutbox records with filter', async () => {
-      const countArgs = { where: {} };
+      const countArgs = { where: {} } as any;
 
       prisma.workflowEventOutbox.count.mockResolvedValue(10);
 
@@ -316,12 +310,12 @@ describe('WorkflowEventOutboxService', () => {
       const groupByArgs = {
         by: ['id'],
         _count: { id: true },
-      };
-      const expectedResult = [{ id: BigInt(1), _count: { id: 50 } }];
+      } as any;
+      const expectedResult = [{ id: 1, _count: { id: 50 } }];
 
       prisma.workflowEventOutbox.groupBy.mockResolvedValue(expectedResult);
 
-      const result = await service.groupBy(groupByArgs as any);
+      const result = await service.groupBy(groupByArgs);
 
       expect(prisma.workflowEventOutbox.groupBy).toHaveBeenCalledWith(
         groupByArgs,
@@ -336,11 +330,11 @@ describe('WorkflowEventOutboxService', () => {
         _count: true,
         _max: { id: true },
         _min: { id: true },
-      } as const;
+      } as any;
       const expectedResult = {
         _count: 100,
-        _max: { id: BigInt(1) },
-        _min: { id: BigInt(1) },
+        _max: { id: 1 },
+        _min: { id: 1 },
       };
 
       prisma.workflowEventOutbox.aggregate.mockResolvedValue(expectedResult);

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

@@ -1,15 +1,47 @@
+/// <reference types="jest" />
+import { ConfigService } from '@nestjs/config';
 import { Test, TestingModule } from '@nestjs/testing';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import { WorkflowNodeInstanceController } from './workflowNodeInstance.controller';
 import { WorkflowNodeInstanceService } from './workflowNodeInstance.service';
 
+// Mock WorkflowNodeInstanceService：用空对象屏蔽真实 Service 的依赖（PrismaService 等），
+// 避免 NestJS 在测试模块编译时去解析 Service 的构造参数。
+const mockWorkflowNodeInstanceService = {};
+
+// Mock ConfigService
+const mockConfigService = {
+  get: jest.fn(),
+};
+
+// Mock Logger
+const mockLogger = {
+  child: jest.fn().mockReturnThis(),
+  info: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+};
+
 describe('WorkflowNodeInstanceController', () => {
   let controller: WorkflowNodeInstanceController;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [WorkflowNodeInstanceController],
-      providers: [WorkflowNodeInstanceService],
-    }).compile();
+      providers: [
+        {
+          provide: WorkflowNodeInstanceService,
+          useValue: mockWorkflowNodeInstanceService,
+        },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    })
+      // 兜底：自动 mock 任何未显式提供的依赖
+      // （例如 ACGuard 内部的 __roles_builder__ token）
+      .useMocker(() => ({}))
+      .compile();
 
     controller = module.get<WorkflowNodeInstanceController>(
       WorkflowNodeInstanceController,