@gadmin2n/schematics 0.0.71 → 0.0.74

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

@@ -0,0 +1,54 @@
+import axios, { AxiosRequestConfig } from 'axios';
+
+export interface HttpRequestInput {
+  url: string;
+  method: string;
+  headers?: Record<string, string>;
+  body?: any;
+  timeout?: number;
+  authentication?: string;
+  followRedirects?: boolean;
+  responseFormat?: 'json' | 'text' | 'binary';
+  ignoreSslErrors?: boolean;
+}
+
+export interface HttpRequestOutput {
+  status: number;
+  data: any;
+  headers: Record<string, string>;
+}
+
+/**
+ * Execute an HTTP request activity.
+ */
+export async function httpRequest(input: HttpRequestInput): Promise<HttpRequestOutput> {
+  const axiosConfig: AxiosRequestConfig = {
+    url: input.url,
+    method: input.method.toLowerCase() as any,
+    headers: input.headers || {},
+    timeout: input.timeout || 30000,
+    maxRedirects: input.followRedirects === false ? 0 : 5,
+    validateStatus: () => true, // Don't throw on non-2xx
+  };
+
+  if (input.body && ['post', 'put', 'patch'].includes(axiosConfig.method as string)) {
+    axiosConfig.data = input.body;
+  }
+
+  if (input.ignoreSslErrors) {
+    const https = await import('https');
+    axiosConfig.httpsAgent = new https.Agent({ rejectUnauthorized: false });
+  }
+
+  if (input.responseFormat === 'binary') {
+    axiosConfig.responseType = 'arraybuffer';
+  }
+
+  const response = await axios(axiosConfig);
+
+  return {
+    status: response.status,
+    data: response.data,
+    headers: response.headers as Record<string, string>,
+  };
+}

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

@@ -0,0 +1,6 @@
+export { httpRequest } from './http-request';
+export { dbQuery } from './db-query';
+export { dbExecute } from './db-execute';
+export { sendNotification } from './send-notification';
+export { codeExecute } from './code-execute';
+export { reportNodeStatus, reportWorkflowStatus } from './reporting';

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

@@ -0,0 +1,62 @@
+import { Pool } from 'pg';
+import { config } from '../config';
+import { ReportNodeStatusInput, ReportWorkflowStatusInput } from '../dsl/types';
+
+const pool = new Pool({ connectionString: config.database.url });
+
+/**
+ * Report a node's execution status to the database.
+ */
+export async function reportNodeStatus(input: ReportNodeStatusInput): Promise<void> {
+  const { instanceId, nodeId, nodeType, nodeLabel, status, input: nodeInput, output, error } = input;
+
+  if (status === 'RUNNING') {
+    // Create or update node execution record with RUNNING status
+    await pool.query(
+      `INSERT INTO t_workflow_node_execution (instance_id, node_id, node_type, node_label, status, input, started_at, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW(), NOW())
+       ON CONFLICT (instance_id, node_id) DO UPDATE SET
+         status = $5, input = $6, started_at = NOW(), updated_at = NOW()`,
+      [instanceId, nodeId, nodeType, nodeLabel || null, status, nodeInput ? JSON.stringify(nodeInput) : null],
+    );
+  } else {
+    // Update with final status
+    await pool.query(
+      `UPDATE t_workflow_node_execution
+       SET status = $1, output = $2, error = $3, finished_at = NOW(), updated_at = NOW()
+       WHERE instance_id = $4 AND node_id = $5`,
+      [status, output ? JSON.stringify(output) : null, error ? JSON.stringify(error) : null, instanceId, nodeId],
+    );
+  }
+}
+
+/**
+ * Report overall workflow execution status.
+ */
+export async function reportWorkflowStatus(input: ReportWorkflowStatusInput): Promise<void> {
+  const { instanceId, status, result } = input;
+
+  const updates: string[] = ['status = $1', 'updated_at = NOW()'];
+  const values: any[] = [status];
+  let paramIdx = 2;
+
+  if (status === 'RUNNING') {
+    updates.push(`started_at = NOW()`);
+  }
+
+  if (status === 'COMPLETED' || status === 'FAILED' || status === 'CANCELLED') {
+    updates.push(`finished_at = NOW()`);
+  }
+
+  if (result !== undefined) {
+    updates.push(`result = $${paramIdx}`);
+    values.push(JSON.stringify(result));
+    paramIdx++;
+  }
+
+  values.push(instanceId);
+  await pool.query(
+    `UPDATE t_workflow_instance SET ${updates.join(', ')} WHERE id = $${paramIdx}`,
+    values,
+  );
+}

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

@@ -0,0 +1,47 @@
+export interface SendNotificationInput {
+  channel: 'email' | 'slack' | 'webhook' | 'dingtalk' | 'wecom';
+  recipients: string[];
+  subject?: string;
+  message: string;
+  templateId?: string;
+}
+
+export interface SendNotificationOutput {
+  sent: boolean;
+  messageId: string;
+}
+
+/**
+ * Send a notification via the configured channel.
+ * Currently stubs — implement actual integrations as needed.
+ */
+export async function sendNotification(input: SendNotificationInput): Promise<SendNotificationOutput> {
+  const { channel, recipients, subject, message } = input;
+
+  console.log(`[Notification] channel=${channel} recipients=${recipients.join(',')} subject=${subject || ''}`);
+  console.log(`[Notification] message: ${message}`);
+
+  // TODO: Implement actual notification channels
+  // For now, log and return success
+  switch (channel) {
+    case 'webhook': {
+      // For webhook channel, POST to each recipient URL
+      const axios = (await import('axios')).default;
+      for (const url of recipients) {
+        await axios.post(url, { subject, message });
+      }
+      break;
+    }
+    case 'email':
+    case 'slack':
+    case 'dingtalk':
+    case 'wecom':
+      // Stub: log only
+      break;
+  }
+
+  return {
+    sent: true,
+    messageId: `notif_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+  };
+}

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

@@ -0,0 +1,13 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+export const config = {
+  temporal: {
+    address: process.env.TEMPORAL_ADDRESS || 'localhost:7233',
+    namespace: process.env.TEMPORAL_NAMESPACE || 'default',
+    taskQueue: process.env.TEMPORAL_TASK_QUEUE || 'workflow-execution',
+  },
+  database: {
+    url: process.env.DATABASE_URL || 'postgresql://kavenma:kavenma@127.0.0.1:5432/gadmin_demo?schema=public',
+  },
+};

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

@@ -0,0 +1,101 @@
+/**
+ * Condition evaluation for if_else and switch nodes.
+ */
+
+export interface ConditionRule {
+  field: string;
+  operator: string;
+  value: string;
+}
+
+/**
+ * Evaluate a single condition rule against a context value.
+ */
+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 'startsWith':
+      return String(fieldValue).startsWith(compareValue);
+    case 'endsWith':
+      return String(fieldValue).endsWith(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 === '' || (Array.isArray(fieldValue) && fieldValue.length === 0);
+    case 'isNotEmpty':
+      return fieldValue != null && fieldValue !== '' && !(Array.isArray(fieldValue) && fieldValue.length === 0);
+    case 'regex':
+      try {
+        return new RegExp(compareValue).test(String(fieldValue));
+      } catch {
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+
+/**
+ * Evaluate multiple condition rules with AND/OR combinator.
+ */
+export function evaluateConditions(
+  conditions: ConditionRule[],
+  contextData: Record<string, any>,
+  combineOperation: 'AND' | 'OR' = 'AND',
+): boolean {
+  if (conditions.length === 0) return true;
+
+  const results = conditions.map((rule) => {
+    const fieldValue = getNestedValue(contextData, rule.field);
+    return evaluateRule(fieldValue, rule.operator, rule.value);
+  });
+
+  return combineOperation === 'AND'
+    ? results.every(Boolean)
+    : results.some(Boolean);
+}
+
+/**
+ * Evaluate a switch node — returns the matched case value or "default".
+ */
+export function evaluateSwitch(
+  field: string,
+  cases: Array<{ value: string; label: string }>,
+  contextData: Record<string, any>,
+): string {
+  const fieldValue = String(getNestedValue(contextData, field) ?? '');
+  const matched = cases.find((c) => c.value === fieldValue);
+  return matched ? matched.value : 'default';
+}
+
+/**
+ * Get a nested value from an object using dot-notation path.
+ */
+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;
+}

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

@@ -0,0 +1,58 @@
+/**
+ * Workflow execution context — a shared data store that flows between nodes.
+ * Each node can read from context and write its output back.
+ */
+export class ExecutionContext {
+  private data: Record<string, any>;
+
+  constructor(initialData: Record<string, any> = {}) {
+    this.data = { ...initialData };
+  }
+
+  /** Get a value by dot-notation path (e.g. "node1.data.email") */
+  get(path: string): any {
+    const parts = path.split('.');
+    let current: any = this.data;
+    for (const part of parts) {
+      if (current == null) return undefined;
+      current = current[part];
+    }
+    return current;
+  }
+
+  /** Set a value by key */
+  set(key: string, value: any): void {
+    this.data[key] = value;
+  }
+
+  /** Merge node output into context under the node's ID */
+  mergeNodeOutput(nodeId: string, output: Record<string, any>): void {
+    this.data[nodeId] = output;
+  }
+
+  /** Get the full context object */
+  toJSON(): Record<string, any> {
+    return { ...this.data };
+  }
+
+  /** Resolve template strings like "{{node1.data.email}}" within a value */
+  resolveTemplates(value: any): any {
+    if (typeof value === 'string') {
+      return value.replace(/\{\{(.+?)\}\}/g, (_, path) => {
+        const resolved = this.get(path.trim());
+        return resolved !== undefined ? String(resolved) : '';
+      });
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => this.resolveTemplates(v));
+    }
+    if (value && typeof value === 'object') {
+      const result: Record<string, any> = {};
+      for (const [k, v] of Object.entries(value)) {
+        result[k] = this.resolveTemplates(v);
+      }
+      return result;
+    }
+    return value;
+  }
+}

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

@@ -0,0 +1,184 @@
+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

@@ -0,0 +1,133 @@
+/**
+ * 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);
+}