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

package/src/__tests__/uber-validation.test.ts

@@ -1,502 +0,0 @@
-/**
- * Uber App Validation Test — Phase 6 UBER VALIDATION
- *
- * Reads the 32-file Uber example app, compiles all files through the
- * ProjectCompiler and standalone modules, and validates the compiled IR
- * has the correct structure.
- */
-
-import { describe, it, expect } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import { compileProject } from '../project-compiler';
-import { compileModel, compileModels } from '../model-compiler';
-import { extractRoutes } from '../route-extractor';
-import { compileActions } from '../action-compiler';
-import { decompileProjectEnhanced } from '../decompiler/project-decompiler';
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-const UBER_APP_DIR = path.resolve(__dirname, '../../examples/uber-app');
-
-/** Recursively read all files from a directory into a Record<string, string>. */
-function readAllFiles(dir: string, prefix = ''): Record<string, string> {
-  const result: Record<string, string> = {};
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const relPath = prefix ? prefix + '/' + entry.name : entry.name;
-    const absPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      Object.assign(result, readAllFiles(absPath, relPath));
-    } else if (/\.(ts|tsx)$/.test(entry.name)) {
-      result[relPath] = fs.readFileSync(absPath, 'utf-8');
-    }
-  }
-  return result;
-}
-
-/** Filter files by path prefix. */
-function filterFiles(files: Record<string, string>, prefix: string): Record<string, string> {
-  const result: Record<string, string> = {};
-  for (const [k, v] of Object.entries(files)) {
-    if (k.startsWith(prefix)) result[k] = v;
-  }
-  return result;
-}
-
-// =============================================================================
-// Load Uber app files
-// =============================================================================
-
-const allFiles = readAllFiles(UBER_APP_DIR);
-
-describe('Uber App Validation', () => {
-  // =========================================================================
-  // File inventory
-  // =========================================================================
-  it('should discover all 32 files', () => {
-    const fileCount = Object.keys(allFiles).length;
-    expect(fileCount).toBeGreaterThanOrEqual(30);
-    // Verify key file categories exist
-    const models = Object.keys(allFiles).filter(f => f.startsWith('models/'));
-    const workflows = Object.keys(allFiles).filter(f => f.startsWith('workflows/'));
-    const actions = Object.keys(allFiles).filter(f => f.startsWith('actions/'));
-    const appPages = Object.keys(allFiles).filter(f => f.startsWith('app/'));
-    expect(models).toHaveLength(6);
-    expect(workflows).toHaveLength(4);
-    expect(actions).toHaveLength(4);
-    expect(appPages).toHaveLength(11);
-  });
-
-  // =========================================================================
-  // Full ProjectCompiler
-  // =========================================================================
-  describe('ProjectCompiler — full compilation', () => {
-    const result = compileProject(allFiles);
-
-    it('should compile without fatal errors', () => {
-      // Some files may produce warnings, but no unrecoverable errors
-      const fatalErrors = result.errors.filter(e => !e.message.includes('Cannot find'));
-      // We allow import resolution errors since examples use mock imports
-      expect(result.ir).toBeDefined();
-      expect(result.ir.slug).toBe('uber-rideshare');
-    });
-
-    it('should resolve config from mm.config.ts', () => {
-      expect(result.ir.name).toBe('Uber Rideshare');
-      expect(result.ir.version).toBe('2.0.0');
-      expect(result.ir.category).toBe('blueprint');
-    });
-
-    it('should produce child definitions for workflows and models', () => {
-      expect(result.childDefinitions.length).toBeGreaterThanOrEqual(10);
-      const slugs = result.childDefinitions.map(c => c.slug);
-      // Should have model children
-      expect(slugs.some(s => s.includes('user') || s.includes('User'))).toBe(true);
-      expect(slugs.some(s => s.includes('ride') || s.includes('Ride'))).toBe(true);
-      // Should have a router child
-      expect(slugs.some(s => s.includes('router'))).toBe(true);
-    });
-
-    it('should extract route table from app/ pages', () => {
-      expect(result.routeTable.length).toBeGreaterThanOrEqual(11);
-      const paths = result.routeTable.map(r => r.path);
-      expect(paths.some(p => p.includes('rider'))).toBe(true);
-      expect(paths.some(p => p.includes('driver'))).toBe(true);
-      expect(paths.some(p => p.includes('admin'))).toBe(true);
-    });
-
-    it('should extract server actions', () => {
-      expect(result.serverActions.length).toBeGreaterThanOrEqual(4);
-      const names = result.serverActions.map(a => a.name);
-      expect(names).toContain('findBestDriver');
-      expect(names).toContain('calculateEstimatedFare');
-      expect(names).toContain('authorizePayment');
-    });
-
-    it('should have composition metadata on parent IR', () => {
-      const meta = result.ir.metadata as Record<string, unknown>;
-      expect(meta.composition).toBeDefined();
-      const comp = meta.composition as Record<string, number>;
-      expect(comp.modelCount).toBe(6);
-      expect(comp.workflowCount).toBe(4);
-      expect(comp.routeCount).toBeGreaterThanOrEqual(11);
-      expect(comp.serverActionCount).toBeGreaterThanOrEqual(4);
-    });
-
-    it('should produce Phase 2 model results', () => {
-      expect(result.modelResults).toBeDefined();
-      expect(result.modelResults!.size).toBe(6);
-    });
-
-    it('should produce Phase 2 action result', () => {
-      expect(result.actionResult).toBeDefined();
-      expect(result.actionResult!.actions.length).toBeGreaterThanOrEqual(4);
-    });
-
-    it('should produce Phase 2 route result', () => {
-      expect(result.routeResult).toBeDefined();
-      expect(result.routeResult!.routes.length).toBeGreaterThanOrEqual(11);
-    });
-
-    it('should capture component definitions from components/*.tsx', () => {
-      expect(result.componentDefinitions).toBeDefined();
-      const names = Object.keys(result.componentDefinitions);
-      expect(names).toContain('MapView');
-      expect(names).toContain('DriverCard');
-      expect(names).toContain('RatingStars');
-      expect(names).toContain('RideCard');
-    });
-
-    it('should capture component experience trees', () => {
-      const mapView = result.componentDefinitions['MapView'];
-      expect(mapView).toBeDefined();
-      expect(mapView.experience).toBeDefined();
-      expect(mapView.experience.component).toBeDefined();
-    });
-
-    it('should capture component props', () => {
-      const mapView = result.componentDefinitions['MapView'];
-      expect(mapView.props.length).toBeGreaterThan(0);
-      expect(mapView.props).toContain('pickupLocation');
-      expect(mapView.props).toContain('dropoffLocation');
-    });
-
-    it('should store componentDefinitions in parent IR metadata', () => {
-      const meta = result.ir.metadata as Record<string, unknown>;
-      expect(meta.componentDefinitions).toBeDefined();
-      const defs = meta.componentDefinitions as Record<string, unknown>;
-      expect(Object.keys(defs)).toContain('MapView');
-      expect(Object.keys(defs)).toContain('DriverCard');
-    });
-
-    it('should include componentCount in composition metadata', () => {
-      const meta = result.ir.metadata as Record<string, unknown>;
-      const comp = meta.composition as Record<string, number>;
-      expect(comp.componentCount).toBe(4);
-    });
-
-    it('should capture server action bodies', () => {
-      const findBestDriver = result.serverActions.find(a => a.name === 'findBestDriver');
-      expect(findBestDriver).toBeDefined();
-      expect(findBestDriver!.body).toBeDefined();
-      expect(findBestDriver!.body).toContain('export async function findBestDriver');
-      expect(findBestDriver!.body).toContain('haversineKm');
-    });
-
-    it('should capture server action return types', () => {
-      const findBestDriver = result.serverActions.find(a => a.name === 'findBestDriver');
-      expect(findBestDriver).toBeDefined();
-      expect(findBestDriver!.returnType).toContain('Promise');
-    });
-
-    it('should capture bodies for all exported server actions', () => {
-      const actionsWithBodies = result.serverActions.filter(a => a.body);
-      expect(actionsWithBodies.length).toBeGreaterThanOrEqual(10);
-      // Every action should have a body
-      for (const action of result.serverActions) {
-        expect(action.body).toBeDefined();
-        expect(action.body!.length).toBeGreaterThan(0);
-      }
-    });
-  });
-
-  // =========================================================================
-  // ModelCompiler — standalone
-  // =========================================================================
-  describe('ModelCompiler — standalone', () => {
-    const modelFiles = filterFiles(allFiles, 'models/');
-
-    it('should compile all 6 models', () => {
-      const results = compileModels(modelFiles);
-      expect(results.size).toBe(6);
-    });
-
-    it('should produce correct field counts per model', () => {
-      const results = compileModels(modelFiles);
-      const fieldCounts: Record<string, number> = {};
-      for (const [filename, r] of results) {
-        fieldCounts[r.interfaceName] = r.fieldNames.length;
-      }
-      // Each model has a substantial number of fields
-      expect(fieldCounts['User']).toBeGreaterThanOrEqual(20);
-      expect(fieldCounts['Ride']).toBeGreaterThanOrEqual(40);
-      expect(fieldCounts['Vehicle']).toBeGreaterThanOrEqual(15);
-      expect(fieldCounts['Payment']).toBeGreaterThanOrEqual(30);
-      expect(fieldCounts['Rating']).toBeGreaterThanOrEqual(15);
-      expect(fieldCounts['Location']).toBeGreaterThanOrEqual(25);
-    });
-
-    it('should have states on all models', () => {
-      const results = compileModels(modelFiles);
-      for (const [, r] of results) {
-        // Models always have at least one state (draft or derived)
-        expect(r.stateNames.length).toBeGreaterThan(0);
-      }
-    });
-
-    it('should detect fieldOptions on all models', () => {
-      const results = compileModels(modelFiles);
-      for (const [, r] of results) {
-        expect(r.hasFieldOptions).toBe(true);
-        expect(Object.keys(r.fieldOptions).length).toBeGreaterThan(0);
-      }
-    });
-
-    it('should set category=data on all models', () => {
-      const results = compileModels(modelFiles);
-      for (const [, r] of results) {
-        expect(r.ir.category).toBe('data');
-      }
-    });
-
-    it('should compile individual models correctly', () => {
-      const rideSource = modelFiles['models/ride.model.ts'];
-      const result = compileModel('models/ride.model.ts', rideSource);
-      expect(result.interfaceName).toBe('Ride');
-      expect(result.ir.category).toBe('data');
-      // Model has many fields from the Ride interface
-      expect(result.fieldNames.length).toBeGreaterThanOrEqual(40);
-      // fieldOptions should be detected
-      expect(result.hasFieldOptions).toBe(true);
-      expect(result.fieldOptions).toHaveProperty('vehicleType');
-    });
-  });
-
-  // =========================================================================
-  // RouteExtractor — standalone
-  // =========================================================================
-  describe('RouteExtractor — standalone', () => {
-    const appFiles = filterFiles(allFiles, 'app/');
-
-    it('should extract 11 routes', () => {
-      const result = extractRoutes(appFiles);
-      expect(result.routes.length).toBe(11);
-    });
-
-    it('should produce correct route paths', () => {
-      const result = extractRoutes(appFiles);
-      const paths = result.routes.map(r => r.path).sort();
-      expect(paths).toContain('/rider/home');
-      expect(paths).toContain('/rider/ride-tracking');
-      expect(paths).toContain('/rider/payment-methods');
-      expect(paths).toContain('/rider/ride-history');
-      expect(paths).toContain('/driver/dashboard');
-      expect(paths).toContain('/driver/earnings');
-      expect(paths).toContain('/driver/navigation');
-      expect(paths).toContain('/driver/ride-acceptance');
-      expect(paths).toContain('/admin/analytics');
-      expect(paths).toContain('/admin/fleet');
-      expect(paths).toContain('/admin/surge-pricing');
-    });
-
-    it('should generate a router IR workflow', () => {
-      const result = extractRoutes(appFiles);
-      expect(result.routerIR).toBeDefined();
-      expect(result.routerIR.slug).toContain('router');
-      expect(result.routerIR.states.length).toBe(11);
-      // Should have one START state
-      const starts = result.routerIR.states.filter(s => s.type === 'START');
-      expect(starts.length).toBe(1);
-    });
-
-    it('should generate navigation transitions', () => {
-      const result = extractRoutes(appFiles);
-      // n*(n-1) transitions for n routes
-      expect(result.routerIR.transitions.length).toBe(11 * 10);
-    });
-
-    it('should assign correct state names', () => {
-      const result = extractRoutes(appFiles);
-      const stateNames = result.routes.map(r => r.stateName);
-      expect(stateNames).toContain('RIDER_HOME');
-      expect(stateNames).toContain('DRIVER_DASHBOARD');
-      expect(stateNames).toContain('ADMIN_ANALYTICS');
-    });
-  });
-
-  // =========================================================================
-  // ActionCompiler — standalone
-  // =========================================================================
-  describe('ActionCompiler — standalone', () => {
-    const actionFiles = filterFiles(allFiles, 'actions/');
-
-    it('should compile all 4 action files', () => {
-      const result = compileActions(actionFiles, { blueprintSlug: 'uber-rideshare' });
-      expect(result.byFile.size).toBe(4);
-    });
-
-    it('should extract action registrations', () => {
-      const result = compileActions(actionFiles, { blueprintSlug: 'uber-rideshare' });
-      expect(result.actions.length).toBeGreaterThanOrEqual(10);
-      const names = result.actions.map(a => a.name);
-      // Matching
-      expect(names).toContain('findBestDriver');
-      expect(names).toContain('batchMatchDrivers');
-      // Pricing
-      expect(names).toContain('calculateEstimatedFare');
-      expect(names).toContain('calculateActualFare');
-      expect(names).toContain('calculateCancellationFee');
-      expect(names).toContain('calculateSurge');
-      // Payments
-      expect(names).toContain('authorizePayment');
-      expect(names).toContain('capturePayment');
-      expect(names).toContain('settlePayment');
-      expect(names).toContain('processRefund');
-      expect(names).toContain('processDriverPayout');
-      // Notifications
-      expect(names).toContain('notifyRideMatched');
-      expect(names).toContain('notifyDriverArrived');
-    });
-
-    it('should generate correct endpoints', () => {
-      const result = compileActions(actionFiles, { blueprintSlug: 'uber-rideshare' });
-      const pricing = result.actions.find(a => a.name === 'calculateEstimatedFare');
-      expect(pricing).toBeDefined();
-      expect(pricing!.endpoint).toBe('/api/v1/actions/uber-rideshare/pricing/calculateEstimatedFare');
-      expect(pricing!.group).toBe('pricing');
-      expect(pricing!.actionId).toBe('pricing:calculateEstimatedFare');
-    });
-
-    it('should group actions by file', () => {
-      const result = compileActions(actionFiles, { blueprintSlug: 'uber-rideshare' });
-      expect(result.byGroup.has('matching')).toBe(true);
-      expect(result.byGroup.has('pricing')).toBe(true);
-      expect(result.byGroup.has('payments')).toBe(true);
-      expect(result.byGroup.has('notifications')).toBe(true);
-    });
-
-    it('should mark async actions correctly', () => {
-      const result = compileActions(actionFiles, { blueprintSlug: 'uber-rideshare' });
-      // All exported functions in server actions should be async
-      for (const action of result.actions) {
-        expect(action.async).toBe(true);
-      }
-    });
-  });
-
-  // =========================================================================
-  // Round-trip: compile → structure check
-  // =========================================================================
-  describe('Round-trip consistency', () => {
-    it('should produce identical results on double compilation', () => {
-      const result1 = compileProject(allFiles);
-      const result2 = compileProject(allFiles);
-
-      // Same number of child definitions
-      expect(result1.childDefinitions.length).toBe(result2.childDefinitions.length);
-      // Same route table
-      expect(result1.routeTable.length).toBe(result2.routeTable.length);
-      // Same server actions
-      expect(result1.serverActions.length).toBe(result2.serverActions.length);
-      // Same parent slug
-      expect(result1.ir.slug).toBe(result2.ir.slug);
-      // Same error count
-      expect(result1.errors.length).toBe(result2.errors.length);
-    });
-
-    it('should preserve model field counts through project compilation', () => {
-      const standalone = compileModels(filterFiles(allFiles, 'models/'));
-      const project = compileProject(allFiles);
-
-      // Model results from project should match standalone
-      expect(project.modelResults).toBeDefined();
-      expect(project.modelResults!.size).toBe(standalone.size);
-
-      for (const [filename, standaloneResult] of standalone) {
-        const projectResult = project.modelResults!.get(filename);
-        expect(projectResult).toBeDefined();
-        expect(projectResult!.fieldNames.length).toBe(standaloneResult.fieldNames.length);
-        expect(projectResult!.interfaceName).toBe(standaloneResult.interfaceName);
-      }
-    });
-
-    it('should preserve action counts through project compilation', () => {
-      const standalone = compileActions(filterFiles(allFiles, 'actions/'), {
-        blueprintSlug: 'uber-rideshare',
-      });
-      const project = compileProject(allFiles);
-
-      expect(project.actionResult).toBeDefined();
-      expect(project.actionResult!.actions.length).toBe(standalone.actions.length);
-    });
-
-    it('should preserve route counts through project compilation', () => {
-      const standalone = extractRoutes(filterFiles(allFiles, 'app/'));
-      const project = compileProject(allFiles);
-
-      expect(project.routeResult).toBeDefined();
-      expect(project.routeResult!.routes.length).toBe(standalone.routes.length);
-    });
-  });
-
-  // =========================================================================
-  // Decompiler round-trip: compile → IR → decompile → verify output
-  // =========================================================================
-  describe('Decompiler round-trip', () => {
-    const compiled = compileProject(allFiles);
-
-    // Build a simplified IR for decompiler testing — strip page experience
-    // to avoid bindJSXTree errors from complex $instance bindings
-    function makeDecompilerInput() {
-      const ir = { ...compiled.ir } as any;
-      // Remove the complex page experience (has $instance bindings the decompiler can't resolve)
-      delete ir.experience;
-      // Set a simple experience tree for the main file
-      ir.experience = {
-        id: 'root',
-        component: 'Stack',
-        children: [
-          { id: 'h1', component: 'Heading', config: { value: 'Uber Rideshare' } },
-        ],
-      };
-      return ir;
-    }
-
-    it('should decompile and reconstruct component files', () => {
-      const decompileResult = decompileProjectEnhanced(makeDecompilerInput());
-      const paths = decompileResult.files.map(f => f.path);
-
-      expect(paths.some(p => p === 'components/MapView.tsx')).toBe(true);
-      expect(paths.some(p => p === 'components/DriverCard.tsx')).toBe(true);
-      expect(paths.some(p => p === 'components/RatingStars.tsx')).toBe(true);
-      expect(paths.some(p => p === 'components/RideCard.tsx')).toBe(true);
-    });
-
-    it('should decompile and reconstruct server action files', () => {
-      const decompileResult = decompileProjectEnhanced(makeDecompilerInput());
-      const actionFiles = decompileResult.files.filter(f => f.role === 'server-action');
-
-      expect(actionFiles.length).toBeGreaterThanOrEqual(1);
-      // At least one action file should contain preserved function bodies
-      const hasPreservedBodies = actionFiles.some(f =>
-        f.content.includes('export async function')
-      );
-      expect(hasPreservedBodies).toBe(true);
-    });
-
-    it('should reconstruct server action files with full function bodies', () => {
-      const decompileResult = decompileProjectEnhanced(makeDecompilerInput());
-      const actionFiles = decompileResult.files.filter(f => f.role === 'server-action');
-
-      // Find an action file that contains matching.server.ts content
-      const matchingFile = actionFiles.find(f =>
-        f.content.includes('findBestDriver')
-      );
-      expect(matchingFile).toBeDefined();
-      expect(matchingFile!.content).toContain('haversineKm');
-      expect(matchingFile!.content).toContain('export async function findBestDriver');
-    });
-
-    it('should reconstruct component files with JSX', () => {
-      const decompileResult = decompileProjectEnhanced(makeDecompilerInput());
-      const mapViewFile = decompileResult.files.find(f => f.path === 'components/MapView.tsx');
-      expect(mapViewFile).toBeDefined();
-      // Should contain JSX from the decompiled experience tree
-      expect(mapViewFile!.content.length).toBeGreaterThan(50);
-      expect(mapViewFile!.content).toContain('MapView');
-    });
-  });
-});