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

package/src/__tests__/pipeline-hardening.test.ts

@@ -1,413 +0,0 @@
-/**
- * Pipeline Hardening Tests — end-to-end validation of the full
- * compiler → validator → migration → NRT pipeline.
- *
- * Tests the complete lifecycle:
- * 1. React source → Babel compiler → IR definition
- * 2. IR definition → validator → issues
- * 3. IR definition → migration → normalized format
- * 4. NRT types → comparator → diff
- *
- * These tests cover edge cases and cross-cutting concerns
- * not addressed by individual phase tests.
- */
-
-import { describe, it, expect } from 'vitest';
-import { transformSync } from '@babel/core';
-import babelPlugin from '../babel';
-import { validateDefinition, isViableDefinition } from '@mindmatrix/player-core';
-import { normalizeDefinition, detectIRVersion } from '@mindmatrix/player-core';
-import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function compile(code: string, mode: 'strict' | 'infer' = 'infer'): IRWorkflowDefinition | null {
-  const result = transformSync(code, {
-    filename: 'test.workflow.tsx',
-    plugins: [[babelPlugin, { mode }]],
-    parserOpts: { plugins: ['jsx', 'typescript'], attachComment: true },
-  });
-  return (result as any)?.metadata?.mindmatrixIR ?? null;
-}
-
-// =============================================================================
-// Full Pipeline: Compile → Validate → Migrate
-// =============================================================================
-
-describe('Full Pipeline', () => {
-  it('should compile a basic workflow and pass validation', () => {
-    const code = `
-/** @workflow slug="pipeline-test" version="1.0.0" */
-import { useState, useOnEnter, useTransition } from '@mindmatrix/react';
-
-export default function PipelineTest() {
-  const [status, setStatus] = useState('idle');
-  const [active, setActive] = useState(false);
-
-  useOnEnter('idle', () => { setStatus('waiting'); });
-  useOnEnter('active', () => { setActive(true); });
-  useTransition('activate', { from: 'idle', to: 'active' });
-
-  return (
-    <Stack>
-      <Text>{status}</Text>
-      <Button onPress={() => {}}>Go</Button>
-    </Stack>
-  );
-}`;
-
-    const ir = compile(code);
-    expect(ir).not.toBeNull();
-    expect(ir!.slug).toBe('pipeline-test');
-
-    // Validate
-    const validation = validateDefinition(ir!);
-    expect(validation.valid).toBe(true);
-    expect(validation.summary.stateCount).toBeGreaterThan(0);
-    expect(validation.summary.fieldCount).toBeGreaterThan(0);
-  });
-
-  it('should compile a multi-state workflow and validate references', () => {
-    const code = `
-/** @workflow slug="multi-state" version="1.0.0" */
-import { useState, useOnEnter, useOnExit, useTransition } from '@mindmatrix/react';
-
-export default function MultiState() {
-  const [count, setCount] = useState(0);
-  const [label, setLabel] = useState('start');
-
-  useOnEnter('idle', () => { setLabel('idle'); });
-  useOnEnter('active', () => { setLabel('active'); setCount(0); });
-  useOnExit('active', () => { setLabel('leaving'); });
-
-  useTransition('begin', { from: 'idle', to: 'active' });
-  useTransition('finish', { from: 'active', to: 'idle' });
-
-  return (
-    <Stack>
-      <Heading>State: {label}</Heading>
-      <Text>Count: {count}</Text>
-    </Stack>
-  );
-}`;
-
-    const ir = compile(code);
-    expect(ir).not.toBeNull();
-
-    // Should have 2 states
-    expect(ir!.states.length).toBe(2);
-    expect(ir!.states.map(s => s.name).sort()).toEqual(['active', 'idle']);
-
-    // Should have 2 transitions
-    expect(ir!.transitions.length).toBe(2);
-
-    // Validate — all references should be clean
-    const validation = validateDefinition(ir!);
-    const refIssues = validation.issues.filter(i => i.category === 'referential');
-    expect(refIssues).toHaveLength(0);
-  });
-
-  it('should detect compiled output as v1.0 and migrate', () => {
-    const code = `
-/** @workflow slug="migration-test" version="1.0.0" */
-import { useState, useTransition } from '@mindmatrix/react';
-
-export default function MigrationTest() {
-  const [value, setValue] = useState('');
-  useTransition('submit');
-  return <Stack><Text>{value}</Text></Stack>;
-}`;
-
-    const ir = compile(code);
-    expect(ir).not.toBeNull();
-
-    // Compiled output uses state_type/action_type/field_type (v1.0 format)
-    const asRecord = ir as unknown as Record<string, unknown>;
-
-    // Check if it needs migration
-    const version = detectIRVersion(asRecord);
-    // Our compiler outputs v1.0 format (with state_type, field_type)
-    // This is fine — the migration layer handles it
-    expect(['1.0', '1.1', '1.2']).toContain(version);
-
-    // Normalize to current
-    const migrated = normalizeDefinition(asRecord);
-    expect(migrated.definition.slug).toBe('migration-test');
-    expect(migrated.definition.states.length).toBeGreaterThan(0);
-  });
-
-  it('should validate compiled output with experience tree', () => {
-    const code = `
-/** @workflow slug="experience-test" version="1.0.0" */
-import { useState, useTransition } from '@mindmatrix/react';
-
-export default function ExperienceTest() {
-  const [name, setName] = useState('');
-
-  useTransition('save');
-
-  return (
-    <Stack>
-      <Heading>Hello {name}</Heading>
-      <Row>
-        <Button onPress={() => {}}>Save</Button>
-        <Button onPress={() => {}}>Cancel</Button>
-      </Row>
-    </Stack>
-  );
-}`;
-
-    const ir = compile(code);
-    expect(ir).not.toBeNull();
-
-    // Should have experience tree in metadata
-    expect(ir!.metadata?.experience).toBeDefined();
-
-    // Validate with known components
-    const validation = validateDefinition(ir!, {
-      knownComponents: ['Stack', 'Heading', 'Text', 'Row', 'Button', 'Card'],
-    });
-
-    // No experience errors expected for known components
-    const expErrors = validation.issues.filter(
-      i => i.category === 'experience' && i.severity === 'error'
-    );
-    expect(expErrors).toHaveLength(0);
-  });
-
-  it('should compile useWhileIn and validate during actions', () => {
-    const code = `
-/** @workflow slug="during-test" version="1.0.0" */
-import { useState, useWhileIn, useTransition } from '@mindmatrix/react';
-
-export default function DuringTest() {
-  const [tick, setTick] = useState(0);
-
-  useWhileIn('active', 500, () => { setTick(tick + 1); });
-  useTransition('start');
-
-  return <Stack><Text>{tick}</Text></Stack>;
-}`;
-
-    const ir = compile(code);
-    expect(ir).not.toBeNull();
-
-    // Find the active state
-    const activeState = ir!.states.find(s => s.name === 'active');
-    expect(activeState).toBeDefined();
-    expect(activeState!.during.length).toBeGreaterThan(0);
-    expect(activeState!.during[0].interval_ms).toBe(500);
-
-    // Validate — during action should be structurally valid
-    const validation = validateDefinition(ir!);
-    const duringIssues = validation.issues.filter(i => i.code.startsWith('DURING_'));
-    expect(duringIssues).toHaveLength(0);
-  });
-
-  it('should compile useOnEvent and validate event subscriptions', () => {
-    const code = `
-/** @workflow slug="event-test" version="1.0.0" */
-import { useState, useOnEvent, useOnEnter, useTransition } from '@mindmatrix/react';
-
-export default function EventTest() {
-  const [alert, setAlert] = useState('');
-
-  useOnEnter('idle', () => { setAlert(''); });
-  useOnEnter('acknowledged', () => { setAlert('ack'); });
-  useOnEvent('system:alert', (payload) => { setAlert('received'); });
-  useTransition('ack', { from: 'idle', to: 'acknowledged' });
-
-  return <Stack><Text>{alert}</Text></Stack>;
-}`;
-
-    const ir = compile(code);
-    expect(ir).not.toBeNull();
-    // Events should be present (either on states or workflow level)
-    const hasEvents = ir!.states.some(s => s.on_event && s.on_event.length > 0) ||
-      (ir!.on_event && ir!.on_event.length > 0);
-    // The definition should be valid with proper from/to on transitions
-    const validation = validateDefinition(ir!);
-    expect(validation.valid).toBe(true);
-  });
-});
-
-// =============================================================================
-// Strict Mode Validation
-// =============================================================================
-
-describe('Strict Mode Pipeline', () => {
-  it('should produce warnings for useEffect in strict mode', () => {
-    const code = `
-/** @workflow slug="strict-test" version="1.0.0" */
-import { useState, useEffect } from 'react';
-import { useTransition } from '@mindmatrix/react';
-
-export default function StrictTest() {
-  const [x, setX] = useState(0);
-  useEffect(() => { console.log('effect'); }, []);
-  useTransition('go');
-  return <Stack><Text>{x}</Text></Stack>;
-}`;
-
-    const ir = compile(code, 'strict');
-    // The IR may still be produced but with errors/warnings in metadata
-    if (ir) {
-      const errors = (ir.metadata as any)?.errors;
-      const warnings = (ir.metadata as any)?.warnings;
-      const allIssues = [...(errors || []), ...(warnings || [])];
-      // In strict mode, useEffect should produce a diagnostic
-      const hasStrictIssue = allIssues.some((i: any) =>
-        i.code === 'STRICT_USE_EFFECT' || i.message?.includes('useEffect')
-      );
-      expect(hasStrictIssue).toBe(true);
-    }
-  });
-});
-
-// =============================================================================
-// isViableDefinition Guard
-// =============================================================================
-
-describe('isViableDefinition Guard', () => {
-  it('should accept compiled workflow output', () => {
-    const code = `
-/** @workflow slug="viable-test" version="1.0.0" */
-import { useState, useTransition } from '@mindmatrix/react';
-
-export default function ViableTest() {
-  const [x, setX] = useState(0);
-  useTransition('go');
-  return <Stack><Text>{x}</Text></Stack>;
-}`;
-
-    const ir = compile(code);
-    expect(isViableDefinition(ir)).toBe(true);
-  });
-
-  it('should reject malformed output', () => {
-    expect(isViableDefinition(null)).toBe(false);
-    expect(isViableDefinition({})).toBe(false);
-    expect(isViableDefinition({ slug: 'test' })).toBe(false);
-    expect(isViableDefinition({ slug: 'test', states: [] })).toBe(false);
-  });
-});
-
-// =============================================================================
-// Cross-Phase Integration
-// =============================================================================
-
-describe('Cross-Phase Integration', () => {
-  it('should handle workflow with all hook types', () => {
-    const code = `
-/** @workflow slug="all-hooks" version="2.0.0" */
-import { useState, useOnEnter, useOnExit, useTransition, useOnEvent, useWhileIn, useOnChange } from '@mindmatrix/react';
-
-export default function AllHooks() {
-  const [count, setCount] = useState(0);
-  const [status, setStatus] = useState('draft');
-  const [alerts, setAlerts] = useState(0);
-
-  useOnEnter('draft', () => { setStatus('drafting'); });
-  useOnExit('draft', () => { setStatus('leaving-draft'); });
-  useOnEnter('active', () => { setCount(0); });
-  useWhileIn('active', 1000, () => { setCount(count + 1); });
-  useOnEvent('system:tick', () => { setAlerts(alerts + 1); });
-  useOnChange('status', () => { setAlerts(0); });
-
-  useTransition('activate', { from: 'draft', to: 'active' });
-  useTransition('deactivate', { from: 'active', to: 'draft' });
-
-  return (
-    <Stack>
-      <Heading>All Hooks Test</Heading>
-      <Text>Count: {count}</Text>
-      <Text>Status: {status}</Text>
-      <Text>Alerts: {alerts}</Text>
-      <Row>
-        <Button onPress={() => {}}>Activate</Button>
-        <Button onPress={() => {}}>Deactivate</Button>
-      </Row>
-    </Stack>
-  );
-}`;
-
-    const ir = compile(code);
-    expect(ir).not.toBeNull();
-    expect(ir!.slug).toBe('all-hooks');
-    expect(ir!.version).toBe('2.0.0');
-    expect(ir!.states.length).toBe(2);
-    expect(ir!.transitions.length).toBe(2);
-    expect(ir!.fields.length).toBe(3);
-
-    // Validate
-    const validation = validateDefinition(ir!);
-    // Should be valid (all refs are correct)
-    expect(validation.valid).toBe(true);
-
-    // Should have experience tree
-    expect(ir!.metadata?.experience).toBeDefined();
-  });
-
-  it('should handle empty workflow gracefully', () => {
-    const code = `
-/** @workflow slug="empty" version="1.0.0" */
-import { useState } from '@mindmatrix/react';
-
-export default function Empty() {
-  const [x] = useState(0);
-  return <Stack><Text>Empty</Text></Stack>;
-}`;
-
-    const ir = compile(code);
-    // Even a minimal workflow should compile
-    if (ir) {
-      const validation = validateDefinition(ir);
-      // May have warnings about missing transitions but should still be structurally valid
-      expect(validation.issues.filter(i => i.severity === 'error').length).toBeLessThanOrEqual(1);
-    }
-  });
-});
-
-// =============================================================================
-// NRT Type Compatibility
-// =============================================================================
-
-describe('NRT Type Compatibility', () => {
-  it('should create valid NRT structure from compiled experience tree', () => {
-    const code = `
-/** @workflow slug="nrt-compat" version="1.0.0" */
-import { useState, useTransition } from '@mindmatrix/react';
-
-export default function NRTCompat() {
-  const [name, setName] = useState('world');
-  useTransition('greet');
-
-  return (
-    <Stack>
-      <Heading>Hello {name}</Heading>
-      <Button onPress={() => {}}>Greet</Button>
-    </Stack>
-  );
-}`;
-
-    const ir = compile(code);
-    expect(ir).not.toBeNull();
-
-    const experience = ir!.metadata?.experience as any;
-    expect(experience).toBeDefined();
-
-    // Experience tree should have the right shape for NRT export
-    expect(experience.id).toBeDefined();
-    expect(experience.component).toBe('Stack');
-    expect(experience.children).toBeDefined();
-    expect(experience.children.length).toBeGreaterThan(0);
-
-    // Each child should have an id and component
-    for (const child of experience.children) {
-      expect(child.id).toBeDefined();
-      expect(child.component).toBeDefined();
-    }
-  });
-});