@mmapp/react-compiler 0.1.0-alpha.1 → 0.1.0-alpha.5

package/src/__tests__/instance-key.test.ts

@@ -1,82 +0,0 @@
-/**
- * Instance Key Tests — validates deterministic key derivation.
- */
-
-import { describe, it, expect } from 'vitest';
-// Inline the function for testing since we can't easily import from the react package
-function djb2Hash(str: string): string {
-  let hash1 = 5381;
-  let hash2 = 52711;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash1 = ((hash1 << 5) + hash1 + char) | 0;
-    hash2 = ((hash2 << 5) + hash2 + char) | 0;
-  }
-  const h1 = (hash1 >>> 0).toString(16).padStart(8, '0');
-  const h2 = (hash2 >>> 0).toString(16).padStart(8, '0');
-  return h1 + h2;
-}
-
-function deriveInstanceKeySync(
-  blueprintSlug: string,
-  layoutPath: string,
-  params: Record<string, string> = {}
-): string {
-  const sortedParams = Object.keys(params)
-    .sort()
-    .map((k) => `${k}=${params[k]}`)
-    .join('&');
-  const input = `${blueprintSlug}:${layoutPath}:${sortedParams}`;
-  const hash = djb2Hash(input);
-  return `${blueprintSlug}:${hash}`;
-}
-
-describe('Instance Key Derivation', () => {
-  it('should produce deterministic keys', () => {
-    const key1 = deriveInstanceKeySync('mm-chat', '/chat/[channelId]', { channelId: '123' });
-    const key2 = deriveInstanceKeySync('mm-chat', '/chat/[channelId]', { channelId: '123' });
-    expect(key1).toBe(key2);
-  });
-
-  it('should differ for different params', () => {
-    const key1 = deriveInstanceKeySync('mm-chat', '/chat/[channelId]', { channelId: '123' });
-    const key2 = deriveInstanceKeySync('mm-chat', '/chat/[channelId]', { channelId: '456' });
-    expect(key1).not.toBe(key2);
-  });
-
-  it('should differ for different slugs', () => {
-    const key1 = deriveInstanceKeySync('mm-chat', '/home', {});
-    const key2 = deriveInstanceKeySync('mm-tasks', '/home', {});
-    expect(key1).not.toBe(key2);
-  });
-
-  it('should differ for different paths', () => {
-    const key1 = deriveInstanceKeySync('mm-chat', '/chat', {});
-    const key2 = deriveInstanceKeySync('mm-chat', '/settings', {});
-    expect(key1).not.toBe(key2);
-  });
-
-  it('should include blueprint slug as prefix', () => {
-    const key = deriveInstanceKeySync('mm-chat', '/home', {});
-    expect(key.startsWith('mm-chat:')).toBe(true);
-  });
-
-  it('should produce 16-char hex hash suffix', () => {
-    const key = deriveInstanceKeySync('mm-chat', '/home', {});
-    const hash = key.split(':')[1];
-    expect(hash).toHaveLength(16);
-    expect(/^[0-9a-f]+$/.test(hash)).toBe(true);
-  });
-
-  it('should sort params for determinism', () => {
-    const key1 = deriveInstanceKeySync('app', '/route', { b: '2', a: '1' });
-    const key2 = deriveInstanceKeySync('app', '/route', { a: '1', b: '2' });
-    expect(key1).toBe(key2);
-  });
-
-  it('should handle empty params', () => {
-    const key = deriveInstanceKeySync('mm-chat', '/home', {});
-    expect(key).toBeDefined();
-    expect(key.length).toBeGreaterThan(0);
-  });
-});

package/src/__tests__/ir-migration.test.ts

@@ -1,255 +0,0 @@
-/**
- * IR Migration Tests — validates version detection and migration chain.
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  detectIRVersion,
-  normalizeDefinition,
-  needsMigration,
-  CURRENT_IR_VERSION,
-} from '@mindmatrix/player-core';
-
-// =============================================================================
-// Version Detection
-// =============================================================================
-
-describe('IR Version Detection', () => {
-  it('should detect explicit ir_version', () => {
-    expect(detectIRVersion({ ir_version: '1.2', slug: 'test', states: [] })).toBe('1.2');
-  });
-
-  it('should detect v1.0 from state_type naming', () => {
-    const def = {
-      slug: 'test',
-      states: [{ name: 'draft', state_type: 'START' }],
-      fields: [{ name: 'x', field_type: 'text' }],
-    };
-    expect(detectIRVersion(def)).toBe('1.0');
-  });
-
-  it('should detect v1.1 from type naming', () => {
-    const def = {
-      slug: 'test',
-      states: [{ name: 'draft', type: 'START' }],
-      fields: [{ name: 'x', type: 'text' }],
-    };
-    expect(detectIRVersion(def)).toBe('1.1');
-  });
-
-  it('should detect v1.2 from extensions', () => {
-    const def = {
-      slug: 'test',
-      states: [{ name: 'draft', type: 'START' }],
-      extensions: { cedar: [] },
-    };
-    expect(detectIRVersion(def)).toBe('1.2');
-  });
-
-  it('should detect v1.2 from workflow-level on_event', () => {
-    const def = {
-      slug: 'test',
-      states: [{ name: 'draft', type: 'START' }],
-      on_event: [{ match: '*', actions: [] }],
-    };
-    expect(detectIRVersion(def)).toBe('1.2');
-  });
-
-  it('should default to v1.0 for ambiguous definitions', () => {
-    expect(detectIRVersion({ slug: 'test', states: [] })).toBe('1.0');
-  });
-});
-
-// =============================================================================
-// needsMigration
-// =============================================================================
-
-describe('needsMigration', () => {
-  it('should return true for v1.0 definitions', () => {
-    const def = {
-      slug: 'test',
-      states: [{ name: 'draft', state_type: 'START' }],
-    };
-    expect(needsMigration(def)).toBe(true);
-  });
-
-  it('should return false for current version', () => {
-    const def = {
-      ir_version: CURRENT_IR_VERSION,
-      slug: 'test',
-      states: [],
-    };
-    expect(needsMigration(def)).toBe(false);
-  });
-});
-
-// =============================================================================
-// Migration: v1.0 → v1.2
-// =============================================================================
-
-describe('Migration v1.0 → current', () => {
-  it('should normalize state_type to type', () => {
-    const v10 = {
-      slug: 'counter',
-      name: 'Counter',
-      version: '1.0.0',
-      category: 'demo',
-      states: [
-        {
-          name: 'idle',
-          state_type: 'START',
-          on_enter: [
-            { id: 'a1', action_type: 'set_field', config: { field: 'status', value: 'idle' } },
-          ],
-          on_exit: [],
-          during: [],
-        },
-        {
-          name: 'counting',
-          state_type: 'REGULAR',
-          on_enter: [],
-          on_exit: [],
-          during: [
-            {
-              id: 'd1', type: 'interval', interval_ms: 1000,
-              actions: [{ id: 'a2', action_type: 'set_field', config: { field: 'count', value: 1 } }],
-            },
-          ],
-        },
-      ],
-      transitions: [
-        {
-          name: 'start',
-          from: ['idle'],
-          to: 'counting',
-          actions: [{ id: 'ta1', action_type: 'log_event', config: {} }],
-        },
-      ],
-      fields: [
-        { name: 'count', field_type: 'number', default_value: 0 },
-        { name: 'status', field_type: 'text', default_value: 'idle' },
-      ],
-      roles: [],
-    };
-
-    const result = normalizeDefinition(v10);
-    expect(result.migrated).toBe(true);
-    expect(result.fromVersion).toBe('1.0');
-    expect(result.toVersion).toBe(CURRENT_IR_VERSION);
-    expect(result.appliedMigrations).toHaveLength(2);
-
-    const def = result.definition;
-
-    // States should use 'type' not 'state_type'
-    expect(def.states[0].type).toBe('START');
-    expect((def.states[0] as any).state_type).toBeUndefined();
-
-    // Actions should use 'type' not 'action_type'
-    const action = def.states[0].on_enter[0];
-    expect(action.type).toBe('set_field');
-    expect((action as any).action_type).toBeUndefined();
-
-    // During actions should be normalized
-    const duringAction = def.states[1].during[0].actions[0];
-    expect(duringAction.type).toBe('set_field');
-    expect((duringAction as any).action_type).toBeUndefined();
-
-    // Transition actions should be normalized
-    const transAction = def.transitions[0].actions[0];
-    expect(transAction.type).toBe('log_event');
-    expect((transAction as any).action_type).toBeUndefined();
-
-    // Fields should use 'type' not 'field_type'
-    expect(def.fields[0].type).toBe('number');
-    expect((def.fields[0] as any).field_type).toBeUndefined();
-
-    // States should have during and on_event arrays (v1.2)
-    expect(def.states[0].during).toEqual([]);
-    expect(def.states[0].on_event).toEqual([]);
-  });
-
-  it('should not re-migrate current version', () => {
-    const v12 = {
-      ir_version: CURRENT_IR_VERSION,
-      slug: 'test',
-      name: 'Test',
-      version: '1.0.0',
-      category: 'test',
-      states: [{ name: 'draft', type: 'START', on_enter: [], during: [], on_exit: [], on_event: [] }],
-      transitions: [],
-      fields: [],
-      roles: [],
-      extensions: {},
-    };
-
-    const result = normalizeDefinition(v12);
-    expect(result.migrated).toBe(false);
-    expect(result.appliedMigrations).toHaveLength(0);
-  });
-});
-
-// =============================================================================
-// Migration: v1.1 → v1.2
-// =============================================================================
-
-describe('Migration v1.1 → v1.2', () => {
-  it('should add extensions and ensure during/on_event arrays', () => {
-    const v11 = {
-      slug: 'test',
-      name: 'Test',
-      version: '1.0.0',
-      category: 'test',
-      states: [{ name: 'draft', type: 'START', on_enter: [], on_exit: [] }],
-      transitions: [],
-      fields: [{ name: 'x', type: 'text' }],
-      roles: [],
-    };
-
-    const result = normalizeDefinition(v11);
-    expect(result.migrated).toBe(true);
-    expect(result.fromVersion).toBe('1.1');
-    expect(result.toVersion).toBe(CURRENT_IR_VERSION);
-
-    const def = result.definition;
-    expect(def.extensions).toEqual({});
-    expect(def.states[0].during).toEqual([]);
-    expect(def.states[0].on_event).toEqual([]);
-  });
-});
-
-// =============================================================================
-// Edge Cases
-// =============================================================================
-
-describe('Migration Edge Cases', () => {
-  it('should handle empty states array', () => {
-    const def = { slug: 'test', states: [], fields: [], transitions: [], roles: [] };
-    const result = normalizeDefinition(def as any);
-    expect(result.definition.states).toEqual([]);
-  });
-
-  it('should handle states without on_enter/on_exit', () => {
-    const def = {
-      slug: 'test',
-      states: [{ name: 'draft', state_type: 'START' }],
-      fields: [],
-      transitions: [],
-      roles: [],
-    };
-    const result = normalizeDefinition(def as any);
-    expect(result.definition.states[0].type).toBe('START');
-  });
-
-  it('should preserve extra metadata through migration', () => {
-    const def = {
-      slug: 'test',
-      states: [{ name: 'draft', state_type: 'START' }],
-      fields: [],
-      transitions: [],
-      roles: [],
-      metadata: { custom: 'data' },
-    };
-    const result = normalizeDefinition(def as any);
-    expect(result.definition.metadata).toEqual({ custom: 'data' });
-  });
-});

package/src/__tests__/lock-file.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  readLockFile,
-  writeLockFile,
-  upsertLockEntry,
-  removeLockEntry,
-  computeHash,
-} from '../cli/lock-file';
-
-describe('lock-file', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'mmrc-lock-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('readLockFile', () => {
-    it('returns empty object when no lock file exists', () => {
-      const result = readLockFile(tempDir);
-      expect(result).toEqual({});
-    });
-
-    it('reads existing lock file', () => {
-      const data = {
-        'test-pkg': {
-          slug: 'test-pkg',
-          version: '1.0.0',
-          installedAt: '2026-01-01T00:00:00.000Z',
-          mode: 'type-only' as const,
-          hash: 'abc123',
-        },
-      };
-      const { writeFileSync } = require('fs');
-      writeFileSync(join(tempDir, 'mm.lock'), JSON.stringify(data), 'utf-8');
-
-      const result = readLockFile(tempDir);
-      expect(result['test-pkg'].slug).toBe('test-pkg');
-      expect(result['test-pkg'].version).toBe('1.0.0');
-    });
-  });
-
-  describe('writeLockFile', () => {
-    it('writes sorted entries', () => {
-      const data = {
-        'z-pkg': { slug: 'z-pkg', version: '1.0.0', installedAt: '', mode: 'type-only' as const, hash: '' },
-        'a-pkg': { slug: 'a-pkg', version: '2.0.0', installedAt: '', mode: 'full' as const, hash: '' },
-      };
-
-      writeLockFile(tempDir, data);
-
-      const content = readFileSync(join(tempDir, 'mm.lock'), 'utf-8');
-      const parsed = JSON.parse(content);
-      const keys = Object.keys(parsed);
-      expect(keys).toEqual(['a-pkg', 'z-pkg']);
-    });
-  });
-
-  describe('upsertLockEntry', () => {
-    it('adds a new entry', () => {
-      upsertLockEntry(tempDir, 'my-pkg', '1.0.0', 'type-only', 'content');
-
-      const result = readLockFile(tempDir);
-      expect(result['my-pkg']).toBeDefined();
-      expect(result['my-pkg'].slug).toBe('my-pkg');
-      expect(result['my-pkg'].version).toBe('1.0.0');
-      expect(result['my-pkg'].mode).toBe('type-only');
-      expect(result['my-pkg'].hash).toBe(computeHash('content'));
-    });
-
-    it('updates existing entry', () => {
-      upsertLockEntry(tempDir, 'my-pkg', '1.0.0', 'type-only', 'v1');
-      upsertLockEntry(tempDir, 'my-pkg', '2.0.0', 'full', 'v2');
-
-      const result = readLockFile(tempDir);
-      expect(result['my-pkg'].version).toBe('2.0.0');
-      expect(result['my-pkg'].mode).toBe('full');
-    });
-  });
-
-  describe('removeLockEntry', () => {
-    it('removes an existing entry', () => {
-      upsertLockEntry(tempDir, 'my-pkg', '1.0.0', 'type-only', 'content');
-      const removed = removeLockEntry(tempDir, 'my-pkg');
-
-      expect(removed).toBe(true);
-      const result = readLockFile(tempDir);
-      expect(result['my-pkg']).toBeUndefined();
-    });
-
-    it('returns false for non-existent entry', () => {
-      const removed = removeLockEntry(tempDir, 'nonexistent');
-      expect(removed).toBe(false);
-    });
-  });
-
-  describe('computeHash', () => {
-    it('produces deterministic 16-char hash', () => {
-      const hash1 = computeHash('hello');
-      const hash2 = computeHash('hello');
-      expect(hash1).toBe(hash2);
-      expect(hash1).toHaveLength(16);
-    });
-
-    it('produces different hashes for different content', () => {
-      const hash1 = computeHash('hello');
-      const hash2 = computeHash('world');
-      expect(hash1).not.toBe(hash2);
-    });
-  });
-});

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

@@ -1,195 +0,0 @@
-/**
- * Model Extractor Tests — validates TypeScript interface → field extraction.
- */
-
-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, filename = 'models/test.ts'): IRWorkflowDefinition {
-  const result = transformSync(code, {
-    filename,
-    plugins: [[babelPlugin, { mode: 'strict' }]],
-    parserOpts: { plugins: ['typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-describe('Model Extractor — Interface → Fields', () => {
-  it('should extract string fields', () => {
-    const ir = compileModel(`
-      export interface Order {
-        name: string;
-        status: 'draft' | 'active';
-      }
-      export const transitions = {};
-    `);
-
-    const nameField = ir.fields.find((f) => f.name === 'name');
-    expect(nameField).toBeDefined();
-    expect(nameField!.type).toBe('text');
-    expect(nameField!.required).toBe(true);
-  });
-
-  it('should extract number fields', () => {
-    const ir = compileModel(`
-      export interface Product {
-        price: number;
-        status: 'available' | 'sold';
-      }
-      export const transitions = {};
-    `);
-
-    const priceField = ir.fields.find((f) => f.name === 'price');
-    expect(priceField).toBeDefined();
-    expect(priceField!.type).toBe('number');
-    expect(priceField!.default_value).toBe(0);
-  });
-
-  it('should extract boolean fields', () => {
-    const ir = compileModel(`
-      export interface Feature {
-        isEnabled: boolean;
-        status: 'draft' | 'live';
-      }
-      export const transitions = {};
-    `);
-
-    const field = ir.fields.find((f) => f.name === 'isEnabled');
-    expect(field).toBeDefined();
-    expect(field!.type).toBe('boolean');
-    expect(field!.default_value).toBe(false);
-  });
-
-  it('should extract Date fields as datetime', () => {
-    const ir = compileModel(`
-      export interface Event {
-        startAt: Date;
-        status: 'upcoming' | 'past';
-      }
-      export const transitions = {};
-    `);
-
-    const field = ir.fields.find((f) => f.name === 'startAt');
-    expect(field).toBeDefined();
-    expect(field!.type).toBe('datetime');
-  });
-
-  it('should extract union literal types as select with options', () => {
-    const ir = compileModel(`
-      export interface Task {
-        priority: 'low' | 'medium' | 'high';
-        status: 'todo' | 'done';
-      }
-      export const transitions = {};
-    `);
-
-    const field = ir.fields.find((f) => f.name === 'priority');
-    expect(field).toBeDefined();
-    expect(field!.type).toBe('select');
-    expect(field!.validation?.options).toEqual(['low', 'medium', 'high']);
-  });
-
-  it('should extract array types as multi_select', () => {
-    const ir = compileModel(`
-      export interface Item {
-        tags: string[];
-        status: 'new' | 'old';
-      }
-      export const transitions = {};
-    `);
-
-    const field = ir.fields.find((f) => f.name === 'tags');
-    expect(field).toBeDefined();
-    expect(field!.type).toBe('multi_select');
-  });
-
-  it('should mark optional fields as not required', () => {
-    const ir = compileModel(`
-      export interface Doc {
-        title: string;
-        description?: string;
-        status: 'draft' | 'published';
-      }
-      export const transitions = {};
-    `);
-
-    const titleField = ir.fields.find((f) => f.name === 'title');
-    const descField = ir.fields.find((f) => f.name === 'description');
-    expect(titleField!.required).toBe(true);
-    expect(descField!.required).toBe(false);
-  });
-
-  it('should extract Record types as json', () => {
-    const ir = compileModel(`
-      export interface Config {
-        metadata: Record<string, unknown>;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-    `);
-
-    const field = ir.fields.find((f) => f.name === 'metadata');
-    expect(field).toBeDefined();
-    expect(field!.type).toBe('json');
-  });
-
-  it('should generate labels from field names', () => {
-    const ir = compileModel(`
-      export interface Entity {
-        firstName: string;
-        createdAt: Date;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-    `);
-
-    const firstName = ir.fields.find((f) => f.name === 'firstName');
-    expect(firstName!.label).toBe('First Name');
-  });
-
-  it('should create states from first union field', () => {
-    const ir = compileModel(`
-      export interface Ticket {
-        title: string;
-        status: 'open' | 'in_progress' | 'closed';
-      }
-      export const transitions = {};
-    `);
-
-    expect(ir.states.length).toBeGreaterThanOrEqual(3);
-    const stateNames = ir.states.map((s) => s.name);
-    expect(stateNames).toContain('open');
-    expect(stateNames).toContain('in_progress');
-    expect(stateNames).toContain('closed');
-
-    // First option should be START
-    const openState = ir.states.find((s) => s.name === 'open');
-    expect(openState!.type).toBe('START');
-  });
-
-  it('should infer slug from interface name', () => {
-    const ir = compileModel(`
-      export interface UserProfile {
-        name: string;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-    `);
-
-    expect(ir.slug).toBe('user-profile');
-  });
-
-  it('should infer name from interface name', () => {
-    const ir = compileModel(`
-      export interface OrderItem {
-        qty: number;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-    `);
-
-    expect(ir.name).toBe('OrderItem');
-  });
-});