@mmapp/react-compiler 0.1.0-alpha.1

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

@@ -0,0 +1,502 @@
+/**
+ * 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');
+    });
+  });
+});