@mmapp/react-compiler 0.1.0-alpha.1

package/src/__tests__/auth-module-compilation.test.ts

@@ -0,0 +1,247 @@
+/**
+ * Auth Module Compilation Tests
+ *
+ * Verifies the authentication module (examples/authentication/) compiles
+ * through the project compiler and produces correct IR:
+ *
+ * 1. All files compile without errors
+ * 2. Correct fields extracted (config + runtime)
+ * 3. Correct states and transitions (auth state machine)
+ * 4. Experience tree has Router/Route structure
+ * 5. Category is 'module' (not 'blueprint')
+ * 6. Compiled output can be used as a DB seed
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { compileProject } from '../project-compiler';
+import type { IRExperienceNode } from '@mindmatrix/player-core';
+
+// ---------------------------------------------------------------------------
+// Load source files from disk
+// ---------------------------------------------------------------------------
+
+const EXAMPLES_DIR = resolve(__dirname, '../../examples/authentication');
+
+function readExample(relativePath: string): string {
+  return readFileSync(resolve(EXAMPLES_DIR, relativePath), 'utf-8');
+}
+
+function findAllByComponent(node: IRExperienceNode, component: string): IRExperienceNode[] {
+  const results: IRExperienceNode[] = [];
+  if (node.component === component) results.push(node);
+  for (const child of node.children ?? []) {
+    results.push(...findAllByComponent(child, component));
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('Auth Module — Project Compilation', () => {
+  // Compile once, share across tests
+  const files: Record<string, string> = {
+    'mm.config.ts': readExample('mm.config.ts'),
+    'main.workflow.tsx': readExample('main.workflow.tsx'),
+    'pages/LoginPage.tsx': readExample('pages/LoginPage.tsx'),
+    'pages/SignupPage.tsx': readExample('pages/SignupPage.tsx'),
+    'models/auth.ts': readExample('models/auth.ts'),
+  };
+
+  const result = compileProject(files);
+  const ir = result.ir;
+
+  it('compiles all files without errors', () => {
+    const errors = result.errors.filter(e => e.severity === 'error');
+    if (errors.length > 0) {
+      console.log('Compilation errors:');
+      for (const err of errors) {
+        console.log(`  ${err.file} (line ${err.line}): ${err.message}`);
+      }
+    }
+    expect(errors).toHaveLength(0);
+  });
+
+  it('produces file IRs for all source files', () => {
+    expect(result.fileIRs['main.workflow.tsx']).toBeDefined();
+  });
+
+  it('extracts slug from @workflow annotation', () => {
+    expect(ir.slug).toBe('mod-authentication');
+  });
+
+  it('extracts category as module', () => {
+    expect(ir.category).toBe('module');
+  });
+
+  it('extracts version', () => {
+    expect(ir.version).toBe('1.0.0');
+  });
+
+  it('extracts config fields from useState', () => {
+    const fieldNames = ir.fields.map(f => f.name);
+    expect(fieldNames).toContain('appName');
+    expect(fieldNames).toContain('layout');
+    expect(fieldNames).toContain('showSignup');
+    expect(fieldNames).toContain('showForgotPassword');
+    expect(fieldNames).toContain('redirectPath');
+  });
+
+  it('extracts runtime fields from useState', () => {
+    const fieldNames = ir.fields.map(f => f.name);
+    expect(fieldNames).toContain('email');
+    expect(fieldNames).toContain('password');
+    expect(fieldNames).toContain('confirmPassword');
+    expect(fieldNames).toContain('firstName');
+    expect(fieldNames).toContain('lastName');
+    expect(fieldNames).toContain('errorMessage');
+  });
+
+  it('infers correct field types', () => {
+    const appName = ir.fields.find(f => f.name === 'appName');
+    expect(appName?.type).toBe('text');
+
+    const showSignup = ir.fields.find(f => f.name === 'showSignup');
+    expect(showSignup?.type).toBe('boolean');
+
+    const layout = ir.fields.find(f => f.name === 'layout');
+    // Compiler may infer 'text' or 'select' depending on usage context
+    expect(['text', 'select']).toContain(layout?.type);
+
+    const email = ir.fields.find(f => f.name === 'email');
+    expect(email?.type).toBe('text');
+  });
+
+  it('extracts auth state machine states', () => {
+    const stateNames = ir.states.map(s => s.name);
+    expect(stateNames).toContain('unauthenticated');
+    expect(stateNames).toContain('error');
+    expect(stateNames).toContain('authenticated');
+  });
+
+  it('extracts state enter hooks', () => {
+    const unauthenticated = ir.states.find(s => s.name === 'unauthenticated');
+    expect(unauthenticated?.on_enter.length).toBeGreaterThanOrEqual(1);
+
+    const error = ir.states.find(s => s.name === 'error');
+    expect(error?.on_enter.length).toBeGreaterThanOrEqual(1);
+
+    const authenticated = ir.states.find(s => s.name === 'authenticated');
+    expect(authenticated?.on_enter.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('extracts 8 transitions', () => {
+    expect(ir.transitions.length).toBe(8);
+    const names = ir.transitions.map(t => t.name);
+    expect(names).toContain('login');
+    expect(names).toContain('login_success');
+    expect(names).toContain('login_error');
+    expect(names).toContain('signup');
+    expect(names).toContain('signup_success');
+    expect(names).toContain('signup_error');
+    expect(names).toContain('logout');
+    expect(names).toContain('retry');
+  });
+
+  it('transitions have correct from/to states', () => {
+    const login = ir.transitions.find(t => t.name === 'login');
+    // from can be string or array depending on compiler output
+    const loginFrom = Array.isArray(login?.from) ? login.from[0] : login?.from;
+    expect(loginFrom).toBe('unauthenticated');
+    expect(login?.to).toBe('authenticating');
+
+    const loginSuccess = ir.transitions.find(t => t.name === 'login_success');
+    const lsFrom = Array.isArray(loginSuccess?.from) ? loginSuccess.from[0] : loginSuccess?.from;
+    expect(lsFrom).toBe('authenticating');
+    expect(loginSuccess?.to).toBe('authenticated');
+
+    const logout = ir.transitions.find(t => t.name === 'logout');
+    const logoutFrom = Array.isArray(logout?.from) ? logout.from[0] : logout?.from;
+    expect(logoutFrom).toBe('authenticated');
+    expect(logout?.to).toBe('unauthenticated');
+  });
+
+  it('login transition has required fields', () => {
+    const login = ir.transitions.find(t => t.name === 'login');
+    // required_fields may be stored in different places depending on compiler version
+    const reqFields = login?.required_fields ?? (login as any)?.requiredFields ?? [];
+    expect(reqFields).toContain('email');
+    expect(reqFields).toContain('password');
+  });
+
+  it('produces an experience tree', () => {
+    const exp = ir.view ?? (ir.metadata as any)?.experience;
+    expect(exp).toBeDefined();
+  });
+
+  it('experience tree has Route components', () => {
+    const exp = ir.view ?? (ir.metadata as any)?.experience;
+    if (exp) {
+      const routes = findAllByComponent(exp, 'Route');
+      expect(routes.length).toBeGreaterThanOrEqual(1);
+    }
+  });
+
+  it('experience tree has child page references or inlined components', () => {
+    const exp = ir.view ?? (ir.metadata as any)?.experience;
+    if (exp) {
+      // Pages may be inlined or referenced — either way the tree should have children
+      const allChildren: IRExperienceNode[] = [];
+      function collect(node: IRExperienceNode) {
+        allChildren.push(node);
+        for (const child of node.children ?? []) collect(child);
+      }
+      collect(exp);
+      // The tree should have at least root + some children (Route, Card, etc.)
+      expect(allChildren.length).toBeGreaterThanOrEqual(2);
+    }
+  });
+});
+
+describe('Auth Module — Seed Payload Generation', () => {
+  const files: Record<string, string> = {
+    'mm.config.ts': readExample('mm.config.ts'),
+    'main.workflow.tsx': readExample('main.workflow.tsx'),
+    'pages/LoginPage.tsx': readExample('pages/LoginPage.tsx'),
+    'pages/SignupPage.tsx': readExample('pages/SignupPage.tsx'),
+    'models/auth.ts': readExample('models/auth.ts'),
+  };
+
+  const result = compileProject(files);
+  const ir = result.ir;
+
+  it('IR can be serialized to JSON for DB storage', () => {
+    const json = JSON.stringify(ir);
+    expect(json).toBeTruthy();
+    const parsed = JSON.parse(json);
+    expect(parsed.slug).toBe('mod-authentication');
+  });
+
+  it('fields array is valid JSONB for workflow_definitions.fields', () => {
+    const fieldsJson = JSON.stringify(ir.fields);
+    const parsed = JSON.parse(fieldsJson);
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.length).toBeGreaterThanOrEqual(11); // 5 config + 6 runtime
+  });
+
+  it('states array is valid JSONB for workflow_definitions.states', () => {
+    const statesJson = JSON.stringify(ir.states);
+    const parsed = JSON.parse(statesJson);
+    expect(Array.isArray(parsed)).toBe(true);
+  });
+
+  it('transitions array is valid JSONB for workflow_definitions.transitions', () => {
+    const transitionsJson = JSON.stringify(ir.transitions);
+    const parsed = JSON.parse(transitionsJson);
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.length).toBe(8);
+  });
+
+  it('metadata includes system_module flag', () => {
+    // The seed process should add this; verify IR has metadata we can augment
+    expect(ir.metadata).toBeDefined();
+  });
+});