@gadmin2n/schematics 0.0.72 → 0.0.74

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

@@ -0,0 +1,411 @@
+/**
+ * DSL Workflow — The dynamic interpreter that executes any workflow DSL.
+ *
+ * This is the ONLY Temporal workflow in the system. It receives a DSL definition
+ * and interprets it at runtime, calling the appropriate activities for each node.
+ *
+ * Temporal Workflow constraints apply:
+ * - Must be deterministic (no Math.random, Date.now, etc.)
+ * - Side effects only through activities
+ * - Use workflow.sleep() instead of setTimeout
+ */
+import {
+  proxyActivities,
+  defineSignal,
+  defineQuery,
+  setHandler,
+  condition,
+  sleep,
+  CancellationScope,
+  isCancellation,
+  executeChild,
+} from '@temporalio/workflow';
+import type {
+  WorkflowInput,
+  WorkflowResult,
+  DslNode,
+  WorkflowDSL,
+  NodeStatus,
+  ApprovalSignalPayload,
+  ReportNodeStatusInput,
+  ReportWorkflowStatusInput,
+} from '../dsl/types';
+import { assertNever } from '../dsl/node-types';
+import {
+  resolveTemplates,
+  resolveExpression,
+  getNestedValue,
+  evaluateConditions,
+  getSuccessorsFromNodes,
+  getNextNodes,
+} from '../dsl/helpers';
+
+// ─── Activity Proxies ─────────────────────────────────────────────────────────
+
+const acts = proxyActivities<typeof import('../activities')>({
+  startToCloseTimeout: '60s',
+  retry: { maximumAttempts: 3 },
+});
+
+const reportActs = proxyActivities<typeof import('../activities')>({
+  startToCloseTimeout: '10s',
+  retry: { maximumAttempts: 5 },
+});
+
+// ─── Signals & Queries ────────────────────────────────────────────────────────
+
+export const approvalSignal = defineSignal<[ApprovalSignalPayload]>('approval');
+export const cancelSignal = defineSignal('cancel');
+
+export const getProgressQuery = defineQuery<Record<string, NodeStatus>>('getProgress');
+
+// ─── Main Workflow ────────────────────────────────────────────────────────────
+
+export async function dslWorkflow(input: WorkflowInput): Promise<WorkflowResult> {
+  const { instanceId, dsl, context: initialContext } = input;
+
+  // Node status tracking (for queries)
+  const nodeStatuses: Record<string, NodeStatus> = {};
+  // Execution context — flows between nodes
+  const ctx: Record<string, any> = { ...initialContext };
+  // Approval results collected from signals
+  const approvalResults: Record<string, ApprovalSignalPayload> = {};
+  // Cancellation flag
+  let cancelled = false;
+
+  // Set up signal handlers
+  setHandler(approvalSignal, (payload: ApprovalSignalPayload) => {
+    approvalResults[payload.nodeId] = payload;
+  });
+
+  setHandler(cancelSignal, () => {
+    cancelled = true;
+  });
+
+  setHandler(getProgressQuery, () => nodeStatuses);
+
+  // Report workflow as RUNNING
+  await reportActs.reportWorkflowStatus({ instanceId, status: 'RUNNING' });
+
+  try {
+    // Find trigger nodes and start from their successors
+    const triggerNodes = dsl.nodes.filter((n) => n.type.endsWith('_trigger'));
+    const startNodeIds = getSuccessorsFromNodes(dsl, triggerNodes.map((n) => n.id));
+
+    // Execute the graph starting from trigger successors
+    await executeGraph(dsl, startNodeIds, ctx, nodeStatuses, instanceId, approvalResults, () => cancelled);
+
+    // Report success
+    await reportActs.reportWorkflowStatus({ instanceId, status: 'COMPLETED', result: ctx });
+    return { status: 'COMPLETED', context: ctx };
+  } catch (err: any) {
+    if (isCancellation(err) || cancelled) {
+      await reportActs.reportWorkflowStatus({ instanceId, status: 'CANCELLED' });
+      return { status: 'CANCELLED', context: ctx };
+    }
+    await reportActs.reportWorkflowStatus({ instanceId, status: 'FAILED', result: { error: err.message } });
+    return { status: 'FAILED', context: ctx, error: err.message };
+  }
+}
+
+// ─── Graph Execution Engine ───────────────────────────────────────────────────
+
+async function executeGraph(
+  dsl: WorkflowDSL,
+  startNodeIds: string[],
+  ctx: Record<string, any>,
+  nodeStatuses: Record<string, NodeStatus>,
+  instanceId: number,
+  approvalResults: Record<string, ApprovalSignalPayload>,
+  isCancelled: () => boolean,
+): Promise<void> {
+  // BFS-style execution following edges
+  const executed = new Set<string>();
+  const queue = [...startNodeIds];
+
+  while (queue.length > 0) {
+    if (isCancelled()) throw new CancellationScope().cancel;
+
+    const nodeId = queue.shift()!;
+    if (executed.has(nodeId)) continue;
+
+    // Check if all predecessors have been executed
+    const predecessors = dsl.edges.filter((e) => e.target === nodeId).map((e) => e.source);
+    const allPredsDone = predecessors.every((p) => executed.has(p) || dsl.nodes.find((n) => n.id === p)?.type.endsWith('_trigger'));
+    if (!allPredsDone) {
+      // Re-queue for later
+      queue.push(nodeId);
+      continue;
+    }
+
+    const node = dsl.nodes.find((n) => n.id === nodeId);
+    if (!node) continue;
+
+    executed.add(nodeId);
+    nodeStatuses[nodeId] = 'RUNNING';
+
+    // Report node as RUNNING
+    await reportActs.reportNodeStatus({
+      instanceId,
+      nodeId: node.id,
+      nodeType: node.type,
+      nodeLabel: node.label,
+      status: 'RUNNING',
+      input: ctx,
+    });
+
+    try {
+      // Execute the node and get result
+      const result = await executeNode(node, dsl, ctx, instanceId, approvalResults, nodeStatuses, isCancelled);
+      nodeStatuses[nodeId] = 'COMPLETED';
+
+      // Report node completion
+      await reportActs.reportNodeStatus({
+        instanceId,
+        nodeId: node.id,
+        nodeType: node.type,
+        nodeLabel: node.label,
+        status: 'COMPLETED',
+        output: result?.output,
+      });
+
+      // Merge output into context
+      if (result?.output) {
+        ctx[nodeId] = result.output;
+      }
+
+      // Determine next nodes based on node type
+      const nextNodeIds = getNextNodes(dsl, node, result?.branch);
+      for (const nextId of nextNodeIds) {
+        if (!executed.has(nextId)) queue.push(nextId);
+      }
+    } catch (err: any) {
+      nodeStatuses[nodeId] = 'FAILED';
+      await reportActs.reportNodeStatus({
+        instanceId,
+        nodeId: node.id,
+        nodeType: node.type,
+        nodeLabel: node.label,
+        status: 'FAILED',
+        error: { message: err.message, stack: err.stack },
+      });
+      throw err; // Propagate to workflow level
+    }
+  }
+}
+
+// ─── Node Execution Dispatcher ────────────────────────────────────────────────
+
+async function executeNode(
+  node: DslNode,
+  dsl: WorkflowDSL,
+  ctx: Record<string, any>,
+  instanceId: number,
+  approvalResults: Record<string, ApprovalSignalPayload>,
+  nodeStatuses: Record<string, NodeStatus>,
+  isCancelled: () => boolean,
+): Promise<{ output?: Record<string, any>; branch?: string } | undefined> {
+  const config = resolveTemplates(node.config, ctx);
+
+  switch (node.type) {
+    // ─── Triggers (never reach executeNode; handled at graph entry) ──
+    case 'cron_trigger':
+    case 'webhook_trigger':
+    case 'event_trigger':
+    case 'manual_trigger':
+      return { output: { triggeredAt: new Date().toISOString() } };
+
+    // ─── Actions ────────────────────────────────────────────────────
+    case 'http_request': {
+      const result = await acts.httpRequest(config as any);
+      return { output: result };
+    }
+
+    case 'db_query': {
+      const result = await acts.dbQuery(config as any);
+      return { output: result };
+    }
+
+    case 'db_execute': {
+      const result = await acts.dbExecute(config as any);
+      return { output: result };
+    }
+
+    case 'send_notification': {
+      const result = await acts.sendNotification(config as any);
+      return { output: result };
+    }
+
+    case 'code': {
+      const result = await acts.codeExecute({
+        ...config,
+        data: ctx,
+      } as any);
+      return { output: result };
+    }
+
+    // ─── Data Processing ────────────────────────────────────────────
+    case 'set_variable': {
+      const assignments = config.assignments as Array<{ name: string; value: string }>;
+      const output: Record<string, any> = {};
+      for (const { name, value } of assignments || []) {
+        const resolved = resolveExpression(value, ctx);
+        ctx[name] = resolved;
+        output[name] = resolved;
+      }
+      return { output };
+    }
+
+    // ─── Conditions ─────────────────────────────────────────────────
+    case 'if_else': {
+      const conditions = config.conditions as Array<{ field: string; operator: string; value: string }> || [];
+      const combineOp = (config.combineOperation as 'AND' | 'OR') || 'AND';
+      const result = evaluateConditions(conditions, ctx, combineOp);
+      return { output: { branch: result ? 'true' : 'false' }, branch: result ? 'true' : 'false' };
+    }
+
+    case 'switch': {
+      const field = config.field as string;
+      const cases = config.cases as Array<{ value: string; label: string }> || [];
+      const fieldValue = String(getNestedValue(ctx, field) ?? '');
+      const matched = cases.find((c) => c.value === fieldValue);
+      const branch = matched ? matched.value : (config.defaultCase as string || 'default');
+      return { output: { matchedCase: branch }, branch };
+    }
+
+    // ─── Flow Control ───────────────────────────────────────────────
+    case 'delay': {
+      const delayType = config.delayType as string;
+      if (delayType === 'fixedDuration') {
+        const duration = (config.duration as number) || 1;
+        await sleep(duration * 1000);
+      } else if (delayType === 'untilTime') {
+        const targetTime = new Date(config.untilTime as string).getTime();
+        const now = Date.now();
+        if (targetTime > now) {
+          await sleep(targetTime - now);
+        }
+      } else if (delayType === 'untilSignal') {
+        // Wait for a specific signal (reuse approval mechanism)
+        await condition(() => approvalResults[node.id] !== undefined, '24h');
+      }
+      return { output: { resumedAt: new Date().toISOString(), resumeReason: delayType } };
+    }
+
+    case 'parallel': {
+      // Execute all outgoing branches in parallel
+      const branches = getSuccessorsFromNodes(dsl, [node.id]);
+      const branchPromises = branches.map(async (branchNodeId) => {
+        await executeGraph(
+          dsl,
+          [branchNodeId],
+          ctx,
+          nodeStatuses,
+          instanceId,
+          approvalResults,
+          isCancelled,
+        );
+      });
+
+      const waitMode = config.waitMode as string || 'all';
+      if (waitMode === 'all') {
+        await Promise.all(branchPromises);
+      } else if (waitMode === 'any') {
+        await Promise.race(branchPromises);
+      }
+      return { output: { completedBranches: branches.length } };
+    }
+
+    case 'for_each': {
+      const iteratorField = config.iteratorField as string;
+      const items = getNestedValue(ctx, iteratorField) as any[];
+      if (!Array.isArray(items)) {
+        return { output: { results: [], error: 'iteratorField is not an array' } };
+      }
+
+      const concurrency = (config.concurrency as number) || 1;
+      const errorPolicy = (config.errorPolicy as string) || 'stop';
+      const results: any[] = [];
+      const errors: any[] = [];
+
+      // Process items with concurrency control
+      for (let i = 0; i < items.length; i += concurrency) {
+        const batch = items.slice(i, i + concurrency);
+        const batchPromises = batch.map(async (item, batchIdx) => {
+          const idx = i + batchIdx;
+          // Set iteration context
+          ctx['$currentItem'] = item;
+          ctx['$index'] = idx;
+          try {
+            // Execute successor nodes for each item
+            const successors = getSuccessorsFromNodes(dsl, [node.id]);
+            if (successors.length > 0) {
+              await executeGraph(dsl, successors, { ...ctx }, nodeStatuses, instanceId, approvalResults, isCancelled);
+            }
+            results.push({ index: idx, success: true });
+          } catch (err: any) {
+            if (errorPolicy === 'stop') throw err;
+            errors.push({ index: idx, error: err.message });
+          }
+        });
+        await Promise.all(batchPromises);
+      }
+
+      return { output: { results, errors, totalProcessed: items.length } };
+    }
+
+    case 'error_handler': {
+      // Error handler is special — it wraps the execution of upstream nodes
+      // In practice, the error handling is done at the graph execution level
+      return { output: { handled: true } };
+    }
+
+    // ─── Approval ───────────────────────────────────────────────────
+    case 'approval': {
+      const timeoutSec = (config.timeout as number) || 86400; // Default 24h
+      const timeoutAction = (config.timeoutAction as string) || 'auto_reject';
+
+      // Wait for approval signal
+      const gotApproval = await condition(
+        () => approvalResults[node.id] !== undefined,
+        `${timeoutSec}s`,
+      );
+
+      if (!gotApproval) {
+        // Timeout
+        if (timeoutAction === 'auto_approve') {
+          return { output: { approved: true, approvedBy: 'system', comment: 'Auto-approved (timeout)' } };
+        } else {
+          return { output: { approved: false, approvedBy: 'system', comment: 'Auto-rejected (timeout)' } };
+        }
+      }
+
+      const approval = approvalResults[node.id];
+      return {
+        output: { approved: approval.approved, approvedBy: approval.approvedBy, comment: approval.comment },
+        branch: approval.approved ? 'true' : 'false',
+      };
+    }
+
+    // ─── Sub Workflow ────────────────────────────────────────────────
+    case 'sub_workflow': {
+      const childWorkflowId = config.workflowId as string;
+      const inputMapping = config.inputMapping as Record<string, string> || {};
+      const childContext: Record<string, any> = {};
+
+      for (const [key, path] of Object.entries(inputMapping)) {
+        childContext[key] = getNestedValue(ctx, path);
+      }
+
+      // TODO: Load child workflow DSL from DB via activity, then execute as child workflow
+      // For now, placeholder
+      return { output: { status: 'not_implemented', childWorkflowId } };
+    }
+
+    default:
+      return assertNever(node.type);
+  }
+}
+
+// ─── Helper Functions ─────────────────────────────────────────────────────────
+// Pure functions are defined in ../dsl/helpers.ts and imported above.

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "commonjs",
+    "lib": ["ES2021"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    root: './src',
+    include: ['**/__tests__/**/*.test.ts'],
+  },
+});