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

package/src/config/defineWorkspace.ts

@@ -1,24 +0,0 @@
-/**
- * defineWorkspace — configuration function for mm.config.ts files.
- *
- * Declares workspace metadata used by the mmrc CLI (build, deploy, pull).
- * This is a compile-time configuration — the function simply returns its
- * input for the project compiler to consume.
- */
-
-export interface WorkspaceConfig {
-  slug: string;
-  name?: string;
-  version?: string;
-  category?: string;
-  description?: string;
-  models?: string[];
-  entries?: string[];
-  actions?: string[];
-  pages?: string[];
-  components?: string[];
-}
-
-export function defineWorkspace(config: WorkspaceConfig): WorkspaceConfig {
-  return config;
-}

package/src/core/WorkflowRuntime.ts

@@ -1,153 +0,0 @@
-/**
- * WorkflowRuntime — Class-based runtime for MindMatrix workflows
- *
- * Wraps StateMachine + EventBus + ActionDispatcher in a subscribable class
- * that can be used outside of React hooks (e.g., in vanilla JS contexts).
- */
-
-import {
-  StateMachine,
-  EventBus,
-  ActionDispatcher,
-  createEvaluator,
-  WEB_FAILURE_POLICIES,
-} from '@mindmatrix/player-core';
-import type {
-  PlayerWorkflowDefinition,
-  TransitionResult,
-  ActionHandler,
-  ExpressionContext,
-  PlayerAction,
-  Evaluator,
-} from '@mindmatrix/player-core';
-
-export interface RuntimeConfig {
-  definition: PlayerWorkflowDefinition;
-  initialData?: Record<string, unknown>;
-  actionHandlers?: Record<string, (config: Record<string, unknown>, ctx: ExpressionContext) => void | Promise<void>>;
-  debug?: boolean;
-}
-
-export interface RuntimeSnapshot {
-  currentState: string;
-  stateData: Record<string, unknown>;
-  memory: Record<string, unknown>;
-  status: 'ACTIVE' | 'COMPLETED' | 'CANCELLED';
-  availableTransitions: string[];
-}
-
-export class WorkflowRuntime {
-  readonly sm: StateMachine;
-  readonly eventBus: EventBus;
-  readonly dispatcher: ActionDispatcher;
-  readonly evaluator: Evaluator;
-  private listeners = new Set<(snap: RuntimeSnapshot) => void>();
-
-  constructor(config: RuntimeConfig) {
-    // 1. Create evaluator with WEB_FAILURE_POLICIES.EVENT_REACTION
-    this.evaluator = createEvaluator({
-      functions: [],
-      failurePolicy: WEB_FAILURE_POLICIES.EVENT_REACTION,
-    });
-
-    // 2. Create action handlers map (built-in set_field, set_memory + custom)
-    const actionHandlers = new Map<string, ActionHandler>();
-
-    // Wrap custom ActionHandlerFn (config, ctx) into ActionHandler (action, ctx)
-    if (config.actionHandlers) {
-      for (const [type, handler] of Object.entries(config.actionHandlers)) {
-        actionHandlers.set(type, (action: PlayerAction, ctx: ExpressionContext) =>
-          handler(action.config, ctx)
-        );
-      }
-    }
-
-    // Built-in set_field handler
-    let smRef: StateMachine | null = null;
-    actionHandlers.set('set_field', (action: PlayerAction) => {
-      if (smRef && typeof action.config.field === 'string') {
-        smRef.setField(action.config.field, action.config.value);
-      }
-    });
-
-    // Built-in set_memory handler
-    actionHandlers.set('set_memory', (action: PlayerAction) => {
-      if (smRef && typeof action.config.key === 'string') {
-        smRef.setMemory(action.config.key, action.config.value);
-      }
-    });
-
-    // 3. Create StateMachine(definition, initialData, { evaluator, actionHandlers })
-    this.sm = new StateMachine(
-      config.definition,
-      config.initialData ?? {},
-      { evaluator: this.evaluator, actionHandlers },
-    );
-    smRef = this.sm;
-
-    // 4. Create EventBus + ActionDispatcher
-    this.eventBus = new EventBus();
-    this.dispatcher = new ActionDispatcher();
-
-    // 5. Mirror custom handlers to dispatcher
-    // Register built-in handlers on dispatcher (for on_event action dispatch)
-    this.dispatcher.register('set_field', (cfg: Record<string, unknown>) => {
-      if (smRef && typeof cfg.field === 'string') {
-        smRef.setField(cfg.field, cfg.value);
-      }
-    });
-    this.dispatcher.register('set_memory', (cfg: Record<string, unknown>) => {
-      if (smRef && typeof cfg.key === 'string') {
-        smRef.setMemory(cfg.key, cfg.value);
-      }
-    });
-
-    // Mirror custom action handlers to dispatcher (dispatcher uses ActionHandlerFn signature)
-    if (config.actionHandlers) {
-      for (const [type, handler] of Object.entries(config.actionHandlers)) {
-        this.dispatcher.register(type, handler);
-      }
-    }
-  }
-
-  getSnapshot(): RuntimeSnapshot {
-    return {
-      currentState: this.sm.currentState,
-      stateData: this.sm.stateData,
-      memory: this.sm.getSnapshot().memory,
-      status: this.sm.status as RuntimeSnapshot['status'],
-      availableTransitions: this.sm.getAvailableTransitions().map(t => t.name),
-    };
-  }
-
-  subscribe(listener: (snap: RuntimeSnapshot) => void): () => void {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-
-  async transition(name: string, data?: Record<string, unknown>): Promise<TransitionResult> {
-    const result = await this.sm.transition(name, data);
-    this.notify();
-    return result;
-  }
-
-  setField(field: string, value: unknown): void {
-    this.sm.setField(field, value);
-    this.notify();
-  }
-
-  setMemory(key: string, value: unknown): void {
-    this.sm.setMemory(key, value);
-  }
-
-  publishEvent(topic: string, payload?: Record<string, unknown>): void {
-    this.eventBus.emit(topic, payload);
-  }
-
-  private notify(): void {
-    const snap = this.getSnapshot();
-    for (const listener of this.listeners) {
-      listener(snap);
-    }
-  }
-}

package/src/factories.ts

@@ -1,425 +0,0 @@
-/**
- * Transition factories — reusable workflow patterns as ModelDefinition mixins.
- *
- * Each factory returns a mixin function compatible with ModelBuilder.mixin().
- * Factories add states, transitions, fields, and roles as a cohesive unit.
- *
- * @example
- * ```typescript
- * import { model, field, state } from '@mindmatrix/react';
- * import { approval, escalation, review, crud } from '@mindmatrix/react/factories';
- *
- * export default model('invoice')
- *   .field('amount', field.currency().required())
- *   .state('draft', state.initial())
- *   .mixin(approval({ approverRole: 'manager', field: 'status' }))
- *   .mixin(escalation({ timeout: '24h', notifyRole: 'admin' }))
- *   .build();
- * ```
- */
-
-import type {
-  ModelDefinition,
-  TransitionDescriptor,
-  StateDescriptor,
-  ActionDefinition,
-  WorkflowFieldDescriptor,
-  RoleDefinition,
-} from './config/defineModel';
-import { setField, logEvent, notify } from './actions';
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-/** Merge fields into a definition without overwriting existing ones. */
-function mergeFields(
-  def: ModelDefinition,
-  fields: Record<string, WorkflowFieldDescriptor>,
-): void {
-  for (const [name, desc] of Object.entries(fields)) {
-    if (!def.fields[name]) {
-      def.fields[name] = desc;
-    }
-  }
-}
-
-/** Merge states into a definition without overwriting existing ones. */
-function mergeStates(
-  def: ModelDefinition,
-  states: Record<string, StateDescriptor>,
-): void {
-  for (const [name, desc] of Object.entries(states)) {
-    if (!def.states[name]) {
-      def.states[name] = desc;
-    }
-  }
-}
-
-/** Merge transitions into a definition without overwriting existing ones. */
-function mergeTransitions(
-  def: ModelDefinition,
-  transitions: Record<string, TransitionDescriptor>,
-): void {
-  for (const [name, desc] of Object.entries(transitions)) {
-    if (!def.transitions[name]) {
-      def.transitions[name] = desc;
-    }
-  }
-}
-
-/** Merge roles into a definition without overwriting existing ones. */
-function mergeRoles(
-  def: ModelDefinition,
-  roles: Record<string, RoleDefinition>,
-): void {
-  if (!def.roles) def.roles = {};
-  for (const [name, desc] of Object.entries(roles)) {
-    if (!def.roles[name]) {
-      def.roles[name] = desc;
-    }
-  }
-}
-
-// =============================================================================
-// Approval Pattern
-// =============================================================================
-
-export interface ApprovalConfig {
-  /** Role required to approve (default: 'approver'). */
-  approverRole?: string;
-  /** Field to track approval status (default: 'approvalStatus'). */
-  field?: string;
-  /** State to transition FROM for approval (default: 'pending_approval'). */
-  fromState?: string;
-  /** State to transition TO on approval (default: 'approved'). */
-  approvedState?: string;
-  /** State to transition TO on rejection (default: 'rejected'). */
-  rejectedState?: string;
-  /** Require a reason for rejection. */
-  requireRejectionReason?: boolean;
-}
-
-/**
- * Approval pattern — adds approve/reject transitions with role guards.
- *
- * Adds: pending_approval state, approved state, rejected state,
- * approve transition, reject transition, approvalStatus field.
- */
-export function approval(config: ApprovalConfig = {}): (def: ModelDefinition) => ModelDefinition {
-  const {
-    approverRole = 'approver',
-    field: statusField = 'approvalStatus',
-    fromState = 'pending_approval',
-    approvedState = 'approved',
-    rejectedState = 'rejected',
-    requireRejectionReason = false,
-  } = config;
-
-  return (def) => {
-    mergeFields(def, {
-      [statusField]: { type: 'string', default: 'pending', enum: ['pending', 'approved', 'rejected'] },
-      approvedBy: { type: 'string', default: '' },
-      approvedAt: { type: 'datetime' },
-      rejectionReason: { type: 'string', default: '' },
-    });
-
-    mergeStates(def, {
-      [fromState]: {},
-      [approvedState]: {},
-      [rejectedState]: {},
-    });
-
-    mergeRoles(def, {
-      [approverRole]: { description: `Can approve or reject`, permissions: ['approve', 'reject'] },
-    });
-
-    const approveActions: ActionDefinition[] = [
-      setField(statusField, '"approved"'),
-      setField('approvedBy', 'context.actor_id'),
-      setField('approvedAt', 'NOW()'),
-      logEvent('approved'),
-    ];
-
-    const rejectActions: ActionDefinition[] = [
-      setField(statusField, '"rejected"'),
-      setField('rejectionReason', 'COALESCE(input.reason, "")'),
-      logEvent('rejected', { reason: '{{ input.reason }}' }),
-    ];
-
-    mergeTransitions(def, {
-      approve: {
-        from: fromState,
-        to: approvedState,
-        roles: [approverRole],
-        actions: approveActions,
-        description: 'Approve the request',
-      },
-      reject: {
-        from: fromState,
-        to: rejectedState,
-        roles: [approverRole],
-        actions: rejectActions,
-        ...(requireRejectionReason ? { requiredFields: ['reason'] } : {}),
-        description: 'Reject the request',
-      },
-    });
-
-    return def;
-  };
-}
-
-// =============================================================================
-// Escalation Pattern
-// =============================================================================
-
-export interface EscalationConfig {
-  /** Duration before escalation (e.g., '24h', '2d'). */
-  timeout: string;
-  /** Role to notify on escalation (default: 'admin'). */
-  notifyRole?: string;
-  /** State to escalate FROM (default: 'pending_approval'). */
-  fromState?: string;
-  /** State to escalate TO (default: 'escalated'). */
-  escalatedState?: string;
-}
-
-/**
- * Escalation pattern — adds timeout-based escalation with notification.
- *
- * Adds: escalated state, escalate transition (auto, timed),
- * notification to the specified role.
- */
-export function escalation(config: EscalationConfig): (def: ModelDefinition) => ModelDefinition {
-  const {
-    timeout,
-    notifyRole = 'admin',
-    fromState = 'pending_approval',
-    escalatedState = 'escalated',
-  } = config;
-
-  return (def) => {
-    mergeFields(def, {
-      escalatedAt: { type: 'datetime' },
-      escalationLevel: { type: 'number', default: 0 },
-    });
-
-    // Add timeout to the source state
-    if (def.states[fromState]) {
-      def.states[fromState].timeout = {
-        duration: timeout,
-        fallback: { transition: 'escalate' },
-      };
-    }
-
-    mergeStates(def, {
-      [escalatedState]: {
-        onEnter: [
-          setField('escalatedAt', 'NOW()'),
-          setField('escalationLevel', 'state_data.escalationLevel + 1'),
-          logEvent('escalated'),
-          notify('escalation', { to: `role:${notifyRole}` }),
-        ],
-      },
-    });
-
-    mergeTransitions(def, {
-      escalate: {
-        from: fromState,
-        to: escalatedState,
-        auto: true,
-        description: `Auto-escalate after ${timeout}`,
-        actions: [logEvent('escalated', { timeout })],
-      },
-    });
-
-    return def;
-  };
-}
-
-// =============================================================================
-// Review Pattern
-// =============================================================================
-
-export interface ReviewConfig {
-  /** Role that submits for review (default: 'author'). */
-  authorRole?: string;
-  /** Role that reviews (default: 'reviewer'). */
-  reviewerRole?: string;
-  /** State the item starts in (default: 'draft'). */
-  draftState?: string;
-  /** State when under review (default: 'in_review'). */
-  reviewState?: string;
-  /** State when revisions requested (default: 'revisions_requested'). */
-  revisionsState?: string;
-  /** State when approved (default: 'approved'). */
-  approvedState?: string;
-}
-
-/**
- * Review cycle pattern — submit → review → approve/request-revisions → resubmit.
- *
- * Adds: in_review state, revisions_requested state, approved state,
- * submit, approve_review, request_revisions, resubmit transitions.
- */
-export function review(config: ReviewConfig = {}): (def: ModelDefinition) => ModelDefinition {
-  const {
-    authorRole = 'author',
-    reviewerRole = 'reviewer',
-    draftState = 'draft',
-    reviewState = 'in_review',
-    revisionsState = 'revisions_requested',
-    approvedState = 'approved',
-  } = config;
-
-  return (def) => {
-    mergeFields(def, {
-      reviewNotes: { type: 'string', default: '' },
-      reviewedBy: { type: 'string', default: '' },
-      reviewedAt: { type: 'datetime' },
-      revisionCount: { type: 'number', default: 0 },
-    });
-
-    mergeStates(def, {
-      [reviewState]: {
-        onEnter: [logEvent('submitted_for_review')],
-      },
-      [revisionsState]: {
-        onEnter: [
-          setField('revisionCount', 'state_data.revisionCount + 1'),
-          logEvent('revisions_requested'),
-        ],
-      },
-      [approvedState]: {
-        onEnter: [
-          setField('reviewedBy', 'context.actor_id'),
-          setField('reviewedAt', 'NOW()'),
-          logEvent('review_approved'),
-        ],
-      },
-    });
-
-    mergeRoles(def, {
-      [authorRole]: { description: 'Can submit and revise', permissions: ['submit', 'revise'] },
-      [reviewerRole]: { description: 'Can approve or request revisions', permissions: ['approve', 'request_revisions'] },
-    });
-
-    mergeTransitions(def, {
-      submit_for_review: {
-        from: draftState,
-        to: reviewState,
-        roles: [authorRole],
-        description: 'Submit for review',
-      },
-      approve_review: {
-        from: reviewState,
-        to: approvedState,
-        roles: [reviewerRole],
-        description: 'Approve the submission',
-      },
-      request_revisions: {
-        from: reviewState,
-        to: revisionsState,
-        roles: [reviewerRole],
-        actions: [setField('reviewNotes', 'COALESCE(input.notes, "")')],
-        description: 'Request revisions',
-      },
-      resubmit: {
-        from: revisionsState,
-        to: reviewState,
-        roles: [authorRole],
-        description: 'Resubmit after revisions',
-      },
-    });
-
-    return def;
-  };
-}
-
-// =============================================================================
-// CRUD Pattern
-// =============================================================================
-
-export interface CrudConfig {
-  /** Use soft delete (archived state) instead of hard delete. Default: true. */
-  softDelete?: boolean;
-  /** Owner role name (default: 'owner'). */
-  ownerRole?: string;
-  /** Admin role name (default: 'admin'). */
-  adminRole?: string;
-}
-
-/**
- * CRUD lifecycle pattern — draft → active → archived/deleted.
- *
- * Adds: draft (initial), active, archived/deleted states,
- * publish, update, archive/delete, restore transitions.
- */
-export function crud(config: CrudConfig = {}): (def: ModelDefinition) => ModelDefinition {
-  const {
-    softDelete = true,
-    ownerRole = 'owner',
-    adminRole = 'admin',
-  } = config;
-
-  return (def) => {
-    mergeFields(def, {
-      createdBy: { type: 'string', default: '' },
-      createdAt: { type: 'datetime' },
-      updatedAt: { type: 'datetime' },
-    });
-
-    mergeStates(def, {
-      draft: { type: 'initial', onEnter: [setField('createdAt', 'NOW()'), setField('createdBy', 'context.actor_id')] },
-      active: { onEnter: [setField('updatedAt', 'NOW()')] },
-    });
-
-    mergeRoles(def, {
-      [ownerRole]: { description: 'Record owner', permissions: ['read', 'write', 'delete'] },
-      [adminRole]: { description: 'Administrator', permissions: ['read', 'write', 'delete', 'manage'] },
-    });
-
-    const transitions: Record<string, TransitionDescriptor> = {
-      publish: {
-        from: 'draft',
-        to: 'active',
-        description: 'Publish the draft',
-        actions: [logEvent('published')],
-      },
-      update: {
-        from: 'active',
-        to: 'active',
-        description: 'Update the record',
-        actions: [setField('updatedAt', 'NOW()'), logEvent('updated')],
-      },
-    };
-
-    if (softDelete) {
-      mergeStates(def, { archived: {} });
-      transitions.archive = {
-        from: 'active',
-        to: 'archived',
-        description: 'Archive the record',
-        actions: [logEvent('archived')],
-      };
-      transitions.restore = {
-        from: 'archived',
-        to: 'active',
-        description: 'Restore from archive',
-        actions: [logEvent('restored')],
-      };
-    } else {
-      mergeStates(def, { deleted: { type: 'end' } });
-      transitions.delete_record = {
-        from: ['draft', 'active'],
-        to: 'deleted',
-        roles: [ownerRole, adminRole],
-        description: 'Permanently delete',
-        actions: [logEvent('deleted')],
-      };
-    }
-
-    mergeTransitions(def, transitions);
-    return def;
-  };
-}