@gadmin2n/schematics 0.0.87 → 0.0.89

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

@@ -0,0 +1,158 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ScheduleNotFoundError } from '@temporalio/client';
+import { TemporalService } from './temporal.service';
+
+/**
+ * Mock the @temporalio/client module so we can intercept schedule / workflow ops
+ * without needing a running Temporal Server.
+ */
+const mockHandle = {
+  describe: jest.fn(),
+  update: jest.fn(),
+  pause: jest.fn(),
+  unpause: jest.fn(),
+  delete: jest.fn(),
+};
+const mockClient = {
+  schedule: {
+    getHandle: jest.fn(() => mockHandle),
+    create: jest.fn(),
+  },
+  workflow: {
+    start: jest.fn(),
+    getHandle: jest.fn(() => ({ cancel: jest.fn() })),
+  },
+};
+
+jest.mock('@temporalio/client', () => {
+  class FakeScheduleNotFoundError extends Error {
+    constructor(msg = 'not found') {
+      super(msg);
+      this.name = 'ScheduleNotFoundError';
+    }
+  }
+  return {
+    Client: jest.fn(() => mockClient),
+    Connection: { connect: jest.fn(async () => ({ close: jest.fn() })) },
+    ScheduleNotFoundError: FakeScheduleNotFoundError,
+  };
+});
+
+describe('TemporalService — cron schedule methods', () => {
+  let service: TemporalService;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [TemporalService],
+    }).compile();
+    service = module.get<TemporalService>(TemporalService);
+    await service.onModuleInit();
+  });
+
+  describe('upsertCronSchedule', () => {
+    it('creates a new schedule when none exists', async () => {
+      mockHandle.describe.mockRejectedValueOnce(
+        new ScheduleNotFoundError('nf', 'wf-x-cron'),
+      );
+
+      await service.upsertCronSchedule({
+        workflowId: 42,
+        versionId: 7,
+        dsl: { nodes: [], edges: [] },
+        cron: '0 * * * *',
+        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.timezoneName).toBe('Asia/Shanghai');
+      expect(arg.action.workflowType).toBe('cronTriggerWorkflow');
+      expect(arg.action.args[0]).toMatchObject({
+        workflowId: 42,
+        versionId: 7,
+        scheduleId: 'wf-42-cron',
+      });
+    });
+
+    it('updates an existing schedule', async () => {
+      mockHandle.describe.mockResolvedValueOnce({});
+
+      await service.upsertCronSchedule({
+        workflowId: 42,
+        versionId: 8,
+        dsl: { nodes: [], edges: [] },
+        cron: '*/5 * * * *',
+      });
+
+      expect(mockClient.schedule.create).not.toHaveBeenCalled();
+      expect(mockHandle.update).toHaveBeenCalledTimes(1);
+    });
+
+    it('omits timezoneName when timezone is not provided', async () => {
+      mockHandle.describe.mockRejectedValueOnce(
+        new ScheduleNotFoundError('nf', 'wf-x-cron'),
+      );
+      await service.upsertCronSchedule({
+        workflowId: 1,
+        versionId: 1,
+        dsl: {},
+        cron: '0 0 * * *',
+      });
+      const spec = mockClient.schedule.create.mock.calls[0][0].spec;
+      expect(spec.timezoneName).toBeUndefined();
+    });
+  });
+
+  describe('pauseCronSchedule', () => {
+    it('calls handle.pause for existing schedule', async () => {
+      mockHandle.pause.mockResolvedValueOnce(undefined);
+      await service.pauseCronSchedule(42);
+      expect(mockHandle.pause).toHaveBeenCalled();
+    });
+
+    it('is a no-op when schedule does not exist', async () => {
+      mockHandle.pause.mockRejectedValueOnce(
+        new ScheduleNotFoundError('nf', 'wf-x-cron'),
+      );
+      await expect(service.pauseCronSchedule(42)).resolves.toBeUndefined();
+    });
+
+    it('rethrows non-NotFound errors', async () => {
+      mockHandle.pause.mockRejectedValueOnce(new Error('boom'));
+      await expect(service.pauseCronSchedule(42)).rejects.toThrow('boom');
+    });
+  });
+
+  describe('unpauseCronSchedule', () => {
+    it('calls handle.unpause', async () => {
+      mockHandle.unpause.mockResolvedValueOnce(undefined);
+      await service.unpauseCronSchedule(42);
+      expect(mockHandle.unpause).toHaveBeenCalled();
+    });
+
+    it('swallows ScheduleNotFoundError', async () => {
+      mockHandle.unpause.mockRejectedValueOnce(
+        new ScheduleNotFoundError('nf', 'wf-x-cron'),
+      );
+      await expect(service.unpauseCronSchedule(42)).resolves.toBeUndefined();
+    });
+  });
+
+  describe('deleteCronSchedule', () => {
+    it('calls handle.delete', async () => {
+      mockHandle.delete.mockResolvedValueOnce(undefined);
+      await service.deleteCronSchedule(42);
+      expect(mockHandle.delete).toHaveBeenCalled();
+    });
+
+    it('swallows ScheduleNotFoundError', async () => {
+      mockHandle.delete.mockRejectedValueOnce(
+        new ScheduleNotFoundError('nf', 'wf-x-cron'),
+      );
+      await expect(service.deleteCronSchedule(42)).resolves.toBeUndefined();
+    });
+  });
+});

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

@@ -4,12 +4,14 @@ import {
   OnModuleDestroy,
   OnModuleInit,
 } from '@nestjs/common';
-import { Client, Connection } from '@temporalio/client';
+import { Client, Connection, ScheduleNotFoundError } 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`;
+
 @Injectable()
 export class TemporalService implements OnModuleInit, OnModuleDestroy {
   private connection: Connection;
@@ -97,4 +99,111 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
   isAvailable(): boolean {
     return !!this.client;
   }
+
+  // ─── Cron Schedules ────────────────────────────────────────────────────────
+
+  /**
+   * Create or update a Temporal Schedule that periodically starts cronTriggerWorkflow.
+   * Idempotent — safe to call on every publish.
+   */
+  async upsertCronSchedule(input: {
+    workflowId: number;
+    versionId: number;
+    dsl: any;
+    cron: string;
+    timezone?: string;
+  }): Promise<void> {
+    if (!this.client) throw new Error('Temporal client not connected');
+
+    const scheduleId = cronScheduleId(input.workflowId);
+    const action = {
+      type: 'startWorkflow' as const,
+      workflowType: 'cronTriggerWorkflow',
+      taskQueue: TASK_QUEUE,
+      args: [
+        {
+          workflowId: input.workflowId,
+          versionId: input.versionId,
+          dsl: input.dsl,
+          scheduleId,
+        },
+      ],
+    };
+    const spec = {
+      cronExpressions: [input.cron],
+      ...(input.timezone ? { timezoneName: input.timezone } : {}),
+    };
+
+    const handle = this.client.schedule.getHandle(scheduleId);
+    try {
+      await handle.describe();
+      // Exists — update spec + action so DSL/version changes propagate
+      await handle.update((prev) => ({
+        ...prev,
+        spec,
+        action,
+      }));
+      this.logger.log(
+        `Updated cron schedule ${scheduleId} (cron="${input.cron}")`,
+      );
+    } catch (err: any) {
+      if (err instanceof ScheduleNotFoundError) {
+        await this.client.schedule.create({
+          scheduleId,
+          spec,
+          action,
+        });
+        this.logger.log(
+          `Created cron schedule ${scheduleId} (cron="${input.cron}")`,
+        );
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Pause a cron schedule. No-op if it doesn't exist.
+   */
+  async pauseCronSchedule(workflowId: number): Promise<void> {
+    if (!this.client) return;
+    const scheduleId = cronScheduleId(workflowId);
+    try {
+      await this.client.schedule.getHandle(scheduleId).pause();
+      this.logger.log(`Paused cron schedule ${scheduleId}`);
+    } catch (err: any) {
+      if (err instanceof ScheduleNotFoundError) return;
+      throw err;
+    }
+  }
+
+  /**
+   * Resume a paused cron schedule. No-op if it doesn't exist.
+   */
+  async unpauseCronSchedule(workflowId: number): Promise<void> {
+    if (!this.client) return;
+    const scheduleId = cronScheduleId(workflowId);
+    try {
+      await this.client.schedule.getHandle(scheduleId).unpause();
+      this.logger.log(`Unpaused cron schedule ${scheduleId}`);
+    } catch (err: any) {
+      if (err instanceof ScheduleNotFoundError) return;
+      throw err;
+    }
+  }
+
+  /**
+   * Delete a cron schedule. No-op if it doesn't exist.
+   */
+  async deleteCronSchedule(workflowId: number): Promise<void> {
+    if (!this.client) return;
+    const scheduleId = cronScheduleId(workflowId);
+    try {
+      await this.client.schedule.getHandle(scheduleId).delete();
+      this.logger.log(`Deleted cron schedule ${scheduleId}`);
+    } catch (err: any) {
+      if (err instanceof ScheduleNotFoundError) return;
+      throw err;
+    }
+  }
 }

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

@@ -0,0 +1,79 @@
+import {
+  signWebhookPayload,
+  verifyWebhookSignature,
+} from './webhook-signature.util';
+
+describe('webhook-signature.util', () => {
+  const secret = 'super-secret';
+  const ts = '1700000000';
+  const body = '{"orderId":42}';
+
+  describe('verifyWebhookSignature', () => {
+    it('returns true for a valid signature', () => {
+      const sig = signWebhookPayload(secret, ts, body);
+      expect(verifyWebhookSignature(secret, ts, body, sig)).toBe(true);
+    });
+
+    it('returns false when secret is wrong', () => {
+      const sig = signWebhookPayload(secret, ts, body);
+      expect(verifyWebhookSignature('different', ts, body, sig)).toBe(false);
+    });
+
+    it('returns false when body is tampered', () => {
+      const sig = signWebhookPayload(secret, ts, body);
+      expect(verifyWebhookSignature(secret, ts, '{"orderId":99}', sig)).toBe(
+        false,
+      );
+    });
+
+    it('returns false when timestamp differs', () => {
+      const sig = signWebhookPayload(secret, ts, body);
+      expect(verifyWebhookSignature(secret, '1700000099', body, sig)).toBe(
+        false,
+      );
+    });
+
+    it('returns false on missing signature header', () => {
+      expect(verifyWebhookSignature(secret, ts, body, undefined)).toBe(false);
+    });
+
+    it('returns false on missing secret', () => {
+      const sig = signWebhookPayload(secret, ts, body);
+      expect(verifyWebhookSignature('', ts, body, sig)).toBe(false);
+    });
+
+    it('returns false (no throw) on length-mismatched signature', () => {
+      expect(() =>
+        verifyWebhookSignature(secret, ts, body, 'sha256=short'),
+      ).not.toThrow();
+      expect(verifyWebhookSignature(secret, ts, body, 'sha256=short')).toBe(
+        false,
+      );
+    });
+
+    it('accepts Buffer body input', () => {
+      const buf = Buffer.from(body);
+      const sig = signWebhookPayload(secret, ts, buf);
+      expect(verifyWebhookSignature(secret, ts, buf, sig)).toBe(true);
+    });
+
+    it('produces different signatures for different timestamps (replay protection)', () => {
+      const sig1 = signWebhookPayload(secret, '1700000000', body);
+      const sig2 = signWebhookPayload(secret, '1700000001', body);
+      expect(sig1).not.toBe(sig2);
+    });
+  });
+
+  describe('signWebhookPayload', () => {
+    it('produces a sha256= prefixed hex digest', () => {
+      const sig = signWebhookPayload(secret, ts, body);
+      expect(sig).toMatch(/^sha256=[a-f0-9]{64}$/);
+    });
+
+    it('is deterministic for same inputs', () => {
+      expect(signWebhookPayload(secret, ts, body)).toBe(
+        signWebhookPayload(secret, ts, body),
+      );
+    });
+  });
+});

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

@@ -0,0 +1,54 @@
+import * as crypto from 'crypto';
+
+/**
+ * Verify an HMAC-SHA256 signature for a webhook request.
+ *
+ * Signing payload format: `${timestamp}.${rawBody}` — the timestamp prefix prevents
+ * replay attacks even if the body is captured.
+ *
+ * Header format: `X-Workflow-Signature: sha256=<hex digest>`
+ *
+ * Uses crypto.timingSafeEqual to prevent timing attacks.
+ * Returns false (not throw) on length mismatch or any other comparison failure.
+ */
+export function verifyWebhookSignature(
+  secret: string,
+  timestamp: string,
+  rawBody: Buffer | string,
+  signatureHeader: string | undefined,
+): boolean {
+  if (!signatureHeader || !secret || !timestamp) return false;
+
+  const body = typeof rawBody === 'string' ? Buffer.from(rawBody) : rawBody;
+  const signingPayload = Buffer.concat([Buffer.from(`${timestamp}.`), body]);
+  const expected = `sha256=${crypto
+    .createHmac('sha256', secret)
+    .update(signingPayload)
+    .digest('hex')}`;
+
+  const expectedBuf = Buffer.from(expected);
+  const actualBuf = Buffer.from(signatureHeader);
+  if (expectedBuf.length !== actualBuf.length) return false;
+
+  try {
+    return crypto.timingSafeEqual(expectedBuf, actualBuf);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Helper for tests / manual signing — returns the X-Workflow-Signature header value.
+ */
+export function signWebhookPayload(
+  secret: string,
+  timestamp: string,
+  rawBody: Buffer | string,
+): string {
+  const body = typeof rawBody === 'string' ? Buffer.from(rawBody) : rawBody;
+  const signingPayload = Buffer.concat([Buffer.from(`${timestamp}.`), body]);
+  return `sha256=${crypto
+    .createHmac('sha256', secret)
+    .update(signingPayload)
+    .digest('hex')}`;
+}

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

@@ -3,16 +3,20 @@ import {
   Controller,
   Delete,
   Get,
+  Headers,
+  HttpCode,
   Param,
   ParseIntPipe,
   Patch,
   Post,
   Query,
+  RawBodyRequest,
   Req,
   UnauthorizedException,
   UseGuards,
 } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
+import { Request } from 'express';
 import AuthGuard, { AllowUnauthorizedRequest } from '../../lib/auth.guard';
 import { TemporalService } from './temporal.service';
 import {
@@ -217,4 +221,34 @@ export class WorkflowController {
       this.temporalService,
     );
   }
+
+  /**
+   * Public webhook entry point.
+   * Triggers any published workflow with a webhook_trigger node matching (path, method).
+   * Caller must provide HMAC-SHA256 signature in X-Workflow-Signature header.
+   *
+   * Returns 202 Accepted with the list of created instance IDs (workflow runs async).
+   */
+  @Post('webhook/:path')
+  @HttpCode(202)
+  @AllowUnauthorizedRequest()
+  async receiveWebhook(
+    @Param('path') path: string,
+    @Headers('x-workflow-signature') signature: string,
+    @Headers('x-workflow-timestamp') timestamp: string,
+    @Req() req: RawBodyRequest<Request>,
+    @Body() body: any,
+    @Query() query: any,
+  ): Promise<{ instanceIds: string[] }> {
+    return this.workflowService.receiveWebhook({
+      path,
+      method: req.method,
+      signatureHeader: signature,
+      timestampHeader: timestamp,
+      rawBody: req.rawBody ?? Buffer.from(''),
+      body,
+      headers: req.headers as Record<string, any>,
+      query,
+    });
+  }
 }