@gadmin2n/schematics 0.0.72 → 0.0.75

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

@@ -0,0 +1,28 @@
+{
+  "name": "gadmin-workflow-worker",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@temporalio/activity": "^1.11.6",
+    "@temporalio/client": "^1.11.6",
+    "@temporalio/worker": "^1.11.6",
+    "@temporalio/workflow": "^1.11.6",
+    "axios": "^1.7.9",
+    "dotenv": "^16.4.7",
+    "pg": "^8.16.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/pg": "^8.11.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.0",
+    "vitest": "^3.1.0"
+  }
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/__tests__/activities/code-execute.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi } from 'vitest';
+import { codeExecute } from '../../activities/code-execute';
+
+describe('codeExecute activity', () => {
+  it('executes simple script and returns result', async () => {
+    const output = await codeExecute({
+      script: 'return 1 + 2;',
+    });
+    expect(output.result).toBe(3);
+  });
+
+  it('has access to data context', async () => {
+    const output = await codeExecute({
+      script: 'return data.x * 2;',
+      data: { x: 5 },
+    });
+    expect(output.result).toBe(10);
+  });
+
+  it('runOnceForEach mode processes each item', async () => {
+    const output = await codeExecute({
+      script: 'return item * 10;',
+      mode: 'runOnceForEach',
+      items: [1, 2, 3],
+    });
+    expect(output.result).toEqual([10, 20, 30]);
+  });
+
+  it('respects timeout', async () => {
+    await expect(
+      codeExecute({
+        script: 'while(true) {}',
+        timeout: 100,
+      }),
+    ).rejects.toThrow();
+  });
+
+  it('sandbox cannot access Node.js globals', async () => {
+    const output = await codeExecute({
+      script: 'return typeof require;',
+    });
+    expect(output.result).toBe('undefined');
+  });
+});

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

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { HttpRequestInput } from '../../activities/http-request';
+
+// Mock axios at module level
+vi.mock('axios', () => ({
+  default: vi.fn(),
+}));
+
+import axios from 'axios';
+import { httpRequest } from '../../activities/http-request';
+
+const mockedAxios = vi.mocked(axios);
+
+describe('httpRequest activity', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('makes GET request and returns response', async () => {
+    mockedAxios.mockResolvedValueOnce({
+      status: 200,
+      data: { message: 'ok' },
+      headers: { 'content-type': 'application/json' },
+    } as any);
+
+    const result = await httpRequest({
+      url: 'https://api.example.com/data',
+      method: 'GET',
+    });
+
+    expect(result.status).toBe(200);
+    expect(result.data).toEqual({ message: 'ok' });
+    expect(mockedAxios).toHaveBeenCalledOnce();
+  });
+
+  it('sends body for POST request', async () => {
+    mockedAxios.mockResolvedValueOnce({
+      status: 201,
+      data: { id: 1 },
+      headers: {},
+    } as any);
+
+    await httpRequest({
+      url: 'https://api.example.com/items',
+      method: 'POST',
+      body: { name: 'test' },
+    });
+
+    const callConfig = mockedAxios.mock.calls[0][0] as any;
+    expect(callConfig.data).toEqual({ name: 'test' });
+    expect(callConfig.method).toBe('post');
+  });
+
+  it('applies custom timeout', async () => {
+    mockedAxios.mockResolvedValueOnce({
+      status: 200,
+      data: null,
+      headers: {},
+    } as any);
+
+    await httpRequest({
+      url: 'https://api.example.com',
+      method: 'GET',
+      timeout: 5000,
+    });
+
+    const callConfig = mockedAxios.mock.calls[0][0] as any;
+    expect(callConfig.timeout).toBe(5000);
+  });
+
+  it('disables redirects when followRedirects is false', async () => {
+    mockedAxios.mockResolvedValueOnce({
+      status: 302,
+      data: null,
+      headers: { location: '/new' },
+    } as any);
+
+    await httpRequest({
+      url: 'https://api.example.com/old',
+      method: 'GET',
+      followRedirects: false,
+    });
+
+    const callConfig = mockedAxios.mock.calls[0][0] as any;
+    expect(callConfig.maxRedirects).toBe(0);
+  });
+});

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

@@ -0,0 +1,225 @@
+import { describe, it, expect } from 'vitest';
+import {
+  resolveTemplates,
+  resolveExpression,
+  getNestedValue,
+  evaluateConditions,
+  evaluateRule,
+  getSuccessorsFromNodes,
+  getNextNodes,
+} from '../dsl/helpers';
+import type { WorkflowDSL, DslNode } from '../dsl/types';
+
+// ─── getNestedValue ──────────────────────────────────────────────────────────
+
+describe('getNestedValue', () => {
+  it('resolves simple path', () => {
+    expect(getNestedValue({ a: 1 }, 'a')).toBe(1);
+  });
+
+  it('resolves nested path', () => {
+    expect(getNestedValue({ a: { b: { c: 42 } } }, 'a.b.c')).toBe(42);
+  });
+
+  it('returns undefined for missing path', () => {
+    expect(getNestedValue({ a: 1 }, 'b')).toBeUndefined();
+  });
+
+  it('returns undefined for null intermediate', () => {
+    expect(getNestedValue({ a: null }, 'a.b')).toBeUndefined();
+  });
+
+  it('resolves array index via dot notation', () => {
+    expect(getNestedValue({ items: ['x', 'y'] }, 'items.0')).toBe('x');
+  });
+});
+
+// ─── resolveTemplates ────────────────────────────────────────────────────────
+
+describe('resolveTemplates', () => {
+  const ctx = { name: 'Alice', node1: { status: 200, data: { id: 5 } } };
+
+  it('replaces simple template', () => {
+    expect(resolveTemplates('Hello {{name}}', ctx)).toBe('Hello Alice');
+  });
+
+  it('replaces nested path template', () => {
+    expect(resolveTemplates('Status: {{node1.status}}', ctx)).toBe('Status: 200');
+  });
+
+  it('replaces multiple templates in one string', () => {
+    expect(resolveTemplates('{{name}} got {{node1.status}}', ctx)).toBe('Alice got 200');
+  });
+
+  it('replaces missing path with empty string', () => {
+    expect(resolveTemplates('{{missing}}', ctx)).toBe('');
+  });
+
+  it('recursively resolves objects', () => {
+    const obj = { url: 'https://api.com/{{node1.data.id}}', method: 'GET' };
+    expect(resolveTemplates(obj, ctx)).toEqual({ url: 'https://api.com/5', method: 'GET' });
+  });
+
+  it('recursively resolves arrays', () => {
+    expect(resolveTemplates(['{{name}}', '{{node1.status}}'], ctx)).toEqual(['Alice', '200']);
+  });
+
+  it('passes through non-string primitives', () => {
+    expect(resolveTemplates(42, ctx)).toBe(42);
+    expect(resolveTemplates(null, ctx)).toBe(null);
+    expect(resolveTemplates(true, ctx)).toBe(true);
+  });
+});
+
+// ─── resolveExpression ───────────────────────────────────────────────────────
+
+describe('resolveExpression', () => {
+  it('resolves existing path', () => {
+    expect(resolveExpression('a.b', { a: { b: 10 } })).toBe(10);
+  });
+
+  it('returns raw string for unresolvable expression', () => {
+    expect(resolveExpression('literal_value', {})).toBe('literal_value');
+  });
+});
+
+// ─── evaluateRule ────────────────────────────────────────────────────────────
+
+describe('evaluateRule', () => {
+  it('equals / ==', () => {
+    expect(evaluateRule('hello', 'equals', 'hello')).toBe(true);
+    expect(evaluateRule('hello', '==', 'world')).toBe(false);
+  });
+
+  it('notEquals / !=', () => {
+    expect(evaluateRule('a', 'notEquals', 'b')).toBe(true);
+    expect(evaluateRule('a', '!=', 'a')).toBe(false);
+  });
+
+  it('contains / notContains', () => {
+    expect(evaluateRule('hello world', 'contains', 'world')).toBe(true);
+    expect(evaluateRule('hello world', 'notContains', 'xyz')).toBe(true);
+  });
+
+  it('numeric comparisons', () => {
+    expect(evaluateRule(10, 'greaterThan', '5')).toBe(true);
+    expect(evaluateRule(10, '>', '15')).toBe(false);
+    expect(evaluateRule(10, 'lessThan', '15')).toBe(true);
+    expect(evaluateRule(10, '<', '5')).toBe(false);
+    expect(evaluateRule(10, '>=', '10')).toBe(true);
+    expect(evaluateRule(10, '<=', '10')).toBe(true);
+  });
+
+  it('isEmpty / isNotEmpty', () => {
+    expect(evaluateRule(null, 'isEmpty', '')).toBe(true);
+    expect(evaluateRule('', 'isEmpty', '')).toBe(true);
+    expect(evaluateRule('x', 'isEmpty', '')).toBe(false);
+    expect(evaluateRule('x', 'isNotEmpty', '')).toBe(true);
+    expect(evaluateRule(null, 'isNotEmpty', '')).toBe(false);
+  });
+
+  it('unknown operator returns false', () => {
+    expect(evaluateRule('a', 'unknownOp', 'b')).toBe(false);
+  });
+});
+
+// ─── evaluateConditions ──────────────────────────────────────────────────────
+
+describe('evaluateConditions', () => {
+  const ctx = { status: 'active', count: '10' };
+
+  it('returns true for empty conditions', () => {
+    expect(evaluateConditions([], ctx, 'AND')).toBe(true);
+  });
+
+  it('AND: all must pass', () => {
+    const conds = [
+      { field: 'status', operator: 'equals', value: 'active' },
+      { field: 'count', operator: 'greaterThan', value: '5' },
+    ];
+    expect(evaluateConditions(conds, ctx, 'AND')).toBe(true);
+  });
+
+  it('AND: one fails → false', () => {
+    const conds = [
+      { field: 'status', operator: 'equals', value: 'active' },
+      { field: 'count', operator: 'greaterThan', value: '100' },
+    ];
+    expect(evaluateConditions(conds, ctx, 'AND')).toBe(false);
+  });
+
+  it('OR: one passes → true', () => {
+    const conds = [
+      { field: 'status', operator: 'equals', value: 'inactive' },
+      { field: 'count', operator: 'equals', value: '10' },
+    ];
+    expect(evaluateConditions(conds, ctx, 'OR')).toBe(true);
+  });
+
+  it('OR: all fail → false', () => {
+    const conds = [
+      { field: 'status', operator: 'equals', value: 'inactive' },
+      { field: 'count', operator: 'greaterThan', value: '100' },
+    ];
+    expect(evaluateConditions(conds, ctx, 'OR')).toBe(false);
+  });
+});
+
+// ─── Graph Navigation ────────────────────────────────────────────────────────
+
+describe('getSuccessorsFromNodes', () => {
+  const dsl: WorkflowDSL = {
+    nodes: [
+      { id: 'a', type: 'manual_trigger', label: 'A', position: { x: 0, y: 0 }, config: {} },
+      { id: 'b', type: 'http_request', label: 'B', position: { x: 0, y: 0 }, config: {} },
+      { id: 'c', type: 'db_query', label: 'C', position: { x: 0, y: 0 }, config: {} },
+    ],
+    edges: [
+      { id: 'e1', source: 'a', target: 'b' },
+      { id: 'e2', source: 'a', target: 'c' },
+      { id: 'e3', source: 'b', target: 'c' },
+    ],
+  };
+
+  it('finds direct successors', () => {
+    expect(getSuccessorsFromNodes(dsl, ['a'])).toEqual(['b', 'c']);
+  });
+
+  it('finds successors from multiple sources', () => {
+    expect(getSuccessorsFromNodes(dsl, ['a', 'b'])).toEqual(['b', 'c', 'c']);
+  });
+
+  it('returns empty for leaf nodes', () => {
+    expect(getSuccessorsFromNodes(dsl, ['c'])).toEqual([]);
+  });
+});
+
+describe('getNextNodes', () => {
+  const dsl: WorkflowDSL = {
+    nodes: [
+      { id: 'cond', type: 'if_else', label: 'Condition', position: { x: 0, y: 0 }, config: {} },
+      { id: 'yes', type: 'http_request', label: 'Yes', position: { x: 0, y: 0 }, config: {} },
+      { id: 'no', type: 'send_notification', label: 'No', position: { x: 0, y: 0 }, config: {} },
+    ],
+    edges: [
+      { id: 'e1', source: 'cond', target: 'yes', sourceHandle: 'true' },
+      { id: 'e2', source: 'cond', target: 'no', sourceHandle: 'false' },
+    ],
+  };
+
+  it('follows branch edge when branch specified', () => {
+    const node = dsl.nodes[0];
+    expect(getNextNodes(dsl, node, 'true')).toEqual(['yes']);
+    expect(getNextNodes(dsl, node, 'false')).toEqual(['no']);
+  });
+
+  it('follows all edges when no branch', () => {
+    const node = dsl.nodes[0];
+    expect(getNextNodes(dsl, node, undefined)).toEqual(['yes', 'no']);
+  });
+
+  it('falls back to all edges if branch has no matching edge', () => {
+    const node = dsl.nodes[0];
+    expect(getNextNodes(dsl, node, 'nonexistent')).toEqual(['yes', 'no']);
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/__tests__/node-type-consistency.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_NODE_TYPES, ACTIVITY_NODE_TYPES, NodeType } from '../dsl/node-types';
+import * as path from 'path';
+import * as fs from 'fs';
+
+// ─── Consistency with seed file ──────────────────────────────────────────────
+
+describe('Node Type Consistency', () => {
+  // Read the seed file and extract types
+  const seedFilePath = path.resolve(__dirname, '../../../../server/seed/workflow-node-types.ts');
+  const seedContent = fs.readFileSync(seedFilePath, 'utf-8');
+
+  // Extract only top-level node type identifiers (at 4-space indent, not JSON Schema "type" fields)
+  // Pattern: lines like `    type: 'cron_trigger',` (4 spaces indent, contains underscore or known names)
+  const typeRegex = /^\s{4}type:\s*'([a-z][a-z_]+)'/gm;
+  const seedTypes: string[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = typeRegex.exec(seedContent)) !== null) {
+    // Exclude JSON Schema type values like 'object', 'string', 'number', 'array', 'boolean'
+    const jsonSchemaTypes = ['object', 'string', 'number', 'array', 'boolean', 'integer'];
+    if (!jsonSchemaTypes.includes(match[1])) {
+      seedTypes.push(match[1]);
+    }
+  }
+
+  it('seed file has node types defined', () => {
+    expect(seedTypes.length).toBeGreaterThan(0);
+  });
+
+  it('every seed node type exists in ALL_NODE_TYPES', () => {
+    const allTypes = ALL_NODE_TYPES as readonly string[];
+    const missing = seedTypes.filter((t) => !allTypes.includes(t));
+    expect(missing).toEqual([]);
+  });
+
+  it('every ALL_NODE_TYPES entry exists in seed file', () => {
+    const missing = ALL_NODE_TYPES.filter((t) => !seedTypes.includes(t));
+    expect(missing).toEqual([]);
+  });
+
+  it('no duplicates in ALL_NODE_TYPES', () => {
+    const set = new Set(ALL_NODE_TYPES);
+    expect(set.size).toBe(ALL_NODE_TYPES.length);
+  });
+
+  it('ACTIVITY_NODE_TYPES is a subset of ALL_NODE_TYPES', () => {
+    const allTypes = ALL_NODE_TYPES as readonly string[];
+    for (const t of ACTIVITY_NODE_TYPES) {
+      expect(allTypes).toContain(t);
+    }
+  });
+});
+
+// ─── Consistency with executeNode switch ─────────────────────────────────────
+
+describe('executeNode switch coverage', () => {
+  const workflowFilePath = path.resolve(__dirname, '../workflows/dsl-workflow.ts');
+  const workflowContent = fs.readFileSync(workflowFilePath, 'utf-8');
+
+  it('every NodeType has a case in executeNode', () => {
+    const missingCases: string[] = [];
+    for (const nodeType of ALL_NODE_TYPES) {
+      // Check for case 'nodeType': pattern
+      if (!workflowContent.includes(`case '${nodeType}'`)) {
+        missingCases.push(nodeType);
+      }
+    }
+    expect(missingCases).toEqual([]);
+  });
+});
+
+// ─── Consistency with activity files ─────────────────────────────────────────
+
+describe('Activity file coverage', () => {
+  const activitiesIndexPath = path.resolve(__dirname, '../activities/index.ts');
+  const activitiesContent = fs.readFileSync(activitiesIndexPath, 'utf-8');
+
+  // Map node types to expected activity function names
+  const nodeTypeToActivity: Record<string, string> = {
+    http_request: 'httpRequest',
+    db_query: 'dbQuery',
+    db_execute: 'dbExecute',
+    send_notification: 'sendNotification',
+    code: 'codeExecute',
+  };
+
+  it('every ACTIVITY_NODE_TYPE has a corresponding exported activity', () => {
+    const missing: string[] = [];
+    for (const nodeType of ACTIVITY_NODE_TYPES) {
+      const expectedFn = nodeTypeToActivity[nodeType];
+      if (!expectedFn) {
+        missing.push(`${nodeType}: no mapping defined in test`);
+        continue;
+      }
+      if (!activitiesContent.includes(expectedFn)) {
+        missing.push(`${nodeType}: activity "${expectedFn}" not found in activities/index.ts`);
+      }
+    }
+    expect(missing).toEqual([]);
+  });
+});

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

@@ -0,0 +1,51 @@
+export interface CodeExecuteInput {
+  script: string;
+  mode?: 'runOnceForAll' | 'runOnceForEach';
+  timeout?: number;
+  data?: any;
+  items?: any[];
+}
+
+export interface CodeExecuteOutput {
+  result: any;
+}
+
+/**
+ * Execute custom JavaScript code in a sandboxed environment.
+ * Uses Node.js vm module for basic isolation.
+ * For production, consider isolated-vm for stronger sandboxing.
+ */
+export async function codeExecute(input: CodeExecuteInput): Promise<CodeExecuteOutput> {
+  const { script, mode = 'runOnceForAll', timeout = 5000, data, items } = input;
+  const vm = await import('vm');
+
+  if (mode === 'runOnceForEach' && Array.isArray(items)) {
+    const results: any[] = [];
+    for (const item of items) {
+      const sandbox = {
+        item,
+        data,
+        console: { log: () => {} },
+        result: undefined as any,
+      };
+      const context = vm.createContext(sandbox);
+      const wrappedScript = new vm.Script(`result = (function() { ${script} })()`);
+      wrappedScript.runInContext(context, { timeout });
+      results.push(sandbox.result);
+    }
+    return { result: results };
+  }
+
+  // runOnceForAll
+  const sandbox = {
+    data,
+    items: items || [],
+    console: { log: () => {} },
+    result: undefined as any,
+  };
+  const context = vm.createContext(sandbox);
+  const wrappedScript = new vm.Script(`result = (function() { ${script} })()`);
+  wrappedScript.runInContext(context, { timeout });
+
+  return { result: sandbox.result };
+}

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

@@ -0,0 +1,85 @@
+import { Pool } from 'pg';
+import { config } from '../config';
+
+const pool = new Pool({ connectionString: config.database.url });
+
+export interface DbExecuteInput {
+  operation: 'insert' | 'update' | 'delete' | 'raw';
+  table?: string;
+  data?: Record<string, any>;
+  where?: string;
+  rawSql?: string;
+  params?: any[];
+  datasource?: string;
+  timeout?: number;
+}
+
+export interface DbExecuteOutput {
+  affectedRows: number;
+  insertedId?: string;
+}
+
+/**
+ * Execute a database write operation (INSERT/UPDATE/DELETE).
+ */
+export async function dbExecute(input: DbExecuteInput): Promise<DbExecuteOutput> {
+  const client = await pool.connect();
+  try {
+    if (input.timeout) {
+      await client.query(`SET statement_timeout = ${input.timeout}`);
+    }
+
+    let query: string;
+    let params: any[] = [];
+
+    switch (input.operation) {
+      case 'raw':
+        query = input.rawSql || '';
+        params = input.params || [];
+        break;
+
+      case 'insert': {
+        if (!input.table || !input.data) throw new Error('table and data required for insert');
+        const keys = Object.keys(input.data);
+        const values = Object.values(input.data);
+        const placeholders = keys.map((_, i) => `$${i + 1}`);
+        query = `INSERT INTO ${input.table} (${keys.join(', ')}) VALUES (${placeholders.join(', ')}) RETURNING id`;
+        params = values;
+        break;
+      }
+
+      case 'update': {
+        if (!input.table || !input.data) throw new Error('table and data required for update');
+        const entries = Object.entries(input.data);
+        const sets = entries.map(([k], i) => `${k} = $${i + 1}`);
+        params = entries.map(([, v]) => v);
+        query = `UPDATE ${input.table} SET ${sets.join(', ')}`;
+        if (input.where) {
+          query += ` WHERE ${input.where}`;
+        }
+        break;
+      }
+
+      case 'delete': {
+        if (!input.table) throw new Error('table required for delete');
+        query = `DELETE FROM ${input.table}`;
+        if (input.where) {
+          query += ` WHERE ${input.where}`;
+        }
+        params = input.params || [];
+        break;
+      }
+
+      default:
+        throw new Error(`Unknown operation: ${input.operation}`);
+    }
+
+    const result = await client.query(query, params);
+    return {
+      affectedRows: result.rowCount || 0,
+      insertedId: result.rows?.[0]?.id?.toString(),
+    };
+  } finally {
+    client.release();
+  }
+}

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

@@ -0,0 +1,35 @@
+import { Pool } from 'pg';
+import { config } from '../config';
+
+const pool = new Pool({ connectionString: config.database.url });
+
+export interface DbQueryInput {
+  query: string;
+  params?: any[];
+  datasource?: string;
+  timeout?: number;
+}
+
+export interface DbQueryOutput {
+  rows: any[];
+  rowCount: number;
+}
+
+/**
+ * Execute a database SELECT query.
+ */
+export async function dbQuery(input: DbQueryInput): Promise<DbQueryOutput> {
+  const client = await pool.connect();
+  try {
+    if (input.timeout) {
+      await client.query(`SET statement_timeout = ${input.timeout}`);
+    }
+    const result = await client.query(input.query, input.params || []);
+    return {
+      rows: result.rows,
+      rowCount: result.rowCount || 0,
+    };
+  } finally {
+    client.release();
+  }
+}