@auto-engineer/narrative 1.138.0 → 1.140.0

package/src/validate-slice-requests.specs.ts

@@ -1,29 +1,29 @@
 import { describe, expect, it } from 'vitest';
 import type { Model } from './schema';
-import { validateSliceRequests } from './validate-slice-requests';
+import { validateMomentRequests } from './validate-slice-requests';
 
 function emptyModel(overrides: Partial<Model> = {}): Model {
   return {
     variant: 'specs',
-    narratives: [],
+    scenes: [],
     messages: [],
     modules: [],
     ...overrides,
   };
 }
 
-describe('validateSliceRequests', () => {
+describe('validateMomentRequests', () => {
   describe('burst 1: parse safety', () => {
     it('returns empty array for empty model', () => {
-      expect(validateSliceRequests(emptyModel())).toEqual([]);
+      expect(validateMomentRequests(emptyModel())).toEqual([]);
     });
 
-    it('skips slices without request', () => {
+    it('skips moments without request', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -34,15 +34,15 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
 
-    it('skips slices with empty string request', () => {
+    it('skips moments with empty string request', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -54,15 +54,15 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
 
     it('returns request_parse_error for invalid syntax', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -74,22 +74,22 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'request_parse_error',
           message: expect.any(String),
-          flowName: 'TestFlow',
-          sliceName: 'DoThing',
+          sceneName: 'TestFlow',
+          momentName: 'DoThing',
         },
       ]);
     });
 
     it('returns request_parse_error for anonymous operation', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -101,22 +101,22 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'request_parse_error',
           message: 'Operation must have a name',
-          flowName: 'TestFlow',
-          sliceName: 'DoThing',
+          sceneName: 'TestFlow',
+          momentName: 'DoThing',
         },
       ]);
     });
 
     it('returns request_parse_error when no operation definition found', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -128,12 +128,12 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'request_parse_error',
           message: 'No operation found in request',
-          flowName: 'TestFlow',
-          sliceName: 'DoThing',
+          sceneName: 'TestFlow',
+          momentName: 'DoThing',
         },
       ]);
     });
@@ -145,10 +145,10 @@ describe('validateSliceRequests', () => {
       const jsonAst = JSON.stringify(ast);
 
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -168,19 +168,19 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      const errors = validateSliceRequests(model);
+      const errors = validateMomentRequests(model);
       const parseErrors = errors.filter((e) => e.type === 'request_parse_error');
       expect(parseErrors).toEqual([]);
     });
   });
 
   describe('burst 2: mutation validation', () => {
-    it('returns mutation_wrong_operation_type when command slice uses query', () => {
+    it('returns mutation_wrong_operation_type when command moment uses query', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -192,22 +192,22 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'mutation_wrong_operation_type',
-          message: "Command slice 'DoThing' request should be a mutation, but found query",
-          flowName: 'TestFlow',
-          sliceName: 'DoThing',
+          message: "Command moment 'DoThing' request should be a mutation, but found query",
+          sceneName: 'TestFlow',
+          momentName: 'DoThing',
         },
       ]);
     });
 
     it('returns mutation_missing_input_arg when no $input variable', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -219,22 +219,22 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'mutation_missing_input_arg',
           message: "Mutation 'DoThing' is missing required $input variable",
-          flowName: 'TestFlow',
-          sliceName: 'DoThing',
+          sceneName: 'TestFlow',
+          momentName: 'DoThing',
         },
       ]);
     });
 
     it('returns mutation_input_type_mismatch when input type does not match', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -246,22 +246,22 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'mutation_input_type_mismatch',
           message: "Mutation 'DoThing' input type should be 'DoThingInput', but found 'WrongInput'",
-          flowName: 'TestFlow',
-          sliceName: 'DoThing',
+          sceneName: 'TestFlow',
+          momentName: 'DoThing',
         },
       ]);
     });
 
     it('returns mutation_message_not_found when command not in messages', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -274,22 +274,22 @@ describe('validateSliceRequests', () => {
         ],
         messages: [],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'mutation_message_not_found',
           message: "No command message 'DoThing' found in model.messages",
-          flowName: 'TestFlow',
-          sliceName: 'DoThing',
+          sceneName: 'TestFlow',
+          momentName: 'DoThing',
         },
       ]);
     });
 
     it('returns no errors for valid mutation', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'DoThing',
@@ -308,17 +308,17 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
   });
 
   describe('burst 3: query validation — operation type, state, top-level fields', () => {
-    it('returns query_wrong_operation_type when query slice uses mutation', () => {
+    it('returns query_wrong_operation_type when query moment uses mutation', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -330,22 +330,22 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'query_wrong_operation_type',
-          message: "Query slice 'GetThing' request should be a query, but found mutation",
-          flowName: 'TestFlow',
-          sliceName: 'GetThing',
+          message: "Query moment 'GetThing' request should be a query, but found mutation",
+          sceneName: 'TestFlow',
+          momentName: 'GetThing',
         },
       ]);
     });
 
     it('returns query_state_not_found when target state not in messages', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -366,22 +366,22 @@ describe('validateSliceRequests', () => {
         ],
         messages: [],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'query_state_not_found',
           message: "State 'ThingState' referenced by query 'GetThing' not found in model.messages",
-          flowName: 'TestFlow',
-          sliceName: 'GetThing',
+          sceneName: 'TestFlow',
+          momentName: 'GetThing',
         },
       ]);
     });
 
     it('returns query_field_not_found when selecting field not on state', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -411,22 +411,22 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'query_field_not_found',
           message: "Field 'missing' in query 'GetThing' not found on state 'ThingState'",
-          flowName: 'TestFlow',
-          sliceName: 'GetThing',
+          sceneName: 'TestFlow',
+          momentName: 'GetThing',
         },
       ]);
     });
 
-    it('skips query slice without data gracefully', () => {
+    it('skips query moment without data gracefully', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -438,15 +438,15 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
 
     it('skips __typename in selection', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -473,15 +473,15 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
 
     it('returns no errors for valid query', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -511,17 +511,17 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
   });
 
   describe('burst 4: query nested field validation', () => {
     it('returns query_nested_field_not_found for nested field not in inline object', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -551,22 +551,22 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'query_nested_field_not_found',
           message: "Nested field 'missing' in query 'GetThing' not found on type of 'address'",
-          flowName: 'TestFlow',
-          sliceName: 'GetThing',
+          sceneName: 'TestFlow',
+          momentName: 'GetThing',
         },
       ]);
     });
 
     it('resolves nested field on referenced message type', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -601,15 +601,15 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
 
     it('skips nested field on unresolvable type without error', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -639,15 +639,15 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
 
     it('resolves nested fields on bracket array syntax type', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -677,15 +677,15 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
 
     it('returns no errors for valid query with nested selections', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'TestFlow',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'GetThing',
@@ -715,17 +715,17 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
   });
 
   describe('burst 5: integration', () => {
     it('returns no false positives on a questionnaires-style model', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'Questionnaire Management',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'SubmitAnswer',
@@ -799,15 +799,15 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([]);
+      expect(validateMomentRequests(model)).toEqual([]);
     });
 
-    it('catches multiple errors across narratives', () => {
+    it('catches multiple errors across scenes', () => {
       const model = emptyModel({
-        narratives: [
+        scenes: [
           {
             name: 'Flow1',
-            slices: [
+            moments: [
               {
                 type: 'command',
                 name: 'BadCmd',
@@ -819,7 +819,7 @@ describe('validateSliceRequests', () => {
           },
           {
             name: 'Flow2',
-            slices: [
+            moments: [
               {
                 type: 'query',
                 name: 'BadQuery',
@@ -831,18 +831,18 @@ describe('validateSliceRequests', () => {
           },
         ],
       });
-      expect(validateSliceRequests(model)).toEqual([
+      expect(validateMomentRequests(model)).toEqual([
         {
           type: 'mutation_wrong_operation_type',
-          message: "Command slice 'BadCmd' request should be a mutation, but found query",
-          flowName: 'Flow1',
-          sliceName: 'BadCmd',
+          message: "Command moment 'BadCmd' request should be a mutation, but found query",
+          sceneName: 'Flow1',
+          momentName: 'BadCmd',
         },
         {
           type: 'query_wrong_operation_type',
-          message: "Query slice 'BadQuery' request should be a query, but found mutation",
-          flowName: 'Flow2',
-          sliceName: 'BadQuery',
+          message: "Query moment 'BadQuery' request should be a query, but found mutation",
+          sceneName: 'Flow2',
+          momentName: 'BadQuery',
         },
       ]);
     });