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

package/src/__tests__/builders.test.ts

@@ -1,336 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { model, field, state, transition, StateBuilder } from '../builders';
-import { setField, logEvent, serverAction } from '../actions';
-
-describe('StateBuilder.to() — inline transitions', () => {
-  it('declares a single outgoing transition', () => {
-    const result = model('test')
-      .state('draft', state.initial().to('review', 'submit'))
-      .state('review')
-      .build();
-
-    expect(result.transitions.submit).toBeDefined();
-    expect(result.transitions.submit.from).toBe('draft');
-    expect(result.transitions.submit.to).toBe('review');
-  });
-
-  it('declares multiple outgoing transitions from one state', () => {
-    const result = model('test')
-      .state('review', new StateBuilder()
-        .to('approved', 'approve')
-        .to('rejected', 'reject')
-      )
-      .build();
-
-    expect(result.transitions.approve).toEqual({ from: 'review', to: 'approved' });
-    expect(result.transitions.reject).toEqual({ from: 'review', to: 'rejected' });
-  });
-
-  it('supports transition configuration via callback', () => {
-    const result = model('test')
-      .state('draft', state.initial()
-        .to('review', 'submit', t => t.require('title', 'body').roles('author'))
-      )
-      .state('review')
-      .build();
-
-    expect(result.transitions.submit.requiredFields).toEqual(['title', 'body']);
-    expect(result.transitions.submit.roles).toEqual(['author']);
-  });
-
-  it('standalone transitions override inline transitions', () => {
-    const result = model('test')
-      .state('draft', state.initial().to('review', 'submit'))
-      .state('review')
-      .transition('submit', transition.from('draft').to('review').roles('admin'))
-      .build();
-
-    expect(result.transitions.submit.roles).toEqual(['admin']);
-  });
-
-  it('inline transitions work with actions', () => {
-    const result = model('test')
-      .state('active', new StateBuilder()
-        .to('inactive', 'deactivate', t =>
-          t.do(setField('active', 'false'), logEvent('deactivated'))
-        )
-      )
-      .build();
-
-    expect(result.transitions.deactivate.actions).toHaveLength(2);
-    expect(result.transitions.deactivate.actions![0].type).toBe('set_field');
-    expect(result.transitions.deactivate.actions![1].type).toBe('log_event');
-  });
-
-  it('coexists with standalone transitions on the same model', () => {
-    const result = model('test')
-      .state('draft', state.initial().to('review', 'submit'))
-      .state('review')
-      .state('published')
-      .transition('publish', transition.from('review').to('published'))
-      .build();
-
-    expect(result.transitions.submit.from).toBe('draft');
-    expect(result.transitions.publish.from).toBe('review');
-  });
-});
-
-describe('ModelBuilder.line() — auto-named transitions', () => {
-  it('auto-generates transition names from state pairs', () => {
-    const result = model('order')
-      .line(
-        ['placed', state.initial()],
-        'confirmed',
-        'shipped',
-        ['delivered', state.end()],
-      )
-      .build();
-
-    expect(Object.keys(result.states).sort()).toEqual(
-      ['confirmed', 'delivered', 'placed', 'shipped'].sort()
-    );
-    expect(result.states.placed.type).toBe('initial');
-    expect(result.states.delivered.type).toBe('end');
-    expect(result.transitions.placed_to_confirmed).toEqual({ from: 'placed', to: 'confirmed' });
-    expect(result.transitions.confirmed_to_shipped).toEqual({ from: 'confirmed', to: 'shipped' });
-    expect(result.transitions.shipped_to_delivered).toEqual({ from: 'shipped', to: 'delivered' });
-  });
-
-  it('configures incoming edge via tuple callback', () => {
-    const result = model('test')
-      .line(
-        'draft',
-        ['review', t => t.require('title', 'body')],
-        ['approved', t => t.roles('manager')],
-      )
-      .build();
-
-    expect(result.transitions.draft_to_review.requiredFields).toEqual(['title', 'body']);
-    expect(result.transitions.review_to_approved.roles).toEqual(['manager']);
-  });
-
-  it('branching via multiple lines', () => {
-    const result = model('order')
-      .line(
-        ['placed', state.initial()],
-        'confirmed',
-        'shipped',
-      )
-      .line('placed', 'cancelled')
-      .line('confirmed', 'cancelled')
-      .build();
-
-    expect(Object.keys(result.transitions).sort()).toEqual([
-      'confirmed_to_cancelled',
-      'confirmed_to_shipped',
-      'placed_to_cancelled',
-      'placed_to_confirmed',
-    ].sort());
-  });
-
-  it('two-state line', () => {
-    const result = model('test')
-      .line('active', 'inactive')
-      .build();
-
-    expect(result.transitions.active_to_inactive).toEqual({ from: 'active', to: 'inactive' });
-  });
-
-  it('self-loop', () => {
-    const result = model('test')
-      .line('active', 'active')
-      .build();
-
-    expect(result.transitions.active_to_active).toEqual({ from: 'active', to: 'active' });
-  });
-
-  it('with actions on edges', () => {
-    const result = model('test')
-      .line(
-        'draft',
-        ['published', t => t.do(logEvent('published'), setField('publishedAt', 'NOW()'))],
-      )
-      .build();
-
-    const tr = result.transitions.draft_to_published;
-    expect(tr.actions).toHaveLength(2);
-    expect(tr.actions![0].type).toBe('log_event');
-    expect(tr.actions![1].type).toBe('set_field');
-  });
-
-  it('works with field definitions', () => {
-    const result = model('invoice')
-      .field('amount', field.currency().required())
-      .line(
-        ['draft', state.initial()],
-        ['sent', t => t.require('amount')],
-        ['paid', state.end()],
-      )
-      .build();
-
-    expect(result.fields.amount.type).toBe('currency');
-    expect(result.transitions.draft_to_sent.requiredFields).toEqual(['amount']);
-  });
-
-  it('mixes with .state() and .transition() methods', () => {
-    const result = model('test')
-      .state('error', new StateBuilder().onEnter(setField('hasError', 'true')))
-      .line(
-        ['draft', state.initial()],
-        'review',
-        ['published', state.end()],
-      )
-      .transition('fail', transition.from('review').to('error'))
-      .build();
-
-    expect(result.states.error.onEnter).toHaveLength(1);
-    expect(result.states.draft.type).toBe('initial');
-    expect(result.transitions.draft_to_review).toBeDefined();
-    expect(result.transitions.fail.from).toBe('review');
-  });
-
-  it('shared states across lines are unified', () => {
-    const result = model('auth')
-      .line(
-        ['unauthenticated', state.initial()],
-        'authenticating',
-        'authenticated',
-      )
-      .line(
-        'unauthenticated',
-        'authenticating',
-        'authenticated',
-      )
-      .build();
-
-    // States appear only once
-    expect(Object.keys(result.states)).toEqual([
-      'unauthenticated', 'authenticating', 'authenticated',
-    ]);
-    expect(result.states.unauthenticated.type).toBe('initial');
-  });
-});
-
-describe('ModelBuilder.line() — named transitions via tuple', () => {
-  it('overrides auto-name with explicit transition name', () => {
-    const result = model('test')
-      .line(
-        'draft',
-        ['review', 'submit'],
-        ['published', 'approve'],
-      )
-      .build();
-
-    expect(result.transitions.submit).toEqual({ from: 'draft', to: 'review' });
-    expect(result.transitions.approve).toEqual({ from: 'review', to: 'published' });
-    // Auto-named versions should NOT exist
-    expect(result.transitions.draft_to_review).toBeUndefined();
-    expect(result.transitions.review_to_published).toBeUndefined();
-  });
-
-  it('named transition with configuration', () => {
-    const result = model('test')
-      .line(
-        'draft',
-        ['review', 'submit', t => t.require('title')],
-        ['published', 'approve', t => t.roles('manager')],
-      )
-      .build();
-
-    expect(result.transitions.submit.requiredFields).toEqual(['title']);
-    expect(result.transitions.approve.roles).toEqual(['manager']);
-  });
-
-  it('mix named and auto-named in same line', () => {
-    const result = model('test')
-      .line(
-        'draft',
-        ['review', 'submit'],      // named
-        'published',                // auto-named: review_to_published
-      )
-      .build();
-
-    expect(result.transitions.submit).toBeDefined();
-    expect(result.transitions.review_to_published).toBeDefined();
-  });
-
-  it('merges from-states for named transitions across lines', () => {
-    const result = model('order')
-      .line('placed', ['cancelled', 'cancel'])
-      .line('confirmed', ['cancelled', 'cancel'])
-      .build();
-
-    const cancelFrom = result.transitions.cancel.from;
-    expect(Array.isArray(cancelFrom)).toBe(true);
-    expect(cancelFrom).toContain('placed');
-    expect(cancelFrom).toContain('confirmed');
-  });
-});
-
-describe('ModelBuilder.line() — complete auth example', () => {
-  it('models auth with auto-named transitions', () => {
-    const result = model('mod-authentication')
-      .field('errorMessage', field.string(''))
-
-      // Login flow
-      .line(
-        ['unauthenticated', state.initial().onEnter(setField('errorMessage', '""'))],
-        ['authenticating', t => t.do(serverAction('authenticate', { method: 'login' }))],
-        'authenticated',
-      )
-
-      // Error handling
-      .line('authenticating', 'error')
-      .line('error', 'unauthenticated')
-
-      // Logout
-      .line(
-        'authenticated',
-        ['unauthenticated', t => t.do(serverAction('destroy_session'))],
-      )
-      .build();
-
-    expect(result.states.unauthenticated.type).toBe('initial');
-    expect(result.transitions.unauthenticated_to_authenticating.actions![0].type).toBe('server:authenticate');
-    expect(result.transitions.authenticated_to_unauthenticated.actions![0].type).toBe('server:destroy_session');
-    expect(result.transitions.authenticating_to_error).toBeDefined();
-    expect(result.transitions.error_to_unauthenticated).toBeDefined();
-  });
-
-  it('models auth with named transitions', () => {
-    const result = model('mod-authentication')
-      .field('errorMessage', field.string(''))
-
-      .line(
-        ['unauthenticated', state.initial().onEnter(setField('errorMessage', '""'))],
-        ['authenticating', 'login', t => t.do(serverAction('authenticate', { method: 'login' }))],
-        ['authenticated', 'login_success'],
-      )
-      .line(
-        'unauthenticated',
-        ['authenticating', 'signup', t => t.do(serverAction('authenticate', { method: 'signup' }))],
-        ['authenticated', 'signup_success'],
-      )
-      .line('authenticating', ['error', 'login_error'])
-      .line('authenticating', ['error', 'signup_error'])
-      .line('error', ['unauthenticated', 'retry'])
-      .line(
-        'authenticated',
-        ['unauthenticated', 'logout', t => t.do(serverAction('destroy_session'))],
-      )
-      .build();
-
-    expect(result.states.unauthenticated.type).toBe('initial');
-    expect(result.transitions.login.actions![0].type).toBe('server:authenticate');
-    expect(result.transitions.signup.actions![0].type).toBe('server:authenticate');
-    expect(result.transitions.logout.actions![0].type).toBe('server:destroy_session');
-    expect(result.transitions.login_success.from).toBe('authenticating');
-    expect(result.transitions.signup_success.from).toBe('authenticating');
-    expect(result.transitions.retry.from).toBe('error');
-    expect(result.transitions.retry.to).toBe('unauthenticated');
-
-    // login_error and signup_error merge from-states
-    const loginErrorFrom = result.transitions.login_error.from;
-    expect(loginErrorFrom).toBe('authenticating');
-  });
-});

package/src/__tests__/defineBlueprint-composition.test.ts

@@ -1,106 +0,0 @@
-/**
- * Tests for BlueprintDependency composition types — routeConfig, slotMapping.
- */
-
-import { describe, it, expect } from 'vitest';
-import { defineBlueprint, type BlueprintDependency, type ModuleRouteConfig } from '../config/defineBlueprint';
-
-describe('BlueprintDependency composition types', () => {
-  it('accepts routeConfig with prefix', () => {
-    const dep: BlueprintDependency = {
-      slug: 'mod-authentication',
-      version: '>=3.0.0',
-      routeConfig: {
-        prefix: '/auth',
-      },
-    };
-    expect(dep.routeConfig?.prefix).toBe('/auth');
-  });
-
-  it('accepts routeConfig with per-route remapping', () => {
-    const dep: BlueprintDependency = {
-      slug: 'mod-authentication',
-      routeConfig: {
-        prefix: '/auth',
-        routes: {
-          '/login': '/',
-          '/signup': '/join',
-          '/profile': false,
-        },
-      },
-    };
-    expect(dep.routeConfig?.routes?.['/login']).toBe('/');
-    expect(dep.routeConfig?.routes?.['/profile']).toBe(false);
-  });
-
-  it('accepts slotMapping', () => {
-    const dep: BlueprintDependency = {
-      slug: 'mod-authentication',
-      slotMapping: {
-        'auth:login-providers': 'app:social-login',
-        'auth:profile-sections': 'app:settings-tabs',
-      },
-    };
-    expect(dep.slotMapping?.['auth:login-providers']).toBe('app:social-login');
-  });
-
-  it('accepts config', () => {
-    const dep: BlueprintDependency = {
-      slug: 'mod-authentication',
-      config: {
-        layout: 'card',
-        methods: ['email-password', 'google'],
-      },
-    };
-    expect(dep.config?.layout).toBe('card');
-  });
-
-  it('works in defineBlueprint with full dependency config', () => {
-    const blueprint = defineBlueprint({
-      slug: 'employee-salary-tracking',
-      name: 'Employee Salary Tracking',
-      version: '1.0.0',
-      dependencies: [
-        {
-          slug: 'mod-authentication',
-          version: '>=3.0.0',
-          required: true,
-          routeConfig: {
-            prefix: '/auth',
-            routes: { '/login': '/' },
-          },
-          slotMapping: {
-            'auth:profile-sections': 'app:settings-tabs',
-          },
-          config: {
-            layout: 'split',
-          },
-        },
-      ],
-    });
-
-    expect(blueprint.dependencies).toHaveLength(1);
-    expect(blueprint.dependencies![0].routeConfig?.prefix).toBe('/auth');
-    expect(blueprint.dependencies![0].slotMapping?.['auth:profile-sections']).toBe('app:settings-tabs');
-  });
-
-  it('ModuleRouteConfig type works independently', () => {
-    const config: ModuleRouteConfig = {
-      prefix: '/account',
-      routes: {
-        '/login': '/signin',
-        '/register': false,
-      },
-    };
-    expect(config.prefix).toBe('/account');
-  });
-
-  it('backward compatible — all new fields are optional', () => {
-    const dep: BlueprintDependency = {
-      slug: 'mod-auth',
-    };
-    expect(dep.routeConfig).toBeUndefined();
-    expect(dep.slotMapping).toBeUndefined();
-    expect(dep.config).toBeUndefined();
-  });
-});

package/src/__tests__/factories.test.ts

@@ -1,229 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { model, field, state } from '../builders';
-import { approval, escalation, review, crud } from '../factories';
-
-describe('approval factory', () => {
-  it('adds approve/reject transitions with defaults', () => {
-    const def = model('invoice')
-      .field('amount', field.currency())
-      .state('draft', state.initial())
-      .state('pending_approval')
-      .mixin(approval())
-      .build();
-
-    expect(def.transitions.approve).toBeDefined();
-    expect(def.transitions.approve.from).toBe('pending_approval');
-    expect(def.transitions.approve.to).toBe('approved');
-    expect(def.transitions.approve.roles).toContain('approver');
-
-    expect(def.transitions.reject).toBeDefined();
-    expect(def.transitions.reject.from).toBe('pending_approval');
-    expect(def.transitions.reject.to).toBe('rejected');
-  });
-
-  it('adds approval-related fields', () => {
-    const def = model('invoice')
-      .state('draft', state.initial())
-      .mixin(approval())
-      .build();
-
-    expect(def.fields.approvalStatus).toBeDefined();
-    expect(def.fields.approvedBy).toBeDefined();
-    expect(def.fields.approvedAt).toBeDefined();
-    expect(def.fields.rejectionReason).toBeDefined();
-  });
-
-  it('respects custom config', () => {
-    const def = model('invoice')
-      .state('draft', state.initial())
-      .state('review')
-      .mixin(approval({
-        approverRole: 'manager',
-        field: 'status',
-        fromState: 'review',
-        approvedState: 'done',
-        rejectedState: 'cancelled',
-      }))
-      .build();
-
-    expect(def.transitions.approve.from).toBe('review');
-    expect(def.transitions.approve.to).toBe('done');
-    expect(def.transitions.approve.roles).toContain('manager');
-    expect(def.transitions.reject.to).toBe('cancelled');
-    expect(def.fields.status).toBeDefined();
-  });
-
-  it('adds approver role', () => {
-    const def = model('invoice')
-      .state('draft', state.initial())
-      .mixin(approval())
-      .build();
-
-    expect(def.roles!.approver).toBeDefined();
-    expect(def.roles!.approver.permissions).toContain('approve');
-  });
-});
-
-describe('escalation factory', () => {
-  it('adds escalate transition with timeout', () => {
-    const def = model('ticket')
-      .state('pending_approval', state.initial())
-      .mixin(escalation({ timeout: '24h' }))
-      .build();
-
-    expect(def.transitions.escalate).toBeDefined();
-    expect(def.transitions.escalate.from).toBe('pending_approval');
-    expect(def.transitions.escalate.to).toBe('escalated');
-    expect(def.transitions.escalate.auto).toBe(true);
-  });
-
-  it('sets timeout on the source state', () => {
-    const def = model('ticket')
-      .state('pending_approval', state.initial())
-      .mixin(escalation({ timeout: '2d', fromState: 'pending_approval' }))
-      .build();
-
-    expect(def.states.pending_approval.timeout).toBeDefined();
-    expect(def.states.pending_approval.timeout!.duration).toBe('2d');
-    expect(def.states.pending_approval.timeout!.fallback?.transition).toBe('escalate');
-  });
-
-  it('adds escalation fields', () => {
-    const def = model('ticket')
-      .state('open', state.initial())
-      .mixin(escalation({ timeout: '1h', fromState: 'open' }))
-      .build();
-
-    expect(def.fields.escalatedAt).toBeDefined();
-    expect(def.fields.escalationLevel).toBeDefined();
-  });
-});
-
-describe('review factory', () => {
-  it('adds submit/approve/revise cycle', () => {
-    const def = model('article')
-      .field('content', field.string())
-      .state('draft', state.initial())
-      .mixin(review())
-      .build();
-
-    expect(def.transitions.submit_for_review).toBeDefined();
-    expect(def.transitions.submit_for_review.from).toBe('draft');
-    expect(def.transitions.submit_for_review.to).toBe('in_review');
-
-    expect(def.transitions.approve_review).toBeDefined();
-    expect(def.transitions.approve_review.from).toBe('in_review');
-    expect(def.transitions.approve_review.to).toBe('approved');
-
-    expect(def.transitions.request_revisions).toBeDefined();
-    expect(def.transitions.request_revisions.from).toBe('in_review');
-    expect(def.transitions.request_revisions.to).toBe('revisions_requested');
-
-    expect(def.transitions.resubmit).toBeDefined();
-    expect(def.transitions.resubmit.from).toBe('revisions_requested');
-    expect(def.transitions.resubmit.to).toBe('in_review');
-  });
-
-  it('adds review fields', () => {
-    const def = model('article')
-      .state('draft', state.initial())
-      .mixin(review())
-      .build();
-
-    expect(def.fields.reviewNotes).toBeDefined();
-    expect(def.fields.reviewedBy).toBeDefined();
-    expect(def.fields.reviewedAt).toBeDefined();
-    expect(def.fields.revisionCount).toBeDefined();
-  });
-
-  it('adds author and reviewer roles', () => {
-    const def = model('article')
-      .state('draft', state.initial())
-      .mixin(review())
-      .build();
-
-    expect(def.roles!.author).toBeDefined();
-    expect(def.roles!.reviewer).toBeDefined();
-  });
-
-  it('respects custom role names', () => {
-    const def = model('article')
-      .state('draft', state.initial())
-      .mixin(review({ authorRole: 'writer', reviewerRole: 'editor' }))
-      .build();
-
-    expect(def.roles!.writer).toBeDefined();
-    expect(def.roles!.editor).toBeDefined();
-    expect(def.transitions.submit_for_review.roles).toContain('writer');
-    expect(def.transitions.approve_review.roles).toContain('editor');
-  });
-});
-
-describe('crud factory', () => {
-  it('adds draft/active/archived lifecycle (soft delete)', () => {
-    const def = model('product')
-      .field('name', field.string().required())
-      .mixin(crud())
-      .build();
-
-    expect(def.states.draft).toBeDefined();
-    expect(def.states.draft.type).toBe('initial');
-    expect(def.states.active).toBeDefined();
-    expect(def.states.archived).toBeDefined();
-
-    expect(def.transitions.publish).toBeDefined();
-    expect(def.transitions.update).toBeDefined();
-    expect(def.transitions.archive).toBeDefined();
-    expect(def.transitions.restore).toBeDefined();
-  });
-
-  it('adds hard delete when softDelete=false', () => {
-    const def = model('temp')
-      .field('data', field.string())
-      .mixin(crud({ softDelete: false }))
-      .build();
-
-    expect(def.states.deleted).toBeDefined();
-    expect(def.states.deleted.type).toBe('end');
-    expect(def.transitions.delete_record).toBeDefined();
-    expect(def.transitions.archive).toBeUndefined();
-    expect(def.transitions.restore).toBeUndefined();
-  });
-
-  it('adds CRUD fields', () => {
-    const def = model('product')
-      .mixin(crud())
-      .build();
-
-    expect(def.fields.createdBy).toBeDefined();
-    expect(def.fields.createdAt).toBeDefined();
-    expect(def.fields.updatedAt).toBeDefined();
-  });
-
-  it('does not overwrite existing fields', () => {
-    const def = model('product')
-      .field('createdBy', field.string('system'))
-      .mixin(crud())
-      .build();
-
-    // Our manually set field should be preserved
-    expect(def.fields.createdBy.default).toBe('system');
-  });
-
-  it('composable: approval + escalation', () => {
-    const def = model('po')
-      .field('amount', field.currency())
-      .state('draft', state.initial())
-      .state('pending_approval')
-      .mixin(approval({ approverRole: 'manager' }))
-      .mixin(escalation({ timeout: '48h' }))
-      .build();
-
-    // Both patterns should coexist
-    expect(def.transitions.approve).toBeDefined();
-    expect(def.transitions.reject).toBeDefined();
-    expect(def.transitions.escalate).toBeDefined();
-    expect(def.states.escalated).toBeDefined();
-    expect(def.states.approved).toBeDefined();
-  });
-});