@auto-engineer/narrative 0.11.11 → 0.11.13

package/src/{model-to-flow.specs.ts → model-to-narrative.specs.ts}

@@ -1739,7 +1739,7 @@ narrative('Date Handling Flow', 'DATE-FLOW', () => {
       narratives: [
         {
           name: 'Home Screen',
-          sourceFile: '/path/to/homepage.flow.ts',
+          sourceFile: '/path/to/homepage.narrative.ts',
           slices: [
             {
               name: 'Active Surveys Summary',
@@ -1756,7 +1756,7 @@ narrative('Date Handling Flow', 'DATE-FLOW', () => {
         },
         {
           name: 'Create Survey',
-          sourceFile: '/path/to/homepage.flow.ts',
+          sourceFile: '/path/to/homepage.narrative.ts',
           slices: [
             {
               name: 'Create Survey Form',
@@ -1773,7 +1773,7 @@ narrative('Date Handling Flow', 'DATE-FLOW', () => {
         },
         {
           name: 'Response Analytics',
-          sourceFile: '/path/to/homepage.flow.ts',
+          sourceFile: '/path/to/homepage.narrative.ts',
           slices: [
             {
               name: 'Response Rate Charts',
@@ -1819,4 +1819,216 @@ narrative('Response Analytics', () => {
 });
 `);
   });
+
+  it('should omit .when({}) when given has multiple items and when is empty', async () => {
+    const modelWithEmptyWhen: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Todo List Summary',
+          id: 'TODO-001',
+          slices: [
+            {
+              name: 'views completion summary',
+              id: 'SUMMARY-001',
+              type: 'query',
+              client: {
+                description: 'Summary view client',
+              },
+              server: {
+                description: 'Summary calculation server',
+                specs: {
+                  name: 'Summary Statistics',
+                  rules: [
+                    {
+                      id: 'RULE-SUMMARY',
+                      description: 'summary shows overall todo list statistics',
+                      examples: [
+                        {
+                          description: 'calculates summary from multiple todos',
+                          given: [
+                            {
+                              eventRef: 'TodoAdded',
+                              exampleData: {
+                                todoId: 'todo-001',
+                                description: 'Buy groceries',
+                                status: 'pending',
+                                addedAt: new Date('2030-01-01T09:00:00.000Z'),
+                              },
+                            },
+                            {
+                              eventRef: 'TodoAdded',
+                              exampleData: {
+                                todoId: 'todo-002',
+                                description: 'Write report',
+                                status: 'pending',
+                                addedAt: new Date('2030-01-01T09:10:00.000Z'),
+                              },
+                            },
+                            {
+                              eventRef: 'TodoMarkedInProgress',
+                              exampleData: {
+                                todoId: 'todo-001',
+                                markedAt: new Date('2030-01-01T10:00:00.000Z'),
+                              },
+                            },
+                            {
+                              eventRef: 'TodoMarkedComplete',
+                              exampleData: {
+                                todoId: 'todo-002',
+                                completedAt: new Date('2030-01-01T11:00:00.000Z'),
+                              },
+                            },
+                          ],
+                          when: {
+                            eventRef: '',
+                            exampleData: {},
+                          },
+                          then: [
+                            {
+                              stateRef: 'TodoListSummary',
+                              exampleData: {
+                                summaryId: 'main-summary',
+                                totalTodos: 2,
+                                pendingCount: 0,
+                                inProgressCount: 1,
+                                completedCount: 1,
+                                completionPercentage: 50,
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'event',
+          name: 'TodoAdded',
+          fields: [
+            { name: 'todoId', type: 'string', required: true },
+            { name: 'description', type: 'string', required: true },
+            { name: 'status', type: 'string', required: true },
+            { name: 'addedAt', type: 'Date', required: true },
+          ],
+          source: 'internal',
+          metadata: { version: 1 },
+        },
+        {
+          type: 'event',
+          name: 'TodoMarkedInProgress',
+          fields: [
+            { name: 'todoId', type: 'string', required: true },
+            { name: 'markedAt', type: 'Date', required: true },
+          ],
+          source: 'internal',
+          metadata: { version: 1 },
+        },
+        {
+          type: 'event',
+          name: 'TodoMarkedComplete',
+          fields: [
+            { name: 'todoId', type: 'string', required: true },
+            { name: 'completedAt', type: 'Date', required: true },
+          ],
+          source: 'internal',
+          metadata: { version: 1 },
+        },
+        {
+          type: 'state',
+          name: 'TodoListSummary',
+          fields: [
+            { name: 'summaryId', type: 'string', required: true },
+            { name: 'totalTodos', type: 'number', required: true },
+            { name: 'pendingCount', type: 'number', required: true },
+            { name: 'inProgressCount', type: 'number', required: true },
+            { name: 'completedCount', type: 'number', required: true },
+            { name: 'completionPercentage', type: 'number', required: true },
+          ],
+          metadata: { version: 1 },
+        },
+      ],
+      integrations: [],
+    };
+
+    const code = await modelToNarrative(modelWithEmptyWhen);
+
+    expect(code).toEqual(`import { example, narrative, query, rule, specs } from '@auto-engineer/narrative';
+import type { Event, State } from '@auto-engineer/narrative';
+type TodoAdded = Event<
+  'TodoAdded',
+  {
+    todoId: string;
+    description: string;
+    status: string;
+    addedAt: Date;
+  }
+>;
+type TodoMarkedInProgress = Event<
+  'TodoMarkedInProgress',
+  {
+    todoId: string;
+    markedAt: Date;
+  }
+>;
+type TodoMarkedComplete = Event<
+  'TodoMarkedComplete',
+  {
+    todoId: string;
+    completedAt: Date;
+  }
+>;
+type TodoListSummary = State<
+  'TodoListSummary',
+  {
+    summaryId: string;
+    totalTodos: number;
+    pendingCount: number;
+    inProgressCount: number;
+    completedCount: number;
+    completionPercentage: number;
+  }
+>;
+narrative('Todo List Summary', 'TODO-001', () => {
+  query('views completion summary', 'SUMMARY-001').server(() => {
+    specs('Summary Statistics', () => {
+      rule('summary shows overall todo list statistics', 'RULE-SUMMARY', () => {
+        example('calculates summary from multiple todos')
+          .given<TodoAdded>({
+            todoId: 'todo-001',
+            description: 'Buy groceries',
+            status: 'pending',
+            addedAt: new Date('2030-01-01T09:00:00.000Z'),
+          })
+          .and<TodoAdded>({
+            todoId: 'todo-002',
+            description: 'Write report',
+            status: 'pending',
+            addedAt: new Date('2030-01-01T09:10:00.000Z'),
+          })
+          .and<TodoMarkedInProgress>({ todoId: 'todo-001', markedAt: new Date('2030-01-01T10:00:00.000Z') })
+          .and<TodoMarkedComplete>({ todoId: 'todo-002', completedAt: new Date('2030-01-01T11:00:00.000Z') })
+          .then<TodoListSummary>({
+            summaryId: 'main-summary',
+            totalTodos: 2,
+            pendingCount: 0,
+            inProgressCount: 1,
+            completedCount: 1,
+            completionPercentage: 50,
+          });
+      });
+    });
+  });
+});
+`);
+
+    expect(code).not.toContain('.when({})');
+    expect(code).not.toContain('.when<');
+  });
 });

package/src/narrative-context.ts

@@ -321,7 +321,6 @@ export function recordExample(description: string): void {
     const rule = objectRules[context.currentRuleIndex];
     rule.examples.push({
       description,
-      when: { commandRef: '', exampleData: {} }, // Default, will be updated
       then: [],
     });
     context.currentExampleIndex = rule.examples.length - 1;

package/src/narrative.ts

@@ -93,7 +93,7 @@ export function rule(description: string, idOrFn: string | (() => void), fn?: ()
   callback();
 }
 
-export const example = (description: string) => {
+export const example = (description: string): TypedExampleBuilder => {
   recordExample(description);
   return createExampleBuilder();
 };
@@ -122,6 +122,7 @@ interface TypedExampleBuilder {
 interface TypedGivenBuilder<G> {
   and<U>(data: ExtractData<U> | ExtractData<U>[], context?: ContextFor<U>): TypedGivenBuilder<G | U>;
   when<W>(data: ExtractData<W> | ExtractData<W>[], context?: ContextFor<W>): TypedGivenWhenBuilder<G, W>;
+  then<T>(data: ExtractData<T> | ExtractData<T>[], context?: ContextFor<T>): TypedGivenThenBuilder<G, never, T>;
 }
 
 interface TypedWhenBuilder<W> {
@@ -180,6 +181,20 @@ function createGivenBuilder<G>(): TypedGivenBuilder<G> {
         },
       };
     },
+    then<T>(data: ExtractData<T> | ExtractData<T>[], context?: ContextFor<T>): TypedGivenThenBuilder<G, never, T> {
+      const thenItems = Array.isArray(data) ? data : [data];
+      recordThenData(thenItems, normalizeContext(context as Partial<Record<string, string>>));
+      return {
+        and<A>(
+          data: ExtractData<A> | ExtractData<A>[],
+          context?: ContextFor<A>,
+        ): TypedGivenThenBuilder<G, never, T | A> {
+          const andItems = Array.isArray(data) ? data : [data];
+          recordAndThenData(andItems, normalizeContext(context as Partial<Record<string, string>>));
+          return createThenBuilder<never, T | A>() as TypedGivenThenBuilder<G, never, T | A>;
+        },
+      };
+    },
   };
 }
 

package/src/samples/{mixed-given-types.flow.ts → mixed-given-types.narrative.ts}

@@ -58,7 +58,6 @@ flow('Mixed Given Types', 'FLOW-MGT', () => {
               itemId: 'item-002',
               addedAt: new Date('2024-01-01T10:02:00Z'),
             })
-            .when({}) // empty when clause
             .then<SystemStatus>({
               systemId: 'system-001',
               itemCount: 2,

package/src/samples/{place-order.flow.ts → place-order.narrative.ts}

@@ -11,7 +11,7 @@ export interface OrderPlaced {
   };
 }
 
-export interface PlaceOrderFlow {
+export interface PlaceOrderNarrative {
   type: 'PlaceOrder';
   data: {
     productId: string;
@@ -41,7 +41,7 @@ flow('Place order', () => {
       specs('User submits a new order', () => {
         rule('Valid orders should be processed successfully', () => {
           example('User places order for available product')
-            .when<PlaceOrderFlow>({
+            .when<PlaceOrderNarrative>({
               productId: 'product_789',
               quantity: 3,
             })

package/src/samples/{questionnaires.flow.ts → questionnaires.narrative.ts}

@@ -135,7 +135,6 @@ flow('Questionnaires', 'AUTO-Q9m2Kp4Lx', () => {
               link: 'https://app.example.com/q/q-001?participant=participant-abc',
               sentAt: new Date('2030-01-01T09:00:00Z'),
             })
-            .when({})
             .then<QuestionnaireProgress>({
               questionnaireId: 'q-001',
               participantId: 'participant-abc',
@@ -259,7 +258,6 @@ flow('Questionnaires', 'AUTO-Q9m2Kp4Lx', () => {
               answer: 'No',
               savedAt: new Date('2030-01-01T09:05:00Z'),
             })
-            .when({}) // FIX ME
             .then<QuestionnaireProgress>({
               questionnaireId: 'q-001',
               participantId: 'participant-abc',

package/src/samples/seasonal-assistant.schema.json

@@ -452,7 +452,7 @@
           }
         }
       ],
-      "sourceFile": "/Users/ramihatoum/WebstormProjects/xolvio/auto-engineer/examples/shopping-app/flows/shopping-assistant.flow.ts"
+      "sourceFile": "/Users/ramihatoum/WebstormProjects/xolvio/auto-engineer/examples/shopping-app/flows/shopping-assistant.narrative.ts"
     }
   ],
   "messages": [

package/src/schema.ts

@@ -181,6 +181,7 @@ const ExampleSchema = z
       .describe('Given conditions'),
     when: z
       .union([CommandExampleSchema, EventExampleSchema, z.array(CommandExampleSchema), z.array(EventExampleSchema)])
+      .optional()
       .describe('When action or events occur'),
     then: z
       .array(z.union([EventExampleSchema, StateExampleSchema, CommandExampleSchema, ErrorExampleSchema]))

package/src/transformers/model-to-narrative/generators/gwt.ts

@@ -164,26 +164,61 @@ function addEventWhenToChain(
   );
 }
 
-function addWhenToChain(
+function isEmptyEventWhen(when: { eventRef: string; exampleData: Record<string, unknown> }): boolean {
+  return (!when.eventRef || when.eventRef === '') && Object.keys(when.exampleData).length === 0;
+}
+
+function isEmptyCommandWhen(when: { commandRef: string; exampleData: Record<string, unknown> }): boolean {
+  return (!when.commandRef || when.commandRef === '') && Object.keys(when.exampleData).length === 0;
+}
+
+function isEmptyWhen(whenData: GWTBlock['when']): boolean {
+  if (!whenData) return true;
+  if (Array.isArray(whenData) && whenData.length === 0) return true;
+  if (typeof whenData === 'object' && 'eventRef' in whenData) {
+    return isEmptyEventWhen(whenData as { eventRef: string; exampleData: Record<string, unknown> });
+  }
+  if (typeof whenData === 'object' && 'commandRef' in whenData) {
+    return isEmptyCommandWhen(whenData as { commandRef: string; exampleData: Record<string, unknown> });
+  }
+  return false;
+}
+
+function processWhenForSliceKind(
   ts: typeof import('typescript'),
   f: tsNS.NodeFactory,
   exampleChain: tsNS.Expression,
-  g: GWTBlock,
+  when: GWTBlock['when'],
   sliceKind: 'command' | 'react' | 'query' | 'experience',
   messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
 ): tsNS.Expression {
-  if (sliceKind === 'command' && isWhenCommand(g.when)) {
-    return addCommandWhenToChain(ts, f, exampleChain, g.when, messages);
-  } else if ((sliceKind === 'react' || sliceKind === 'query') && isWhenEvents(g.when)) {
-    const firstWhenEvent = g.when[0];
-    return addEventWhenToChain(ts, f, exampleChain, firstWhenEvent, messages);
-  } else if (sliceKind === 'query' && g.when && !Array.isArray(g.when) && 'eventRef' in g.when) {
-    const whenEvent = g.when as { eventRef: string; exampleData: Record<string, unknown> };
+  if (sliceKind === 'command' && isWhenCommand(when)) {
+    return addCommandWhenToChain(ts, f, exampleChain, when, messages);
+  }
+  if ((sliceKind === 'react' || sliceKind === 'query') && isWhenEvents(when)) {
+    return addEventWhenToChain(ts, f, exampleChain, when[0], messages);
+  }
+  if (sliceKind === 'query' && when && !Array.isArray(when) && 'eventRef' in when) {
+    const whenEvent = when as { eventRef: string; exampleData: Record<string, unknown> };
     return addEventWhenToChain(ts, f, exampleChain, whenEvent, messages);
   }
   return exampleChain;
 }
 
+function addWhenToChain(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  exampleChain: tsNS.Expression,
+  g: GWTBlock,
+  sliceKind: 'command' | 'react' | 'query' | 'experience',
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): tsNS.Expression {
+  if (isEmptyWhen(g.when)) {
+    return exampleChain;
+  }
+  return processWhenForSliceKind(ts, f, exampleChain, g.when, sliceKind, messages);
+}
+
 function getThenTypeRef(firstThenItem: GWTBlock['then'][0]): string {
   if ('eventRef' in firstThenItem) {
     return (firstThenItem as { eventRef: string }).eventRef;

package/src/transformers/narrative-to-model/debug.ts

@@ -1,6 +1,6 @@
 import createDebug from 'debug';
 
-export const debugIntegrations = createDebug('auto:flow:getFlows:integrations');
+export const debugIntegrations = createDebug('auto:flow:getNarratives:integrations');
 if (typeof debugIntegrations === 'object' && debugIntegrations !== null && 'color' in debugIntegrations) {
   (debugIntegrations as { color: string }).color = '6';
 }

package/.turbo/turbo-format.log

@@ -1,4 +0,0 @@
-
-> @auto-engineer/narrative@0.11.10 format /Users/sam/WebstormProjects/top/auto-engineer-2/packages/narrative
-> prettier --write "**/*.{js,ts,json,md,yml,yaml}" --ignore-path ../../.prettierignore --log-level warn
-

package/.turbo/turbo-lint.log

@@ -1,4 +0,0 @@
-
-> @auto-engineer/narrative@0.11.10 lint /Users/sam/WebstormProjects/top/auto-engineer-2/packages/narrative
-> eslint '{src,scripts}/**/*.ts' --max-warnings 0 --config ./eslint.config.ts
-

package/.turbo/turbo-test.log

@@ -1,14 +0,0 @@
-
-> @auto-engineer/narrative@0.11.10 test /Users/sam/WebstormProjects/top/auto-engineer-2/packages/narrative
-> vitest run --reporter=dot
-
-
- RUN  v3.2.4 /Users/sam/WebstormProjects/top/auto-engineer-2/packages/narrative
-
-·································································
-
- Test Files  8 passed (8)
-      Tests  65 passed (65)
-   Start at  15:23:05
-   Duration  2.32s (transform 1.53s, setup 0ms, collect 5.01s, tests 2.45s, environment 1ms, prepare 1.30s)
-

package/.turbo/turbo-type-check.log

@@ -1,4 +0,0 @@
-
-> @auto-engineer/narrative@0.11.10 type-check /Users/sam/WebstormProjects/top/auto-engineer-2/packages/narrative
-> tsc --noEmit
-

package/dist/src/data-flow-builders.d.ts

@@ -1,71 +0,0 @@
-import type { DataSinkItem, DataSourceItem, MessageTarget, Integration } from './types';
-export interface ChainableSinkMethods {
-    additionalInstructions(instructions: string): ChainableSink;
-    withState(source: DataSourceItem | ChainableSource): ChainableSink;
-}
-export interface ChainableSourceMethods {
-    additionalInstructions(instructions: string): ChainableSource;
-}
-export type ChainableSink = DataSinkItem & ChainableSinkMethods;
-export type ChainableSource = DataSourceItem & ChainableSourceMethods;
-export interface FieldSelector {
-    [key: string]: boolean | FieldSelector;
-}
-declare abstract class MessageTargetBuilder<TResult> {
-    protected target: Partial<MessageTarget>;
-    protected instructions?: string;
-    fields(selector: FieldSelector): this;
-    additionalInstructions(instructions: string): this;
-    abstract build(): TResult;
-}
-export declare class EventSinkBuilder extends MessageTargetBuilder<DataSinkItem> {
-    constructor(name: string);
-    toStream(pattern: string): ChainableSink;
-    toIntegration(...systems: Integration[]): ChainableSink;
-    toDatabase(collection: string): ChainableSink;
-    toTopic(name: string): ChainableSink;
-    build(): DataSinkItem;
-}
-export declare class CommandSinkBuilder extends MessageTargetBuilder<DataSinkItem> {
-    private stateSource?;
-    constructor(name: string);
-    withState(source: DataSourceItem | ChainableSource): this;
-    toIntegration(system: Integration | string, messageName: string, messageType: 'command' | 'query' | 'reaction'): ChainableSink;
-    hints(hint: string): ChainableSink;
-    toDatabase(collection: string): ChainableSink;
-    toTopic(name: string): ChainableSink;
-    build(): DataSinkItem;
-}
-export declare class StateSinkBuilder extends MessageTargetBuilder<DataSinkItem> {
-    constructor(name: string);
-    toDatabase(collection: string): ChainableSink;
-    toStream(pattern: string): ChainableSink;
-    build(): DataSinkItem;
-}
-export declare class StateSourceBuilder extends MessageTargetBuilder<DataSourceItem> {
-    constructor(name: string);
-    fromProjection(name: string, idField: string): ChainableSource;
-    fromReadModel(name: string): ChainableSource;
-    fromDatabase(collection: string, query?: Record<string, unknown>): ChainableSource;
-    fromApi(endpoint: string, method?: string): ChainableSource;
-    fromIntegration(...systems: (Integration | string)[]): ChainableSource;
-    build(): DataSourceItem;
-}
-interface BuilderResult {
-    type: string;
-    __messageCategory: 'event' | 'command' | 'state';
-}
-export declare class DataSinkBuilder {
-    event(nameOrBuilder: string | BuilderResult): EventSinkBuilder;
-    command(nameOrBuilder: string | BuilderResult): CommandSinkBuilder;
-    state(nameOrBuilder: string | BuilderResult): StateSinkBuilder;
-}
-export declare class DataSourceBuilder {
-    state(nameOrBuilder: string | BuilderResult): StateSourceBuilder;
-}
-export declare const sink: () => DataSinkBuilder;
-export declare const source: () => DataSourceBuilder;
-export declare function typedSink(builderResult: BuilderResult): EventSinkBuilder | CommandSinkBuilder | StateSinkBuilder;
-export declare function typedSource(builderResult: BuilderResult): StateSourceBuilder;
-export {};
-//# sourceMappingURL=data-flow-builders.d.ts.map

package/dist/src/data-flow-builders.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-flow-builders.d.ts","sourceRoot":"","sources":["../../src/data-flow-builders.ts"],"names":[],"mappings":"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"}