@auto-engineer/narrative 1.138.0 → 1.140.0

package/src/id/addAutoIds.ts

@@ -1,4 +1,4 @@
-import type { ClientSpecNode, Example, Model, Rule, Slice, Spec, Step } from '../index';
+import type { ClientSpecNode, Example, Model, Moment, Rule, Spec, Step } from '../index';
 import { generateAutoId } from './generators';
 
 function ensureId(item: { id?: string }): void {
@@ -42,18 +42,18 @@ function processSpecs(specs: Spec[]): Spec[] {
   });
 }
 
-function processServerSpecs(slice: Slice): Slice {
+function processServerSpecs(slice: Moment): Moment {
   if (!('server' in slice) || slice.server?.specs === undefined || !Array.isArray(slice.server.specs)) return slice;
 
-  const modifiedSlice = structuredClone(slice);
+  const modifiedMoment = structuredClone(slice);
   if (
-    'server' in modifiedSlice &&
-    modifiedSlice.server?.specs !== undefined &&
-    Array.isArray(modifiedSlice.server.specs)
+    'server' in modifiedMoment &&
+    modifiedMoment.server?.specs !== undefined &&
+    Array.isArray(modifiedMoment.server.specs)
   ) {
-    modifiedSlice.server.specs = processSpecs(modifiedSlice.server.specs);
+    modifiedMoment.server.specs = processSpecs(modifiedMoment.server.specs);
   }
-  return modifiedSlice;
+  return modifiedMoment;
 }
 
 function processClientSpecNodes(nodes: ClientSpecNode[]): ClientSpecNode[] {
@@ -67,27 +67,27 @@ function processClientSpecNodes(nodes: ClientSpecNode[]): ClientSpecNode[] {
   });
 }
 
-function processClientSpecs(slice: Slice): Slice {
+function processClientSpecs(slice: Moment): Moment {
   if (!('client' in slice) || slice.client?.specs === undefined || !Array.isArray(slice.client.specs)) return slice;
 
-  const modifiedSlice = structuredClone(slice);
-  if ('client' in modifiedSlice && modifiedSlice.client?.specs !== undefined) {
-    modifiedSlice.client.specs = processClientSpecNodes(modifiedSlice.client.specs);
+  const modifiedMoment = structuredClone(slice);
+  if ('client' in modifiedMoment && modifiedMoment.client?.specs !== undefined) {
+    modifiedMoment.client.specs = processClientSpecNodes(modifiedMoment.client.specs);
   }
-  return modifiedSlice;
+  return modifiedMoment;
 }
 
-function processDataItems(slice: Slice): Slice {
+function processDataItems(slice: Moment): Moment {
   if (!('server' in slice) || !slice.server?.data) return slice;
 
-  const modifiedSlice = structuredClone(slice);
-  if ('server' in modifiedSlice && modifiedSlice.server?.data) {
+  const modifiedMoment = structuredClone(slice);
+  if ('server' in modifiedMoment && modifiedMoment.server?.data) {
     // Ensure the data wrapper has an ID
-    ensureId(modifiedSlice.server.data);
+    ensureId(modifiedMoment.server.data);
 
     // Process items array if it exists
-    if (Array.isArray(modifiedSlice.server.data.items)) {
-      modifiedSlice.server.data.items = modifiedSlice.server.data.items.map((item) => {
+    if (Array.isArray(modifiedMoment.server.data.items)) {
+      modifiedMoment.server.data.items = modifiedMoment.server.data.items.map((item) => {
         const itemCopy = { ...item };
         ensureId(itemCopy);
         if ('destination' in itemCopy && itemCopy._withState) {
@@ -98,10 +98,10 @@ function processDataItems(slice: Slice): Slice {
       });
     }
   }
-  return modifiedSlice;
+  return modifiedMoment;
 }
 
-function processSlice(slice: Slice): Slice {
+function processMoment(slice: Moment): Moment {
   let sliceCopy = { ...slice };
   ensureId(sliceCopy);
   sliceCopy = processServerSpecs(sliceCopy);
@@ -112,11 +112,11 @@ function processSlice(slice: Slice): Slice {
 
 export function addAutoIds(specs: Model): Model {
   const result = structuredClone(specs);
-  result.narratives = result.narratives.map((narrative) => {
-    const narrativeCopy = { ...narrative };
-    ensureId(narrativeCopy);
-    narrativeCopy.slices = narrative.slices.map(processSlice);
-    return narrativeCopy;
+  result.scenes = result.scenes.map((scene) => {
+    const sceneCopy = { ...scene };
+    ensureId(sceneCopy);
+    sceneCopy.moments = scene.moments.map(processMoment);
+    return sceneCopy;
   });
   return result;
 }

package/src/id/hasAllIds.specs.ts

@@ -5,13 +5,13 @@ import { addAutoIds, hasAllIds } from './index';
 describe('hasAllIds', () => {
   const createModelWithoutIds = (): Model => ({
     variant: 'specs',
-    narratives: [
+    scenes: [
       {
         name: 'Test Flow Without IDs',
-        slices: [
+        moments: [
           {
             type: 'command',
-            name: 'Test slice without ID',
+            name: 'Test moment without ID',
             client: { specs: [] },
             server: {
               description: 'Test server',
@@ -39,14 +39,14 @@ describe('hasAllIds', () => {
 
   const createModelWithIds = (): Model => ({
     variant: 'specs',
-    narratives: [
+    scenes: [
       {
         name: 'Test Flow with IDs',
         id: 'FLOW-001',
-        slices: [
+        moments: [
           {
             type: 'command',
-            name: 'Test slice with ID',
+            name: 'Test moment with ID',
             id: 'SLICE-001',
             client: { specs: [] },
             server: {
@@ -77,14 +77,14 @@ describe('hasAllIds', () => {
 
   const createModelWithFullIds = (): Model => ({
     variant: 'specs',
-    narratives: [
+    scenes: [
       {
         name: 'Test Flow with Full IDs',
         id: 'FLOW-001',
-        slices: [
+        moments: [
           {
             type: 'command',
-            name: 'Test slice with ID',
+            name: 'Test moment with ID',
             id: 'SLICE-001',
             client: { specs: [] },
             server: {
@@ -136,14 +136,14 @@ describe('hasAllIds', () => {
     modules: [],
   });
 
-  const createMultipleFlowsModel = (includeAllIds: boolean, includeAllSliceIds: boolean): Model => ({
+  const createMultipleFlowsModel = (includeAllIds: boolean, includeAllMomentIds: boolean): Model => ({
     variant: 'specs',
-    narratives: [
+    scenes: [
       {
         name: 'Home Screen',
         id: 'aifPcU3hw',
         sourceFile: '/path/to/homepage.narrative.ts',
-        slices: [
+        moments: [
           {
             name: 'Active Surveys Summary',
             id: 'slice1',
@@ -156,10 +156,10 @@ describe('hasAllIds', () => {
         name: 'Create Survey',
         id: includeAllIds ? 'MPviTMrQC' : undefined,
         sourceFile: '/path/to/homepage.narrative.ts',
-        slices: [
+        moments: [
           {
             name: 'Create Survey Form',
-            id: includeAllSliceIds ? 'slice2' : undefined,
+            id: includeAllMomentIds ? 'slice2' : undefined,
             type: 'experience',
             client: { specs: [{ type: 'it', id: 'it2', title: 'allow entering survey title' }] },
           },
@@ -169,7 +169,7 @@ describe('hasAllIds', () => {
         name: 'Response Analytics',
         id: 'eME978Euk',
         sourceFile: '/path/to/homepage.narrative.ts',
-        slices: [
+        moments: [
           {
             name: 'Response Rate Charts',
             id: 'slice3',
@@ -200,17 +200,17 @@ describe('hasAllIds', () => {
     expect(hasAllIds(model)).toBe(true);
   });
 
-  it('should return false if any slice is missing an ID', () => {
+  it('should return false if any moment is missing an ID', () => {
     const model = createModelWithIds();
     const modifiedModel = structuredClone(model);
-    modifiedModel.narratives[0].slices[0].id = '';
+    modifiedModel.scenes[0].moments[0].id = '';
     expect(hasAllIds(modifiedModel)).toBe(false);
   });
 
   it('should return false if any rule is missing an ID', () => {
     const model = createModelWithIds();
     const modifiedModel = structuredClone(model);
-    const slice = modifiedModel.narratives[0].slices[0];
+    const slice = modifiedModel.scenes[0].moments[0];
     if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
       slice.server.specs[0].rules[0].id = '';
     }
@@ -227,7 +227,7 @@ describe('hasAllIds', () => {
     expect(hasAllIds(model)).toBe(false);
   });
 
-  it('should return false when any slice in multiple flows with same sourceFile is missing ID', () => {
+  it('should return false when any moment in multiple flows with same sourceFile is missing ID', () => {
     const model = createMultipleFlowsModel(true, false);
     expect(hasAllIds(model)).toBe(false);
   });
@@ -235,7 +235,7 @@ describe('hasAllIds', () => {
   it('should return false if any spec is missing an ID', () => {
     const model = createModelWithFullIds();
     const modifiedModel = structuredClone(model);
-    const slice = modifiedModel.narratives[0].slices[0];
+    const slice = modifiedModel.scenes[0].moments[0];
     if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
       slice.server.specs[0].id = '';
     }
@@ -245,7 +245,7 @@ describe('hasAllIds', () => {
   it('should return false if any example is missing an ID', () => {
     const model = createModelWithFullIds();
     const modifiedModel = structuredClone(model);
-    const slice = modifiedModel.narratives[0].slices[0];
+    const slice = modifiedModel.scenes[0].moments[0];
     if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
       slice.server.specs[0].rules[0].examples[0].id = '';
     }
@@ -255,7 +255,7 @@ describe('hasAllIds', () => {
   it('should return false if any step is missing an ID', () => {
     const model = createModelWithFullIds();
     const modifiedModel = structuredClone(model);
-    const slice = modifiedModel.narratives[0].slices[0];
+    const slice = modifiedModel.scenes[0].moments[0];
     if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
       slice.server.specs[0].rules[0].examples[0].steps[0].id = '';
     }
@@ -265,14 +265,14 @@ describe('hasAllIds', () => {
   it('should return false if step with error is missing an ID', () => {
     const model: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Test Flow',
           id: 'FLOW-001',
-          slices: [
+          moments: [
             {
               type: 'command',
-              name: 'Test slice',
+              name: 'Test moment',
               id: 'SLICE-001',
               client: { specs: [] },
               server: {
@@ -322,13 +322,13 @@ describe('hasAllIds', () => {
   it('should return false if client it spec is missing an ID', () => {
     const model: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Test Flow',
           id: 'FLOW-001',
-          slices: [
+          moments: [
             {
-              name: 'Test slice',
+              name: 'Test moment',
               id: 'SLICE-001',
               type: 'experience',
               client: {
@@ -348,13 +348,13 @@ describe('hasAllIds', () => {
   it('should return false if client describe spec is missing an ID', () => {
     const model: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Test Flow',
           id: 'FLOW-001',
-          slices: [
+          moments: [
             {
-              name: 'Test slice',
+              name: 'Test moment',
               id: 'SLICE-001',
               type: 'experience',
               client: {
@@ -380,13 +380,13 @@ describe('hasAllIds', () => {
   it('should return false if nested client it spec is missing an ID', () => {
     const model: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Test Flow',
           id: 'FLOW-001',
-          slices: [
+          moments: [
             {
-              name: 'Test slice',
+              name: 'Test moment',
               id: 'SLICE-001',
               type: 'experience',
               client: {
@@ -413,13 +413,13 @@ describe('hasAllIds', () => {
   it('should return true for client specs with all IDs', () => {
     const model: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Test Flow',
           id: 'FLOW-001',
-          slices: [
+          moments: [
             {
-              name: 'Test slice',
+              name: 'Test moment',
               id: 'SLICE-001',
               type: 'experience',
               client: {
@@ -455,14 +455,14 @@ describe('hasAllIds', () => {
     it('should return false when data wrapper is missing an ID', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Test Flow',
             id: 'FLOW-001',
-            slices: [
+            moments: [
               {
                 type: 'command',
-                name: 'Test slice',
+                name: 'Test moment',
                 id: 'SLICE-001',
                 client: { specs: [] },
                 server: {
@@ -492,14 +492,14 @@ describe('hasAllIds', () => {
     it('should return false when data sink item is missing an ID', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Test Flow',
             id: 'FLOW-001',
-            slices: [
+            moments: [
               {
                 type: 'command',
-                name: 'Test slice',
+                name: 'Test moment',
                 id: 'SLICE-001',
                 client: { specs: [] },
                 server: {
@@ -529,14 +529,14 @@ describe('hasAllIds', () => {
     it('should return false when data source item is missing an ID', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Test Flow',
             id: 'FLOW-001',
-            slices: [
+            moments: [
               {
                 type: 'query',
-                name: 'Test slice',
+                name: 'Test moment',
                 id: 'SLICE-001',
                 client: { specs: [] },
                 server: {
@@ -566,14 +566,14 @@ describe('hasAllIds', () => {
     it('should return false when nested _withState source is missing an ID', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Test Flow',
             id: 'FLOW-001',
-            slices: [
+            moments: [
               {
                 type: 'command',
-                name: 'Test slice',
+                name: 'Test moment',
                 id: 'SLICE-001',
                 client: { specs: [] },
                 server: {
@@ -608,14 +608,14 @@ describe('hasAllIds', () => {
     it('should return true when all data items have IDs', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Test Flow',
             id: 'FLOW-001',
-            slices: [
+            moments: [
               {
                 type: 'command',
-                name: 'Test slice',
+                name: 'Test moment',
                 id: 'SLICE-001',
                 client: { specs: [] },
                 server: {
@@ -651,14 +651,14 @@ describe('hasAllIds', () => {
     it('should return true when sink with _withState both have IDs', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Test Flow',
             id: 'FLOW-001',
-            slices: [
+            moments: [
               {
                 type: 'command',
-                name: 'Test slice',
+                name: 'Test moment',
                 id: 'SLICE-001',
                 client: { specs: [] },
                 server: {
@@ -691,17 +691,17 @@ describe('hasAllIds', () => {
       expect(hasAllIds(model)).toBe(true);
     });
 
-    it('should return true when slice has no data', () => {
+    it('should return true when moment has no data', () => {
       const model: Model = {
         variant: 'specs',
-        narratives: [
+        scenes: [
           {
             name: 'Test Flow',
             id: 'FLOW-001',
-            slices: [
+            moments: [
               {
                 type: 'command',
-                name: 'Test slice',
+                name: 'Test moment',
                 id: 'SLICE-001',
                 client: { specs: [] },
                 server: {

package/src/id/hasAllIds.ts

@@ -1,4 +1,4 @@
-import type { ClientSpecNode, Example, Model, Rule, Slice, Spec, Step } from '../index';
+import type { ClientSpecNode, Example, Model, Moment, Rule, Spec, Step } from '../index';
 
 function hasValidId(item: { id?: string }): boolean {
   return item.id !== undefined && item.id !== '';
@@ -20,7 +20,7 @@ function hasSpecIds(specs: Spec[]): boolean {
   return specs.every((spec) => hasValidId(spec) && hasRuleIds(spec.rules));
 }
 
-function hasServerSpecIds(slice: Slice): boolean {
+function hasServerSpecIds(slice: Moment): boolean {
   if (!('server' in slice) || slice.server?.specs === undefined || !Array.isArray(slice.server.specs)) return true;
   return hasSpecIds(slice.server.specs);
 }
@@ -35,12 +35,12 @@ function hasClientSpecNodeIds(nodes: ClientSpecNode[]): boolean {
   });
 }
 
-function hasClientSpecIds(slice: Slice): boolean {
+function hasClientSpecIds(slice: Moment): boolean {
   if (!('client' in slice) || slice.client?.specs === undefined || !Array.isArray(slice.client.specs)) return true;
   return hasClientSpecNodeIds(slice.client.specs);
 }
 
-function hasDataIds(slice: Slice): boolean {
+function hasDataIds(slice: Moment): boolean {
   if (!('server' in slice) || !slice.server?.data) return true;
 
   // Validate the data wrapper has an ID
@@ -58,10 +58,10 @@ function hasDataIds(slice: Slice): boolean {
   });
 }
 
-function hasSliceIds(slice: Slice): boolean {
+function hasMomentIds(slice: Moment): boolean {
   return hasValidId(slice) && hasServerSpecIds(slice) && hasClientSpecIds(slice) && hasDataIds(slice);
 }
 
 export function hasAllIds(specs: Model): boolean {
-  return specs.narratives.every((narrative) => hasValidId(narrative) && narrative.slices.every(hasSliceIds));
+  return specs.scenes.every((scene) => hasValidId(scene) && scene.moments.every(hasMomentIds));
 }

package/src/index.ts

@@ -28,38 +28,37 @@ export type { DataTargetItem, FieldSelector } from './data-narrative-builders';
 
 export { sink, source, target } from './data-narrative-builders';
 export type {
-  FluentCommandSliceBuilder,
-  FluentExperienceSliceBuilder,
-  FluentQuerySliceBuilder,
-  FluentReactionSliceBuilder,
+  FluentCommandMomentBuilder,
+  FluentExperienceMomentBuilder,
+  FluentQueryMomentBuilder,
+  FluentReactionMomentBuilder,
 } from './fluent-builder';
 export { command, decide, evolve, experience, query, react } from './fluent-builder';
-export { getNarratives } from './getNarratives';
+export { getScenes } from './getScenes';
 export { addAutoIds, hasAllIds } from './id';
-export type { ExampleBuilder, GivenBuilder, SliceTypeValueInterface, ThenBuilder, WhenBuilder } from './narrative';
+export type { ExampleBuilder, GivenBuilder, MomentTypeValueInterface, ThenBuilder, WhenBuilder } from './narrative';
 export {
   client,
   data,
   describe,
   example,
   it,
-  narrative,
-  narrative as flow,
+  MomentType,
   request,
   rule,
-  SliceType,
+  scene,
   server,
   should,
   specs,
   thenError,
 } from './narrative';
 export type { ParsedArg, ParsedGraphQlOperation } from './parse-graphql-request';
-export { parseGraphQlRequest, parseSliceRequest } from './parse-graphql-request';
+export { parseGraphQlRequest, parseMomentRequest } from './parse-graphql-request';
 export * from './schema';
 export { createNarrativeSpec, given as testGiven, when as testWhen } from './testing';
-export type { GeneratedNarratives } from './transformers/model-to-narrative';
+export type { GeneratedScenes } from './transformers/model-to-narrative';
 export { modelToNarrative } from './transformers/model-to-narrative';
 export { detectQueryAction, extractQueryNameFromRequest } from './transformers/narrative-to-model/spec-processors';
 export { isInlineObject, isInlineObjectArray, parseInlineObjectFields } from './ts-type-helpers';
-export type { SliceRequestValidationError } from './validate-slice-requests';
-export { validateSliceRequests } from './validate-slice-requests';
+export type { MomentRequestValidationError } from './validate-slice-requests';
+export { validateMomentRequests } from './validate-slice-requests';

package/src/loader/index.ts

@@ -65,7 +65,7 @@ export async function executeAST(
 
   runGraph(entryFiles, final.graph);
 
-  const flowsCount = registry.getAllNarratives().length;
+  const flowsCount = registry.getAllScenes().length;
   const integrationsCount = integrationRegistry.getAll().length;
 
   debug(

package/src/loader/runtime-cjs.ts

@@ -160,5 +160,5 @@ export function runGraph(entryFiles: string[], graph: Graph): void {
   }
 
   for (const entry of entryFiles) loadFromVfs(entry);
-  debug('runGraph: flows=%d integrations=%d', registry.getAllNarratives().length, integrationRegistry.getAll().length);
+  debug('runGraph: flows=%d integrations=%d', registry.getAllScenes().length, integrationRegistry.getAll().length);
 }