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

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

@@ -1,502 +0,0 @@
-/**
- * Model Round-Trip Test — validates full channel model → complete IR.
- *
- * This is the acceptance test for model file compilation.
- */
-
-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/channel.ts'): IRWorkflowDefinition {
-  const result = transformSync(code, {
-    filename,
-    plugins: [[babelPlugin, { mode: 'strict' }]],
-    parserOpts: { plugins: ['typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-function compileDefinition(code: string, filename = 'models/channel.ts'): Record<string, unknown> {
-  const result = transformSync(code, {
-    filename,
-    plugins: [[babelPlugin, { mode: 'strict' }]],
-    parserOpts: { plugins: ['typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixDefinition;
-}
-
-const CHANNEL_MODEL = `
-  /**
-   * @workflow slug="mm-chat-channel-model" version="1.0.0" category="model"
-   * @description Channel lifecycle management
-   */
-  export interface Channel {
-    name: string;
-    description: string;
-    status: 'draft' | 'active' | 'archived';
-    memberCount: number;
-    isPublic: boolean;
-    createdAt: Date;
-    tags: string[];
-  }
-
-  export const transitions = {
-    activate: {
-      from: 'draft',
-      to: 'active',
-      guard: '$instance.name != ""',
-      required_fields: ['name'],
-    },
-    archive: {
-      from: 'active',
-      to: 'archived',
-      guard: '$user.role == "admin"',
-      roles: ['admin', 'owner'],
-    },
-    reactivate: {
-      from: 'archived',
-      to: 'active',
-      roles: ['admin'],
-    },
-  };
-
-  export const endStates = ['deleted'];
-  export const cancelledStates = ['cancelled'];
-
-  export const hooks = {
-    on_enter_active: {
-      emit: 'channel:activated',
-      actions: ['notifyMembers', 'indexForSearch'],
-    },
-    on_exit_active: {
-      actions: ['logDeactivation'],
-    },
-  };
-
-  export const runtime = 'backend';
-
-  export const fieldOptions = {
-    name: {
-      scope: 'instance',
-      persistence: 'durable',
-      sync: 'tenant',
-      editable_in_states: ['draft'],
-      validation: { minLength: 1, maxLength: 100 },
-    },
-    memberCount: {
-      computed: 'count(refs("member", { channel_id: $instance.id }))',
-      computed_deps: [],
-      visible_in_states: ['active', 'archived'],
-      editable_by_roles: ['admin'],
-    },
-    isPublic: {
-      editable_by_roles: ['admin', 'owner'],
-      visible_when: '$instance.status != "deleted"',
-    },
-  };
-`;
-
-describe('Model Round-Trip — Channel', () => {
-  it('should have correct metadata', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    expect(ir.slug).toBe('mm-chat-channel-model');
-    expect(ir.name).toBe('Channel');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('model');
-    expect(ir.metadata?.runtime).toBe('backend');
-  });
-
-  it('should have 7 fields', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    expect(ir.fields).toHaveLength(7);
-    const fieldNames = ir.fields.map((f) => f.name);
-    expect(fieldNames).toEqual(['name', 'description', 'status', 'memberCount', 'isPublic', 'createdAt', 'tags']);
-  });
-
-  it('should have correct field types', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    const typeMap = Object.fromEntries(ir.fields.map((f) => [f.name, f.type]));
-    expect(typeMap.name).toBe('text');
-    expect(typeMap.description).toBe('text');
-    expect(typeMap.status).toBe('select');
-    expect(typeMap.memberCount).toBe('number');
-    expect(typeMap.isPublic).toBe('boolean');
-    expect(typeMap.createdAt).toBe('datetime');
-    expect(typeMap.tags).toBe('multi_select');
-  });
-
-  it('should have status field with select options', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    const status = ir.fields.find((f) => f.name === 'status');
-    expect(status!.validation?.options).toEqual(['draft', 'active', 'archived']);
-  });
-
-  it('should have 3 transitions with guards and roles', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    expect(ir.transitions).toHaveLength(3);
-
-    const activate = ir.transitions.find((t) => t.name === 'activate');
-    expect(activate!.from).toEqual(['draft']);
-    expect(activate!.to).toBe('active');
-    expect(activate!.conditions).toBeDefined();
-    expect(activate!.required_fields).toEqual(['name']);
-
-    const archive = ir.transitions.find((t) => t.name === 'archive');
-    expect(archive!.roles).toEqual(['admin', 'owner']);
-    expect(archive!.conditions).toBeDefined();
-
-    const reactivate = ir.transitions.find((t) => t.name === 'reactivate');
-    expect(reactivate!.roles).toEqual(['admin']);
-  });
-
-  it('should have states from union + endStates + cancelledStates', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    const stateMap = Object.fromEntries(ir.states.map((s) => [s.name, s.type]));
-
-    expect(stateMap.draft).toBe('START');
-    expect(stateMap.active).toBe('REGULAR');
-    expect(stateMap.archived).toBe('REGULAR');
-    expect(stateMap.deleted).toBe('END');
-    expect(stateMap.cancelled).toBe('CANCELLED');
-  });
-
-  it('should have on_enter hooks on active state', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    const active = ir.states.find((s) => s.name === 'active');
-    expect(active!.on_enter).toHaveLength(3); // 1 emit + 2 server actions
-    expect(active!.on_enter[0].type).toBe('emit_event');
-    expect(active!.on_enter[0].config.event).toBe('channel:activated');
-    expect(active!.on_enter[1].type).toBe('server_action');
-    expect(active!.on_enter[1].config.handler).toBe('notifyMembers');
-    expect(active!.on_enter[2].type).toBe('server_action');
-    expect(active!.on_enter[2].config.handler).toBe('indexForSearch');
-  });
-
-  it('should have on_exit hooks on active state', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    const active = ir.states.find((s) => s.name === 'active');
-    expect(active!.on_exit).toHaveLength(1);
-    expect(active!.on_exit[0].type).toBe('server_action');
-    expect(active!.on_exit[0].config.handler).toBe('logDeactivation');
-  });
-
-  it('should have field ACL on name field', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    const name = ir.fields.find((f) => f.name === 'name');
-    expect(name!.editable_in_states).toEqual(['draft']);
-    expect(name!.state_home).toEqual({
-      scope: 'instance',
-      persistence: 'durable',
-      sync: 'tenant',
-    });
-    expect(name!.validation?.minLength).toBe(1);
-    expect(name!.validation?.maxLength).toBe(100);
-  });
-
-  it('should have computed field on memberCount', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    const memberCount = ir.fields.find((f) => f.name === 'memberCount');
-    expect(memberCount!.computed).toBe('count(refs("member", { channel_id: $instance.id }))');
-    expect(memberCount!.computed_deps).toEqual([]);
-    expect(memberCount!.visible_in_states).toEqual(['active', 'archived']);
-    expect(memberCount!.editable_by_roles).toEqual(['admin']);
-  });
-
-  it('should have visible_when on isPublic', () => {
-    const ir = compileModel(CHANNEL_MODEL);
-    const isPublic = ir.fields.find((f) => f.name === 'isPublic');
-    expect(isPublic!.editable_by_roles).toEqual(['admin', 'owner']);
-    expect(isPublic!.visible_when).toBe('$instance.status != "deleted"');
-  });
-
-  it('should produce valid engine-compatible definition', () => {
-    const def = compileDefinition(CHANNEL_MODEL);
-    expect(def.id).toBe('def-mm-chat-channel-model');
-    expect(def.slug).toBe('mm-chat-channel-model');
-    expect(def.version).toBe('1.0.0');
-    expect(def.category).toBe('model');
-
-    const states = def.states as any[];
-    expect(states.length).toBeGreaterThanOrEqual(5);
-
-    const fields = def.fields as any[];
-    expect(fields.length).toBe(7);
-
-    const transitions = def.transitions as any[];
-    expect(transitions.length).toBe(3);
-  });
-});
-
-describe('Model Round-Trip — Message', () => {
-  const MESSAGE_MODEL = `
-    export interface Message {
-      content: string;
-      senderId: string;
-      status: 'composing' | 'sent' | 'delivered' | 'read';
-      isEdited: boolean;
-    }
-
-    export const transitions = {
-      send: {
-        from: 'composing',
-        to: 'sent',
-        guard: '$instance.content != ""',
-        required_fields: ['content', 'senderId'],
-      },
-      deliver: {
-        from: 'sent',
-        to: 'delivered',
-        auto: true,
-      },
-      markRead: {
-        from: 'delivered',
-        to: 'read',
-      },
-      edit: {
-        from: ['sent', 'delivered', 'read'],
-        to: 'sent',
-        guard: '$user.id == $instance.senderId',
-      },
-    };
-
-    export const endStates = ['deleted'];
-
-    export const hooks = {
-      on_enter_sent: { emit: 'message:sent', actions: ['notifyChannel'] },
-      on_enter_read: { emit: 'message:read' },
-    };
-
-    export const runtime = 'collaborative';
-
-    export const fieldOptions = {
-      content: {
-        editable_in_states: ['composing'],
-        editable_when: '$user.id == $instance.senderId',
-      },
-      isEdited: {
-        computed: '$instance.editedAt != null',
-        computed_deps: ['editedAt'],
-      },
-    };
-  `;
-
-  it('should have 4 fields and 4 transitions', () => {
-    const ir = compileModel(MESSAGE_MODEL, 'models/message.ts');
-    expect(ir.fields).toHaveLength(4);
-    expect(ir.transitions).toHaveLength(4);
-  });
-
-  it('should have auto transition for deliver', () => {
-    const ir = compileModel(MESSAGE_MODEL, 'models/message.ts');
-    const deliver = ir.transitions.find((t) => t.name === 'deliver');
-    expect(deliver!.auto).toBe(true);
-  });
-
-  it('should have edit transition from multiple states', () => {
-    const ir = compileModel(MESSAGE_MODEL, 'models/message.ts');
-    const edit = ir.transitions.find((t) => t.name === 'edit');
-    expect(edit!.from).toEqual(['sent', 'delivered', 'read']);
-  });
-
-  it('should have computed isEdited field', () => {
-    const ir = compileModel(MESSAGE_MODEL, 'models/message.ts');
-    const isEdited = ir.fields.find((f) => f.name === 'isEdited');
-    expect(isEdited!.computed).toBe('$instance.editedAt != null');
-    expect(isEdited!.computed_deps).toEqual(['editedAt']);
-  });
-
-  it('should have collaborative runtime', () => {
-    const ir = compileModel(MESSAGE_MODEL, 'models/message.ts');
-    expect(ir.metadata?.runtime).toBe('collaborative');
-  });
-
-  it('should have deleted as END state', () => {
-    const ir = compileModel(MESSAGE_MODEL, 'models/message.ts');
-    const deleted = ir.states.find((s) => s.name === 'deleted');
-    expect(deleted!.type).toBe('END');
-  });
-});
-
-// =============================================================================
-// defineModel() format compilation
-// =============================================================================
-
-const DEFINE_MODEL_EMPLOYEE = `
-import { defineModel } from '@mindmatrix/react';
-
-export default defineModel({
-  slug: 'employee',
-  version: '1.0.0',
-  category: 'data',
-  description: 'Employee lifecycle model',
-  fields: {
-    name: { type: 'string', required: true },
-    email: { type: 'email', required: true },
-    salary: { type: 'currency', default: 0 },
-    isActive: { type: 'boolean', default: false },
-    department: { type: 'string', enum: ['engineering', 'sales', 'hr'] },
-  },
-  states: {
-    onboarding: { type: 'initial' },
-    active: {},
-    on_leave: {},
-    terminated: { type: 'final' },
-  },
-  transitions: {
-    activate: { from: 'onboarding', to: 'active' },
-    request_leave: { from: 'active', to: 'on_leave', roles: ['hr', 'admin'] },
-    return_from_leave: { from: 'on_leave', to: 'active' },
-    terminate: { from: ['active', 'on_leave'], to: 'terminated', required_fields: ['reason'] },
-  },
-});
-`;
-
-describe('defineModel() format', () => {
-  it('should compile defineModel file into IR', () => {
-    const ir = compileModel(DEFINE_MODEL_EMPLOYEE, 'models/employee.ts');
-    expect(ir).toBeDefined();
-    expect(ir.slug).toBe('employee');
-  });
-
-  it('should extract metadata', () => {
-    const ir = compileModel(DEFINE_MODEL_EMPLOYEE, 'models/employee.ts');
-    expect(ir.version).toBe('1.0.0');
-    expect(ir.category).toBe('data');
-    expect(ir.description).toBe('Employee lifecycle model');
-  });
-
-  it('should extract all fields', () => {
-    const ir = compileModel(DEFINE_MODEL_EMPLOYEE, 'models/employee.ts');
-    expect(ir.fields).toHaveLength(5);
-
-    const name = ir.fields.find(f => f.name === 'name');
-    expect(name).toBeDefined();
-    expect(name!.required).toBe(true);
-
-    const salary = ir.fields.find(f => f.name === 'salary');
-    expect(salary).toBeDefined();
-    expect(salary!.type).toBe('currency');
-
-    const isActive = ir.fields.find(f => f.name === 'isActive');
-    expect(isActive).toBeDefined();
-    expect(isActive!.type).toBe('boolean');
-  });
-
-  it('should extract enum options into validation', () => {
-    const ir = compileModel(DEFINE_MODEL_EMPLOYEE, 'models/employee.ts');
-    const dept = ir.fields.find(f => f.name === 'department');
-    expect(dept).toBeDefined();
-    expect(dept!.validation?.options).toEqual(['engineering', 'sales', 'hr']);
-  });
-
-  it('should extract states with correct types', () => {
-    const ir = compileModel(DEFINE_MODEL_EMPLOYEE, 'models/employee.ts');
-    const stateMap = new Map(ir.states.map(s => [s.name, s]));
-
-    expect(stateMap.get('onboarding')!.type).toBe('START');
-    expect(stateMap.get('active')!.type).toBe('REGULAR');
-    expect(stateMap.get('on_leave')!.type).toBe('REGULAR');
-    expect(stateMap.get('terminated')!.type).toBe('END');
-  });
-
-  it('should extract transitions with from/to/roles', () => {
-    const ir = compileModel(DEFINE_MODEL_EMPLOYEE, 'models/employee.ts');
-
-    const activate = ir.transitions.find(t => t.name === 'activate');
-    expect(activate).toBeDefined();
-    expect(activate!.from).toEqual(['onboarding']);
-    expect(activate!.to).toBe('active');
-
-    const leave = ir.transitions.find(t => t.name === 'request_leave');
-    expect(leave).toBeDefined();
-    expect(leave!.roles).toEqual(['hr', 'admin']);
-  });
-
-  it('should handle multi-from transitions', () => {
-    const ir = compileModel(DEFINE_MODEL_EMPLOYEE, 'models/employee.ts');
-    const terminate = ir.transitions.find(t => t.name === 'terminate');
-    expect(terminate).toBeDefined();
-    expect(terminate!.from).toEqual(['active', 'on_leave']);
-    expect(terminate!.required_fields).toEqual(['reason']);
-  });
-});
-
-// =============================================================================
-// useQuery(modelRef) — identifier-based slug resolution
-// =============================================================================
-
-describe('useQuery(modelRef) identifier resolution', () => {
-  function compileView(code: string, filename = 'app/page.tsx') {
-    const result = transformSync(code, {
-      filename,
-      plugins: [[babelPlugin, { mode: 'lenient' }]],
-      parserOpts: { plugins: ['typescript', 'jsx'], attachComment: true },
-    });
-    return (result as any)?.metadata?.mindmatrixIR as IRWorkflowDefinition;
-  }
-
-  it('should resolve useQuery with string literal', () => {
-    const ir = compileView(`
-      import { useQuery, Stack, Text } from '@mindmatrix/react';
-      export default function Page() {
-        const { data: employees } = useQuery('employee', { limit: 10 });
-        return <Stack><Text value="hello" /></Stack>;
-      }
-    `);
-    expect(ir).toBeDefined();
-    const ds = ir.metadata?.dataSources as any[];
-    expect(ds).toBeDefined();
-    const empDs = ds.find((d: any) => d.slug === 'employee');
-    expect(empDs).toBeDefined();
-    expect(empDs.pageSize).toBe(10);
-  });
-
-  it('should resolve useQuery with imported model identifier', () => {
-    const ir = compileView(`
-      import employeeModel from '../models/employee';
-      import { useQuery, Stack, Text } from '@mindmatrix/react';
-      export default function Page() {
-        const { data: employees } = useQuery(employeeModel, { state: 'active' });
-        return <Stack><Text value="hello" /></Stack>;
-      }
-    `);
-    expect(ir).toBeDefined();
-    const ds = ir.metadata?.dataSources as any[];
-    expect(ds).toBeDefined();
-    const empDs = ds.find((d: any) => d.slug === 'employee');
-    expect(empDs).toBeDefined();
-  });
-
-  it('should resolve useMutation with imported model identifier', () => {
-    const ir = compileView(`
-      import employeeModel from '../models/employee';
-      import { useMutation, Stack, Text } from '@mindmatrix/react';
-      export default function Page() {
-        const mutation = useMutation(employeeModel);
-        return <Stack><Text value="hello" /></Stack>;
-      }
-    `);
-    expect(ir).toBeDefined();
-    const targets = ir.metadata?.mutationTargets as string[];
-    expect(targets).toBeDefined();
-    expect(targets).toContain('employee');
-  });
-
-  it('should handle kebab-case model slugs from import path', () => {
-    const ir = compileView(`
-      import userProfileModel from '../models/user-profile';
-      import { useQuery, Stack, Text } from '@mindmatrix/react';
-      export default function Page() {
-        const { data: profiles } = useQuery(userProfileModel);
-        return <Stack><Text value="hello" /></Stack>;
-      }
-    `);
-    expect(ir).toBeDefined();
-    const ds = ir.metadata?.dataSources as any[];
-    expect(ds).toBeDefined();
-    const profileDs = ds.find((d: any) => d.slug === 'user-profile');
-    expect(profileDs).toBeDefined();
-  });
-});

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

@@ -1,112 +0,0 @@
-/**
- * Model Runtime Tests — validates runtime declaration, endStates, cancelledStates.
- */
-
-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 Runtime', () => {
-  it('should extract runtime profile', () => {
-    const ir = compileModel(`
-      export interface Service {
-        status: 'running' | 'stopped';
-      }
-      export const transitions = {};
-      export const runtime = 'backend';
-    `);
-
-    expect(ir.metadata?.runtime).toBe('backend');
-  });
-
-  it('should extract collaborative runtime', () => {
-    const ir = compileModel(`
-      export interface Doc {
-        status: 'editing' | 'published';
-      }
-      export const transitions = {};
-      export const runtime = 'collaborative';
-    `);
-
-    expect(ir.metadata?.runtime).toBe('collaborative');
-  });
-
-  it('should mark end states', () => {
-    const ir = compileModel(`
-      export interface Ticket {
-        status: 'open' | 'closed';
-      }
-      export const transitions = {};
-      export const endStates = ['closed'];
-    `);
-
-    const closedState = ir.states.find((s) => s.name === 'closed');
-    expect(closedState).toBeDefined();
-    expect(closedState!.type).toBe('END');
-  });
-
-  it('should mark cancelled states', () => {
-    const ir = compileModel(`
-      export interface Order {
-        status: 'pending' | 'cancelled';
-      }
-      export const transitions = {};
-      export const cancelledStates = ['cancelled'];
-    `);
-
-    const cancelledState = ir.states.find((s) => s.name === 'cancelled');
-    expect(cancelledState).toBeDefined();
-    expect(cancelledState!.type).toBe('CANCELLED');
-  });
-
-  it('should handle multiple end states', () => {
-    const ir = compileModel(`
-      export interface Process {
-        status: 'active' | 'completed' | 'failed';
-      }
-      export const transitions = {};
-      export const endStates = ['completed', 'failed'];
-    `);
-
-    const completed = ir.states.find((s) => s.name === 'completed');
-    const failed = ir.states.find((s) => s.name === 'failed');
-    expect(completed!.type).toBe('END');
-    expect(failed!.type).toBe('END');
-  });
-
-  it('should mark first union option as START by default', () => {
-    const ir = compileModel(`
-      export interface Pipeline {
-        status: 'draft' | 'review' | 'published';
-      }
-      export const transitions = {};
-    `);
-
-    const draft = ir.states.find((s) => s.name === 'draft');
-    expect(draft!.type).toBe('START');
-  });
-
-  it('should create end states even if not in union', () => {
-    const ir = compileModel(`
-      export interface Thing {
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const endStates = ['terminated'];
-    `);
-
-    const terminated = ir.states.find((s) => s.name === 'terminated');
-    expect(terminated).toBeDefined();
-    expect(terminated!.type).toBe('END');
-  });
-});