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

package/seed-compiled.mjs

@@ -1,318 +0,0 @@
-/**
- * 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

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