@auto-engineer/server-generator-apollo-emmett 0.11.13 → 0.11.15

package/package.json

@@ -31,8 +31,8 @@
     "graphql-type-json": "^0.3.2",
     "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
-    "@auto-engineer/narrative": "0.11.13",
-    "@auto-engineer/message-bus": "0.11.13"
+    "@auto-engineer/narrative": "0.11.15",
+    "@auto-engineer/message-bus": "0.11.15"
   },
   "publishConfig": {
     "access": "public"
@@ -43,9 +43,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "0.11.13"
+    "@auto-engineer/cli": "0.11.15"
   },
-  "version": "0.11.13",
+  "version": "0.11.15",
   "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/messages.ts

@@ -3,7 +3,7 @@ import { CommandExample, EventExample, Slice } from '@auto-engineer/narrative';
 import { Message, MessageDefinition } from '../types';
 import { extractEventsFromGiven, extractEventsFromThen, extractEventsFromWhen } from './events';
 import { extractFieldsFromMessage } from './fields';
-import { extractProjectionIdField } from './projection';
+import { extractProjectionIdField, extractProjectionSingleton } from './projection';
 import { extractStatesFromData, extractStatesFromTarget } from './states';
 import createDebug from 'debug';
 
@@ -19,6 +19,7 @@ export interface ExtractedMessages {
   states: Message[];
   commandSchemasByName: Record<string, Message>;
   projectionIdField?: string;
+  projectionSingleton?: boolean;
 }
 
 export interface ReactGwtSpec {
@@ -122,6 +123,9 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
   const projectionIdField = extractProjectionIdField(slice);
   debugQuery('  Projection ID field: %s', projectionIdField ?? 'none');
 
+  const projectionSingleton = extractProjectionSingleton(slice);
+  debugQuery('  Projection singleton: %s', projectionSingleton);
+
   const events: Message[] = gwtSpecs.flatMap((gwt) => {
     const eventsFromGiven = Array.isArray(gwt.given)
       ? gwt.given.filter((item): item is EventExample => 'eventRef' in item)
@@ -166,6 +170,7 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
     states,
     commandSchemasByName: {},
     projectionIdField,
+    projectionSingleton,
   };
 
   debugQuery('  Final result: %d events, %d states', result.events.length, result.states.length);

package/src/codegen/extract/projection.ts

@@ -4,6 +4,7 @@ interface ProjectionOrigin {
   type: 'projection';
   idField?: string;
   name?: string;
+  singleton?: boolean;
 }
 
 interface HasOrigin {
@@ -46,3 +47,16 @@ export function extractProjectionIdField(slice: Slice): string | undefined {
 export function extractProjectionName(slice: Slice): string | undefined {
   return extractProjectionField(slice, 'name');
 }
+
+export function extractProjectionSingleton(slice: Slice): boolean {
+  if (!('server' in slice)) return false;
+  const dataSource = slice.server?.data?.[0];
+  if (!hasOrigin(dataSource)) return false;
+
+  const origin = dataSource.origin;
+  if (isProjectionOrigin(origin)) {
+    return origin.singleton === true;
+  }
+
+  return false;
+}

package/src/codegen/scaffoldFromSchema.ts

@@ -490,6 +490,7 @@ async function prepareTemplateData(
   states: Message[],
   commandSchemasByName: Record<string, Message>,
   projectionIdField: string | undefined,
+  projectionSingleton: boolean | undefined,
   allMessages?: MessageDefinition[],
   integrations?: Model['integrations'],
 ): Promise<Record<string, unknown>> {
@@ -538,6 +539,7 @@ async function prepareTemplateData(
     usedErrors,
     commandSchemasByName,
     projectionIdField,
+    projectionSingleton,
     projectionName,
     projectionType: projectionName != null ? pascalCase(projectionName) : undefined,
     parsedRequest: slice.type === 'query' && slice.request != null ? parseGraphQlRequest(slice.request) : undefined,
@@ -693,6 +695,7 @@ async function generateFilesForSlice(
     extracted.states,
     extracted.commandSchemasByName,
     extracted.projectionIdField,
+    extracted.projectionSingleton,
     messages,
     integrations,
   );

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

@@ -620,4 +620,370 @@ describe('projection.specs.ts.ejs', () => {
     // canHandle must include BOTH events
     expect(projectionFile?.contents).toContain("canHandle: ['QuestionnaireLinkSent', 'QuestionAnswered']");
   });
+
+  it('should generate a valid test spec for singleton projection', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'todo-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'manage-todo',
+              stream: 'todo-${todoId}',
+              client: { description: '' },
+              server: {
+                description: '',
+                specs: {
+                  name: 'Manage todo command',
+                  rules: [
+                    {
+                      description: 'Should handle todo operations',
+                      examples: [
+                        {
+                          description: 'User adds todo',
+                          when: {
+                            commandRef: 'AddTodo',
+                            exampleData: {
+                              todoId: 'todo_123',
+                              title: 'Buy milk',
+                            },
+                          },
+                          then: [
+                            {
+                              eventRef: 'TodoAdded',
+                              exampleData: {
+                                todoId: 'todo_123',
+                                title: 'Buy milk',
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+            {
+              type: 'query',
+              name: 'view-summary',
+              stream: 'todos',
+              client: { description: '' },
+              server: {
+                description: '',
+                data: [
+                  {
+                    target: {
+                      type: 'State',
+                      name: 'TodoSummary',
+                    },
+                    origin: {
+                      type: 'projection',
+                      name: 'TodoSummaryProjection',
+                      singleton: true,
+                    },
+                  },
+                ],
+                specs: {
+                  name: 'View summary query',
+                  rules: [
+                    {
+                      description: 'Should aggregate todo counts',
+                      examples: [
+                        {
+                          description: 'Todo added updates count',
+                          when: [
+                            {
+                              eventRef: 'TodoAdded',
+                              exampleData: {
+                                todoId: 'todo_123',
+                                title: 'Buy milk',
+                              },
+                            },
+                          ],
+                          then: [
+                            {
+                              stateRef: 'TodoSummary',
+                              exampleData: {
+                                totalCount: 1,
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'AddTodo',
+          fields: [
+            { name: 'todoId', type: 'string', required: true },
+            { name: 'title', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'TodoAdded',
+          source: 'internal',
+          fields: [
+            { name: 'todoId', type: 'string', required: true },
+            { name: 'title', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'TodoSummary',
+          fields: [{ name: 'totalCount', 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-summary/projection.specs.ts'));
+
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, it, beforeEach, expect } from 'vitest';
+      import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
+      import { projection } from './projection';
+      import type { TodoAdded } from '../manage-todo/events';
+      import { TodoSummary } from './state';
+
+      type ProjectionEvent = TodoAdded;
+
+      describe('Should aggregate todo counts', () => {
+        let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+        beforeEach(() => {
+          given = InMemoryProjectionSpec.for({ projection });
+        });
+
+        it('Todo added updates count', () =>
+          given([])
+            .when([
+              {
+                type: 'TodoAdded',
+                data: {
+                  todoId: 'todo_123',
+                  title: 'Buy milk',
+                },
+                metadata: {
+                  streamName: 'todos',
+                  streamPosition: 1n,
+                  globalPosition: 1n,
+                },
+              },
+            ])
+            .then(async (state) => {
+              const document = await state.database.collection<TodoSummary>('TodoSummaryProjection').findOne();
+
+              const expected: TodoSummary = {
+                totalCount: 1,
+              };
+
+              expect(document).toMatchObject(expected);
+            }));
+      });
+      "
+    `);
+  });
+
+  it('should generate a valid test spec for composite key projection', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'user-project-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'manage-user-project',
+              stream: 'user-project-${userId}-${projectId}',
+              client: { description: '' },
+              server: {
+                description: '',
+                specs: {
+                  name: 'Manage user project command',
+                  rules: [
+                    {
+                      description: 'Should handle user project operations',
+                      examples: [
+                        {
+                          description: 'User joins project',
+                          when: {
+                            commandRef: 'JoinProject',
+                            exampleData: {
+                              userId: 'user_123',
+                              projectId: 'proj_456',
+                              role: 'developer',
+                            },
+                          },
+                          then: [
+                            {
+                              eventRef: 'UserJoinedProject',
+                              exampleData: {
+                                userId: 'user_123',
+                                projectId: 'proj_456',
+                                role: 'developer',
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+            {
+              type: 'query',
+              name: 'view-user-projects',
+              stream: 'user-projects',
+              client: { description: '' },
+              server: {
+                description: '',
+                data: [
+                  {
+                    target: {
+                      type: 'State',
+                      name: 'UserProject',
+                    },
+                    origin: {
+                      type: 'projection',
+                      name: 'UserProjectsProjection',
+                      idField: ['userId', 'projectId'],
+                    },
+                  },
+                ],
+                specs: {
+                  name: 'View user projects query',
+                  rules: [
+                    {
+                      description: 'Should track user project memberships',
+                      examples: [
+                        {
+                          description: 'User joins project',
+                          when: [
+                            {
+                              eventRef: 'UserJoinedProject',
+                              exampleData: {
+                                userId: 'user_123',
+                                projectId: 'proj_456',
+                                role: 'developer',
+                              },
+                            },
+                          ],
+                          then: [
+                            {
+                              stateRef: 'UserProject',
+                              exampleData: {
+                                userId: 'user_123',
+                                projectId: 'proj_456',
+                                role: 'developer',
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'JoinProject',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'projectId', type: 'string', required: true },
+            { name: 'role', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'UserJoinedProject',
+          source: 'internal',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'projectId', type: 'string', required: true },
+            { name: 'role', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'UserProject',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'projectId', type: 'string', required: true },
+            { name: 'role', type: 'string', 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-projects/projection.specs.ts'));
+
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, it, beforeEach, expect } from 'vitest';
+      import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
+      import { projection } from './projection';
+      import type { UserJoinedProject } from '../manage-user-project/events';
+      import { UserProject } from './state';
+
+      type ProjectionEvent = UserJoinedProject;
+
+      describe('Should track user project memberships', () => {
+        let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+        beforeEach(() => {
+          given = InMemoryProjectionSpec.for({ projection });
+        });
+
+        it('User joins project', () =>
+          given([])
+            .when([
+              {
+                type: 'UserJoinedProject',
+                data: {
+                  userId: 'user_123',
+                  projectId: 'proj_456',
+                  role: 'developer',
+                },
+                metadata: {
+                  streamName: 'user-projects',
+                  streamPosition: 1n,
+                  globalPosition: 1n,
+                },
+              },
+            ])
+            .then(async (state) => {
+              const document = await state.database
+                .collection<UserProject>('UserProjectsProjection')
+                .findOne((doc) => doc.id === 'test-id');
+
+              const expected: UserProject = {
+                userId: 'user_123',
+                projectId: 'proj_456',
+                role: 'developer',
+              };
+
+              expect(document).toMatchObject(expected);
+            }));
+      });
+      "
+    `);
+  });
 });