@gadmin2n/schematics 0.0.136 → 0.0.138

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

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

@@ -1,101 +0,0 @@
-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/tests/validate.test.ts

@@ -1,205 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateDslHandles } from '../dsl/validate';
-import type { WorkflowDSL } from '../dsl/types';
-
-// ─── helpers ─────────────────────────────────────────────────────────────────
-
-function makeNode(
-  id: string,
-  type: string,
-  config: Record<string, any> = {},
-): WorkflowDSL['nodes'][number] {
-  return {
-    id,
-    type: type as any,
-    label: id,
-    position: { x: 0, y: 0 },
-    config,
-  };
-}
-
-function makeEdge(
-  id: string,
-  source: string,
-  target: string,
-  sourceHandle?: string,
-): WorkflowDSL['edges'][number] {
-  return sourceHandle === undefined
-    ? { id, source, target }
-    : { id, source, target, sourceHandle };
-}
-
-// ─── if_else (enumerated outputs) ────────────────────────────────────────────
-
-describe('validateDslHandles — if_else', () => {
-  it('accepts sourceHandle "true"', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b', 'true')],
-    };
-    expect(validateDslHandles(dsl)).toEqual([]);
-  });
-
-  it('accepts sourceHandle "false"', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b', 'false')],
-    };
-    expect(validateDslHandles(dsl)).toEqual([]);
-  });
-
-  it('rejects unknown sourceHandle "maybe"', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b', 'maybe')],
-    };
-    const errors = validateDslHandles(dsl);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('UNKNOWN_HANDLE');
-    expect(errors[0].reason).toMatch(/not in declared outputs/);
-  });
-
-  it('rejects missing sourceHandle', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b')],
-    };
-    const errors = validateDslHandles(dsl);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('MISSING_HANDLE');
-    expect(errors[0].reason).toMatch(/requires a sourceHandle/);
-  });
-
-  it('rejects empty-string sourceHandle as missing', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b', '')],
-    };
-    const errors = validateDslHandles(dsl);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('MISSING_HANDLE');
-  });
-});
-
-// ─── cron_trigger (no named outputs) ─────────────────────────────────────────
-
-describe('validateDslHandles — cron_trigger (no named outputs)', () => {
-  it('rejects sourceHandle "foo" on a node with no named handles', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
-      edges: [makeEdge('e1', 't', 'a', 'foo')],
-    };
-    const errors = validateDslHandles(dsl);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('EXTRA_HANDLE');
-    expect(errors[0].reason).toMatch(/no named output handles/);
-  });
-
-  it('accepts no sourceHandle', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
-      edges: [makeEdge('e1', 't', 'a')],
-    };
-    expect(validateDslHandles(dsl)).toEqual([]);
-  });
-
-  it('accepts empty-string sourceHandle (treated as absent for [] nodes)', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
-      edges: [makeEdge('e1', 't', 'a', '')],
-    };
-    expect(validateDslHandles(dsl)).toEqual([]);
-  });
-});
-
-// ─── switch (dynamic outputs) ────────────────────────────────────────────────
-
-describe('validateDslHandles — switch (dynamic outputs)', () => {
-  it('accepts sourceHandle matching a case value', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [
-        makeNode('s', 'switch', { cases: [{ value: 'a' }, { value: 'b' }] }),
-        makeNode('x', 'http_request'),
-      ],
-      edges: [makeEdge('e1', 's', 'x', 'a')],
-    };
-    expect(validateDslHandles(dsl)).toEqual([]);
-  });
-
-  it('rejects sourceHandle not in case values', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [
-        makeNode('s', 'switch', { cases: [{ value: 'a' }] }),
-        makeNode('x', 'http_request'),
-      ],
-      edges: [makeEdge('e1', 's', 'x', 'c')],
-    };
-    const errors = validateDslHandles(dsl);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('UNKNOWN_HANDLE');
-  });
-
-  it('skips validation when switch config has no cases (in-progress editor)', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('s', 'switch'), makeNode('x', 'http_request')],
-      edges: [makeEdge('e1', 's', 'x', 'anything')],
-    };
-    expect(validateDslHandles(dsl)).toEqual([]);
-  });
-});
-
-// ─── out-of-scope (orphan / unknown) ────────────────────────────────────────
-
-describe('validateDslHandles — out-of-scope', () => {
-  it('ignores edge referencing missing source node', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'ghost', 'b', 'true')],
-    };
-    expect(validateDslHandles(dsl)).toEqual([]);
-  });
-
-  it('ignores edges from unknown node types', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [makeNode('u', 'wholly_made_up_type'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'u', 'b', 'whatever')],
-    };
-    expect(validateDslHandles(dsl)).toEqual([]);
-  });
-});
-
-// ─── multiple errors collected ──────────────────────────────────────────────
-
-describe('validateDslHandles — multiple errors', () => {
-  it('collects every error in one pass', () => {
-    const dsl: WorkflowDSL = {
-      nodes: [
-        makeNode('if', 'if_else'),
-        makeNode('cron', 'cron_trigger'),
-        makeNode('sw', 'switch', { cases: [{ value: 'a' }] }),
-        makeNode('x', 'http_request'),
-      ],
-      edges: [
-        makeEdge('e1', 'if', 'x', 'maybe'),    // bad enumerated
-        makeEdge('e2', 'if', 'x'),              // missing required
-        makeEdge('e3', 'cron', 'x', 'foo'),    // forbidden handle
-        makeEdge('e4', 'sw', 'x', 'c'),        // bad dynamic
-      ],
-    };
-    const errors = validateDslHandles(dsl);
-    expect(errors).toHaveLength(4);
-    expect(errors.map((e) => e.edgeId).sort()).toEqual(['e1', 'e2', 'e3', 'e4']);
-    const byEdge = Object.fromEntries(errors.map((e) => [e.edgeId, e.code]));
-    expect(byEdge).toEqual({
-      e1: 'UNKNOWN_HANDLE',
-      e2: 'MISSING_HANDLE',
-      e3: 'EXTRA_HANDLE',
-      e4: 'UNKNOWN_HANDLE',
-    });
-  });
-});