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

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.130.0",
-    "@auto-engineer/message-bus": "1.130.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.130.0"
+    "@auto-engineer/cli": "1.131.0"
   },
-  "version": "1.130.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/scaffoldFromSchema.ts

@@ -37,7 +37,6 @@ import {
   extractProjectionName,
   findPrimitiveLinkingField,
   getAllEventTypes,
-  getLocalEvents,
   groupEventImports,
   isPrimitiveTsType,
   isValidTsIdentifier,
@@ -84,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'],
 };
 
@@ -667,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/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) %>;
+  <% } -%>
+  }
+>;
+<% } -%>
+<% } -%>