@mmapp/react-compiler 0.1.0-alpha.1

package/src/__tests__/model-transitions.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Model Transitions Tests — validates transition extraction with guards, roles, auto.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { transformSync } from '@babel/core';
+import babelPlugin from '../babel';
+import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
+
+function compileModel(code: string): IRWorkflowDefinition {
+  const result = transformSync(code, {
+    filename: 'models/test.ts',
+    plugins: [[babelPlugin, { mode: 'strict' }]],
+    parserOpts: { plugins: ['typescript'], attachComment: true },
+  });
+  return (result as any)?.metadata?.mindmatrixIR;
+}
+
+describe('Model Transitions', () => {
+  it('should extract transitions with from/to', () => {
+    const ir = compileModel(`
+      export interface Task {
+        status: 'todo' | 'done';
+      }
+      export const transitions = {
+        complete: { from: 'todo', to: 'done' },
+      };
+    `);
+
+    expect(ir.transitions).toHaveLength(1);
+    expect(ir.transitions[0].name).toBe('complete');
+    expect(ir.transitions[0].from).toEqual(['todo']);
+    expect(ir.transitions[0].to).toBe('done');
+  });
+
+  it('should extract transitions with from as array', () => {
+    const ir = compileModel(`
+      export interface Item {
+        status: 'draft' | 'review' | 'published';
+      }
+      export const transitions = {
+        publish: { from: ['draft', 'review'], to: 'published' },
+      };
+    `);
+
+    expect(ir.transitions[0].from).toEqual(['draft', 'review']);
+  });
+
+  it('should extract guard as condition expression', () => {
+    const ir = compileModel(`
+      export interface Doc {
+        status: 'draft' | 'published';
+      }
+      export const transitions = {
+        publish: { from: 'draft', to: 'published', guard: '$user.role == "admin"' },
+      };
+    `);
+
+    const conditions = ir.transitions[0].conditions;
+    expect(conditions).toBeDefined();
+    expect(conditions!.length).toBeGreaterThan(0);
+    // Guard parsed into condition
+    const cond = conditions![0];
+    expect(cond.field).toBe('$user.role');
+    expect(cond.operator).toBe('eq');
+    expect(cond.value).toBe('admin');
+  });
+
+  it('should extract roles', () => {
+    const ir = compileModel(`
+      export interface Chan {
+        status: 'active' | 'archived';
+      }
+      export const transitions = {
+        archive: { from: 'active', to: 'archived', roles: ['admin', 'owner'] },
+      };
+    `);
+
+    expect(ir.transitions[0].roles).toEqual(['admin', 'owner']);
+  });
+
+  it('should extract auto flag', () => {
+    const ir = compileModel(`
+      export interface Msg {
+        status: 'sent' | 'delivered';
+      }
+      export const transitions = {
+        deliver: { from: 'sent', to: 'delivered', auto: true },
+      };
+    `);
+
+    expect(ir.transitions[0].auto).toBe(true);
+  });
+
+  it('should extract required_fields', () => {
+    const ir = compileModel(`
+      export interface Form {
+        status: 'draft' | 'submitted';
+      }
+      export const transitions = {
+        submit: { from: 'draft', to: 'submitted', required_fields: ['name', 'email'] },
+      };
+    `);
+
+    expect(ir.transitions[0].required_fields).toEqual(['name', 'email']);
+  });
+
+  it('should extract description', () => {
+    const ir = compileModel(`
+      export interface Flow {
+        status: 'a' | 'b';
+      }
+      export const transitions = {
+        advance: { from: 'a', to: 'b', description: 'Move to next stage' },
+      };
+    `);
+
+    expect(ir.transitions[0].description).toBe('Move to next stage');
+  });
+
+  it('should create states referenced by transitions', () => {
+    const ir = compileModel(`
+      export interface Process {
+        status: 'start' | 'end';
+      }
+      export const transitions = {
+        finish: { from: 'start', to: 'end' },
+      };
+    `);
+
+    const stateNames = ir.states.map((s) => s.name);
+    expect(stateNames).toContain('start');
+    expect(stateNames).toContain('end');
+  });
+
+  it('should handle multiple transitions', () => {
+    const ir = compileModel(`
+      export interface Pipeline {
+        status: 'draft' | 'review' | 'approved' | 'rejected';
+      }
+      export const transitions = {
+        submit: { from: 'draft', to: 'review' },
+        approve: { from: 'review', to: 'approved', roles: ['reviewer'] },
+        reject: { from: 'review', to: 'rejected', roles: ['reviewer'] },
+        revise: { from: ['approved', 'rejected'], to: 'draft' },
+      };
+    `);
+
+    expect(ir.transitions).toHaveLength(4);
+    const names = ir.transitions.map((t) => t.name);
+    expect(names).toEqual(['submit', 'approve', 'reject', 'revise']);
+  });
+
+  it('should handle guard with non-equality operators', () => {
+    const ir = compileModel(`
+      export interface Quota {
+        status: 'open' | 'full';
+      }
+      export const transitions = {
+        fill: { from: 'open', to: 'full', guard: '$instance.memberCount >= 100' },
+      };
+    `);
+
+    const cond = ir.transitions[0].conditions![0];
+    expect(cond.field).toBe('$instance.memberCount');
+    expect(cond.operator).toBe('gte');
+    expect(cond.value).toBe(100);
+  });
+
+  it('should fall back to expression for complex guards', () => {
+    const ir = compileModel(`
+      export interface Complex {
+        status: 'a' | 'b';
+      }
+      export const transitions = {
+        advance: { from: 'a', to: 'b', guard: 'canAdvance($instance, $user)' },
+      };
+    `);
+
+    const cond = ir.transitions[0].conditions![0];
+    expect(cond.expression).toBe('canAdvance($instance, $user)');
+  });
+});

package/src/__tests__/nrt-action-trace.test.ts

@@ -0,0 +1,391 @@
+/**
+ * NRT & Action Trace Tests — validates testing architecture types and utilities.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  createEmptyNRT,
+  findNode,
+  findVisibleNodes,
+  findInteractiveNodes,
+  countNodes,
+  compareNRT,
+  createActionRecorder,
+  getTransitionPath,
+  getFinalState,
+  countByKind,
+  hasTransition,
+} from '@mindmatrix/player-core';
+import type { NRT, NRTNode } from '@mindmatrix/player-core';
+
+// =============================================================================
+// NRT Tests
+// =============================================================================
+
+describe('NRT (Normalized Render Trace)', () => {
+  function createTestNRT(): NRT {
+    return {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [
+          {
+            id: 'heading',
+            type: 'Heading',
+            text: 'Welcome',
+            visible: true,
+            children: [],
+          },
+          {
+            id: 'input',
+            type: 'TextInput',
+            value: '',
+            visible: true,
+            enabled: true,
+            binding: 'name',
+            children: [],
+          },
+          {
+            id: 'submit-btn',
+            type: 'Button',
+            text: 'Submit',
+            visible: true,
+            enabled: true,
+            events: {
+              click: {
+                kind: 'transition',
+                target: { workflow: 'form', transition: 'submit' },
+              },
+            },
+            children: [],
+          },
+          {
+            id: 'hidden-section',
+            type: 'Section',
+            visible: false,
+            children: [
+              {
+                id: 'hidden-text',
+                type: 'Text',
+                text: 'Hidden',
+                visible: false,
+                children: [],
+              },
+            ],
+          },
+        ],
+      },
+    };
+  }
+
+  it('should create an empty NRT', () => {
+    const nrt = createEmptyNRT();
+    expect(nrt.version).toBe(1);
+    expect(nrt.root.type).toBe('Root');
+    expect(nrt.root.children).toHaveLength(0);
+  });
+
+  it('should find a node by ID', () => {
+    const nrt = createTestNRT();
+    const node = findNode(nrt, 'submit-btn');
+    expect(node).toBeDefined();
+    expect(node!.type).toBe('Button');
+    expect(node!.text).toBe('Submit');
+  });
+
+  it('should return undefined for non-existent node', () => {
+    const nrt = createTestNRT();
+    expect(findNode(nrt, 'nonexistent')).toBeUndefined();
+  });
+
+  it('should find visible nodes', () => {
+    const nrt = createTestNRT();
+    const visible = findVisibleNodes(nrt);
+    // root + heading + input + submit-btn = 4 (hidden section and text excluded)
+    expect(visible.length).toBe(4);
+  });
+
+  it('should find interactive nodes', () => {
+    const nrt = createTestNRT();
+    const interactive = findInteractiveNodes(nrt);
+    expect(interactive).toHaveLength(1);
+    expect(interactive[0].id).toBe('submit-btn');
+  });
+
+  it('should count all nodes', () => {
+    const nrt = createTestNRT();
+    expect(countNodes(nrt)).toBe(6); // root + 4 children + 1 nested
+  });
+});
+
+describe('NRT Comparator', () => {
+  it('should detect no changes for identical snapshots', () => {
+    const nrt: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [
+          { id: 'text', type: 'Text', text: 'Hello', visible: true, children: [] },
+        ],
+      },
+    };
+
+    const diff = compareNRT(nrt, nrt);
+    expect(diff.equal).toBe(true);
+    expect(diff.changes).toHaveLength(0);
+  });
+
+  it('should detect text changes', () => {
+    const before: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [
+          { id: 'text', type: 'Text', text: 'Hello', visible: true, children: [] },
+        ],
+      },
+    };
+
+    const after: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [
+          { id: 'text', type: 'Text', text: 'World', visible: true, children: [] },
+        ],
+      },
+    };
+
+    const diff = compareNRT(before, after);
+    expect(diff.equal).toBe(false);
+    expect(diff.changes.some((c) => c.field === 'text')).toBe(true);
+  });
+
+  it('should detect visibility changes', () => {
+    const before: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [
+          { id: 'section', type: 'Section', visible: true, children: [] },
+        ],
+      },
+    };
+
+    const after: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [
+          { id: 'section', type: 'Section', visible: false, children: [] },
+        ],
+      },
+    };
+
+    const diff = compareNRT(before, after);
+    expect(diff.equal).toBe(false);
+    expect(diff.changes.some((c) => c.field === 'visible')).toBe(true);
+  });
+
+  it('should detect added nodes', () => {
+    const before: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [],
+      },
+    };
+
+    const after: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [
+          { id: 'new', type: 'Text', text: 'New', visible: true, children: [] },
+        ],
+      },
+    };
+
+    const diff = compareNRT(before, after);
+    expect(diff.equal).toBe(false);
+    expect(diff.changes.some((c) => c.type === 'added')).toBe(true);
+  });
+
+  it('should detect removed nodes', () => {
+    const before: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [
+          { id: 'old', type: 'Text', text: 'Old', visible: true, children: [] },
+        ],
+      },
+    };
+
+    const after: NRT = {
+      version: 1,
+      root: {
+        id: 'root',
+        type: 'Stack',
+        visible: true,
+        children: [],
+      },
+    };
+
+    const diff = compareNRT(before, after);
+    expect(diff.equal).toBe(false);
+    expect(diff.changes.some((c) => c.type === 'removed')).toBe(true);
+  });
+
+  it('should detect workflow state changes', () => {
+    const before: NRT = {
+      version: 1,
+      workflowState: 'draft',
+      root: { id: 'root', type: 'Root', visible: true, children: [] },
+    };
+
+    const after: NRT = {
+      version: 1,
+      workflowState: 'active',
+      root: { id: 'root', type: 'Root', visible: true, children: [] },
+    };
+
+    const diff = compareNRT(before, after);
+    expect(diff.equal).toBe(false);
+    expect(diff.changes.some((c) => c.field === 'workflowState')).toBe(true);
+  });
+});
+
+// =============================================================================
+// Action Trace Tests
+// =============================================================================
+
+describe('Action Trace', () => {
+  it('should create a recorder', () => {
+    const recorder = createActionRecorder('counter');
+    expect(recorder).toBeDefined();
+    expect(recorder.getTrace().workflowSlug).toBe('counter');
+  });
+
+  it('should record transitions', () => {
+    const recorder = createActionRecorder('counter');
+    recorder.recordTransition('increment', 'idle', 'counting');
+    recorder.recordTransition('reset', 'counting', 'idle');
+
+    const trace = recorder.getTrace();
+    expect(trace.ticks).toHaveLength(2);
+    expect(trace.ticks[0].kind).toBe('transition');
+    expect(trace.ticks[0].name).toBe('increment');
+    expect(trace.ticks[0].fromState).toBe('idle');
+    expect(trace.ticks[0].toState).toBe('counting');
+  });
+
+  it('should auto-increment tick numbers', () => {
+    const recorder = createActionRecorder('test');
+    recorder.recordAction('first');
+    recorder.recordAction('second');
+    recorder.recordAction('third');
+
+    const trace = recorder.getTrace();
+    expect(trace.ticks[0].tick).toBe(0);
+    expect(trace.ticks[1].tick).toBe(1);
+    expect(trace.ticks[2].tick).toBe(2);
+  });
+
+  it('should record different action kinds', () => {
+    const recorder = createActionRecorder('test');
+    recorder.recordTransition('t1', 'a', 'b');
+    recorder.recordAction('a1');
+    recorder.recordTimer('timer1');
+    recorder.recordQuery('q1');
+    recorder.recordMutation('m1');
+    recorder.recordEvent('e1');
+    recorder.recordError('err1');
+
+    const counts = countByKind(recorder.getTrace());
+    expect(counts.transition).toBe(1);
+    expect(counts.action).toBe(1);
+    expect(counts.timer).toBe(1);
+    expect(counts.query).toBe(1);
+    expect(counts.mutation).toBe(1);
+    expect(counts.event).toBe(1);
+    expect(counts.error).toBe(1);
+  });
+
+  it('should get transition path', () => {
+    const recorder = createActionRecorder('test');
+    recorder.recordTransition('start', 'draft', 'active');
+    recorder.recordAction('notify');
+    recorder.recordTransition('archive', 'active', 'archived');
+
+    const path = getTransitionPath(recorder.getTrace());
+    expect(path).toEqual(['draft → active', 'active → archived']);
+  });
+
+  it('should get final state', () => {
+    const recorder = createActionRecorder('test');
+    recorder.recordTransition('start', 'draft', 'active');
+    recorder.recordTransition('archive', 'active', 'archived');
+
+    expect(getFinalState(recorder.getTrace())).toBe('archived');
+  });
+
+  it('should check for specific transitions', () => {
+    const recorder = createActionRecorder('test');
+    recorder.recordTransition('start', 'draft', 'active');
+
+    expect(hasTransition(recorder.getTrace(), 'draft', 'active')).toBe(true);
+    expect(hasTransition(recorder.getTrace(), 'active', 'archived')).toBe(false);
+  });
+
+  it('should finalize trace with endedAt', () => {
+    const recorder = createActionRecorder('test');
+    recorder.recordAction('work');
+    const trace = recorder.finalize();
+
+    expect(trace.endedAt).toBeDefined();
+    expect(trace.startedAt).toBeDefined();
+  });
+
+  it('should reset recorder', () => {
+    const recorder = createActionRecorder('test');
+    recorder.recordAction('work');
+    recorder.recordAction('more');
+    expect(recorder.getTrace().ticks).toHaveLength(2);
+
+    recorder.reset();
+    expect(recorder.getTrace().ticks).toHaveLength(0);
+  });
+
+  it('should include instance ID', () => {
+    const recorder = createActionRecorder('counter', 'instance-123');
+    expect(recorder.getTrace().instanceId).toBe('instance-123');
+  });
+
+  it('should include detail in ticks', () => {
+    const recorder = createActionRecorder('test');
+    recorder.recordTransition('submit', 'draft', 'review', { user: 'admin', reason: 'ready' });
+
+    const tick = recorder.getTrace().ticks[0];
+    expect(tick.detail.user).toBe('admin');
+    expect(tick.detail.reason).toBe('ready');
+  });
+});