@gadmin2n/schematics 0.0.139 → 0.0.140

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

@@ -0,0 +1,177 @@
+import { BadRequestException } from '@nestjs/common';
+import { ApprovalChannelService } from './approval-channel.service';
+
+const dispatchWorkflow = {
+  id: BigInt(11),
+  name: 'Dispatch approvals',
+  status: 'PUBLISHED',
+  isEnabled: true,
+  versions: [
+    {
+      dsl: {
+        nodes: [
+          {
+            type: 'callable_trigger',
+            config: {
+              inputParameters: [
+                { key: 'title', label: '单据标题', required: true },
+                { key: 'content', label: '审批内容', required: true },
+                { key: 'callbackToken', label: '回调凭证', required: true },
+              ],
+            },
+          },
+        ],
+      },
+    },
+  ],
+};
+
+describe('ApprovalChannelService', () => {
+  const prisma = {
+    workflow: {
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+    },
+    approvalChannel: {
+      create: jest.fn(),
+    },
+  };
+  const service = new ApprovalChannelService(prisma as any);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    prisma.workflow.findUnique.mockResolvedValue(dispatchWorkflow);
+    prisma.approvalChannel.create.mockImplementation(({ data }) =>
+      Promise.resolve({
+        id: BigInt(1),
+        ...data,
+        description: data.description ?? null,
+        revision: 1,
+        creator: 'admin',
+        createdAt: new Date('2026-07-24T00:00:00Z'),
+        updatedAt: new Date('2026-07-24T00:00:00Z'),
+        dispatchWorkflow,
+      }),
+    );
+  });
+
+  it('creates a channel with an internal code generated by the server', async () => {
+    const result = await service.create(
+      {
+        name: 'External approval',
+        dispatchWorkflowId: '11',
+        isEnabled: true,
+      },
+      { userId: 'admin' },
+    );
+
+    expect(result).toMatchObject({
+      id: '1',
+      dispatchWorkflowId: '11',
+      dispatchWorkflowName: 'Dispatch approvals',
+      inputParameters: [
+        { key: 'title', label: '单据标题', required: true },
+        { key: 'content', label: '审批内容', required: true },
+        { key: 'callbackToken', label: '回调凭证', required: true },
+      ],
+    });
+    expect(result.code).toMatch(/^approval-[0-9a-f-]{36}$/);
+    expect(prisma.approvalChannel.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ code: result.code }),
+      }),
+    );
+  });
+
+  it('keeps accepting a legacy channel whose event name matches its explicit code', async () => {
+    prisma.workflow.findUnique.mockResolvedValueOnce({
+      ...dispatchWorkflow,
+      versions: [
+        {
+          dsl: {
+            nodes: [
+              {
+                type: 'event_trigger',
+                config: { eventName: 'approval.requested.external-main' },
+              },
+            ],
+          },
+        },
+      ],
+    });
+
+    await expect(
+      service.create(
+        {
+          code: 'external-main',
+          name: 'Legacy external approval',
+          dispatchWorkflowId: '11',
+          isEnabled: true,
+        },
+        { userId: 'admin' },
+      ),
+    ).resolves.toMatchObject({ code: 'external-main' });
+  });
+
+  it('rejects a workflow that cannot receive a one-way call', async () => {
+    prisma.workflow.findUnique.mockResolvedValueOnce({
+      ...dispatchWorkflow,
+      versions: [
+        {
+          dsl: {
+            nodes: [{ type: 'manual_trigger', config: {} }],
+          },
+        },
+      ],
+    });
+
+    await expect(
+      service.create(
+        {
+          name: 'External approval',
+          dispatchWorkflowId: '11',
+          isEnabled: true,
+        },
+        { userId: 'admin' },
+      ),
+    ).rejects.toBeInstanceOf(BadRequestException);
+  });
+
+  it('lists only published workflows that can receive approval requests', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([
+      dispatchWorkflow,
+      {
+        ...dispatchWorkflow,
+        id: BigInt(12),
+        name: 'Legacy dispatcher',
+        versions: [
+          {
+            dsl: {
+              nodes: [
+                {
+                  type: 'event_trigger',
+                  config: { eventName: 'approval.requested.legacy' },
+                },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        ...dispatchWorkflow,
+        id: BigInt(13),
+        name: 'Ordinary workflow',
+        versions: [
+          {
+            dsl: { nodes: [{ type: 'manual_trigger', config: {} }] },
+          },
+        ],
+      },
+    ]);
+
+    await expect(service.listDispatchWorkflows('12')).resolves.toEqual([
+      { id: '11', name: 'Dispatch approvals' },
+      { id: '12', name: 'Legacy dispatcher' },
+    ]);
+  });
+});

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

@@ -0,0 +1,283 @@
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { ApprovalChannel, Prisma } from '@prisma/client';
+import { randomUUID } from 'crypto';
+import { PrismaService } from 'nestjs-prisma';
+import { ActorContext } from '../subjectProvider/subject-provider.types';
+import {
+  describeApprovalChannelInputs,
+  describeCallableWorkflow,
+} from '../workflow/workflow-callable';
+import {
+  CreateApprovalChannelDto,
+  UpdateApprovalChannelDto,
+} from './approval-channel.dto';
+
+const channelRelations = {
+  dispatchWorkflow: {
+    include: {
+      versions: {
+        orderBy: { version: 'desc' as const },
+        take: 1,
+        select: { dsl: true },
+      },
+    },
+  },
+} satisfies Prisma.ApprovalChannelInclude;
+
+type ApprovalChannelWithWorkflows = Prisma.ApprovalChannelGetPayload<{
+  include: typeof channelRelations;
+}>;
+
+@Injectable()
+export class ApprovalChannelService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(query = '') {
+    const entities = await this.prisma.approvalChannel.findMany({
+      where: query
+        ? {
+            OR: [
+              { name: { contains: query, mode: 'insensitive' } },
+              { code: { contains: query, mode: 'insensitive' } },
+            ],
+          }
+        : undefined,
+      include: channelRelations,
+      orderBy: [{ isEnabled: 'desc' }, { updatedAt: 'desc' }],
+    });
+    return entities.map((entity) => this.toPublic(entity));
+  }
+
+  async get(code: string) {
+    return this.toPublic(await this.findOrThrow(code));
+  }
+
+  async listDispatchWorkflows(includeWorkflowId?: string) {
+    const includedId =
+      includeWorkflowId && /^[1-9]\d*$/.test(includeWorkflowId)
+        ? includeWorkflowId
+        : null;
+    const workflows = await this.prisma.workflow.findMany({
+      where: { status: 'PUBLISHED', isEnabled: true },
+      orderBy: { name: 'asc' },
+      include: {
+        versions: {
+          orderBy: { version: 'desc' },
+          take: 1,
+          select: { dsl: true },
+        },
+      },
+    });
+    return workflows.flatMap((workflow) => {
+      const nodes = nodesFromLatestVersion(workflow);
+      let isOneWayCallable = false;
+      try {
+        isOneWayCallable =
+          describeCallableWorkflow(workflow.versions[0]?.dsl)?.mode ===
+          'ONE_WAY';
+      } catch {
+        isOneWayCallable = false;
+      }
+      const isCurrentLegacyWorkflow =
+        String(workflow.id) === includedId &&
+        nodes.some(
+          (node) =>
+            node.type === 'event_trigger' &&
+            typeof asObject(node.config).eventName === 'string' &&
+            asObject(node.config).eventName.startsWith('approval.requested.'),
+        );
+      if (
+        !isOneWayCallable &&
+        !nodes.some((node) => node.type === 'approval_request_trigger') &&
+        !isCurrentLegacyWorkflow
+      )
+        return [];
+      return [{ id: String(workflow.id), name: workflow.name }];
+    });
+  }
+
+  async create(input: CreateApprovalChannelDto, actor: ActorContext) {
+    const code = input.code?.trim() || `approval-${randomUUID()}`;
+    const dispatchWorkflowId = BigInt(input.dispatchWorkflowId);
+    await this.validateDispatchWorkflow(code, dispatchWorkflowId);
+
+    try {
+      const entity = await this.prisma.approvalChannel.create({
+        data: {
+          code,
+          name: input.name.trim(),
+          description: input.description?.trim() || null,
+          dispatchWorkflowId,
+          isEnabled: input.isEnabled ?? true,
+          creator: actor.username ?? actor.userId,
+        },
+        include: channelRelations,
+      });
+      return this.toPublic(entity);
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2002'
+      )
+        throw new ConflictException('Approval channel code already exists');
+      throw error;
+    }
+  }
+
+  async update(
+    code: string,
+    input: UpdateApprovalChannelDto,
+    _actor: ActorContext,
+  ) {
+    const current = await this.findOrThrow(code);
+    const dispatchWorkflowId =
+      input.dispatchWorkflowId === undefined
+        ? current.dispatchWorkflowId
+        : BigInt(input.dispatchWorkflowId);
+    await this.validateDispatchWorkflow(code, dispatchWorkflowId);
+
+    const result = await this.prisma.approvalChannel.updateMany({
+      where: { code, revision: input.expectedRevision },
+      data: {
+        ...(input.name !== undefined && { name: input.name.trim() }),
+        ...(input.description !== undefined && {
+          description: input.description?.trim() || null,
+        }),
+        dispatchWorkflowId,
+        ...(input.isEnabled !== undefined && { isEnabled: input.isEnabled }),
+        revision: { increment: 1 },
+      },
+    });
+    if (!result.count)
+      throw new ConflictException(
+        'Approval channel was updated by someone else; reload and try again',
+      );
+    return this.get(code);
+  }
+
+  async resolveRuntime(code: string) {
+    const channel = await this.findOrThrow(code);
+    if (!channel.isEnabled)
+      throw new BadRequestException({
+        code: 'APPROVAL_CHANNEL_DISABLED',
+        message: `Approval channel ${code} is disabled`,
+        retryable: false,
+      });
+    return channel;
+  }
+
+  private async findOrThrow(code: string) {
+    const entity = await this.prisma.approvalChannel.findUnique({
+      where: { code },
+      include: channelRelations,
+    });
+    if (!entity) throw new NotFoundException('Approval channel not found');
+    return entity;
+  }
+
+  private async validateDispatchWorkflow(
+    code: string,
+    dispatchWorkflowId: bigint,
+  ) {
+    const dispatchWorkflow = await this.loadPublishedWorkflow(
+      dispatchWorkflowId,
+      'Dispatch',
+    );
+    const dispatchNodes = nodesFromLatestVersion(dispatchWorkflow);
+    const expectedEventName = `approval.requested.${code}`;
+    let hasOneWayCallable = false;
+    try {
+      hasOneWayCallable =
+        describeCallableWorkflow(dispatchWorkflow.versions[0]?.dsl)?.mode ===
+        'ONE_WAY';
+    } catch {
+      hasOneWayCallable = false;
+    }
+    const hasApprovalRequestTrigger = dispatchNodes.some(
+      (node) => node.type === 'approval_request_trigger',
+    );
+    const hasLegacyEventTrigger = dispatchNodes.some(
+      (node) =>
+        node.type === 'event_trigger' &&
+        asObject(node.config).eventName === expectedEventName,
+    );
+    if (
+      !hasOneWayCallable &&
+      !hasApprovalRequestTrigger &&
+      !hasLegacyEventTrigger
+    )
+      throw new BadRequestException(
+        'Dispatch workflow must contain Receive Call and must not return a result',
+      );
+  }
+
+  private async loadPublishedWorkflow(id: bigint, label: string) {
+    const workflow = await this.prisma.workflow.findUnique({
+      where: { id },
+      include: {
+        versions: {
+          orderBy: { version: 'desc' },
+          take: 1,
+        },
+      },
+    });
+    if (!workflow)
+      throw new BadRequestException(`${label} workflow does not exist`);
+    if (workflow.status !== 'PUBLISHED' || !workflow.isEnabled)
+      throw new BadRequestException(
+        `${label} workflow must be published and enabled`,
+      );
+    return workflow;
+  }
+
+  private toPublic(
+    entity:
+      | ApprovalChannelWithWorkflows
+      | (ApprovalChannel & {
+          dispatchWorkflow: {
+            name: string;
+            versions: Array<{ dsl: unknown }>;
+          };
+        }),
+  ) {
+    return {
+      id: String(entity.id),
+      code: entity.code,
+      name: entity.name,
+      description: entity.description,
+      dispatchWorkflowId: String(entity.dispatchWorkflowId),
+      dispatchWorkflowName: entity.dispatchWorkflow.name,
+      inputParameters: describeApprovalChannelInputs(
+        entity.dispatchWorkflow.versions[0]?.dsl,
+      ),
+      isEnabled: entity.isEnabled,
+      revision: entity.revision,
+      creator: entity.creator,
+      createdAt: entity.createdAt,
+      updatedAt: entity.updatedAt,
+    };
+  }
+}
+
+type WorkflowNode = {
+  type?: unknown;
+  config?: unknown;
+};
+
+function nodesFromLatestVersion(workflow: {
+  versions: Array<{ dsl: unknown }>;
+}): WorkflowNode[] {
+  const dsl = asObject(workflow.versions[0]?.dsl);
+  return Array.isArray(dsl.nodes) ? (dsl.nodes as WorkflowNode[]) : [];
+}
+
+function asObject(value: unknown): Record<string, any> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, any>)
+    : {};
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ApprovalChannelController } from './approval-channel.controller';
+import { ApprovalChannelService } from './approval-channel.service';
+
+@Module({
+  controllers: [ApprovalChannelController],
+  providers: [ApprovalChannelService],
+  exports: [ApprovalChannelService],
+})
+export class ApprovalChannelModule {}

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

@@ -0,0 +1,42 @@
+import { executeCode } from './code-executor';
+
+describe('executeCode', () => {
+  it('transforms an HTTP response into an array of IDs', async () => {
+    await expect(
+      executeCode(
+        {
+          script: 'return input.data.approvers.map((user) => user.id);',
+          mode: 'runOnceForAll',
+          timeout: 500,
+        },
+        {
+          status: 200,
+          data: { approvers: [{ id: 'u1' }, { id: 'u2' }] },
+          headers: {},
+        },
+      ),
+    ).resolves.toEqual(['u1', 'u2']);
+  });
+
+  it('does not expose Node.js process globals', async () => {
+    await expect(
+      executeCode({ script: 'return typeof process;', timeout: 500 }, {}),
+    ).resolves.toBe('undefined');
+  });
+
+  it('exposes previous-node input and immutable Workflow data separately', async () => {
+    await expect(
+      executeCode(
+        {
+          script:
+            'return { previous: input.ticket.id, applicant: workflow.applicant.id };',
+        },
+        { ticket: { id: 'T-1' } },
+        { applicant: { id: 'alice' } },
+      ),
+    ).resolves.toEqual({
+      previous: 'T-1',
+      applicant: 'alice',
+    });
+  });
+});

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

@@ -0,0 +1,108 @@
+import { Worker } from 'node:worker_threads';
+
+export interface CodeNodeConfig {
+  script: string;
+  mode?: 'runOnceForAll' | 'runOnceForEach';
+  timeout?: number;
+}
+
+const WORKER_SOURCE = String.raw`
+const { parentPort, workerData } = require('node:worker_threads');
+const vm = require('node:vm');
+
+function run(script, input, workflow, timeout) {
+  const sandbox = Object.create(null);
+  sandbox.input = input;
+  sandbox.workflow = workflow;
+  sandbox.data = input && typeof input === 'object' && 'data' in input
+    ? input.data
+    : input;
+  sandbox.items = input && typeof input === 'object' && Array.isArray(input.items)
+    ? input.items
+    : Array.isArray(input) ? input : [];
+  sandbox.console = Object.freeze({ log() {}, warn() {}, error() {} });
+  const context = vm.createContext(sandbox, {
+    codeGeneration: { strings: false, wasm: false },
+  });
+  const program = new vm.Script(
+    '(function () { "use strict";\n' + script + '\n}).call(undefined)',
+    { filename: 'workflow-code-node.js' },
+  );
+  return program.runInContext(context, { timeout });
+}
+
+try {
+  const { config, input, workflow } = 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)
+    );
+  } else {
+    result = run(config.script, input, workflow, config.timeout);
+  }
+  parentPort.postMessage({ ok: true, result });
+} catch (error) {
+  parentPort.postMessage({
+    ok: false,
+    error: error instanceof Error ? error.message : String(error),
+  });
+}
+`;
+
+export async function executeCode(
+  config: CodeNodeConfig,
+  input: unknown,
+  workflow: Record<string, unknown> = {},
+): 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),
+    5000,
+  );
+  const mode = config.mode ?? 'runOnceForAll';
+  if (!['runOnceForAll', 'runOnceForEach'].includes(mode))
+    throw new Error('CODE_MODE_INVALID');
+
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(WORKER_SOURCE, {
+      eval: true,
+      workerData: {
+        config: { script: config.script, mode, timeout },
+        input,
+        workflow,
+      },
+      resourceLimits: {
+        maxOldGenerationSizeMb: 16,
+        maxYoungGenerationSizeMb: 4,
+        stackSizeMb: 1,
+      },
+    });
+    const timer = setTimeout(() => {
+      void worker.terminate();
+      reject(new Error('CODE_EXECUTION_TIMEOUT'));
+    }, timeout + 250);
+    worker.once(
+      'message',
+      (message: { ok: boolean; result?: unknown; error?: string }) => {
+        clearTimeout(timer);
+        void worker.terminate();
+        if (message.ok) resolve(message.result);
+        else reject(new Error(message.error || 'CODE_EXECUTION_FAILED'));
+      },
+    );
+    worker.once('error', (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    worker.once('exit', (code) => {
+      if (code === 0) return;
+      clearTimeout(timer);
+      reject(new Error(`CODE_WORKER_EXITED:${code}`));
+    });
+  });
+}