@gadmin2n/schematics 0.0.143 → 0.0.145

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/human-approval.external-decision.spec.ts

@@ -1,183 +0,0 @@
-import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-config.util';
-import { HumanApprovalService } from './human-approval.service';
-
-describe('HumanApprovalService external decisions', () => {
-  const request = {
-    id: BigInt(41),
-    workflowInstanceId: BigInt(7),
-    nodeId: 'approval-1',
-    status: 'PENDING',
-    configSnapshot: { approvalWorkflowId: '11' },
-    approvalRule: { mode: 'ANY' },
-    rejectionRule: { mode: 'ANY' },
-    candidates: [
-      {
-        id: BigInt(91),
-        principalRef: 'alice',
-        invalidatedAt: null,
-      },
-    ],
-    decisions: [],
-  };
-  const tx = {
-    approvalRequest: {
-      findUnique: jest.fn().mockResolvedValue(request),
-      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
-      create: jest.fn().mockResolvedValue({
-        id: BigInt(42),
-        status: 'PENDING',
-      }),
-    },
-    approvalDecision: {
-      create: jest.fn().mockResolvedValue({
-        id: BigInt(101),
-        decision: 'APPROVE',
-      }),
-    },
-    approvalSignalOutbox: {
-      upsert: jest.fn().mockResolvedValue({ id: BigInt(201) }),
-    },
-  };
-  const prisma = {
-    $transaction: jest.fn((callback) => callback(tx)),
-    approvalRequest: {
-      findUnique: jest.fn().mockResolvedValue(null),
-      findUniqueOrThrow: jest.fn(),
-    },
-    workflow: {
-      findUnique: jest.fn().mockResolvedValue({
-        isEnabled: true,
-        status: 'PUBLISHED',
-      }),
-    },
-  };
-  const providers = {
-    get: jest.fn().mockReturnValue({
-      preview: jest.fn().mockResolvedValue({
-        items: [{ ref: 'alice', revision: 1 }],
-      }),
-      resolve: jest.fn().mockResolvedValue([
-        {
-          principalType: 'USER',
-          principalRef: 'alice',
-          displayName: 'Alice',
-          sourceRefs: ['alice'],
-        },
-      ]),
-    }),
-  };
-  const service = new HumanApprovalService(prisma as any, providers as any);
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('maps a returned Workflow result to the configured approval candidate', async () => {
-    await service.submitExternalDecision(BigInt(41), {
-      approvalWorkflowId: '11',
-      eventId: 'myoa:workitem:123',
-      approverId: 'alice',
-      decision: 'APPROVE',
-      payload: { sourceStatus: 200 },
-    });
-
-    expect(tx.approvalDecision.create).toHaveBeenCalledWith({
-      data: expect.objectContaining({
-        requestId: BigInt(41),
-        candidateId: BigInt(91),
-        decision: 'APPROVE',
-        creator: 'external:11:alice',
-        payload: {
-          sourceStatus: 200,
-          externalEventId: 'myoa:workitem:123',
-          approvalWorkflowId: '11',
-        },
-      }),
-    });
-    expect(tx.approvalSignalOutbox.upsert).toHaveBeenCalled();
-  });
-
-  it('rejects a result from a Workflow not selected by the approval node', async () => {
-    await expect(
-      service.submitExternalDecision(BigInt(41), {
-        approvalWorkflowId: '12',
-        eventId: 'event-2',
-        approverId: 'alice',
-        decision: 'APPROVE',
-      }),
-    ).rejects.toMatchObject({
-      response: { code: 'APPROVAL_WORKFLOW_MISMATCH' },
-    });
-    expect(tx.approvalDecision.create).not.toHaveBeenCalled();
-  });
-
-  it('starts the selected approval Workflow with business and system inputs', async () => {
-    const externalInteractions = {
-      createInteractionInTransaction: jest.fn().mockResolvedValue({
-        interactionId: '51',
-        callbackToken: 'ext_cb_approval',
-        status: 'PENDING',
-      }),
-    };
-    const integratedService = new HumanApprovalService(
-      prisma as any,
-      providers as any,
-      externalInteractions as any,
-    );
-    const configSnapshot = {
-      approvalWorkflowId: '11',
-      subjects: [
-        { source: 'STATIC' as const, provider: 'USER', refs: ['alice'] },
-      ],
-      approvalRule: { mode: 'ANY' as const },
-      rejectionRule: { mode: 'ANY' as const },
-      timeout: { durationSeconds: 0, action: 'REJECTED' as const },
-    };
-
-    const result = await integratedService.startRequest(
-      {
-        workflowInstanceId: '7',
-        workflowVersionId: '3',
-        tenantNamespace: 'tenant-a',
-        temporalRunId: 'wf-7',
-        approvalWorkflowRunId: 'wf-approval-7-approval-1',
-        callbackToken: 'ext_cb_approval',
-        nodeId: 'approval-1',
-        configHash: hashNodeInstanceConfig(configSnapshot),
-        configSnapshot,
-        dynamicInputs: { orderId: 'SO-1001' },
-        approvalWorkflowInputs: {
-          title: '服务器权限申请',
-          content: { orderId: 'SO-1001' },
-        },
-      },
-      { userId: 'runtime:default' },
-    );
-
-    expect(result).toMatchObject({
-      approvalWorkflowInvocation: {
-        workflowId: '11',
-        workflow: {
-          title: '服务器权限申请',
-          content: { orderId: 'SO-1001' },
-          requestId: '42',
-          callbackToken: 'ext_cb_approval',
-          expiresAt: null,
-          candidates: [expect.objectContaining({ approverId: 'alice' })],
-        },
-      },
-    });
-    expect(
-      externalInteractions.createInteractionInTransaction,
-    ).toHaveBeenCalledWith(
-      expect.objectContaining({
-        callbackToken: 'ext_cb_approval',
-        handlerType: 'EXTERNAL_WAIT',
-        handlerConfig: { allowedOutcomes: ['RECEIVED'] },
-        temporalRunId: 'wf-approval-7-approval-1',
-        nodeId: 'approval-1',
-      }),
-      tx,
-    );
-  });
-});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/legacy-approval-config-migration.ts

@@ -1,227 +0,0 @@
-import { ApprovalConfigSnapshotDto } from './human-approval.dto';
-
-type ProviderKey = 'USER' | 'USER_GROUP';
-type MappingEntry = { provider: ProviderKey; ref: string };
-export type ApprovalSubjectMapping = Record<string, MappingEntry>;
-
-export type LegacyApprovalNormalization =
-  | { status: 'READY'; config: ApprovalConfigSnapshotDto }
-  | { status: 'ALREADY_CURRENT'; config: ApprovalConfigSnapshotDto }
-  | { status: 'REQUIRES_MAPPING'; refs: string[] }
-  | { status: 'INVALID'; errors: string[] };
-
-export function normalizeLegacyApprovalConfig(
-  input: unknown,
-  mapping: ApprovalSubjectMapping = {},
-): LegacyApprovalNormalization {
-  if (!isRecord(input)) return invalid('Config must be an object');
-  if (Array.isArray(input.subjects)) {
-    const normalized: Record<string, unknown> = {
-      ...input,
-      subjects: input.subjects.map((subject) =>
-        isRecord(subject) && subject.source === undefined
-          ? { ...subject, source: 'STATIC' }
-          : subject,
-      ),
-    };
-    delete normalized.membershipPolicy;
-    const current = validateCurrent(normalized);
-    return current.length
-      ? { status: 'INVALID', errors: current }
-      : {
-          status:
-            input.membershipPolicy === undefined &&
-            input.subjects.every(
-              (subject) => isRecord(subject) && subject.source !== undefined,
-            )
-              ? 'ALREADY_CURRENT'
-              : 'READY',
-          config: normalized as unknown as ApprovalConfigSnapshotDto,
-        };
-  }
-
-  const subjects = new Map<ProviderKey, string[]>();
-  const add = (provider: ProviderKey, ref: unknown, errors: string[]) => {
-    if (typeof ref !== 'string' || !ref.trim()) {
-      errors.push(`Invalid ${provider} reference`);
-      return;
-    }
-    const refs = subjects.get(provider) ?? [];
-    if (!refs.includes(ref.trim())) refs.push(ref.trim());
-    subjects.set(provider, refs);
-  };
-  const errors: string[] = [];
-  const unresolved: string[] = [];
-
-  for (const ref of array(input.approverUsers)) add('USER', ref, errors);
-  for (const ref of array(input.approverGroups)) add('USER_GROUP', ref, errors);
-  for (const approver of array(input.approvers)) {
-    if (typeof approver === 'string') {
-      const mapped = mapping[approver];
-      if (!mapped) unresolved.push(approver);
-      else add(mapped.provider, mapped.ref, errors);
-      continue;
-    }
-    if (!isRecord(approver)) {
-      errors.push('Invalid approver entry');
-      continue;
-    }
-    const provider =
-      approver.type === 'user'
-        ? 'USER'
-        : approver.type === 'group'
-        ? 'USER_GROUP'
-        : undefined;
-    if (!provider) errors.push('Approver type must be user or group');
-    else add(provider, approver.id, errors);
-  }
-  if (unresolved.length)
-    return {
-      status: 'REQUIRES_MAPPING',
-      refs: [...new Set(unresolved)].sort(),
-    };
-  if (!subjects.size) errors.push('At least one approver is required');
-
-  const approvalRule = normalizeRule(input, errors);
-  const rejectionRule = normalizeExplicitRule(input.rejectionRule, errors) ?? {
-    mode: 'ANY' as const,
-  };
-  const timeout = normalizeTimeout(input, errors);
-  if (errors.length || !approvalRule || !timeout)
-    return { status: 'INVALID', errors };
-
-  return {
-    status: 'READY',
-    config: {
-      subjects: [...subjects].map(([provider, refs]) => ({
-        source: 'STATIC' as const,
-        provider,
-        refs,
-      })),
-      approvalRule,
-      rejectionRule,
-      timeout,
-    },
-  };
-}
-
-function validateCurrent(input: Record<string, unknown>): string[] {
-  const errors: string[] = [];
-  normalizeExplicitRule(input.approvalRule, errors);
-  normalizeExplicitRule(input.rejectionRule, errors);
-  if (!isRecord(input.timeout)) errors.push('Invalid timeout');
-  else {
-    if (!nonNegativeInteger(input.timeout.durationSeconds))
-      errors.push('Invalid timeout durationSeconds');
-    if (!['APPROVED', 'REJECTED'].includes(String(input.timeout.action)))
-      errors.push('Invalid timeout action');
-  }
-  for (const subject of input.subjects as unknown[]) {
-    if (
-      !isRecord(subject) ||
-      !['STATIC', 'DYNAMIC'].includes(String(subject.source)) ||
-      typeof subject.provider !== 'string' ||
-      (subject.source === 'STATIC' &&
-        (!Array.isArray(subject.refs) || subject.refs.length === 0)) ||
-      (subject.source === 'DYNAMIC' &&
-        (typeof subject.inputKey !== 'string' || !subject.inputKey.trim()))
-    )
-      errors.push('Invalid subject');
-  }
-  return errors;
-}
-
-function normalizeRule(input: Record<string, unknown>, errors: string[]) {
-  const explicit = normalizeExplicitRule(input.approvalRule, errors);
-  if (explicit) return explicit;
-  const mode = input.approvalMode ?? 'any';
-  if (mode === 'any') return { mode: 'ANY' as const };
-  if (mode === 'all') return { mode: 'ALL' as const };
-  if (mode === 'percentage') {
-    const percentage = input.minApprovalCount;
-    if (!positiveInteger(percentage) || Number(percentage) > 100) {
-      errors.push(
-        'Percentage approval requires minApprovalCount from 1 to 100',
-      );
-      return undefined;
-    }
-    return { mode: 'PERCENTAGE' as const, percentage: Number(percentage) };
-  }
-  errors.push('Invalid approvalMode');
-  return undefined;
-}
-
-function normalizeExplicitRule(value: unknown, errors: string[]) {
-  if (value === undefined) return undefined;
-  if (!isRecord(value)) {
-    errors.push('Rule must be an object');
-    return undefined;
-  }
-  if (!['ANY', 'ALL', 'COUNT', 'PERCENTAGE'].includes(String(value.mode))) {
-    errors.push('Invalid rule mode');
-    return undefined;
-  }
-  const mode = value.mode as 'ANY' | 'ALL' | 'COUNT' | 'PERCENTAGE';
-  if (mode === 'COUNT' && !positiveInteger(value.count)) {
-    errors.push('COUNT rule requires a positive count');
-    return undefined;
-  }
-  if (
-    mode === 'PERCENTAGE' &&
-    (!positiveInteger(value.percentage) || Number(value.percentage) > 100)
-  ) {
-    errors.push('PERCENTAGE rule requires a percentage from 1 to 100');
-    return undefined;
-  }
-  return {
-    mode,
-    ...(mode === 'COUNT' && { count: Number(value.count) }),
-    ...(mode === 'PERCENTAGE' && {
-      percentage: Number(value.percentage),
-    }),
-  };
-}
-
-function normalizeTimeout(input: Record<string, unknown>, errors: string[]) {
-  if (isRecord(input.timeout)) {
-    if (!nonNegativeInteger(input.timeout.durationSeconds))
-      errors.push('Invalid timeout durationSeconds');
-    if (!['APPROVED', 'REJECTED'].includes(String(input.timeout.action)))
-      errors.push('Invalid timeout action');
-    if (errors.length) return undefined;
-    return {
-      durationSeconds: Number(input.timeout.durationSeconds),
-      action: input.timeout.action as 'APPROVED' | 'REJECTED',
-    };
-  }
-  const durationSeconds = input.timeout ?? 0;
-  if (!nonNegativeInteger(durationSeconds)) {
-    errors.push('Timeout must be a non-negative integer');
-    return undefined;
-  }
-  const legacyAction = input.timeoutAction ?? 'auto_reject';
-  if (!['auto_approve', 'auto_reject'].includes(String(legacyAction))) {
-    errors.push('Legacy timeout action must be auto_approve or auto_reject');
-    return undefined;
-  }
-  return {
-    durationSeconds: Number(durationSeconds),
-    action: legacyAction === 'auto_approve' ? 'APPROVED' : 'REJECTED',
-  } as const;
-}
-
-function invalid(message: string): LegacyApprovalNormalization {
-  return { status: 'INVALID', errors: [message] };
-}
-function array(value: unknown): unknown[] {
-  return value === undefined ? [] : Array.isArray(value) ? value : [value];
-}
-function nonNegativeInteger(value: unknown): boolean {
-  return typeof value === 'number' && Number.isInteger(value) && value >= 0;
-}
-function positiveInteger(value: unknown): boolean {
-  return typeof value === 'number' && Number.isInteger(value) && value > 0;
-}
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}

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

@@ -1,82 +0,0 @@
-import { validateWebhookResponseWorkflow } from './workflow-http-response';
-
-const trigger = {
-  id: 'webhook',
-  type: 'webhook_trigger',
-  config: {
-    responseMode: 'WAIT_FOR_RESULT',
-    responseTimeoutSeconds: 60,
-  },
-};
-
-const returnNode = (id: string) => ({
-  id,
-  type: 'return_result',
-  config: {},
-});
-
-describe('webhook function response contract', () => {
-  it('accepts conditional branches that each return their previous result', () => {
-    expect(() =>
-      validateWebhookResponseWorkflow({
-        nodes: [
-          trigger,
-          { id: 'branch', type: 'if_else', config: {} },
-          returnNode('accepted'),
-          returnNode('rejected'),
-        ],
-        edges: [
-          { source: 'webhook', target: 'branch', kind: 'FLOW' },
-          { source: 'branch', target: 'accepted', kind: 'FLOW' },
-          { source: 'branch', target: 'rejected', kind: 'FLOW' },
-        ],
-      }),
-    ).not.toThrow();
-  });
-
-  it('accepts returning the external request data directly', () => {
-    expect(() =>
-      validateWebhookResponseWorkflow({
-        nodes: [trigger, returnNode('return')],
-        edges: [{ source: 'webhook', target: 'return', kind: 'FLOW' }],
-      }),
-    ).not.toThrow();
-  });
-
-  it('rejects a function-mode webhook with a terminal branch that does not return', () => {
-    expect(() =>
-      validateWebhookResponseWorkflow({
-        nodes: [
-          trigger,
-          { id: 'branch', type: 'if_else', config: {} },
-          returnNode('accepted'),
-          { id: 'unfinished', type: 'code', config: {} },
-        ],
-        edges: [
-          { source: 'webhook', target: 'branch', kind: 'FLOW' },
-          { source: 'branch', target: 'accepted', kind: 'FLOW' },
-          { source: 'branch', target: 'unfinished', kind: 'FLOW' },
-        ],
-      }),
-    ).toThrow('等待返回结果时，每个流程分支都必须以“返回调用”结束');
-  });
-
-  it('rejects a return node with more than one previous node', () => {
-    expect(() =>
-      validateWebhookResponseWorkflow({
-        nodes: [
-          trigger,
-          { id: 'left', type: 'code', config: {} },
-          { id: 'right', type: 'code', config: {} },
-          returnNode('return'),
-        ],
-        edges: [
-          { source: 'webhook', target: 'left', kind: 'FLOW' },
-          { source: 'webhook', target: 'right', kind: 'FLOW' },
-          { source: 'left', target: 'return', kind: 'FLOW' },
-          { source: 'right', target: 'return', kind: 'FLOW' },
-        ],
-      }),
-    ).toThrow('“返回调用”前需要连接一个节点');
-  });
-});

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

@@ -1,111 +0,0 @@
-type DslNode = {
-  id?: unknown;
-  type?: unknown;
-  config?: unknown;
-};
-
-type DslEdge = {
-  source?: unknown;
-  target?: unknown;
-  kind?: unknown;
-  pairId?: unknown;
-};
-
-type DslLike = {
-  nodes?: DslNode[];
-  edges?: DslEdge[];
-};
-
-export function validateWebhookResponseWorkflow(dsl: unknown): void {
-  const graph = asDsl(dsl);
-  const nodes = graph.nodes ?? [];
-  const edges = (graph.edges ?? []).filter(
-    (edge) => (!edge.kind || edge.kind === 'FLOW') && !edge.pairId,
-  );
-  const waitingTriggers = nodes.filter(
-    (node) =>
-      node.type === 'webhook_trigger' &&
-      asRecord(node.config).responseMode === 'WAIT_FOR_RESULT',
-  );
-
-  for (const trigger of waitingTriggers) {
-    const config = asRecord(trigger.config);
-    const timeout = config.responseTimeoutSeconds ?? 60;
-    if (
-      typeof timeout !== 'number' ||
-      !Number.isInteger(timeout) ||
-      timeout < 1 ||
-      timeout > 300
-    ) {
-      throw new Error('等待返回结果的超时时间必须是 1 到 300 秒');
-    }
-    validateReturningBranches(nodes, edges, String(trigger.id));
-  }
-}
-
-function validateReturningBranches(
-  nodes: DslNode[],
-  edges: DslEdge[],
-  triggerId: string,
-): void {
-  const nodeById = new Map(
-    nodes
-      .filter((node) => typeof node.id === 'string')
-      .map((node) => [String(node.id), node]),
-  );
-  const outgoing = new Map<string, string[]>();
-  const incoming = new Map<string, string[]>();
-  for (const edge of edges) {
-    if (typeof edge.source !== 'string' || typeof edge.target !== 'string')
-      continue;
-    const targets = outgoing.get(edge.source) ?? [];
-    targets.push(edge.target);
-    outgoing.set(edge.source, targets);
-    const sources = incoming.get(edge.target) ?? [];
-    sources.push(edge.source);
-    incoming.set(edge.target, sources);
-  }
-
-  const queue = [...(outgoing.get(triggerId) ?? [])];
-  const visited = new Set<string>();
-  if (queue.length === 0) {
-    throw new Error('等待返回结果时，每个流程分支都必须以“返回调用”结束');
-  }
-
-  while (queue.length > 0) {
-    const nodeId = queue.shift()!;
-    if (visited.has(nodeId)) continue;
-    visited.add(nodeId);
-    const node = nodeById.get(nodeId);
-    if (!node) continue;
-    const next = outgoing.get(nodeId) ?? [];
-
-    if (node.type === 'return_result') {
-      validateReturnNode(next, incoming.get(nodeId) ?? []);
-      continue;
-    }
-    if (next.length === 0) {
-      throw new Error('等待返回结果时，每个流程分支都必须以“返回调用”结束');
-    }
-    queue.push(...next);
-  }
-}
-
-function validateReturnNode(next: string[], previous: string[]): void {
-  if (next.length > 0) {
-    throw new Error('“返回调用”必须是流程分支的最后一个节点');
-  }
-  if (previous.length !== 1) throw new Error('“返回调用”前需要连接一个节点');
-}
-
-function asDsl(value: unknown): DslLike {
-  return value && typeof value === 'object' && !Array.isArray(value)
-    ? (value as DslLike)
-    : {};
-}
-
-function asRecord(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/workflowEventOutbox/workflowEventOutbox.controller.spec.ts

@@ -1,54 +0,0 @@
-/// <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: [
-        {
-          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,
-    );
-  });
-
-  it('should be defined', () => {
-    expect(controller).toBeDefined();
-  });
-});