@auto-engineer/narrative 1.138.0 → 1.140.0

package/src/schema.specs.ts

@@ -1,32 +1,32 @@
 import { describe, expect, it } from 'vitest';
 import type {
   ComponentDefinition,
-  Journey,
-  JourneyPlanning,
+  Narrative,
+  NarrativePlanning,
   RegionEntry,
   SceneClassification,
   SceneRoute,
   UI,
 } from './schema';
 import {
-  CommandSliceSchema,
+  CommandMomentSchema,
   ComponentDefinitionSchema,
   DataSchema,
   DataTargetSchema,
   DesignSchema,
-  JourneyPlanningSchema,
-  JourneySchema,
   modelSchema,
-  NarrativeNamesOnlySchema,
+  NarrativePlanningSchema,
   NarrativeSchema,
-  QuerySliceSchema,
+  QueryMomentSchema,
   RegionEntrySchema,
   SceneClassificationSchema,
+  SceneNamesOnlySchema,
   SceneRouteSchema,
+  SceneSchema,
   UISchema,
 } from './schema';
 
-describe('CommandSliceSchema', () => {
+describe('CommandMomentSchema', () => {
   it('should accept optional mappings field with structured entries', () => {
     const slice = {
       type: 'command' as const,
@@ -41,7 +41,7 @@ describe('CommandSliceSchema', () => {
       ],
     };
 
-    const result = CommandSliceSchema.safeParse(slice);
+    const result = CommandMomentSchema.safeParse(slice);
 
     expect(result.success).toBe(true);
     if (result.success) {
@@ -142,11 +142,11 @@ describe('SceneClassificationSchema', () => {
   });
 });
 
-describe('NarrativeSchema scene field', () => {
+describe('SceneSchema scene field', () => {
   it('should accept a narrative with optional scene classification', () => {
-    const result = NarrativeSchema.safeParse({
+    const result = SceneSchema.safeParse({
       name: 'Create Todo',
-      slices: [],
+      moments: [],
       scene: {
         kind: 'page',
         pattern: 'create-form',
@@ -162,9 +162,9 @@ describe('NarrativeSchema scene field', () => {
   });
 
   it('should accept a narrative without scene', () => {
-    const result = NarrativeSchema.safeParse({
+    const result = SceneSchema.safeParse({
       name: 'Create Todo',
-      slices: [],
+      moments: [],
     });
     expect(result.success).toBe(true);
     if (result.success) {
@@ -173,26 +173,26 @@ describe('NarrativeSchema scene field', () => {
   });
 });
 
-describe('JourneySchema', () => {
-  it('should accept a valid journey with required fields', () => {
-    const result = JourneySchema.safeParse({
+describe('NarrativeSchema', () => {
+  it('should accept a valid narrative with required fields', () => {
+    const result = NarrativeSchema.safeParse({
       name: 'Onboarding',
-      narrativeIds: ['n-1', 'n-2'],
+      sceneIds: ['n-1', 'n-2'],
     });
     expect(result.success).toBe(true);
     if (result.success) {
       expect(result.data.name).toBe('Onboarding');
-      expect(result.data.narrativeIds).toEqual(['n-1', 'n-2']);
+      expect(result.data.sceneIds).toEqual(['n-1', 'n-2']);
     }
   });
 
   it('should accept all optional fields', () => {
-    const result = JourneySchema.safeParse({
+    const result = NarrativeSchema.safeParse({
       id: 'j-1',
       name: 'Checkout',
       description: 'Full checkout flow',
       actors: ['buyer', 'seller'],
-      narrativeIds: ['n-cart', 'n-pay'],
+      sceneIds: ['n-cart', 'n-pay'],
     });
     expect(result.success).toBe(true);
     if (result.success) {
@@ -203,67 +203,74 @@ describe('JourneySchema', () => {
   });
 
   it('should reject missing name', () => {
-    const result = JourneySchema.safeParse({ narrativeIds: ['n-1'] });
+    const result = NarrativeSchema.safeParse({ sceneIds: ['n-1'] });
     expect(result.success).toBe(false);
   });
 
-  it('should reject missing narrativeIds', () => {
-    const result = JourneySchema.safeParse({ name: 'Onboarding' });
+  it('should reject missing sceneIds', () => {
+    const result = NarrativeSchema.safeParse({ name: 'Onboarding' });
     expect(result.success).toBe(false);
   });
 });
 
-describe('modelSchema journeys field', () => {
+describe('modelSchema narratives field', () => {
   const minimalModel = {
     variant: 'specs' as const,
-    narratives: [],
+    scenes: [],
     messages: [],
     modules: [],
+    narratives: [],
   };
 
-  it('should accept model without journeys (optional)', () => {
+  it('should reject model without narratives (required)', () => {
+    const { narratives: _, ...modelWithoutNarratives } = minimalModel;
+    const result = modelSchema.safeParse(modelWithoutNarratives);
+    expect(result.success).toBe(false);
+  });
+
+  it('should accept model with empty narratives array', () => {
     const result = modelSchema.safeParse(minimalModel);
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.data.journeys).toBeUndefined();
+      expect(result.data.narratives).toEqual([]);
     }
   });
 
-  it('should accept model with journeys array', () => {
+  it('should accept model with narratives array', () => {
     const result = modelSchema.safeParse({
       ...minimalModel,
-      journeys: [
+      narratives: [
         {
           id: 'j-1',
           name: 'Onboarding',
-          narrativeIds: ['n-1', 'n-2'],
+          sceneIds: ['n-1', 'n-2'],
         },
       ],
     });
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.data.journeys).toHaveLength(1);
-      expect(result.data.journeys![0].name).toBe('Onboarding');
+      expect(result.data.narratives).toHaveLength(1);
+      expect(result.data.narratives![0].name).toBe('Onboarding');
     }
   });
 });
 
-describe('JourneyPlanningSchema', () => {
-  it('should accept a valid journey-planning variant', () => {
+describe('NarrativePlanningSchema', () => {
+  it('should accept a valid narrative-planning variant', () => {
     const input = {
-      variant: 'journey-planning',
-      journeys: [
+      variant: 'narrative-planning',
+      narratives: [
         {
           name: 'Onboarding',
           description: 'New user onboarding flow',
-          narrativeNames: ['Sign Up', 'Verify Email'],
+          sceneNames: ['Sign Up', 'Verify Email'],
         },
         {
           name: 'Checkout',
-          narrativeNames: ['Add to Cart', 'Payment'],
+          sceneNames: ['Add to Cart', 'Payment'],
         },
       ],
-      narratives: [
+      scenes: [
         { name: 'Sign Up' },
         { name: 'Verify Email', id: 'n-verify', description: 'Email verification' },
         { name: 'Add to Cart' },
@@ -271,24 +278,24 @@ describe('JourneyPlanningSchema', () => {
       ],
     };
 
-    const result = JourneyPlanningSchema.safeParse(input);
+    const result = NarrativePlanningSchema.safeParse(input);
 
     expect(result.success).toBe(true);
     if (result.success) {
       expect(result.data).toEqual({
-        variant: 'journey-planning',
-        journeys: [
+        variant: 'narrative-planning',
+        narratives: [
           {
             name: 'Onboarding',
             description: 'New user onboarding flow',
-            narrativeNames: ['Sign Up', 'Verify Email'],
+            sceneNames: ['Sign Up', 'Verify Email'],
           },
           {
             name: 'Checkout',
-            narrativeNames: ['Add to Cart', 'Payment'],
+            sceneNames: ['Add to Cart', 'Payment'],
           },
         ],
-        narratives: [
+        scenes: [
           { name: 'Sign Up' },
           { name: 'Verify Email', id: 'n-verify', description: 'Email verification' },
           { name: 'Add to Cart' },
@@ -299,74 +306,74 @@ describe('JourneyPlanningSchema', () => {
   });
 
   it('should reject missing variant', () => {
-    const result = JourneyPlanningSchema.safeParse({
-      journeys: [],
+    const result = NarrativePlanningSchema.safeParse({
       narratives: [],
+      scenes: [],
     });
 
     expect(result.success).toBe(false);
   });
 
   it('should reject wrong variant', () => {
-    const result = JourneyPlanningSchema.safeParse({
-      variant: 'narrative-names',
-      journeys: [],
+    const result = NarrativePlanningSchema.safeParse({
+      variant: 'scene-names',
       narratives: [],
+      scenes: [],
     });
 
     expect(result.success).toBe(false);
   });
 
-  it('should reject missing journeys', () => {
-    const result = JourneyPlanningSchema.safeParse({
-      variant: 'journey-planning',
-      narratives: [],
+  it('should reject missing narratives', () => {
+    const result = NarrativePlanningSchema.safeParse({
+      variant: 'narrative-planning',
+      scenes: [],
     });
 
     expect(result.success).toBe(false);
   });
 
-  it('should reject missing narratives', () => {
-    const result = JourneyPlanningSchema.safeParse({
-      variant: 'journey-planning',
-      journeys: [],
+  it('should reject missing scenes', () => {
+    const result = NarrativePlanningSchema.safeParse({
+      variant: 'narrative-planning',
+      narratives: [],
     });
 
     expect(result.success).toBe(false);
   });
 
-  it('should accept journey with actors', () => {
-    const result = JourneyPlanningSchema.safeParse({
-      variant: 'journey-planning',
-      journeys: [
+  it('should accept narrative with actors', () => {
+    const result = NarrativePlanningSchema.safeParse({
+      variant: 'narrative-planning',
+      narratives: [
         {
           name: 'Onboarding',
           actors: ['new-user', 'admin'],
-          narrativeNames: ['Sign Up'],
+          sceneNames: ['Sign Up'],
         },
       ],
-      narratives: [{ name: 'Sign Up' }],
+      scenes: [{ name: 'Sign Up' }],
     });
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.data.journeys[0].actors).toEqual(['new-user', 'admin']);
+      expect(result.data.narratives[0].actors).toEqual(['new-user', 'admin']);
     }
   });
 
-  it('should reject journey missing narrativeNames', () => {
-    const result = JourneyPlanningSchema.safeParse({
-      variant: 'journey-planning',
-      journeys: [{ name: 'Onboarding' }],
-      narratives: [],
+  it('should reject narrative missing sceneNames', () => {
+    const result = NarrativePlanningSchema.safeParse({
+      variant: 'narrative-planning',
+      narratives: [{ name: 'Onboarding' }],
+      scenes: [],
     });
 
     expect(result.success).toBe(false);
   });
 });
 
-describe('NarrativeNamesOnlySchema', () => {
+describe('SceneNamesOnlySchema', () => {
   it('should be exported and accept valid input', () => {
-    const result = NarrativeNamesOnlySchema.safeParse({
+    const result = SceneNamesOnlySchema.safeParse({
       name: 'Create Todo',
       id: 'n-1',
       description: 'Create a todo item',
@@ -378,18 +385,18 @@ describe('NarrativeNamesOnlySchema', () => {
   });
 
   it('should require name', () => {
-    const result = NarrativeNamesOnlySchema.safeParse({ description: 'no name' });
+    const result = SceneNamesOnlySchema.safeParse({ description: 'no name' });
     expect(result.success).toBe(false);
   });
 });
 
 describe('exported types', () => {
-  it('Journey type matches JourneySchema inference', () => {
-    const input = { name: 'Onboarding', narrativeIds: ['n-1'] };
-    const parsed = JourneySchema.parse(input);
-    const typed: Journey = parsed;
+  it('Narrative type matches NarrativeSchema inference', () => {
+    const input = { name: 'Onboarding', sceneIds: ['n-1'] };
+    const parsed = NarrativeSchema.parse(input);
+    const typed: Narrative = parsed;
 
-    expect(typed).toEqual({ name: 'Onboarding', narrativeIds: ['n-1'] });
+    expect(typed).toEqual({ name: 'Onboarding', sceneIds: ['n-1'] });
   });
 
   it('SceneClassification type matches SceneClassificationSchema inference', () => {
@@ -408,19 +415,19 @@ describe('exported types', () => {
     expect(typed).toEqual({ type: 'dedicated', deepLinkable: true });
   });
 
-  it('JourneyPlanning type matches JourneyPlanningSchema inference', () => {
+  it('NarrativePlanning type matches NarrativePlanningSchema inference', () => {
     const input = {
-      variant: 'journey-planning' as const,
-      journeys: [{ name: 'Flow', narrativeNames: ['Step 1'] }],
-      narratives: [{ name: 'Step 1' }],
+      variant: 'narrative-planning' as const,
+      narratives: [{ name: 'Flow', sceneNames: ['Step 1'] }],
+      scenes: [{ name: 'Step 1' }],
     };
-    const parsed = JourneyPlanningSchema.parse(input);
-    const typed: JourneyPlanning = parsed;
+    const parsed = NarrativePlanningSchema.parse(input);
+    const typed: NarrativePlanning = parsed;
 
     expect(typed).toEqual({
-      variant: 'journey-planning',
-      journeys: [{ name: 'Flow', narrativeNames: ['Step 1'] }],
-      narratives: [{ name: 'Step 1' }],
+      variant: 'narrative-planning',
+      narratives: [{ name: 'Flow', sceneNames: ['Step 1'] }],
+      scenes: [{ name: 'Step 1' }],
     });
   });
 });
@@ -511,7 +518,7 @@ describe('DataSchema with target-only items', () => {
   });
 });
 
-describe('QuerySliceSchema', () => {
+describe('QueryMomentSchema', () => {
   it('should accept optional mappings field with structured entries', () => {
     const slice = {
       type: 'query' as const,
@@ -526,7 +533,7 @@ describe('QuerySliceSchema', () => {
       ],
     };
 
-    const result = QuerySliceSchema.safeParse(slice);
+    const result = QueryMomentSchema.safeParse(slice);
 
     expect(result.success).toBe(true);
     if (result.success) {
@@ -682,9 +689,10 @@ describe('DesignSchema ui field', () => {
 describe('modelSchema design.components field', () => {
   const minimalModel = {
     variant: 'specs' as const,
-    narratives: [],
+    scenes: [],
     messages: [],
     modules: [],
+    narratives: [],
   };
 
   it('should accept model with design.components', () => {