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

package/src/__tests__/model-field-acl.test.ts

@@ -1,237 +0,0 @@
-/**
- * Model Field ACL Tests — validates field-level access control, computed fields, validation.
- */
-
-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 Field ACL', () => {
-  it('should apply visible_in_states', () => {
-    const ir = compileModel(`
-      export interface Item {
-        name: string;
-        balance: number;
-        status: 'draft' | 'active';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        balance: { visible_in_states: ['active'] },
-      };
-    `);
-
-    const balance = ir.fields.find((f) => f.name === 'balance');
-    expect(balance!.visible_in_states).toEqual(['active']);
-  });
-
-  it('should apply editable_in_states', () => {
-    const ir = compileModel(`
-      export interface Doc {
-        title: string;
-        status: 'draft' | 'published';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        title: { editable_in_states: ['draft'] },
-      };
-    `);
-
-    const title = ir.fields.find((f) => f.name === 'title');
-    expect(title!.editable_in_states).toEqual(['draft']);
-  });
-
-  it('should apply visible_to_roles', () => {
-    const ir = compileModel(`
-      export interface Account {
-        balance: number;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        balance: { visible_to_roles: ['admin', 'accountant'] },
-      };
-    `);
-
-    const balance = ir.fields.find((f) => f.name === 'balance');
-    expect(balance!.visible_to_roles).toEqual(['admin', 'accountant']);
-  });
-
-  it('should apply editable_by_roles', () => {
-    const ir = compileModel(`
-      export interface Config {
-        setting: string;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        setting: { editable_by_roles: ['admin'] },
-      };
-    `);
-
-    const setting = ir.fields.find((f) => f.name === 'setting');
-    expect(setting!.editable_by_roles).toEqual(['admin']);
-  });
-
-  it('should apply visible_when expression', () => {
-    const ir = compileModel(`
-      export interface Toggle {
-        secret: string;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        secret: { visible_when: '$user.role == "admin"' },
-      };
-    `);
-
-    const secret = ir.fields.find((f) => f.name === 'secret');
-    expect(secret!.visible_when).toBe('$user.role == "admin"');
-  });
-
-  it('should apply editable_when expression', () => {
-    const ir = compileModel(`
-      export interface Record {
-        content: string;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        content: { editable_when: '$user.id == $instance.ownerId' },
-      };
-    `);
-
-    const content = ir.fields.find((f) => f.name === 'content');
-    expect(content!.editable_when).toBe('$user.id == $instance.ownerId');
-  });
-
-  it('should apply computed field expression', () => {
-    const ir = compileModel(`
-      export interface Order {
-        total: number;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        total: { computed: 'fields.quantity * fields.unit_price', computed_deps: ['quantity', 'unit_price'] },
-      };
-    `);
-
-    const total = ir.fields.find((f) => f.name === 'total');
-    expect(total!.computed).toBe('fields.quantity * fields.unit_price');
-    expect(total!.computed_deps).toEqual(['quantity', 'unit_price']);
-  });
-
-  it('should apply state home', () => {
-    const ir = compileModel(`
-      export interface Chat {
-        draft: string;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        draft: { scope: 'route', persistence: 'local', sync: 'none' },
-      };
-    `);
-
-    const draft = ir.fields.find((f) => f.name === 'draft');
-    expect(draft!.state_home).toEqual({
-      scope: 'route',
-      persistence: 'local',
-      sync: 'none',
-    });
-  });
-
-  it('should apply validation rules', () => {
-    const ir = compileModel(`
-      export interface Form {
-        email: string;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        email: {
-          validation: {
-            minLength: 5,
-            maxLength: 255,
-            rules: [{ expression: 'contains(email, "@")', message: 'Must be valid email', severity: 'error' }],
-          },
-        },
-      };
-    `);
-
-    const email = ir.fields.find((f) => f.name === 'email');
-    expect(email!.validation?.minLength).toBe(5);
-    expect(email!.validation?.maxLength).toBe(255);
-    expect(email!.validation?.rules).toHaveLength(1);
-    expect(email!.validation?.rules![0].expression).toBe('contains(email, "@")');
-    expect(email!.validation?.rules![0].message).toBe('Must be valid email');
-    expect(email!.validation?.rules![0].severity).toBe('error');
-  });
-
-  it('should merge validation with existing options', () => {
-    const ir = compileModel(`
-      export interface Selector {
-        priority: 'low' | 'medium' | 'high';
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        priority: {
-          validation: { min: 0, max: 10 },
-        },
-      };
-    `);
-
-    const priority = ir.fields.find((f) => f.name === 'priority');
-    // Should keep existing options from union type AND add min/max
-    expect(priority!.validation?.options).toEqual(['low', 'medium', 'high']);
-    expect(priority!.validation?.min).toBe(0);
-    expect(priority!.validation?.max).toBe(10);
-  });
-
-  it('should combine multiple field options', () => {
-    const ir = compileModel(`
-      export interface Full {
-        data: string;
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const fieldOptions = {
-        data: {
-          scope: 'instance',
-          persistence: 'durable',
-          sync: 'tenant',
-          computed: 'upper(data)',
-          computed_deps: ['data'],
-          visible_in_states: ['a'],
-          editable_in_states: ['a'],
-          visible_to_roles: ['admin'],
-          editable_by_roles: ['admin'],
-          visible_when: '$state == "a"',
-          editable_when: '$user.role == "admin"',
-        },
-      };
-    `);
-
-    const data = ir.fields.find((f) => f.name === 'data');
-    expect(data!.state_home).toBeDefined();
-    expect(data!.computed).toBe('upper(data)');
-    expect(data!.computed_deps).toEqual(['data']);
-    expect(data!.visible_in_states).toEqual(['a']);
-    expect(data!.editable_in_states).toEqual(['a']);
-    expect(data!.visible_to_roles).toEqual(['admin']);
-    expect(data!.editable_by_roles).toEqual(['admin']);
-    expect(data!.visible_when).toBe('$state == "a"');
-    expect(data!.editable_when).toBe('$user.role == "admin"');
-  });
-});

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

@@ -1,130 +0,0 @@
-/**
- * Model Hooks Tests — validates hook extraction (on_enter/on_exit actions, emit events, server actions).
- */
-
-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 Hooks', () => {
-  it('should extract on_enter hooks with emit event action', () => {
-    const ir = compileModel(`
-      export interface Item {
-        status: 'draft' | 'active';
-      }
-      export const transitions = {
-        activate: { from: 'draft', to: 'active' },
-      };
-      export const hooks = {
-        on_enter_active: { emit: 'item:activated' },
-      };
-    `);
-
-    const activeState = ir.states.find((s) => s.name === 'active');
-    expect(activeState).toBeDefined();
-    expect(activeState!.on_enter).toHaveLength(1);
-    expect(activeState!.on_enter[0].type).toBe('emit_event');
-    expect(activeState!.on_enter[0].config.event).toBe('item:activated');
-  });
-
-  it('should extract on_enter hooks with server action references', () => {
-    const ir = compileModel(`
-      export interface Channel {
-        status: 'draft' | 'active';
-      }
-      export const transitions = {};
-      export const hooks = {
-        on_enter_active: { actions: ['notifyMembers', 'indexForSearch'] },
-      };
-    `);
-
-    const activeState = ir.states.find((s) => s.name === 'active');
-    expect(activeState!.on_enter).toHaveLength(2);
-    expect(activeState!.on_enter[0].type).toBe('server_action');
-    expect(activeState!.on_enter[0].config.handler).toBe('notifyMembers');
-    expect(activeState!.on_enter[1].type).toBe('server_action');
-    expect(activeState!.on_enter[1].config.handler).toBe('indexForSearch');
-  });
-
-  it('should extract on_exit hooks', () => {
-    const ir = compileModel(`
-      export interface Session {
-        status: 'active' | 'ended';
-      }
-      export const transitions = {};
-      export const hooks = {
-        on_exit_active: { actions: ['cleanup'] },
-      };
-    `);
-
-    const activeState = ir.states.find((s) => s.name === 'active');
-    expect(activeState!.on_exit).toHaveLength(1);
-    expect(activeState!.on_exit[0].type).toBe('server_action');
-    expect(activeState!.on_exit[0].config.handler).toBe('cleanup');
-  });
-
-  it('should combine emit and actions in same hook', () => {
-    const ir = compileModel(`
-      export interface Flow {
-        status: 'pending' | 'approved';
-      }
-      export const transitions = {};
-      export const hooks = {
-        on_enter_approved: { emit: 'flow:approved', actions: ['notifyOwner', 'logApproval'] },
-      };
-    `);
-
-    const approvedState = ir.states.find((s) => s.name === 'approved');
-    expect(approvedState!.on_enter).toHaveLength(3); // 1 emit + 2 server actions
-    expect(approvedState!.on_enter[0].type).toBe('emit_event');
-    expect(approvedState!.on_enter[1].type).toBe('server_action');
-    expect(approvedState!.on_enter[2].type).toBe('server_action');
-  });
-
-  it('should handle hooks for states not yet declared', () => {
-    const ir = compileModel(`
-      export interface Widget {
-        status: 'a' | 'b';
-      }
-      export const transitions = {};
-      export const hooks = {
-        on_enter_c: { emit: 'widget:c_entered' },
-      };
-    `);
-
-    const cState = ir.states.find((s) => s.name === 'c');
-    expect(cState).toBeDefined();
-    expect(cState!.on_enter).toHaveLength(1);
-  });
-
-  it('should have unique action IDs across hooks', () => {
-    const ir = compileModel(`
-      export interface Multi {
-        status: 'a' | 'b' | 'c';
-      }
-      export const transitions = {};
-      export const hooks = {
-        on_enter_a: { actions: ['h1'] },
-        on_enter_b: { actions: ['h2'] },
-        on_exit_a: { actions: ['h3'] },
-      };
-    `);
-
-    const allActionIds: string[] = [];
-    for (const state of ir.states) {
-      for (const action of state.on_enter) allActionIds.push(action.id);
-      for (const action of state.on_exit) allActionIds.push(action.id);
-    }
-    expect(new Set(allActionIds).size).toBe(allActionIds.length);
-  });
-});

package/src/__tests__/model-ref-resolution.test.ts

@@ -1,268 +0,0 @@
-/**
- * Model Ref Resolution Tests — validates useQuery(modelRef) and useMutation(modelRef)
- * where modelRef is an imported defineModel result.
- *
- * The compiler should resolve the import path to derive the slug, allowing:
- *   import ChannelModel from '../models/channel';
- *   const { data } = useQuery(ChannelModel);
- * instead of requiring:
- *   const { data } = useQuery('channel');
- */
-
-import { describe, it, expect } from 'vitest';
-import { transformSync } from '@babel/core';
-import babelPlugin from '../babel';
-import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
-
-function compile(code: string, filename = 'test.workflow.tsx'): IRWorkflowDefinition {
-  const result = transformSync(code, {
-    filename,
-    plugins: [[babelPlugin]],
-    parserOpts: { plugins: ['typescript', 'jsx'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-describe('useQuery — model ref resolution', () => {
-  it('should resolve slug from default model import', () => {
-    const ir = compile(`
-      import ChannelModel from '../models/channel';
-      export function Dashboard() {
-        const { data: channels } = useQuery(ChannelModel);
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('channel');
-    expect(sources[0].type).toBe('workflow');
-  });
-
-  it('should resolve slug from PascalCase model filename', () => {
-    const ir = compile(`
-      import UserProfile from '../models/UserProfile';
-      export function Dashboard() {
-        const { data } = useQuery(UserProfile);
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('user-profile');
-  });
-
-  it('should resolve slug from kebab-case model filename', () => {
-    const ir = compile(`
-      import OrderItem from '../models/order-item';
-      export function Dashboard() {
-        const { data } = useQuery(OrderItem);
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('order-item');
-  });
-
-  it('should resolve slug stripping file extension', () => {
-    const ir = compile(`
-      import ProductModel from '../models/product.ts';
-      export function Dashboard() {
-        const { data } = useQuery(ProductModel);
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('product');
-  });
-
-  it('should still work with string literal slugs', () => {
-    const ir = compile(`
-      import { useQuery } from '@mindmatrix/react';
-      export function Dashboard() {
-        const { data } = useQuery('channel');
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('channel');
-  });
-
-  it('should resolve model ref with query options', () => {
-    const ir = compile(`
-      import ChannelModel from '../models/channel';
-      export function Dashboard() {
-        const { data } = useQuery(ChannelModel, { limit: 25, orderBy: 'name' });
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('channel');
-    expect(sources[0].pageSize).toBe(25);
-    expect(sources[0].sort).toBe('name');
-  });
-
-  it('should resolve named import from model file', () => {
-    const ir = compile(`
-      import { Channel } from '../models/channel';
-      export function Dashboard() {
-        const { data } = useQuery(Channel);
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('channel');
-  });
-
-  it('should handle multiple model imports', () => {
-    const ir = compile(`
-      import ChannelModel from '../models/channel';
-      import MessageModel from '../models/message';
-      export function Dashboard() {
-        const { data: channels } = useQuery(ChannelModel);
-        const { data: messages } = useQuery(MessageModel);
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(2);
-    expect(sources[0].slug).toBe('channel');
-    expect(sources[1].slug).toBe('message');
-  });
-
-  it('should ignore non-model imports as useQuery arguments', () => {
-    const ir = compile(`
-      import { someUtil } from '../utils/helpers';
-      export function Dashboard() {
-        const { data } = useQuery('channel');
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('channel');
-  });
-});
-
-describe('useMutation — model ref resolution', () => {
-  it('should resolve slug from default model import', () => {
-    const ir = compile(`
-      import ChannelModel from '../models/channel';
-      export function ChannelForm() {
-        const mutation = useMutation(ChannelModel);
-        return <div />;
-      }
-    `);
-
-    const targets = (ir.metadata as any).mutationTargets;
-    expect(targets).toHaveLength(1);
-    expect(targets[0]).toBe('channel');
-  });
-
-  it('should resolve slug from PascalCase model filename for mutation', () => {
-    const ir = compile(`
-      import UserProfile from '../models/UserProfile';
-      export function ProfileEditor() {
-        const mutation = useMutation(UserProfile);
-        return <div />;
-      }
-    `);
-
-    const targets = (ir.metadata as any).mutationTargets;
-    expect(targets).toHaveLength(1);
-    expect(targets[0]).toBe('user-profile');
-  });
-
-  it('should still work with string literal slugs for mutation', () => {
-    const ir = compile(`
-      import { useMutation } from '@mindmatrix/react';
-      export function ChannelForm() {
-        const mutation = useMutation('channel');
-        return <div />;
-      }
-    `);
-
-    const targets = (ir.metadata as any).mutationTargets;
-    expect(targets).toHaveLength(1);
-    expect(targets[0]).toBe('channel');
-  });
-
-  it('should handle mixed model ref and string literal', () => {
-    const ir = compile(`
-      import ChannelModel from '../models/channel';
-      export function Dashboard() {
-        const { data } = useQuery(ChannelModel);
-        const mutation = useMutation('message');
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    const targets = (ir.metadata as any).mutationTargets;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('channel');
-    expect(targets).toHaveLength(1);
-    expect(targets[0]).toBe('message');
-  });
-});
-
-describe('Model import tracking', () => {
-  it('should only track imports from model paths', () => {
-    const ir = compile(`
-      import React from 'react';
-      import { useQuery } from '@mindmatrix/react';
-      import ChannelModel from '../models/channel';
-      import { formatDate } from '../utils/format';
-      export function Dashboard() {
-        const { data } = useQuery(ChannelModel);
-        return <div />;
-      }
-    `);
-
-    // Should resolve the model import
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('channel');
-  });
-
-  it('should not leak __modelImports into emitted metadata', () => {
-    const ir = compile(`
-      import ChannelModel from '../models/channel';
-      export function Dashboard() {
-        const { data } = useQuery(ChannelModel);
-        return <div />;
-      }
-    `);
-
-    // Internal tracking keys should be stripped
-    expect((ir.metadata as any).__modelImports).toBeUndefined();
-    expect((ir.metadata as any).__modelImportSlugs).toBeUndefined();
-  });
-
-  it('should track .model suffix imports', () => {
-    const ir = compile(`
-      import TaskModel from '../task.model';
-      export function Dashboard() {
-        const { data } = useQuery(TaskModel);
-        return <div />;
-      }
-    `);
-
-    const sources = (ir.metadata as any).dataSources;
-    expect(sources).toHaveLength(1);
-    expect(sources[0].slug).toBe('task');
-  });
-});