@auto-engineer/server-generator-apollo-emmett 1.129.0 → 1.131.0

package/ketchup-plan.md

@@ -1,11 +1,10 @@
-# Ketchup Plan: Fix Outstanding Issues from Typical Server Generation
+# Ketchup Plan: Fix Unescaped Quotes in EJS Template String Literals
 
 ## TODO
 
-(none)
+- [x] Burst 1: Add `escapeJsString` utility + unit tests + wire into renderTemplate (7a5544a6)
+- [x] Burst 2: Fix `projection.specs.ts.ejs` interpolation points (d108c530)
+- [x] Burst 3: Fix `decide.specs.ts.ejs` and `decide.ts.ejs` interpolation points (f9b46ada)
+- [x] Burst 4: Fix `react.specs.ts.ejs` interpolation points
 
 ## DONE
-
-- [x] Burst 1: Align ReactorLike return type with MessageHandlerResult (3b1217fc)
-- [x] Burst 2: Rename `then` → `thenSends` to eliminate thenable risk (c65fa28d)
-- [x] Burst 3: Prefix unused aggregateStream state var with `_` (04fd4cbb)

package/package.json

@@ -32,8 +32,8 @@
     "uuid": "^13.0.0",
     "web-streams-polyfill": "^4.1.0",
     "zod": "^3.22.4",
-    "@auto-engineer/narrative": "1.129.0",
-    "@auto-engineer/message-bus": "1.129.0"
+    "@auto-engineer/message-bus": "1.131.0",
+    "@auto-engineer/narrative": "1.131.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.129.0"
+    "@auto-engineer/cli": "1.131.0"
   },
-  "version": "1.129.0",
+  "version": "1.131.0",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src",

package/src/codegen/extract/imports.ts

@@ -51,14 +51,6 @@ export function groupEventImports(context: CrossSliceImportContext): ImportGroup
   }));
 }
 
-/**
- * Filters events to only include those from the current slice (source === 'then').
- * Used for generating local event definitions.
- */
-export function getLocalEvents(events: Message[]): Message[] {
-  return events.filter((event) => event.source === 'then');
-}
-
 /**
  * Extracts all unique event types from a list of events.
  */

package/src/codegen/extract/type-helpers.specs.ts

@@ -2,6 +2,7 @@ import { parseInlineObjectFields } from '@auto-engineer/narrative';
 import { describe, expect, it } from 'vitest';
 import {
   createFieldUsesJSON,
+  escapeJsString,
   findPrimitiveLinkingField,
   isPrimitiveTsType,
   isValidTsIdentifier,
@@ -172,6 +173,28 @@ describe('findPrimitiveLinkingField', () => {
   });
 });
 
+describe('escapeJsString', () => {
+  it('escapes single quotes', () => {
+    expect(escapeJsString("user's workouts")).toBe("user\\'s workouts");
+  });
+
+  it('escapes backslashes', () => {
+    expect(escapeJsString('path\\to\\file')).toBe('path\\\\to\\\\file');
+  });
+
+  it('escapes newlines and carriage returns', () => {
+    expect(escapeJsString('line1\nline2\rline3')).toBe('line1\\nline2\\rline3');
+  });
+
+  it('escapes backslashes before single quotes', () => {
+    expect(escapeJsString("it\\'s")).toBe("it\\\\\\'s");
+  });
+
+  it('returns plain strings unchanged', () => {
+    expect(escapeJsString('no special chars')).toBe('no special chars');
+  });
+});
+
 describe('createFieldUsesJSON', () => {
   const stubGraphqlType = (ts: string): string => {
     if (ts === 'unknown' || ts === 'any' || ts === 'object') return 'GraphQLJSON';

package/src/codegen/extract/type-helpers.ts

@@ -105,6 +105,10 @@ export function isPrimitiveTsType(tsType: string): boolean {
   return ['string', 'number', 'boolean', 'Date', 'ID'].includes(baseTs(tsType));
 }
 
+export function escapeJsString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+}
+
 export function findPrimitiveLinkingField(
   stateFields: Array<{ name: string; type?: string; tsType?: string }>,
   eventFields: Array<{ name: string; type?: string; tsType?: string }>,

package/src/codegen/scaffoldFromSchema.ts

@@ -32,11 +32,11 @@ import {
   createFieldUsesFloat,
   createFieldUsesJSON,
   createIsEnumType,
+  escapeJsString,
   extractMessagesFromSpecs,
   extractProjectionName,
   findPrimitiveLinkingField,
   getAllEventTypes,
-  getLocalEvents,
   groupEventImports,
   isPrimitiveTsType,
   isValidTsIdentifier,
@@ -83,7 +83,7 @@ const defaultFilesByType: Record<string, string[]> = {
     'decide.specs.ts.ejs',
     'register.ts.ejs',
   ],
-  query: ['projection.ts.ejs', 'state.ts.ejs', 'projection.specs.ts.ejs', 'query.resolver.ts.ejs'],
+  query: ['events.ts.ejs', 'projection.ts.ejs', 'state.ts.ejs', 'projection.specs.ts.ejs', 'query.resolver.ts.ejs'],
   react: ['events.ts.ejs', 'react.ts.ejs', 'react.specs.ts.ejs', 'register.ts.ejs'],
 };
 
@@ -402,6 +402,7 @@ async function renderTemplate(
 
   const result = await template({
     ...data,
+    escapeJsString,
     pascalCase,
     toKebabCase,
     camelCase,
@@ -665,7 +666,10 @@ async function prepareTemplateData(
   const eventImportGroups = groupEventImports({ currentSliceName: slice.name, currentFlowName: flow.name, events });
   const allEventTypesArray = getAllEventTypes(events);
   const allEventTypes = createEventUnionType(events);
-  const localEvents = getLocalEvents(events);
+  const selfImportedTypes = new Set(
+    eventImportGroups.filter((g) => g.importPath === './events').flatMap((g) => g.eventTypes),
+  );
+  const localEvents = events.filter((e) => selfImportedTypes.has(e.type));
 
   const messagesByName = new Map((allMessages ?? []).map((m) => [m.name, m]));
   const targetName = 'server' in slice ? slice.server?.data?.items?.[0]?.target?.name : undefined;

package/src/codegen/templates/command/decide.specs.ts.ejs

@@ -110,7 +110,7 @@ import type { <%= group.eventTypes.join(', ') %> } from '<%= group.importPath %>
 <% } -%>
 import type { <%= Object.keys(commandSchemasByName).join(', ') %> } from './commands';
 <% for (const [ruleDescription, ruleGwts] of ruleGroups.entries()) { %>
-describe('<%= ruleDescription %>', () => {
+describe('<%= escapeJsString(ruleDescription) %>', () => {
 
   type Events = <%= uniqueEventTypes.length > 0 ? uniqueEventTypes.join(' | ') : 'never' %>;
 
@@ -134,7 +134,7 @@ describe('<%= ruleDescription %>', () => {
             ? `should throw ${errorResult.errorType} when ${gwt.failingFields?.join(', ') || 'invalid input'}`
             : `should emit ${eventResults.map(e => e.eventRef).join(', ')} for ${commandName}`);
 %>
-  it('<%= testDescription %>', () => {
+  it('<%= escapeJsString(testDescription) %>', () => {
     given([
 <%_ if (gwt.given && gwt.given.length) { _%>
       <%- gwt.given.map(g => `{
@@ -158,7 +158,7 @@ describe('<%= ruleDescription %>', () => {
         metadata: { now: <%= derivedDate ? `new Date('${derivedDate}')` : 'new Date()' %> },
       })
 <% if (errorResult) { %>
-      .thenThrows((err) => err instanceof <%= errorResult.errorType %> && err.message === '<%= errorResult.message || '' %>');
+      .thenThrows((err) => err instanceof <%= errorResult.errorType %> && err.message === '<%= escapeJsString(errorResult.message || '') %>');
 <% } else { %>
 
       .then(expectEvents(

package/src/codegen/templates/command/decide.ts.ejs

@@ -95,7 +95,7 @@ if (error && gwt.failingFields?.length) {
     const condition = gwt.failingFields.map(field => `command.data.${field} === ''`).join(' || ');
 -%>
 if (<%- condition %>) {
-throw new <%= error.errorType %>('<%- error.message ?? 'Validation failed' %>');
+throw new <%= error.errorType %>('<%= escapeJsString(error.message ?? "Validation failed") %>');
 }
 <% } } -%>
 

package/src/codegen/templates/query/events.specs.ts

@@ -0,0 +1,112 @@
+import type { Model } from '@auto-engineer/narrative';
+import { describe, expect, it } from 'vitest';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+
+describe('query events.ts.ejs', () => {
+  it('generates events.ts for orphan events not produced by any command slice', async () => {
+    const spec: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'appointment-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'view-appointments',
+              stream: 'appointments',
+              client: { specs: [] },
+              server: {
+                description: 'projection for booked appointments',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'State', name: 'Appointment' },
+                      origin: {
+                        type: 'projection',
+                        name: 'AppointmentsProjection',
+                        idField: 'appointmentId',
+                      },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'View appointments query',
+                    rules: [
+                      {
+                        name: 'Should project appointments',
+                        examples: [
+                          {
+                            name: 'Appointment booked shows in list',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'AppointmentBooked',
+                                docString: {
+                                  appointmentId: 'appt_1',
+                                  date: '2024-06-15',
+                                },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'Appointment',
+                                docString: {
+                                  appointmentId: 'appt_1',
+                                  date: '2024-06-15',
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'event',
+          name: 'AppointmentBooked',
+          source: 'internal',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'Appointment',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+
+    const eventFile = plans.find((p) => p.outputPath.endsWith('view-appointments/events.ts'));
+    expect(eventFile).toBeDefined();
+    expect(eventFile?.contents).toMatchInlineSnapshot(`
+"import type { Event } from '@event-driven-io/emmett';
+
+export type AppointmentBooked = Event<
+  'AppointmentBooked',
+  {
+    appointmentId: string;
+    date: string;
+  }
+>;
+"
+    `);
+
+    const projectionFile = plans.find((p) => p.outputPath.endsWith('view-appointments/projection.ts'));
+    expect(projectionFile?.contents).toContain("import type { AppointmentBooked } from './events'");
+  });
+});

package/src/codegen/templates/query/events.ts.ejs

@@ -0,0 +1,17 @@
+<%
+const enumList = collectEnumNames(localEvents.flatMap(e => e.fields));
+%><% if (localEvents.length) { -%>
+import type { Event } from '@event-driven-io/emmett';
+<% if (enumList.length > 0) { %>import { <%= enumList.join(', ') %> } from '../../../shared';
+<% } %>
+<% for (const event of localEvents) { -%>
+export type <%= pascalCase(event.type) %> = Event<
+  '<%= event.type %>',
+  {
+  <% for (const field of event.fields) { -%>
+    <%- field.name %>: <%- toTsFieldType(field.tsType) %>;
+  <% } -%>
+  }
+>;
+<% } -%>
+<% } -%>

package/src/codegen/templates/query/projection.specs.specs.ts

@@ -2616,4 +2616,129 @@ describe('projection.specs.ts.ejs', () => {
       "
     `);
   });
+
+  it('should escape apostrophes in rule names and test descriptions', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'workout-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'log-workout',
+              stream: 'workouts-${memberId}',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log',
+                        examples: [
+                          {
+                            name: 'Logs workout',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { memberId: 'mem_001', caloriesBurned: 250 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutRecorded',
+                                docString: { memberId: 'mem_001', caloriesBurned: 250 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'query',
+              name: 'view-user-workouts',
+              stream: 'workouts',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'State', name: 'UserWorkouts' },
+                      origin: { type: 'projection', name: 'UserWorkoutsProjection', idField: 'memberId' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: "View user's workouts",
+                    rules: [
+                      {
+                        name: "List of user's workouts",
+                        examples: [
+                          {
+                            name: "User's workout history",
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'WorkoutRecorded',
+                                docString: { memberId: 'mem_001', caloriesBurned: 300 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'UserWorkouts',
+                                docString: { totalCalories: 300 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogWorkout',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'caloriesBurned', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'WorkoutRecorded',
+          source: 'internal',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'caloriesBurned', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'UserWorkouts',
+          fields: [{ name: 'totalCalories', type: 'number', required: true }],
+        },
+      ],
+    } as SpecsSchema;
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('view-user-workouts/projection.specs.ts'));
+
+    expect(specFile?.contents).toContain('describe("List of user\'s workouts"');
+    expect(specFile?.contents).toContain('it("User\'s workout history"');
+  });
 });

package/src/codegen/templates/query/projection.specs.ts.ejs

@@ -172,7 +172,7 @@ import { <%= TargetType %> } from './state';
 type ProjectionEvent = <%= uniqueEventTypes.length ? uniqueEventTypes.join(' | ') : 'never' %>;
 
 <% for (const [ruleDescription, ruleTests] of ruleGroups.entries()) { %>
-describe('<%= ruleDescription %>', () => {
+describe('<%= escapeJsString(ruleDescription) %>', () => {
   let given: InMemoryProjectionSpec<ProjectionEvent>;
 
   beforeEach(() => {
@@ -199,7 +199,7 @@ describe('<%= ruleDescription %>', () => {
       : 'should handle events correctly');
 _%>
 
-  it('<%= description %>', () =>
+  it('<%= escapeJsString(description) %>', () =>
     given([<% if (givenEvents.length > 0) {
       for (const evt of givenEvents) {
         if (!evt.eventRef || evt.eventRef === '') continue;

package/src/codegen/templates/react/react.specs.ts.ejs

@@ -85,7 +85,7 @@ type ReactorEvent = <%= allEventTypes.length ? allEventTypes.join(' | ') : 'neve
 type ReactorCommand = <%= allCommandTypes.length ? allCommandTypes.join(' | ') : 'never' %>;
 
 <% for (const [ruleDescription, ruleTests] of ruleGroups.entries()) { %>
-describe('<%= ruleDescription %>', () => {
+describe('<%= escapeJsString(ruleDescription) %>', () => {
   let eventStore: InMemoryEventStore;
   let given: ReactorSpecification<ReactorEvent, ReactorCommand, ReactorContext>;
   let messageBus: CommandSender;
@@ -114,7 +114,7 @@ describe('<%= ruleDescription %>', () => {
         const description = testCase.description ||
             `should send ${thenCommands.map(c => c.commandRef).join(', ')} when ${exampleEvent.eventRef} is received`;
 %>
-  it('<%= description %>', async () => {
+  it('<%= escapeJsString(description) %>', async () => {
 <%
     const givenStates = testCase.given.filter(g =>
       messages.some(m => m.type === 'state' && m.name === g.eventRef)