@mmapp/react-compiler 0.1.0-alpha.1

package/seed-compiled.mjs

@@ -0,0 +1,318 @@
+/**
+ * Seeds compiled workflow definitions (with views) into the backend DB.
+ *
+ * Reads compiled JSONs from packages/frontend/src/workflows/compiled/,
+ * which now contain { canonical, ir } format.
+ *
+ * The IR already has normalized view tree (prop renames, binding rewrites,
+ * template conversion done by the compiler). This script adds:
+ * - dataSources injection at root node
+ * - Blueprint manifest metadata
+ * - Backend format normalization (state_type→type, field_type→type, action_type→type)
+ *
+ * Run from repo root: node packages/react-compiler/seed-compiled.mjs
+ *
+ * Environment:
+ *   API_URL  — backend base URL (default: http://178.156.197.133:3010/api/v1)
+ *   EMAIL    — login email (default: admin@mindmatrix.com)
+ *   PASSWORD — login password (default: Admin123!)
+ */
+import { readFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const API_URL = process.env.API_URL || 'http://178.156.197.133:3010/api/v1';
+const EMAIL = process.env.EMAIL || 'admin@mindmatrix.com';
+const PASSWORD = process.env.PASSWORD || 'Admin123!';
+
+const compiledDir = join(__dirname, '../frontend/src/workflows/compiled');
+
+// ============================================================================
+// Definition normalization — v1.0 IR format → backend format
+// ============================================================================
+
+/**
+ * Normalizes compiled definition fields from v1.0 IR format (state_type,
+ * field_type, action_type) to the backend's expected format (type).
+ */
+function normalizeDefinitionFields(def) {
+  // Normalize states: state_type → type
+  if (def.states) {
+    for (const state of def.states) {
+      if (state.state_type && !state.type) {
+        state.type = state.state_type;
+        delete state.state_type;
+      }
+      normalizeActions(state.on_enter);
+      normalizeActions(state.on_exit);
+      if (state.during && state.during.length > 0) {
+        state.during = state.during.flatMap(d => {
+          const innerActions = d.actions || [];
+          normalizeActions(innerActions);
+          const intervalMs = d.interval_ms || 60000;
+          const intervalSec = Math.max(1, Math.round(intervalMs / 1000));
+          return innerActions.map((action, idx) => ({
+            ...action,
+            id: action.id || `${d.id}_action_${idx}`,
+            mode: action.mode || 'auto',
+            schedule: {
+              type: 'recurring',
+              delay: `${intervalSec} seconds`,
+            },
+          }));
+        });
+      }
+      if (state.on_event) {
+        for (const e of state.on_event) {
+          normalizeActions(e.actions);
+        }
+      }
+    }
+  }
+
+  // Normalize fields: field_type → type
+  if (def.fields) {
+    for (const field of def.fields) {
+      if (field.field_type && !field.type) {
+        field.type = field.field_type;
+        delete field.field_type;
+      }
+    }
+  }
+
+  // Normalize transition actions
+  if (def.transitions) {
+    for (const t of def.transitions) {
+      normalizeActions(t.actions);
+    }
+  }
+
+  return def;
+}
+
+/**
+ * Normalizes action_type → type for an array of actions.
+ */
+function normalizeActions(actions) {
+  if (!actions || !Array.isArray(actions)) return;
+  for (const action of actions) {
+    if (action.action_type && !action.type) {
+      action.type = action.action_type;
+      delete action.action_type;
+    }
+    if (!action.mode) {
+      action.mode = 'auto';
+    }
+  }
+}
+
+/**
+ * Builds a blueprint_manifest for a definition.
+ */
+function buildManifest(def) {
+  return {
+    workflows: [{ slug: def.slug, role: 'primary' }],
+    experience_id: `${def.slug}-root`,
+    routes: [{ path: `/${def.slug}`, node: `${def.slug}-root`, label: def.name }],
+    config: { auth_required: true },
+  };
+}
+
+// ============================================================================
+// Main
+// ============================================================================
+
+async function main() {
+  // 1. Authenticate
+  console.log(`Authenticating with ${API_URL}...`);
+  const loginRes = await fetch(`${API_URL}/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email: EMAIL, password: PASSWORD }),
+  });
+
+  if (!loginRes.ok) {
+    throw new Error(`Login failed: ${loginRes.status} ${await loginRes.text()}`);
+  }
+
+  const loginData = await loginRes.json();
+  const token = loginData.token || loginData.access_token;
+  if (!token) throw new Error('No token in login response');
+  console.log('  Authenticated.\n');
+
+  // 2. Read compiled definitions
+  const files = readdirSync(compiledDir).filter(f => f.endsWith('.json') && f !== 'index.json');
+  console.log(`Found ${files.length} compiled definitions.`);
+
+  let seeded = 0;
+  let skipped = 0;
+
+  for (const file of files) {
+    const raw = JSON.parse(readFileSync(join(compiledDir, file), 'utf-8'));
+
+    // Support both new { canonical, ir } format and legacy flat format
+    const def = raw.ir || raw;
+    const canonical = raw.canonical || null;
+
+    // The view tree is now a top-level field on the IR (normalized by the compiler).
+    // Fall back to metadata.experience for legacy compiled files.
+    const viewTree = def.view || def.metadata?.experience;
+    if (!viewTree) {
+      console.log(`  - ${def.slug}: no view tree, skipping`);
+      skipped++;
+      continue;
+    }
+
+    // 3. Normalize definition structure (v1.0 IR → backend format)
+    normalizeDefinitionFields(def);
+
+    // 3a. Deep clone the view tree for mutation
+    const normalizedView = JSON.parse(JSON.stringify(viewTree));
+
+    // 3b. Build initialData from field defaults
+    const initialData = {};
+    for (const field of (def.fields || [])) {
+      const fieldName = field.name;
+      const defaultVal = field.default_value;
+      if (defaultVal !== undefined) {
+        initialData[fieldName] = defaultVal;
+      }
+    }
+    if (def.state_data && typeof def.state_data === 'object') {
+      Object.assign(initialData, def.state_data);
+    }
+
+    // 3c. Inject dataSources at root node
+    if (!normalizedView.dataSources) {
+      normalizedView.dataSources = [{
+        type: 'workflow',
+        name: 'main',
+        slug: def.slug,
+        query: 'latest',
+        autoStart: true,
+        entity: null,
+        includeDefinition: true,
+        ...(Object.keys(initialData).length > 0 ? { initialData } : {}),
+      }];
+    }
+
+    // 4. Build payload
+    const payload = {
+      slug: def.slug,
+      name: def.name,
+      version: def.version || '1.0.0',
+      description: def.description || `Compiled from ${file}`,
+      category: 'blueprint',
+      states: def.states || [],
+      transitions: def.transitions || [],
+      fields: def.fields || [],
+      roles: def.roles || [],
+      view: normalizedView,
+      visibility: 'PUBLIC',
+      publish_status: 'PUBLISHED',
+      tags: ['compiled', 'react'],
+      metadata: {
+        ...def.metadata,
+        blueprint_manifest: buildManifest(def),
+        // Store canonical tree in metadata for future use (Phase 2: backend alignment)
+        ...(canonical ? { canonical_tree: canonical } : {}),
+      },
+    };
+
+    // 5. Check if definition already exists
+    const existingRes = await fetch(`${API_URL}/definitions/${def.slug}`, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    if (existingRes.ok) {
+      const existing = await existingRes.json();
+      const defId = existing.id;
+      console.log(`  ~ ${def.slug}: exists (${defId}), patching...`);
+
+      const patchRes = await fetch(`${API_URL}/definitions/${defId}`, {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+          name: payload.name,
+          description: payload.description,
+          category: payload.category,
+          states: payload.states,
+          transitions: payload.transitions,
+          fields: payload.fields,
+          roles: payload.roles,
+          view: payload.view,
+          visibility: payload.visibility,
+          publish_status: payload.publish_status,
+          tags: payload.tags,
+          metadata: payload.metadata,
+        }),
+      });
+
+      if (!patchRes.ok) {
+        const errText = await patchRes.text();
+        if (errText.includes('immutable') || patchRes.status === 400) {
+          console.log(`    immutable structural fields, patching view + metadata only...`);
+
+          const viewPatchRes = await fetch(`${API_URL}/definitions/${defId}`, {
+            method: 'PATCH',
+            headers: {
+              'Content-Type': 'application/json',
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              description: payload.description,
+              view: payload.view,
+              metadata: payload.metadata,
+              visibility: payload.visibility,
+              publish_status: payload.publish_status,
+            }),
+          });
+
+          if (!viewPatchRes.ok) {
+            console.error(`    view PATCH failed: ${viewPatchRes.status} ${await viewPatchRes.text()}`);
+            continue;
+          }
+          console.log(`    view + metadata updated.`);
+        } else {
+          console.error(`    PATCH failed: ${patchRes.status} ${errText}`);
+          continue;
+        }
+      } else {
+        console.log(`    updated.`);
+      }
+    } else {
+      console.log(`  + ${def.slug}: creating...`);
+
+      const createRes = await fetch(`${API_URL}/definitions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify(payload),
+      });
+
+      if (!createRes.ok) {
+        const errText = await createRes.text();
+        console.error(`    POST failed: ${createRes.status} ${errText}`);
+        continue;
+      }
+      console.log(`    created.`);
+    }
+
+    seeded++;
+  }
+
+  console.log(`\nDone: ${seeded} seeded, ${skipped} skipped (no views).`);
+}
+
+main().catch((err) => {
+  console.error('Seed failed:', err.message);
+  process.exit(1);
+});

package/src/RoundTripValidator.ts

@@ -0,0 +1,400 @@
+/**
+ * RoundTripValidator — validates that decompile → recompile produces equivalent IR.
+ *
+ * Given an IR definition:
+ *   1. Decompiles it to .workflow.tsx source code
+ *   2. Recompiles that source via the Babel compiler
+ *   3. Structurally compares the original and round-tripped IR
+ *
+ * This validates that the decompiler produces code the compiler can understand,
+ * and that no information is silently dropped during the round trip.
+ */
+
+import { transformSync } from '@babel/core';
+import type { IRWorkflowDefinition, IRFieldDefinition, IRStateDefinition, IRTransitionDefinition } from '@mindmatrix/player-core';
+import { decompile, type DecompilerInput } from './decompiler';
+import babelPlugin from './babel';
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface RoundTripResult {
+  /** Whether the round trip preserves all structural data. */
+  success: boolean;
+  /** The generated TSX source code (intermediate). */
+  generatedSource: string;
+  /** The original IR. */
+  originalIR: IRWorkflowDefinition;
+  /** The round-tripped IR (compiled from generated source). */
+  roundTrippedIR: IRWorkflowDefinition | null;
+  /** List of structural differences found. */
+  diffs: RoundTripDiff[];
+}
+
+export interface RoundTripDiff {
+  path: string;
+  expected: unknown;
+  actual: unknown;
+  severity: 'error' | 'warning';
+}
+
+// =============================================================================
+// Main
+// =============================================================================
+
+/**
+ * Validates the decompile → compile round trip for a given IR definition.
+ */
+export function validateRoundTrip(
+  definition: DecompilerInput,
+): RoundTripResult {
+  // Step 1: Decompile IR → TSX
+  const { code: generatedSource } = decompile(definition, {
+    includeAnnotation: true,
+  });
+
+  // Step 2: Compile TSX → IR
+  let roundTrippedIR: IRWorkflowDefinition | null = null;
+  try {
+    const result = transformSync(generatedSource, {
+      filename: `${definition.slug}.workflow.tsx`,
+      plugins: [[babelPlugin, { mode: 'infer' }]],
+      parserOpts: { plugins: ['typescript', 'jsx'], attachComment: true },
+    });
+    roundTrippedIR = (result as any)?.metadata?.mindmatrixIR ?? null;
+  } catch (err) {
+    return {
+      success: false,
+      generatedSource,
+      originalIR: definition,
+      roundTrippedIR: null,
+      diffs: [{
+        path: '<compile>',
+        expected: 'valid compilation',
+        actual: `compilation failed: ${(err as Error).message}`,
+        severity: 'error',
+      }],
+    };
+  }
+
+  if (!roundTrippedIR) {
+    return {
+      success: false,
+      generatedSource,
+      originalIR: definition,
+      roundTrippedIR: null,
+      diffs: [{
+        path: '<compile>',
+        expected: 'IR output',
+        actual: 'no IR produced',
+        severity: 'error',
+      }],
+    };
+  }
+
+  // Step 3: Structural comparison
+  const diffs = compareIR(definition, roundTrippedIR);
+
+  return {
+    success: diffs.filter(d => d.severity === 'error').length === 0,
+    generatedSource,
+    originalIR: definition,
+    roundTrippedIR,
+    diffs,
+  };
+}
+
+// =============================================================================
+// IR Comparison
+// =============================================================================
+
+function compareIR(
+  original: IRWorkflowDefinition,
+  roundTripped: IRWorkflowDefinition,
+): RoundTripDiff[] {
+  const diffs: RoundTripDiff[] = [];
+
+  // Metadata
+  comparePrimitive(diffs, 'slug', original.slug, roundTripped.slug);
+  comparePrimitive(diffs, 'version', original.version, roundTripped.version);
+  comparePrimitive(diffs, 'category', original.category, roundTripped.category);
+
+  // Fields
+  compareFields(diffs, original.fields, roundTripped.fields);
+
+  // States
+  compareStates(diffs, original.states, roundTripped.states);
+
+  // Transitions
+  compareTransitions(diffs, original.transitions, roundTripped.transitions);
+
+  // Events
+  const origEvents = original.on_event ?? [];
+  const rtEvents = roundTripped.on_event ?? [];
+  if (origEvents.length !== rtEvents.length) {
+    diffs.push({
+      path: 'on_event.length',
+      expected: origEvents.length,
+      actual: rtEvents.length,
+      severity: origEvents.length > 0 ? 'error' : 'warning',
+    });
+  }
+
+  return diffs;
+}
+
+function comparePrimitive(
+  diffs: RoundTripDiff[],
+  path: string,
+  expected: unknown,
+  actual: unknown,
+): void {
+  if (expected !== actual) {
+    diffs.push({ path, expected, actual, severity: 'error' });
+  }
+}
+
+// =============================================================================
+// Field comparison
+// =============================================================================
+
+function compareFields(
+  diffs: RoundTripDiff[],
+  original: IRFieldDefinition[],
+  roundTripped: IRFieldDefinition[],
+): void {
+  // Filter out computed fields (not emitted by decompiler)
+  const origFields = original.filter(f => !f.computed);
+
+  if (origFields.length !== roundTripped.length) {
+    diffs.push({
+      path: 'fields.length',
+      expected: origFields.length,
+      actual: roundTripped.length,
+      severity: 'error',
+    });
+  }
+
+  // Compare by name
+  const rtMap = new Map(roundTripped.map(f => [f.name, f]));
+
+  for (const field of origFields) {
+    const rt = rtMap.get(field.name);
+    if (!rt) {
+      diffs.push({
+        path: `fields[${field.name}]`,
+        expected: field.name,
+        actual: undefined,
+        severity: 'error',
+      });
+      continue;
+    }
+
+    // Compare type (allow some type coercion since decompiler infers types)
+    if (field.type !== rt.type && !isCompatibleType(field.type, rt.type)) {
+      diffs.push({
+        path: `fields[${field.name}].type`,
+        expected: field.type,
+        actual: rt.type,
+        severity: 'warning',
+      });
+    }
+  }
+}
+
+/** Types that are compatible due to decompiler type inference limits. */
+function isCompatibleType(original: string, roundTripped: string): boolean {
+  // The decompiler uses inferDefaultFromType which may produce different defaults
+  // The compiler uses useState type inference which may produce different types
+  const stringTypes = ['text', 'rich_text', 'email', 'url', 'phone', 'color', 'select'];
+  const numberTypes = ['number', 'currency', 'percentage', 'rating', 'duration', 'auto_number'];
+
+  if (stringTypes.includes(original) && stringTypes.includes(roundTripped)) return true;
+  if (numberTypes.includes(original) && numberTypes.includes(roundTripped)) return true;
+  return false;
+}
+
+// =============================================================================
+// State comparison
+// =============================================================================
+
+function compareStates(
+  diffs: RoundTripDiff[],
+  original: IRStateDefinition[],
+  roundTripped: IRStateDefinition[],
+): void {
+  // Build name maps for structural comparison
+  const rtMap = new Map(roundTripped.map(s => [s.name, s]));
+
+  // Check that all original states with actions exist in round-tripped
+  for (const state of original) {
+    const hasActions = state.on_enter.length > 0 || state.on_exit.length > 0 || state.during.length > 0;
+    const rt = rtMap.get(state.name);
+
+    if (!rt && hasActions) {
+      diffs.push({
+        path: `states[${state.name}]`,
+        expected: state.name,
+        actual: undefined,
+        severity: 'error',
+      });
+      continue;
+    }
+    if (!rt) continue; // States without actions may be auto-generated differently
+
+    // Compare action counts
+    if (state.on_enter.length !== rt.on_enter.length) {
+      diffs.push({
+        path: `states[${state.name}].on_enter.length`,
+        expected: state.on_enter.length,
+        actual: rt.on_enter.length,
+        severity: state.on_enter.length > 0 ? 'error' : 'warning',
+      });
+    }
+
+    if (state.on_exit.length !== rt.on_exit.length) {
+      diffs.push({
+        path: `states[${state.name}].on_exit.length`,
+        expected: state.on_exit.length,
+        actual: rt.on_exit.length,
+        severity: state.on_exit.length > 0 ? 'error' : 'warning',
+      });
+    }
+
+    if (state.during.length !== rt.during.length) {
+      diffs.push({
+        path: `states[${state.name}].during.length`,
+        expected: state.during.length,
+        actual: rt.during.length,
+        severity: state.during.length > 0 ? 'error' : 'warning',
+      });
+    }
+  }
+}
+
+// =============================================================================
+// Transition comparison
+// =============================================================================
+
+function compareTransitions(
+  diffs: RoundTripDiff[],
+  original: IRTransitionDefinition[],
+  roundTripped: IRTransitionDefinition[],
+): void {
+  if (original.length !== roundTripped.length) {
+    diffs.push({
+      path: 'transitions.length',
+      expected: original.length,
+      actual: roundTripped.length,
+      severity: 'error',
+    });
+  }
+
+  const rtMap = new Map(roundTripped.map(t => [t.name, t]));
+
+  for (const transition of original) {
+    const rt = rtMap.get(transition.name);
+    if (!rt) {
+      diffs.push({
+        path: `transitions[${transition.name}]`,
+        expected: transition.name,
+        actual: undefined,
+        severity: 'error',
+      });
+      continue;
+    }
+
+    // Compare 'to' state
+    if (transition.to !== rt.to) {
+      diffs.push({
+        path: `transitions[${transition.name}].to`,
+        expected: transition.to,
+        actual: rt.to,
+        severity: 'error',
+      });
+    }
+
+    // Compare 'from' states (order-independent)
+    const origFrom = [...transition.from].sort();
+    const rtFrom = [...rt.from].sort();
+    if (JSON.stringify(origFrom) !== JSON.stringify(rtFrom)) {
+      diffs.push({
+        path: `transitions[${transition.name}].from`,
+        expected: origFrom,
+        actual: rtFrom,
+        severity: 'error',
+      });
+    }
+
+    // Compare roles (order-independent)
+    const origRoles = [...(transition.roles ?? [])].sort();
+    const rtRoles = [...(rt.roles ?? [])].sort();
+    if (JSON.stringify(origRoles) !== JSON.stringify(rtRoles)) {
+      diffs.push({
+        path: `transitions[${transition.name}].roles`,
+        expected: origRoles,
+        actual: rtRoles,
+        severity: 'error',
+      });
+    }
+
+    // Compare required_fields (order-independent)
+    const origReq = [...(transition.required_fields ?? [])].sort();
+    const rtReq = [...(rt.required_fields ?? [])].sort();
+    if (JSON.stringify(origReq) !== JSON.stringify(rtReq)) {
+      diffs.push({
+        path: `transitions[${transition.name}].required_fields`,
+        expected: origReq,
+        actual: rtReq,
+        severity: 'error',
+      });
+    }
+
+    // Compare auto flag
+    if (!!transition.auto !== !!rt.auto) {
+      diffs.push({
+        path: `transitions[${transition.name}].auto`,
+        expected: transition.auto,
+        actual: rt.auto,
+        severity: 'error',
+      });
+    }
+  }
+}
+
+// =============================================================================
+// Convenience: compile source and validate
+// =============================================================================
+
+/**
+ * Compiles a .workflow.tsx source file and returns the IR.
+ * Useful for testing the forward direction independently.
+ */
+export function compileSource(
+  source: string,
+  filename: string = 'test.workflow.tsx',
+): IRWorkflowDefinition | null {
+  try {
+    const result = transformSync(source, {
+      filename,
+      plugins: [[babelPlugin, { mode: 'infer' }]],
+      parserOpts: { plugins: ['typescript', 'jsx'], attachComment: true },
+    });
+    return (result as any)?.metadata?.mindmatrixIR ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Full round-trip from source: compile → decompile → recompile → diff.
+ */
+export function validateSourceRoundTrip(
+  source: string,
+  filename: string = 'test.workflow.tsx',
+): RoundTripResult | null {
+  const ir = compileSource(source, filename);
+  if (!ir) return null;
+  return validateRoundTrip(ir as DecompilerInput);
+}