@gadmin2n/schematics 0.0.144 → 0.0.146

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/workflowDateTime.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import {
+  formatWorkflowUtcDate,
+  formatWorkflowUtcDateTime,
+} from './workflowDateTime';
+
+describe('formatWorkflowUtcDateTime', () => {
+  it('always displays an absolute timestamp in UTC', () => {
+    expect(formatWorkflowUtcDateTime('2026-08-18T17:44:16.000Z')).toBe(
+      '2026-08-18 17:44:16 UTC',
+    );
+    expect(formatWorkflowUtcDateTime('2026-08-19T01:44:16+08:00')).toBe(
+      '2026-08-18 17:44:16 UTC',
+    );
+  });
+
+  it('renders missing or invalid timestamps as empty data', () => {
+    expect(formatWorkflowUtcDateTime(null)).toBe('—');
+    expect(formatWorkflowUtcDateTime('not-a-date')).toBe('—');
+  });
+
+  it('uses the UTC calendar date for compact table cells', () => {
+    expect(formatWorkflowUtcDate('2026-08-19T01:30:00+08:00')).toBe(
+      '2026-08-18',
+    );
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/workflowDateTime.ts

@@ -0,0 +1,33 @@
+type WorkflowDateTimeValue = string | number | Date | null | undefined;
+
+function pad(value: number): string {
+  return String(value).padStart(2, '0');
+}
+
+function parseDate(value: WorkflowDateTimeValue): Date | null {
+  if (value === null || value === undefined || value === '') return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+export function formatWorkflowUtcDateTime(
+  value: WorkflowDateTimeValue,
+): string {
+  const date = parseDate(value);
+  if (!date) return '—';
+
+  return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(
+    date.getUTCDate(),
+  )} ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(
+    date.getUTCSeconds(),
+  )} UTC`;
+}
+
+export function formatWorkflowUtcDate(value: WorkflowDateTimeValue): string {
+  const date = parseDate(value);
+  if (!date) return '—';
+
+  return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(
+    date.getUTCDate(),
+  )}`;
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/workflowHistory.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import {
+  emptyWorkflowHistory,
+  pushWorkflowHistory,
+  redoWorkflowHistory,
+  undoWorkflowHistory,
+} from './workflowHistory';
+
+describe('workflow history', () => {
+  it('moves snapshots between undo and redo stacks', () => {
+    const initial = { nodes: ['start'], edges: [] };
+    const edited = { nodes: ['start', 'action'], edges: ['flow'] };
+    const history = pushWorkflowHistory(emptyWorkflowHistory(), initial);
+
+    const undone = undoWorkflowHistory(history, edited);
+    expect(undone?.value).toEqual(initial);
+    expect(undone?.history.past).toEqual([]);
+    expect(undone?.history.future).toEqual([edited]);
+
+    const redone = redoWorkflowHistory(undone!.history, initial);
+    expect(redone?.value).toEqual(edited);
+    expect(redone?.history.past).toEqual([initial]);
+    expect(redone?.history.future).toEqual([]);
+  });
+
+  it('clears redo snapshots after a new edit', () => {
+    const history = {
+      past: [{ value: 1 }],
+      future: [{ value: 3 }],
+    };
+
+    expect(pushWorkflowHistory(history, { value: 2 }).future).toEqual([]);
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/workflowHistory.ts

@@ -0,0 +1,52 @@
+export interface WorkflowHistory<T> {
+  past: T[];
+  future: T[];
+}
+
+const MAX_HISTORY_LENGTH = 50;
+
+export function emptyWorkflowHistory<T>(): WorkflowHistory<T> {
+  return { past: [], future: [] };
+}
+
+export function pushWorkflowHistory<T>(
+  history: WorkflowHistory<T>,
+  snapshot: T,
+): WorkflowHistory<T> {
+  return {
+    past: [...history.past, snapshot].slice(-MAX_HISTORY_LENGTH),
+    future: [],
+  };
+}
+
+export function undoWorkflowHistory<T>(
+  history: WorkflowHistory<T>,
+  current: T,
+): { history: WorkflowHistory<T>; value: T } | null {
+  const value = history.past.at(-1);
+  if (value === undefined) return null;
+
+  return {
+    value,
+    history: {
+      past: history.past.slice(0, -1),
+      future: [...history.future, current],
+    },
+  };
+}
+
+export function redoWorkflowHistory<T>(
+  history: WorkflowHistory<T>,
+  current: T,
+): { history: WorkflowHistory<T>; value: T } | null {
+  const value = history.future.at(-1);
+  if (value === undefined) return null;
+
+  return {
+    value,
+    history: {
+      past: [...history.past, current].slice(-MAX_HISTORY_LENGTH),
+      future: history.future.slice(0, -1),
+    },
+  };
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/workflowPublishError.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest';
+import {
+  describeWorkflowPublishError,
+  workflowPublishErrorMessage,
+} from './workflowPublishError';
+
+describe('describeWorkflowPublishError', () => {
+  it('keeps the node name and every server validation detail', () => {
+    expect(
+      describeWorkflowPublishError(
+        {
+          message: 'Bad Request: undefined',
+          response: {
+            data: {
+              code: 'NODE_CONFIG_INVALID',
+              message: '配置不完整或有误',
+              nodeLabel: '人工审批',
+              nodeId: 'internal-node-uuid',
+              errors: [
+                {
+                  path: '/subjects',
+                  message: 'must NOT have fewer than 1 items',
+                },
+                {
+                  path: '/task/title',
+                  message: "must have required property 'source'",
+                },
+              ],
+            },
+          },
+        },
+        '发布失败',
+      ),
+    ).toEqual({
+      summary: '节点“人工审批”：配置不完整或有误',
+      details: [
+        '/subjects：must NOT have fewer than 1 items',
+        "/task/title：must have required property 'source'",
+      ],
+    });
+  });
+
+  it('falls back without exposing an internal node id', () => {
+    expect(
+      describeWorkflowPublishError(
+        {
+          message: 'Bad Request: undefined',
+          response: { data: { nodeId: 'internal-node-uuid' } },
+        },
+        '发布失败，请检查工作流配置',
+      ),
+    ).toEqual({
+      summary: '发布失败，请检查工作流配置',
+      details: [],
+    });
+  });
+
+  it('uses validation issues instead of the generic Bad Request message', () => {
+    expect(
+      workflowPublishErrorMessage(
+        {
+          message: 'Bad Request: Bad Request Exception',
+          response: {
+            data: {
+              message: 'Bad Request Exception',
+              issues: [
+                {
+                  path: '/subjects/0/refs',
+                  message: 'refs must be a non-empty array',
+                },
+              ],
+            },
+          },
+        },
+        '发布检查未通过，请检查工作流配置',
+      ),
+    ).toBe(
+      '发布检查未通过，请检查工作流配置；/subjects/0/refs：refs must be a non-empty array',
+    );
+  });
+
+  it('explains a missing server widget when the response has no details array', () => {
+    expect(
+      workflowPublishErrorMessage(
+        {
+          message: 'Bad Request: Bad Request Exception',
+          response: {
+            data: {
+              code: 'NODE_WIDGET_NOT_REGISTERED',
+              message: 'Bad Request Exception',
+              widget: 'manual-trigger-config',
+            },
+          },
+        },
+        '发布检查未通过，请检查工作流配置',
+      ),
+    ).toBe('服务端尚未启用当前节点所需的配置组件，请重启服务后重试');
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/workflowPublishError.ts

@@ -0,0 +1,91 @@
+export interface WorkflowPublishErrorDescription {
+  summary: string;
+  details: string[];
+}
+
+export function describeWorkflowPublishError(
+  error: unknown,
+  fallback: string,
+): WorkflowPublishErrorDescription {
+  const value = asRecord(error);
+  const response = asRecord(value.response);
+  const data = asRecord(response.data);
+  const serverMessage = textValue(data.message);
+  const errorMessage = textValue(value.message);
+  const codeMessage = publishErrorCodeMessage(textValue(data.code));
+  const validationDetails = Array.isArray(data.errors)
+    ? data.errors
+    : Array.isArray(data.issues)
+      ? data.issues
+      : [];
+  const details = validationDetails.flatMap((item) => {
+    if (typeof item === 'string' && item.trim()) return [item.trim()];
+    const detail = asRecord(item);
+    const message = textValue(detail.message);
+    if (!message) return [];
+    const path = textValue(detail.path);
+    return [path && path !== '/' ? `${path}：${message}` : message];
+  });
+  const summary =
+    usableMessage(serverMessage) ??
+    codeMessage ??
+    usableMessage(errorMessage) ??
+    fallback;
+  const nodeLabel = textValue(data.nodeLabel);
+
+  return {
+    summary:
+      nodeLabel && !summary.includes(nodeLabel)
+        ? `节点“${nodeLabel}”：${summary}`
+        : summary,
+    details: [...new Set(details.filter((detail) => detail !== summary))],
+  };
+}
+
+function publishErrorCodeMessage(code: string): string | null {
+  switch (code) {
+    case 'NODE_WIDGET_NOT_REGISTERED':
+      return '服务端尚未启用当前节点所需的配置组件，请重启服务后重试';
+    case 'NODE_CONFIG_INVALID':
+      return '节点配置不完整或有误';
+    case 'SUBJECT_REF_INVALID':
+      return '审批人配置不完整或无效';
+    default:
+      return null;
+  }
+}
+
+export function workflowPublishErrorMessage(
+  error: unknown,
+  fallback: string,
+): string {
+  const description = describeWorkflowPublishError(error, fallback);
+  return [description.summary, ...description.details].join('；');
+}
+
+function textValue(value: unknown): string {
+  if (Array.isArray(value))
+    return value
+      .filter((item): item is string => typeof item === 'string')
+      .map((item) => item.trim())
+      .filter(Boolean)
+      .join('；');
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function usableMessage(value: string): string | null {
+  if (
+    !value ||
+    /^(bad request( exception)?)(:\s*(bad request exception|undefined|null)?)?$/i.test(
+      value,
+    )
+  )
+    return null;
+  return value;
+}
+
+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/web/src/routes/workflow/utils/workflowSkillPrompt.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildWorkflowHandlePrompt,
+  buildWorkflowSkillPrompt,
+  selectWorkflowPromptNodeTypes,
+  WORKFLOW_NODE_SKILL_DOCS,
+  WORKFLOW_NODE_TYPES,
+} from './workflowSkillPrompt';
+
+describe('workflowSkillPrompt', () => {
+  it('covers every supported Workflow node type', () => {
+    expect(WORKFLOW_NODE_TYPES).toEqual([
+      'cron_trigger',
+      'manual_trigger',
+      'webhook_trigger',
+      'event_trigger',
+      'http_request',
+      'db_execute',
+      'code',
+      'if_else',
+      'switch',
+      'for_each',
+      'delay',
+      'parallel',
+      'approval',
+      'callable_trigger',
+      'external_wait',
+      'sub_workflow',
+    ]);
+    expect(Object.keys(WORKFLOW_NODE_SKILL_DOCS)).toHaveLength(16);
+  });
+
+  it('mounts the main skill and only the requested node documents', () => {
+    const prompt = buildWorkflowSkillPrompt(['for_each', 'sub_workflow']);
+
+    expect(prompt).toContain('.claude/skills/workflow/SKILL.md');
+    expect(prompt).toContain('.claude/skills/workflow/dsl-and-connections.md');
+    expect(prompt).toContain('.claude/skills/workflow/for-each.md');
+    expect(prompt).toContain('.claude/skills/workflow/sub-workflow.md');
+    expect(prompt).not.toContain('.claude/skills/workflow/cron-trigger.md');
+    expect(prompt).not.toContain('return_result');
+  });
+
+  it('only includes the target node metadata when editing one node', () => {
+    const nodeTypes = [
+      { type: 'cron_trigger' },
+      { type: 'sub_workflow' },
+      { type: 'code' },
+    ];
+
+    expect(selectWorkflowPromptNodeTypes(nodeTypes, 'sub_workflow')).toEqual([
+      { type: 'sub_workflow' },
+    ]);
+    expect(selectWorkflowPromptNodeTypes(nodeTypes)).toBe(nodeTypes);
+  });
+
+  it('uses the same fixed HTTP and Code handles as the canvas', () => {
+    const prompt = buildWorkflowHandlePrompt([
+      { type: 'manual_trigger', outputs: [] },
+      { type: 'http_request', outputs: [] },
+      { type: 'code', outputs: [] },
+    ]);
+
+    expect(prompt).toContain(
+      "http_request：sourceHandle 必须是 ['response-out']",
+    );
+    expect(prompt).toContain(
+      "进入 http_request：targetHandle 必须是 'request-in'",
+    );
+    expect(prompt).toContain("code：sourceHandle 必须是 ['result-out']");
+    expect(prompt).toContain("进入 code：targetHandle 必须是 'data-in'");
+    expect(prompt).toContain('其余节点类型（manual_trigger）');
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/workflowSkillPrompt.ts

@@ -0,0 +1,120 @@
+export const WORKFLOW_NODE_SKILL_DOCS = {
+  cron_trigger: 'cron-trigger.md',
+  manual_trigger: 'manual-trigger.md',
+  webhook_trigger: 'webhook-trigger.md',
+  event_trigger: 'event-trigger.md',
+  http_request: 'http-request.md',
+  db_execute: 'db-execute.md',
+  code: 'code.md',
+  if_else: 'if-else.md',
+  switch: 'switch.md',
+  for_each: 'for-each.md',
+  delay: 'delay.md',
+  parallel: 'parallel.md',
+  approval: 'approval.md',
+  callable_trigger: 'callable-trigger.md',
+  external_wait: 'external-wait.md',
+  sub_workflow: 'sub-workflow.md',
+} as const;
+
+export const WORKFLOW_NODE_TYPES = Object.keys(WORKFLOW_NODE_SKILL_DOCS);
+
+export const WORKFLOW_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' },
+};
+
+const WORKFLOW_SKILL_PATH = '.claude/skills/workflow/SKILL.md';
+const WORKFLOW_DSL_AND_CONNECTIONS_PATH =
+  '.claude/skills/workflow/dsl-and-connections.md';
+
+export function selectWorkflowPromptNodeTypes<T extends { type: string }>(
+  nodeTypes: readonly T[],
+  targetNodeType?: string,
+): readonly T[] {
+  if (!targetNodeType) return nodeTypes;
+  const target = nodeTypes.find((nodeType) => nodeType.type === targetNodeType);
+  return target ? [target] : nodeTypes;
+}
+
+export function buildWorkflowHandlePrompt(
+  nodeTypes: readonly { type: string; outputs: string[] | null }[],
+): string {
+  const enumeratedHandleRules = nodeTypes
+    .filter(
+      (nodeType) =>
+        WORKFLOW_RUNTIME_MAIN_FLOW_PORTS[nodeType.type] ||
+        (Array.isArray(nodeType.outputs) && nodeType.outputs.length > 0),
+    )
+    .map((nodeType) => {
+      const handles = WORKFLOW_RUNTIME_MAIN_FLOW_PORTS[nodeType.type]
+        ? [WORKFLOW_RUNTIME_MAIN_FLOW_PORTS[nodeType.type].output]
+        : nodeType.outputs!;
+      return `  - ${nodeType.type}：sourceHandle 必须是 [${handles
+        .map((handle) => `'${handle}'`)
+        .join(', ')}] 之一`;
+    });
+  const dynamicHandleRules = nodeTypes
+    .filter((nodeType) => nodeType.outputs === null)
+    .map(
+      (nodeType) =>
+        `  - ${nodeType.type}：sourceHandle 必须是 config.cases[].id 中的稳定 ID，或 'default'`,
+    );
+  const noHandleTypes = nodeTypes
+    .filter(
+      (nodeType) =>
+        !WORKFLOW_RUNTIME_MAIN_FLOW_PORTS[nodeType.type] &&
+        Array.isArray(nodeType.outputs) &&
+        nodeType.outputs.length === 0,
+    )
+    .map((nodeType) => nodeType.type);
+  const targetHandleRules = nodeTypes
+    .filter((nodeType) => WORKFLOW_RUNTIME_MAIN_FLOW_PORTS[nodeType.type])
+    .map(
+      (nodeType) =>
+        `  - 进入 ${nodeType.type}：targetHandle 必须是 '${WORKFLOW_RUNTIME_MAIN_FLOW_PORTS[nodeType.type].input}'`,
+    );
+
+  return `FLOW 连线出口规则（sourceHandle 必须与源节点输出一致）：
+${[...enumeratedHandleRules, ...dynamicHandleRules].join('\n')}
+${
+  noHandleTypes.length > 0
+    ? `其余节点类型（${noHandleTypes.join(
+        ', ',
+      )}）没有命名出口，边中必须省略 sourceHandle。`
+    : ''
+}
+
+FLOW 连线入口规则：
+${targetHandleRules.join('\n')}
+进入其余节点时必须省略 targetHandle。CALL/RETURN 私有管道使用 Workflow Skill 规定的命名端口。`;
+}
+
+export function buildWorkflowSkillPrompt(nodeTypes: readonly string[]): string {
+  const nodeDocs = [...new Set(nodeTypes)]
+    .map((nodeType) => {
+      const filename =
+        WORKFLOW_NODE_SKILL_DOCS[
+          nodeType as keyof typeof WORKFLOW_NODE_SKILL_DOCS
+        ];
+      return filename
+        ? `- \`${nodeType}\`：\`.claude/skills/workflow/${filename}\``
+        : null;
+    })
+    .filter((line): line is string => Boolean(line));
+
+  const parts = [
+    '严格按照以下 skill 和节点规范完成任务，开始前先读取对应文件：',
+    `1. **workflow skill**（位于 \`${WORKFLOW_SKILL_PATH}\`）：Workflow DSL、画布拓扑和节点路由总规范。`,
+    `2. **DSL 与画布连线规范**（位于 \`${WORKFLOW_DSL_AND_CONNECTIONS_PATH}\`）：生成 nodes/edges，处理 FLOW、CALL、RETURN、handle、分支和完整性校验。`,
+  ];
+
+  if (nodeDocs.length > 0) {
+    parts.push('3. **本次可用的节点规范**：', ...nodeDocs);
+  }
+
+  return parts.join('\n');
+}