@mmapp/react-compiler 0.1.0-alpha.1

package/src/__tests__/ts-to-expression.test.ts

@@ -0,0 +1,462 @@
+/**
+ * TS → mm-compute Expression Transpiler Tests
+ *
+ * Tests the transpilation of Babel AST Expression nodes into mm-compute
+ * expression strings. Uses @babel/parser to parse JS/TS expressions
+ * into AST nodes, then transpiles them.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parse } from '@babel/parser';
+import type * as t from '@babel/types';
+import { transpileExpression, transpile } from '../babel/transpilers/ts-to-expression';
+
+/**
+ * Parse a JS expression string into a Babel AST Expression node.
+ */
+function parseExpr(code: string): t.Expression {
+  const ast = parse(`(${code})`, {
+    sourceType: 'module',
+    plugins: ['typescript', 'jsx'],
+  });
+  const stmt = ast.program.body[0];
+  if (stmt.type !== 'ExpressionStatement') {
+    throw new Error(`Expected ExpressionStatement, got ${stmt.type}`);
+  }
+  return stmt.expression;
+}
+
+/**
+ * Transpile a JS expression string to mm-compute and return the result.
+ */
+function tx(code: string): string {
+  return transpile(parseExpr(code));
+}
+
+/**
+ * Transpile and check purity.
+ */
+function txFull(code: string) {
+  return transpileExpression(parseExpr(code));
+}
+
+// =============================================================================
+// String Methods
+// =============================================================================
+
+describe('String method transpilation', () => {
+  it('str.toLowerCase() → lower(str)', () => {
+    expect(tx('name.toLowerCase()')).toBe('lower(name)');
+  });
+
+  it('str.toUpperCase() → upper(str)', () => {
+    expect(tx('name.toUpperCase()')).toBe('upper(name)');
+  });
+
+  it('str.trim() → trim(str)', () => {
+    expect(tx('input.trim()')).toBe('trim(input)');
+  });
+
+  it('str.startsWith(s) → starts_with(str, s)', () => {
+    expect(tx('name.startsWith("Dr")')).toBe('starts_with(name, "Dr")');
+  });
+
+  it('str.endsWith(s) → ends_with(str, s)', () => {
+    expect(tx('file.endsWith(".pdf")')).toBe('ends_with(file, ".pdf")');
+  });
+
+  it('str.includes(sub) → contains(str, sub)', () => {
+    expect(tx('msg.includes("error")')).toBe('contains(msg, "error")');
+  });
+
+  it('str.split(sep) → split(str, sep)', () => {
+    expect(tx('csv.split(",")')).toBe('split(csv, ",")');
+  });
+
+  it('str.indexOf(sub) → indexof(str, sub)', () => {
+    expect(tx('name.indexOf("@")')).toBe('indexof(name, "@")');
+  });
+
+  it('str.replace(a, b) → replace(str, a, b)', () => {
+    expect(tx('name.replace("-", "_")')).toBe('replace(name, "-", "_")');
+  });
+
+  it('str.substring(start, end) → substring(str, start, end)', () => {
+    expect(tx('name.substring(0, 5)')).toBe('substring(name, 0, 5)');
+  });
+
+  it('str.slice(start) → substring(str, start)', () => {
+    expect(tx('name.slice(3)')).toBe('substring(name, 3)');
+  });
+
+  it('str.toString() → to_string(str)', () => {
+    expect(tx('value.toString()')).toBe('to_string(value)');
+  });
+});
+
+// =============================================================================
+// Array Methods
+// =============================================================================
+
+describe('Array method transpilation', () => {
+  it('arr.length → length(arr)', () => {
+    expect(tx('items.length')).toBe('length(items)');
+  });
+
+  it('arr.includes(val) → contains(arr, val)', () => {
+    expect(tx('roles.includes("admin")')).toBe('contains(roles, "admin")');
+  });
+
+  it('arr.filter(x => x.active) → filter(arr, x => x.active)', () => {
+    expect(tx('items.filter(x => x.active)')).toBe('filter(items, x => x.active)');
+  });
+
+  it('arr.map(x => x.name) → map(arr, x => x.name)', () => {
+    expect(tx('items.map(x => x.name)')).toBe('map(items, x => x.name)');
+  });
+
+  it('arr.find(x => x.id === val) → find(arr, x => (x.id == val))', () => {
+    expect(tx('items.find(x => x.id === val)')).toBe('find(items, x => (x.id == val))');
+  });
+
+  it('arr.join(sep) → join(arr, sep)', () => {
+    expect(tx('tags.join(", ")')).toBe('join(tags, ", ")');
+  });
+
+  it('arr.reverse() → reverse(arr)', () => {
+    expect(tx('items.reverse()')).toBe('reverse(items)');
+  });
+
+  it('arr.sort() → sort(arr)', () => {
+    expect(tx('items.sort()')).toBe('sort(items)');
+  });
+
+  it('arr.flat() → flat(arr)', () => {
+    expect(tx('nested.flat()')).toBe('flat(nested)');
+  });
+
+  it('arr.reduce((acc, x) => acc + x, 0) → reduce(arr, (acc, x) => (acc + x), 0)', () => {
+    expect(tx('nums.reduce((acc, x) => acc + x, 0)')).toBe('reduce(nums, (acc, x) => (acc + x), 0)');
+  });
+});
+
+// =============================================================================
+// Math Methods
+// =============================================================================
+
+describe('Math method transpilation', () => {
+  it('Math.max(a, b) → max(a, b)', () => {
+    expect(tx('Math.max(a, b)')).toBe('max(a, b)');
+  });
+
+  it('Math.min(a, b) → min(a, b)', () => {
+    expect(tx('Math.min(a, b)')).toBe('min(a, b)');
+  });
+
+  it('Math.round(n) → round(n)', () => {
+    expect(tx('Math.round(x)')).toBe('round(x)');
+  });
+
+  it('Math.floor(n) → floor(n)', () => {
+    expect(tx('Math.floor(x)')).toBe('floor(x)');
+  });
+
+  it('Math.ceil(n) → ceil(n)', () => {
+    expect(tx('Math.ceil(x)')).toBe('ceil(x)');
+  });
+
+  it('Math.abs(n) → abs(n)', () => {
+    expect(tx('Math.abs(x)')).toBe('abs(x)');
+  });
+
+  it('Math.pow(a, b) → power(a, b)', () => {
+    expect(tx('Math.pow(2, 10)')).toBe('power(2, 10)');
+  });
+
+  it('Math.sqrt(n) → sqrt(n)', () => {
+    expect(tx('Math.sqrt(x)')).toBe('sqrt(x)');
+  });
+});
+
+// =============================================================================
+// JSON Methods
+// =============================================================================
+
+describe('JSON method transpilation', () => {
+  it('JSON.stringify(v) → to_string(v)', () => {
+    expect(tx('JSON.stringify(obj)')).toBe('to_string(obj)');
+  });
+
+  it('JSON.parse(s) → from_json(s)', () => {
+    expect(tx('JSON.parse(text)')).toBe('from_json(text)');
+  });
+});
+
+// =============================================================================
+// Date Methods
+// =============================================================================
+
+describe('Date transpilation', () => {
+  it('new Date() → now()', () => {
+    expect(tx('new Date()')).toBe('now()');
+  });
+
+  it('Date.now() → now_ms()', () => {
+    expect(tx('Date.now()')).toBe('now_ms()');
+  });
+});
+
+// =============================================================================
+// Operators
+// =============================================================================
+
+describe('Operator transpilation', () => {
+  it('a === b → (a == b)', () => {
+    expect(tx('a === b')).toBe('(a == b)');
+  });
+
+  it('a !== b → (a != b)', () => {
+    expect(tx('a !== b')).toBe('(a != b)');
+  });
+
+  it('a ? b : c → if(a, b, c)', () => {
+    expect(tx('active ? "yes" : "no"')).toBe('if(active, "yes", "no")');
+  });
+
+  it('a && b → (a && b)', () => {
+    expect(tx('a && b')).toBe('(a && b)');
+  });
+
+  it('a || b → (a || b)', () => {
+    expect(tx('a || b')).toBe('(a || b)');
+  });
+
+  it('!a → not(a)', () => {
+    expect(tx('!active')).toBe('not(active)');
+  });
+
+  it('a ?? b → coalesce(a, b)', () => {
+    expect(tx('name ?? "unknown"')).toBe('coalesce(name, "unknown")');
+  });
+
+  it('arithmetic operators pass through', () => {
+    expect(tx('a + b')).toBe('(a + b)');
+    expect(tx('a - b')).toBe('(a - b)');
+    expect(tx('a * b')).toBe('(a * b)');
+    expect(tx('a / b')).toBe('(a / b)');
+    expect(tx('a % b')).toBe('(a % b)');
+  });
+
+  it('comparison operators pass through', () => {
+    expect(tx('a < b')).toBe('(a < b)');
+    expect(tx('a > b')).toBe('(a > b)');
+    expect(tx('a <= b')).toBe('(a <= b)');
+    expect(tx('a >= b')).toBe('(a >= b)');
+  });
+
+  it('unary minus on literal → negative number', () => {
+    expect(tx('-5')).toBe('-5');
+  });
+
+  it('unary minus on expression → (0 - expr)', () => {
+    expect(tx('-x')).toBe('(0 - x)');
+  });
+
+  it('typeof → typeof()', () => {
+    expect(tx('typeof x')).toBe('typeof(x)');
+  });
+});
+
+// =============================================================================
+// Template Literals
+// =============================================================================
+
+describe('Template literal transpilation', () => {
+  it('`hello ${name}` → concat("hello ", to_string(name))', () => {
+    expect(tx('`hello ${name}`')).toBe('concat("hello ", to_string(name))');
+  });
+
+  it('`${a}-${b}` → concat(to_string(a), "-", to_string(b))', () => {
+    expect(tx('`${a}-${b}`')).toBe('concat(to_string(a), "-", to_string(b))');
+  });
+
+  it('`plain string` → "plain string"', () => {
+    expect(tx('`plain string`')).toBe('"plain string"');
+  });
+
+  it('`${value}` → to_string(value)', () => {
+    expect(tx('`${value}`')).toBe('to_string(value)');
+  });
+});
+
+// =============================================================================
+// Optional Chaining
+// =============================================================================
+
+describe('Optional chaining transpilation', () => {
+  it('a?.b → if(a != null, a.b, null)', () => {
+    expect(tx('a?.b')).toBe('if(a != null, a.b, null)');
+  });
+
+  it('a?.length → if(a != null, length(a), null)', () => {
+    expect(tx('a?.length')).toBe('if(a != null, length(a), null)');
+  });
+});
+
+// =============================================================================
+// Literals & Identifiers
+// =============================================================================
+
+describe('Literals and identifiers', () => {
+  it('string literal', () => {
+    expect(tx('"hello"')).toBe('"hello"');
+  });
+
+  it('number literal', () => {
+    expect(tx('42')).toBe('42');
+  });
+
+  it('boolean literals', () => {
+    expect(tx('true')).toBe('true');
+    expect(tx('false')).toBe('false');
+  });
+
+  it('null literal', () => {
+    expect(tx('null')).toBe('null');
+  });
+
+  it('undefined → null', () => {
+    expect(tx('undefined')).toBe('null');
+  });
+
+  it('identifier passes through', () => {
+    expect(tx('state_data')).toBe('state_data');
+  });
+
+  it('dot path passes through', () => {
+    expect(tx('state_data.name')).toBe('state_data.name');
+  });
+
+  it('array literal', () => {
+    expect(tx('[1, 2, 3]')).toBe('[1, 2, 3]');
+  });
+
+  it('object literal', () => {
+    expect(tx('({name: "Alice", age: 30})')).toBe('{"name": "Alice", "age": 30}');
+  });
+});
+
+// =============================================================================
+// Purity Tracking
+// =============================================================================
+
+describe('Purity tracking', () => {
+  it('pure expressions are marked pure', () => {
+    const result = txFull('a + b');
+    expect(result.pure).toBe(true);
+  });
+
+  it('translatable method calls are pure', () => {
+    const result = txFull('name.toLowerCase()');
+    expect(result.pure).toBe(true);
+  });
+
+  it('unknown methods are marked impure', () => {
+    const result = txFull('obj.unknownMethod()');
+    expect(result.pure).toBe(false);
+    expect(result.expression).toContain('$expr(');
+  });
+});
+
+// =============================================================================
+// Complex / Nested Expressions
+// =============================================================================
+
+describe('Complex expression transpilation', () => {
+  it('chained string methods', () => {
+    expect(tx('name.trim().toLowerCase()')).toBe('lower(trim(name))');
+  });
+
+  it('nested ternary', () => {
+    expect(tx('a ? b : c ? d : e')).toBe('if(a, b, if(c, d, e))');
+  });
+
+  it('Math in ternary', () => {
+    expect(tx('x > 0 ? Math.floor(x) : Math.ceil(x)')).toBe(
+      'if((x > 0), floor(x), ceil(x))',
+    );
+  });
+
+  it('filter + map chain', () => {
+    expect(tx('items.filter(x => x.active).map(x => x.name)')).toBe(
+      'map(filter(items, x => x.active), x => x.name)',
+    );
+  });
+
+  it('complex filter predicate', () => {
+    expect(tx('items.filter(x => x.age > 18 && x.active)')).toBe(
+      'filter(items, x => ((x.age > 18) && x.active))',
+    );
+  });
+
+  it('template literal with method call', () => {
+    expect(tx('`Hello ${name.toUpperCase()}`')).toBe(
+      'concat("Hello ", to_string(upper(name)))',
+    );
+  });
+
+  it('nullish coalescing with method', () => {
+    expect(tx('name?.toLowerCase() ?? "unknown"')).toBe(
+      'coalesce(lower(name), "unknown")',
+    );
+  });
+
+  it('TS type assertion is stripped', () => {
+    expect(tx('(x as string).toLowerCase()')).toBe('lower(x)');
+  });
+
+  it('TS non-null assertion is stripped', () => {
+    expect(tx('x!.toLowerCase()')).toBe('lower(x)');
+  });
+
+  it('array length in comparison', () => {
+    expect(tx('items.length > 0')).toBe('(length(items) > 0)');
+  });
+});
+
+// =============================================================================
+// Context options (localFieldMap, etc.)
+// =============================================================================
+
+describe('TranspileOptions context', () => {
+  it('localFieldMap rewrites identifiers to $local paths', () => {
+    const result = transpile(parseExpr('sidebarOpen'), {
+      localFieldMap: new Map([['sidebarOpen', 'sidebar_open']]),
+    });
+    expect(result).toBe('$local.sidebar_open');
+  });
+
+  it('localFieldMap works inside expressions', () => {
+    const result = transpile(parseExpr('count + 1'), {
+      localFieldMap: new Map([['count', 'count']]),
+    });
+    expect(result).toBe('($local.count + 1)');
+  });
+});
+
+// =============================================================================
+// Opaque Fallback
+// =============================================================================
+
+describe('Opaque fallback for untranslatable expressions', () => {
+  it('unknown method call produces $expr() wrapper', () => {
+    const result = tx('foo.customMethod(1, 2)');
+    expect(result).toContain('$expr(');
+    expect(result).toContain('customMethod');
+  });
+
+  it('await expression produces $expr() wrapper', () => {
+    const result = tx('await fetch("/api")');
+    expect(result).toContain('$expr(');
+  });
+});

package/src/__tests__/type-generator.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect } from 'vitest';
+import { generateTypeDeclaration, generateFullSource } from '../cli/type-generator';
+import type { WorkflowDefinitionResponse } from '../cli/registry-client';
+
+const sampleDef: WorkflowDefinitionResponse = {
+  slug: 'mod-authentication',
+  name: 'Authentication Module',
+  version: '2.0.0',
+  description: 'Handles user authentication flows',
+  category: 'module',
+  fields: [
+    { name: 'appName', type: 'string', default_value: '' },
+    {
+      name: 'layout',
+      type: 'string',
+      default_value: 'card',
+      validation: { enum: ['card', 'split', 'minimal'] },
+    },
+    { name: 'maxRetries', type: 'number', default_value: 3 },
+    { name: 'rememberMe', type: 'boolean', default_value: true },
+    { name: 'email', type: 'email', required: true },
+  ],
+  states: [
+    { name: 'unauthenticated', type: 'initial' },
+    { name: 'authenticating', type: 'normal' },
+    { name: 'authenticated', type: 'normal' },
+    { name: 'error', type: 'normal' },
+    { name: 'locked', type: 'final' },
+  ],
+  transitions: [
+    { name: 'login', from: ['unauthenticated'], to: 'authenticating' },
+    { name: 'success', from: ['authenticating'], to: 'authenticated' },
+    { name: 'fail', from: ['authenticating'], to: 'error' },
+    { name: 'retry', from: ['error'], to: 'authenticating' },
+    { name: 'logout', from: ['authenticated'], to: 'unauthenticated' },
+    { name: 'lockout', from: ['error', 'authenticating'], to: 'locked' },
+  ],
+};
+
+describe('type-generator', () => {
+  describe('generateTypeDeclaration', () => {
+    it('produces valid .d.ts output with defineModel', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      expect(output).toContain("import { defineModel } from '@mindmatrix/react'");
+      expect(output).toContain('declare const _default: ReturnType<typeof defineModel<{');
+      expect(output).toContain("readonly slug: 'mod-authentication'");
+      expect(output).toContain("readonly version: '2.0.0'");
+      expect(output).toContain('export default _default;');
+    });
+
+    it('includes all fields with readonly types', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      expect(output).toContain("readonly appName: { readonly type: 'string'; readonly default: '' }");
+      expect(output).toContain("readonly maxRetries: { readonly type: 'number'; readonly default: 3 }");
+      expect(output).toContain("readonly rememberMe: { readonly type: 'boolean'; readonly default: true }");
+    });
+
+    it('includes enum fields with readonly tuple', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      expect(output).toContain("readonly layout:");
+      expect(output).toContain("readonly enum: readonly ['card', 'split', 'minimal']");
+    });
+
+    it('marks required fields', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      expect(output).toContain("readonly email:");
+      expect(output).toContain('readonly required: true');
+    });
+
+    it('includes all states with type annotations', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      expect(output).toContain("readonly unauthenticated: { readonly type: 'initial' }");
+      expect(output).toContain("readonly locked: { readonly type: 'final' }");
+      // Normal states have no type annotation
+      expect(output).toContain('readonly authenticating: {  }');
+    });
+
+    it('includes all transitions with from/to', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      expect(output).toContain("readonly login: { readonly from: 'unauthenticated'; readonly to: 'authenticating' }");
+      expect(output).toContain("readonly logout: { readonly from: 'authenticated'; readonly to: 'unauthenticated' }");
+    });
+
+    it('handles multi-from transitions as union type', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      // lockout has from: ['error', 'authenticating']
+      expect(output).toContain("readonly lockout: { readonly from: 'error' | 'authenticating'; readonly to: 'locked' }");
+    });
+
+    it('exports State and Transition union types', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      expect(output).toContain("export type States = 'unauthenticated' | 'authenticating' | 'authenticated' | 'error' | 'locked'");
+      expect(output).toContain("export type Transitions = 'login' | 'success' | 'fail' | 'retry' | 'logout' | 'lockout'");
+    });
+
+    it('exports a Fields interface with TypeScript types', () => {
+      const output = generateTypeDeclaration(sampleDef);
+
+      expect(output).toContain('export interface Fields {');
+      expect(output).toContain('appName: string;');
+      expect(output).toContain('layout: string;');
+      expect(output).toContain('maxRetries: number;');
+      expect(output).toContain('rememberMe: boolean;');
+      expect(output).toContain('email: string;');
+    });
+
+    it('handles empty definition gracefully', () => {
+      const emptyDef: WorkflowDefinitionResponse = {
+        slug: 'empty-workflow',
+        name: 'Empty',
+        version: '1.0.0',
+        category: 'workflow',
+        fields: [],
+        states: [],
+        transitions: [],
+      };
+
+      const output = generateTypeDeclaration(emptyDef);
+
+      expect(output).toContain("readonly slug: 'empty-workflow'");
+      expect(output).toContain('readonly fields: {};');
+      expect(output).toContain('readonly states: {};');
+      expect(output).toContain('readonly transitions: {};');
+      // Should NOT export union types for empty arrays
+      expect(output).not.toContain('export type States');
+      expect(output).not.toContain('export type Transitions');
+    });
+
+    it('escapes special characters in string literals', () => {
+      const defWithSpecial: WorkflowDefinitionResponse = {
+        slug: "o'malley-app",
+        name: "O'Malley's App",
+        version: '1.0.0',
+        category: 'workflow',
+        fields: [{ name: 'note', type: 'string', default_value: "it's a test" }],
+        states: [{ name: 'start', type: 'initial' }],
+        transitions: [],
+      };
+
+      const output = generateTypeDeclaration(defWithSpecial);
+
+      expect(output).toContain("readonly slug: 'o\\'malley-app'");
+      expect(output).toContain("readonly default: 'it\\'s a test'");
+    });
+  });
+
+  describe('generateFullSource', () => {
+    it('produces valid TypeScript source with defineModel', () => {
+      const output = generateFullSource(sampleDef);
+
+      expect(output).toContain("import { defineModel } from '@mindmatrix/react'");
+      expect(output).toContain('export default defineModel({');
+      expect(output).toContain("slug: 'mod-authentication'");
+      expect(output).toContain("version: '2.0.0'");
+      expect(output).toContain('} as const);');
+    });
+
+    it('includes fields with type and default', () => {
+      const output = generateFullSource(sampleDef);
+
+      expect(output).toContain("appName: { type: 'string', default: '' },");
+      expect(output).toContain("layout: { type: 'string', default: 'card'");
+      expect(output).toContain("maxRetries: { type: 'number', default: 3 }");
+    });
+
+    it('includes enum as const assertion', () => {
+      const output = generateFullSource(sampleDef);
+
+      expect(output).toContain("enum: ['card', 'split', 'minimal'] as const");
+    });
+
+    it('includes states with type annotations', () => {
+      const output = generateFullSource(sampleDef);
+
+      expect(output).toContain("unauthenticated: { type: 'initial' }");
+      expect(output).toContain("locked: { type: 'final' }");
+      expect(output).toContain('authenticating: {},');
+    });
+
+    it('includes transitions', () => {
+      const output = generateFullSource(sampleDef);
+
+      expect(output).toContain("login: { from: 'unauthenticated', to: 'authenticating' }");
+      expect(output).toContain("logout: { from: 'authenticated', to: 'unauthenticated' }");
+    });
+
+    it('handles multi-from as array', () => {
+      const output = generateFullSource(sampleDef);
+
+      expect(output).toContain("lockout: { from: ['error', 'authenticating'], to: 'locked' }");
+    });
+  });
+});