@gadmin2n/schematics 0.0.135 → 0.0.137

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/dsl/graph.ts

@@ -1,184 +0,0 @@
-import { DslNode, DslEdge, WorkflowDSL } from './types';
-
-/**
- * DAG representation of a workflow DSL.
- * Provides topological ordering and graph traversal utilities.
- */
-export interface GraphNode {
-  node: DslNode;
-  inEdges: DslEdge[];
-  outEdges: DslEdge[];
-}
-
-export interface ExecutionLevel {
-  nodes: DslNode[];
-}
-
-/**
- * Build a graph (adjacency list) from DSL nodes + edges.
- */
-export function buildGraph(dsl: WorkflowDSL): Map<string, GraphNode> {
-  const graph = new Map<string, GraphNode>();
-
-  for (const node of dsl.nodes) {
-    graph.set(node.id, { node, inEdges: [], outEdges: [] });
-  }
-
-  for (const edge of dsl.edges) {
-    const sourceNode = graph.get(edge.source);
-    const targetNode = graph.get(edge.target);
-    if (sourceNode) sourceNode.outEdges.push(edge);
-    if (targetNode) targetNode.inEdges.push(edge);
-  }
-
-  return graph;
-}
-
-/**
- * Find trigger nodes (nodes with category-type starting with *_trigger or no incoming edges).
- */
-export function findTriggerNodes(dsl: WorkflowDSL): DslNode[] {
-  const graph = buildGraph(dsl);
-  const triggers: DslNode[] = [];
-
-  for (const [, gn] of graph) {
-    if (
-      gn.node.type.endsWith('_trigger') ||
-      gn.inEdges.length === 0
-    ) {
-      triggers.push(gn.node);
-    }
-  }
-
-  return triggers;
-}
-
-/**
- * Get successor node IDs from a given node, optionally filtering by sourceHandle (for branches).
- */
-export function getSuccessors(
-  dsl: WorkflowDSL,
-  nodeId: string,
-  branchHandle?: string,
-): string[] {
-  return dsl.edges
-    .filter((e) => {
-      if (e.source !== nodeId) return false;
-      if (branchHandle !== undefined) return e.sourceHandle === branchHandle;
-      return true;
-    })
-    .map((e) => e.target);
-}
-
-/**
- * Topological sort using Kahn's algorithm.
- * Returns nodes in execution order. Nodes at the same "level" can be executed in parallel.
- */
-export function topologicalSort(dsl: WorkflowDSL, startNodeIds: string[]): ExecutionLevel[] {
-  const graph = buildGraph(dsl);
-  const levels: ExecutionLevel[] = [];
-
-  // Calculate in-degree (only count edges from nodes that are reachable from start)
-  const reachable = getReachableNodes(dsl, startNodeIds);
-  const inDegree = new Map<string, number>();
-
-  for (const id of reachable) {
-    inDegree.set(id, 0);
-  }
-
-  for (const edge of dsl.edges) {
-    if (reachable.has(edge.source) && reachable.has(edge.target)) {
-      inDegree.set(edge.target, (inDegree.get(edge.target) || 0) + 1);
-    }
-  }
-
-  // Start with provided start nodes (triggers already fired)
-  let currentLevel = startNodeIds.filter((id) => reachable.has(id));
-
-  while (currentLevel.length > 0) {
-    const levelNodes: DslNode[] = [];
-    const nextLevel: string[] = [];
-
-    for (const nodeId of currentLevel) {
-      const gn = graph.get(nodeId);
-      if (gn) levelNodes.push(gn.node);
-
-      // Decrease in-degree of successors
-      const successors = dsl.edges
-        .filter((e) => e.source === nodeId && reachable.has(e.target))
-        .map((e) => e.target);
-
-      for (const succ of successors) {
-        const deg = (inDegree.get(succ) || 0) - 1;
-        inDegree.set(succ, deg);
-        if (deg === 0) {
-          nextLevel.push(succ);
-        }
-      }
-    }
-
-    if (levelNodes.length > 0) {
-      levels.push({ nodes: levelNodes });
-    }
-
-    currentLevel = [...new Set(nextLevel)];
-  }
-
-  return levels;
-}
-
-/**
- * Get all node IDs reachable from a set of start nodes via BFS.
- */
-export function getReachableNodes(dsl: WorkflowDSL, startNodeIds: string[]): Set<string> {
-  const visited = new Set<string>();
-  const queue = [...startNodeIds];
-
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    if (visited.has(current)) continue;
-    visited.add(current);
-
-    const successors = dsl.edges
-      .filter((e) => e.source === current)
-      .map((e) => e.target);
-
-    for (const succ of successors) {
-      if (!visited.has(succ)) queue.push(succ);
-    }
-  }
-
-  return visited;
-}
-
-/**
- * Get the sub-graph (nodes + edges) reachable from given start nodes,
- * stopping at a set of boundary nodes.
- */
-export function getSubGraph(
-  dsl: WorkflowDSL,
-  startNodeIds: string[],
-  stopNodeIds: Set<string> = new Set(),
-): WorkflowDSL {
-  const visited = new Set<string>();
-  const queue = [...startNodeIds];
-
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    if (visited.has(current) || stopNodeIds.has(current)) continue;
-    visited.add(current);
-
-    const successors = dsl.edges
-      .filter((e) => e.source === current)
-      .map((e) => e.target);
-
-    for (const succ of successors) {
-      if (!visited.has(succ) && !stopNodeIds.has(succ)) queue.push(succ);
-    }
-  }
-
-  return {
-    nodes: dsl.nodes.filter((n) => visited.has(n.id)),
-    edges: dsl.edges.filter((e) => visited.has(e.source) && visited.has(e.target)),
-  };
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/dsl/helpers.ts

@@ -1,133 +0,0 @@
-/**
- * Pure helper functions for the DSL workflow interpreter.
- *
- * These functions are deterministic and have no side effects,
- * making them safe to import in Temporal workflow code and easy to unit test.
- */
-import type { WorkflowDSL, DslNode } from './types';
-
-// ─── Template Resolution ─────────────────────────────────────────────────────
-
-/**
- * Recursively resolve {{path}} template variables in an object.
- */
-export function resolveTemplates(obj: any, ctx: Record<string, any>): any {
-  if (typeof obj === 'string') {
-    return obj.replace(/\{\{(.+?)\}\}/g, (_, path) => {
-      const val = getNestedValue(ctx, path.trim());
-      return val !== undefined ? String(val) : '';
-    });
-  }
-  if (Array.isArray(obj)) return obj.map((v) => resolveTemplates(v, ctx));
-  if (obj && typeof obj === 'object') {
-    const result: Record<string, any> = {};
-    for (const [k, v] of Object.entries(obj)) {
-      result[k] = resolveTemplates(v, ctx);
-    }
-    return result;
-  }
-  return obj;
-}
-
-/**
- * Resolve a simple path expression against the context.
- * If the path resolves to a value, return it; otherwise return the raw string.
- */
-export function resolveExpression(expr: string, ctx: Record<string, any>): any {
-  const value = getNestedValue(ctx, expr);
-  if (value !== undefined) return value;
-  return expr;
-}
-
-// ─── Object Path Access ──────────────────────────────────────────────────────
-
-/**
- * Get a nested value from an object using dot notation.
- * e.g. getNestedValue({ a: { b: 1 } }, "a.b") → 1
- */
-export function getNestedValue(obj: Record<string, any>, path: string): any {
-  const parts = path.split('.');
-  let current: any = obj;
-  for (const part of parts) {
-    if (current == null) return undefined;
-    current = current[part];
-  }
-  return current;
-}
-
-// ─── Condition Evaluation ────────────────────────────────────────────────────
-
-/**
- * Evaluate multiple condition rules with AND/OR combining.
- */
-export function evaluateConditions(
-  conditions: Array<{ field: string; operator: string; value: string }>,
-  ctx: Record<string, any>,
-  combineOp: 'AND' | 'OR',
-): boolean {
-  if (conditions.length === 0) return true;
-  const results = conditions.map((rule) => {
-    const fieldValue = getNestedValue(ctx, rule.field);
-    return evaluateRule(fieldValue, rule.operator, rule.value);
-  });
-  return combineOp === 'AND' ? results.every(Boolean) : results.some(Boolean);
-}
-
-/**
- * Evaluate a single condition rule.
- */
-export function evaluateRule(fieldValue: any, operator: string, compareValue: string): boolean {
-  switch (operator) {
-    case 'equals':
-    case '==':
-      return String(fieldValue) === compareValue;
-    case 'notEquals':
-    case '!=':
-      return String(fieldValue) !== compareValue;
-    case 'contains':
-      return String(fieldValue).includes(compareValue);
-    case 'notContains':
-      return !String(fieldValue).includes(compareValue);
-    case 'greaterThan':
-    case '>':
-      return Number(fieldValue) > Number(compareValue);
-    case 'lessThan':
-    case '<':
-      return Number(fieldValue) < Number(compareValue);
-    case 'greaterThanOrEqual':
-    case '>=':
-      return Number(fieldValue) >= Number(compareValue);
-    case 'lessThanOrEqual':
-    case '<=':
-      return Number(fieldValue) <= Number(compareValue);
-    case 'isEmpty':
-      return fieldValue == null || fieldValue === '';
-    case 'isNotEmpty':
-      return fieldValue != null && fieldValue !== '';
-    default:
-      return false;
-  }
-}
-
-// ─── Graph Navigation ────────────────────────────────────────────────────────
-
-/**
- * Get successor node IDs from a list of source node IDs.
- */
-export function getSuccessorsFromNodes(dsl: WorkflowDSL, nodeIds: string[]): string[] {
-  return dsl.edges.filter((e) => nodeIds.includes(e.source)).map((e) => e.target);
-}
-
-/**
- * Determine next nodes to execute based on the current node and optional branch.
- * For condition nodes, follows only the matching branch edge.
- */
-export function getNextNodes(dsl: WorkflowDSL, node: DslNode, branch?: string): string[] {
-  if (branch !== undefined) {
-    const branchEdges = dsl.edges.filter(
-      (e) => e.source === node.id && e.sourceHandle === branch,
-    );
-    if (branchEdges.length > 0) return branchEdges.map((e) => e.target);
-  }
-  return dsl.edges.filter((e) => e.source === node.id).map((e) => e.target);
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/dsl/node-types.ts

@@ -1,96 +0,0 @@
-/**
- * Node type metadata. Source of truth for which node types exist and
- * what handle ids each one declares.
- *
- * outputs semantics:
- *   null      = dynamic (handles derived from config at render/validate time, e.g. switch)
- *   []        = single anonymous source (no named sourceHandle on outgoing edges)
- *   ['a','b'] = enumerated named handles (each outgoing edge MUST have sourceHandle ∈ outputs)
- *
- * MUST stay in sync with server/seed/workflow-node-types.ts and the
- * t_workflow_node_type.outputs column. Validators read this map.
- */
-export interface NodeTypeMeta {
-  outputs: string[] | null;
-}
-
-/**
- * Canonical tuple of all workflow node types.
- *
- * Preserved as an `as const` tuple (in addition to NODE_TYPE_META below)
- * so that consumers like DslNode.type and the executeNode switch keep
- * compile-time literal-union types and exhaustiveness checks.
- *
- * The order and contents MUST match the keys of NODE_TYPE_META.
- */
-export const ALL_NODE_TYPES = [
-  // TRIGGER
-  'cron_trigger',
-  'webhook_trigger',
-  'event_trigger',
-  'manual_trigger',
-  // ACTION (calls an activity)
-  'http_request',
-  'db_query',
-  'db_execute',
-  'send_notification',
-  'code',
-  // DATA PROCESSING (inline logic)
-  'set_variable',
-  // CONDITION (inline logic)
-  'if_else',
-  'switch',
-  // FLOW CONTROL
-  'for_each',
-  'delay',
-  'parallel',
-  'error_handler',
-  // APPROVAL (Temporal signal)
-  'approval',
-  // SUB WORKFLOW
-  'sub_workflow',
-] as const;
-
-/** Union of all supported node type strings. */
-export type NodeType = (typeof ALL_NODE_TYPES)[number];
-
-export const NODE_TYPE_META: Record<NodeType, NodeTypeMeta> = {
-  cron_trigger:      { outputs: [] },
-  webhook_trigger:   { outputs: [] },
-  event_trigger:     { outputs: [] },
-  manual_trigger:    { outputs: [] },
-  http_request:      { outputs: [] },
-  db_query:          { outputs: [] },
-  db_execute:        { outputs: [] },
-  send_notification: { outputs: [] },
-  code:              { outputs: [] },
-  set_variable:      { outputs: [] },
-  if_else:           { outputs: ['true', 'false'] },
-  switch:            { outputs: null },
-  for_each:          { outputs: [] },
-  delay:             { outputs: [] },
-  parallel:          { outputs: [] },
-  error_handler:     { outputs: [] },
-  approval:          { outputs: [] },
-  sub_workflow:      { outputs: [] },
-};
-
-/** Node types that require a Temporal activity call. */
-export const ACTIVITY_NODE_TYPES = [
-  'http_request',
-  'db_query',
-  'db_execute',
-  'send_notification',
-  'code',
-] as const satisfies readonly NodeType[];
-
-export type ActivityNodeType = (typeof ACTIVITY_NODE_TYPES)[number];
-
-/**
- * Compile-time exhaustiveness check.
- * Place in the `default` of a switch over NodeType — if a case is missing,
- * TypeScript emits: "Argument of type 'X' is not assignable to parameter of type 'never'."
- */
-export function assertNever(x: never): never {
-  throw new Error(`Unhandled node type: ${x}`);
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/dsl/types.ts

@@ -1,77 +0,0 @@
-// ─── DSL Types (mirrors frontend WorkflowDSL) ─────────────────────────────────
-
-import type { NodeType } from './node-types';
-
-export interface DslNode {
-  id: string;
-  type: NodeType;
-  label: string;
-  position: { x: number; y: number };
-  config: Record<string, any>;
-}
-
-export interface DslEdge {
-  id: string;
-  source: string;
-  target: string;
-  sourceHandle?: string; // for condition branches: "true"/"false" or case labels
-  label?: string;
-}
-
-export interface WorkflowDSL {
-  nodes: DslNode[];
-  edges: DslEdge[];
-}
-
-// ─── Workflow Execution Types ──────────────────────────────────────────────────
-
-export interface WorkflowInput {
-  instanceId: number;
-  workflowId: number;
-  versionId: number;
-  dsl: WorkflowDSL;
-  context: Record<string, any>;
-}
-
-export interface WorkflowResult {
-  status: 'COMPLETED' | 'FAILED' | 'CANCELLED';
-  context: Record<string, any>;
-  error?: string;
-}
-
-// ─── Node Execution Context ───────────────────────────────────────────────────
-
-export interface NodeExecutionResult {
-  output: Record<string, any>;
-  branch?: string; // For condition nodes: which branch to take
-}
-
-export type NodeStatus = 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED';
-
-// ─── Activity Input Types ─────────────────────────────────────────────────────
-
-export interface ReportNodeStatusInput {
-  instanceId: number;
-  nodeId: string;
-  nodeType: string;
-  nodeLabel?: string;
-  status: NodeStatus;
-  input?: Record<string, any>;
-  output?: Record<string, any>;
-  error?: Record<string, any>;
-}
-
-export interface ReportWorkflowStatusInput {
-  instanceId: number;
-  status: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED';
-  result?: Record<string, any>;
-}
-
-// ─── Signals ──────────────────────────────────────────────────────────────────
-
-export interface ApprovalSignalPayload {
-  nodeId: string;
-  approved: boolean;
-  comment?: string;
-  approvedBy: string;
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/dsl/validate.ts

@@ -1,109 +0,0 @@
-/**
- * DSL handle validator. Confirms each edge's sourceHandle matches the
- * source node's declared outputs (or, for dynamic nodes like switch,
- * matches a value derived from config).
- *
- * Used at workflow publish time (server-side via a duplicated copy)
- * and optionally during DSL parsing on the worker side.
- */
-
-import type { WorkflowDSL, DslNode } from './types';
-import { NODE_TYPE_META } from './node-types';
-
-export type DslValidationCode =
-  | 'EXTRA_HANDLE'      // node has [] outputs, but edge set sourceHandle
-  | 'MISSING_HANDLE'    // node has named outputs, but edge has no sourceHandle (or empty string)
-  | 'UNKNOWN_HANDLE';   // edge sourceHandle is set but ∉ declared outputs
-
-export interface DslValidationError {
-  edgeId: string;
-  source: string;
-  target: string;
-  code: DslValidationCode;
-  reason: string;
-}
-
-/**
- * Validate every edge's sourceHandle against the source node's outputs metadata.
- *
- * Rules per source node's outputs:
- *  - outputs === null:  dynamic — handles must come from deriveDynamicOutputs(node).
- *                       Edge sourceHandle MUST be present and ∈ derived list, OR if the
- *                       derived list is empty (config not yet filled), no constraint.
- *  - outputs === []:    edge sourceHandle MUST be undefined (no named handles allowed).
- *  - outputs.length>0:  edge sourceHandle MUST be present and ∈ outputs.
- *
- * Returns an array of errors (empty if DSL is valid).
- */
-export function validateDslHandles(dsl: WorkflowDSL): DslValidationError[] {
-  const errors: DslValidationError[] = [];
-  const nodeMap = new Map<string, DslNode>(dsl.nodes.map((n) => [n.id, n]));
-
-  for (const edge of dsl.edges) {
-    const src = nodeMap.get(edge.source);
-    if (!src) continue; // separate concern (orphan edge); not this validator's job
-
-    const meta = NODE_TYPE_META[src.type];
-    if (!meta) continue; // guards against retired/unknown node types from older DSLs
-
-    const handles = meta.outputs === null
-      ? deriveDynamicOutputs(src)
-      : meta.outputs;
-
-    if (meta.outputs !== null && handles.length === 0) {
-      // Single anonymous output: sourceHandle must be absent
-      if (edge.sourceHandle != null && edge.sourceHandle !== '') {
-        errors.push({
-          edgeId: edge.id,
-          source: edge.source,
-          target: edge.target,
-          code: 'EXTRA_HANDLE',
-          reason: `Node "${src.type}" has no named output handles; edge must not set sourceHandle (got "${edge.sourceHandle}").`,
-        });
-      }
-      continue;
-    }
-
-    // Enumerated or dynamic non-empty: sourceHandle required and must match
-    if (handles.length === 0) {
-      // Dynamic + config not yet filled: skip rather than block edits in progress
-      continue;
-    }
-    if (edge.sourceHandle == null || edge.sourceHandle === '') {
-      errors.push({
-        edgeId: edge.id,
-        source: edge.source,
-        target: edge.target,
-        code: 'MISSING_HANDLE',
-        reason: `Node "${src.type}" requires a sourceHandle; choose one of: ${handles.join(', ')}.`,
-      });
-      continue;
-    }
-    if (!handles.includes(edge.sourceHandle)) {
-      errors.push({
-        edgeId: edge.id,
-        source: edge.source,
-        target: edge.target,
-        code: 'UNKNOWN_HANDLE',
-        reason: `Node "${src.type}" sourceHandle "${edge.sourceHandle}" is not in declared outputs: ${handles.join(', ')}.`,
-      });
-    }
-  }
-
-  return errors;
-}
-
-/**
- * For dynamic-output nodes (currently just `switch`), derive the list of
- * handle ids from the node's config.
- */
-function deriveDynamicOutputs(node: DslNode): string[] {
-  if (node.type === 'switch') {
-    const cases = (node.config as any)?.cases as Array<{ value?: string }> | undefined;
-    if (!Array.isArray(cases)) return [];
-    return cases
-      .map((c) => c?.value)
-      .filter((v): v is string => typeof v === 'string' && v.length > 0);
-  }
-  return [];
-}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/index.ts

@@ -1,101 +0,0 @@
-import * as http from 'http';
-import { NativeConnection, Worker } from '@temporalio/worker';
-import * as activities from './activities';
-import { config } from './config';
-import { startOutboxPoller } from './outbox-poller';
-
-// 顶层状态：health server 与 shutdown handler 共享
-let isReady = false;
-let isShuttingDown = false;
-
-async function run() {
-  console.log(`[Worker] Connecting to Temporal at ${config.temporal.address}...`);
-
-  const connection = await NativeConnection.connect({
-    address: config.temporal.address,
-  });
-
-  const worker = await Worker.create({
-    connection,
-    namespace: config.temporal.namespace,
-    taskQueue: config.temporal.taskQueue,
-    workflowsPath: require.resolve('./workflows/dsl-workflow'),
-    activities,
-  });
-
-  console.log(`[Worker] Started. Polling task queue: ${config.temporal.taskQueue}`);
-  console.log(`[Worker] Namespace: ${config.temporal.namespace}`);
-
-  // event_trigger workflow 的 outbox poller
-  const outboxPoller = await startOutboxPoller();
-
-  // K8s probe 用的 HTTP health server
-  const healthServer = startHealthServer();
-
-  // 优雅关闭协调器
-  const shutdown = async (signal: string) => {
-    if (isShuttingDown) return;
-    isShuttingDown = true;
-    console.log(`[Worker] ${signal} received, beginning graceful shutdown...`);
-
-    // 1. worker.shutdown() 是同步调用，触发 worker.run() 在当前 activity/workflow 完成后 resolve
-    worker.shutdown();
-    console.log('[Worker] worker.shutdown() called, draining in-flight tasks');
-
-    // 2. 停止 outbox poller，释放其 PG / Temporal client 连接
-    try {
-      await outboxPoller.stop();
-    } catch (err) {
-      console.error('[Worker] OutboxPoller stop error:', err);
-    }
-
-    // 3. 关闭 health server（停止 K8s probe 请求）
-    await new Promise<void>((resolve) => healthServer.close(() => resolve()));
-    console.log('[Worker] Health server closed');
-  };
-
-  process.on('SIGTERM', () => void shutdown('SIGTERM'));
-  process.on('SIGINT', () => void shutdown('SIGINT'));
-
-  isReady = true;
-
-  // worker.run() 会一直阻塞到 worker.shutdown() 被调用并且 in-flight 任务全部 drain
-  await worker.run();
-
-  // worker.run() resolve 之后再关闭 NativeConnection（worker 仍在用它的时候不能关）
-  await connection.close();
-  console.log('[Worker] Temporal connection closed. Bye.');
-}
-
-/**
- * 最简 HTTP health 端点，用于 K8s liveness/readiness probe。
- * - /health/live  — 进程存活就返回 200
- * - /health/ready — 处于运行中且未进入 shutdown 才返回 200，否则 503
- */
-function startHealthServer(): http.Server {
-  const port = Number(process.env.WORKER_HEALTH_PORT) || 8081;
-  const server = http.createServer((req, res) => {
-    if (req.url === '/health/live') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: 'ok' }));
-      return;
-    }
-    if (req.url === '/health/ready') {
-      const ok = isReady && !isShuttingDown;
-      res.writeHead(ok ? 200 : 503, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: ok ? 'ok' : 'shutting_down' }));
-      return;
-    }
-    res.writeHead(404);
-    res.end();
-  });
-  server.listen(port, () => {
-    console.log(`[Worker] Health server listening on :${port}`);
-  });
-  return server;
-}
-
-run().catch((err) => {
-  console.error('[Worker] Fatal error:', err);
-  process.exit(1);
-});