@auto-engineer/server-generator-apollo-emmett 1.72.0 → 1.74.0

package/ketchup-plan.md

@@ -1,10 +1,8 @@
-# Ketchup Plan: Fix react slice scaffold ignoring Given states
+# Ketchup Plan: Fix query resolver collection name casing mismatch
 
 ## TODO
 
 ## DONE
 
-- [x] Burst 3: Generate real commandSender.send() in react.ts.ejs with field-source mapping (89610315)
-
-- [x] Burst 1: Fix react.specs.ts.ejs — seed event store with Given state data via appendToStream (0afa65ca)
-- [x] Burst 2: Fix react.ts.ejs — generate aggregateStream pattern when Given states exist (8380e5a2)
+- [x] Burst 1: Add regression test + fix EJS template to use projectionName for collection name (5df3ae89)
+- [x] Burst 2: Remove unused projectionType from scaffoldFromSchema template locals

package/package.json

@@ -32,8 +32,8 @@
     "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
     "zod": "^3.22.4",
-    "@auto-engineer/narrative": "1.72.0",
-    "@auto-engineer/message-bus": "1.72.0"
+    "@auto-engineer/narrative": "1.74.0",
+    "@auto-engineer/message-bus": "1.74.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.72.0"
+    "@auto-engineer/cli": "1.74.0"
   },
-  "version": "1.72.0",
+  "version": "1.74.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/scaffoldFromSchema.ts

@@ -608,7 +608,6 @@ async function prepareTemplateData(
     projectionIdField,
     projectionSingleton,
     projectionName,
-    projectionType: projectionName != null ? pascalCase(projectionName) : undefined,
     parsedRequest: slice.type === 'query' && slice.request != null ? parseGraphQlRequest(slice.request) : undefined,
     messages: allMessages,
     message:

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

@@ -957,6 +957,128 @@ describe('query.resolver.ts.ejs', () => {
     `);
   });
 
+  it('should use original-case projection name as collection name, not PascalCase', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'video-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'browse-videos',
+              request: `
+                query BrowseVideos($category: String) {
+                  browseVideos(category: $category) {
+                    videoId
+                    title
+                  }
+                }
+              `,
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      origin: {
+                        type: 'projection',
+                        idField: 'videoId',
+                        name: 'videos',
+                      },
+                      target: {
+                        type: 'State',
+                        name: 'VideoListing',
+                      },
+                    },
+                  ],
+                },
+                specs: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'VideoListing',
+          fields: [
+            { name: 'videoId', type: 'string', required: true },
+            { name: 'title', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain("new ReadModel<VideoListing>(ctx.database, 'videos')");
+    expect(resolverFile?.contents).not.toContain("'Videos'");
+  });
+
+  it('should use original-case projection name in singleton collection lookup', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'video-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'views-video-stats',
+              request: `
+                query VideoStats {
+                  videoStats {
+                    totalViews
+                    totalVideos
+                  }
+                }
+              `,
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      origin: {
+                        type: 'projection',
+                        name: 'videoStats',
+                        singleton: true,
+                      },
+                      target: {
+                        type: 'State',
+                        name: 'VideoStats',
+                      },
+                    },
+                  ],
+                },
+                specs: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'VideoStats',
+          fields: [
+            { name: 'totalViews', type: 'number', required: true },
+            { name: 'totalVideos', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain("ctx.database.collection<VideoStats>('videoStats').findOne()");
+    expect(resolverFile?.contents).not.toContain("'VideoStats'");
+  });
+
   it('should generate @ObjectType classes for referenced message types', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',

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

@@ -4,7 +4,7 @@ const projection = slice?.server?.data?.items?.[0]?.origin;
 const isSingleton = projection?.singleton === true;
 const queryName = parsedRequest?.queryName ?? camelCase(sliceName);
 const viewType = target?.name ? pascalCase(target.name) : 'UnknownView';
-const projectionType = projection?.name ? pascalCase(projection.name) : 'UnknownProjection';
+const collectionName = projectionName || 'unknown-collection';
 const message = messages?.find(m => m.name === viewType);
 const resolverClassName = `${pascalCase(slice.name)}QueryResolver`;
 const usesID = parsedRequest?.args?.some(arg => graphqlType(arg.tsType) === 'ID');
@@ -111,7 +111,7 @@ async <%= queryName %>(
 %>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
 <%   } } %>
 ): Promise<<%= viewType %>> {
-  const result = await ctx.database.collection<<%= viewType %>>('<%= projectionType %>').findOne();
+  const result = await ctx.database.collection<<%= viewType %>>('<%= collectionName %>').findOne();
 
   if (!result) {
     return {
@@ -154,7 +154,7 @@ async <%= queryName %>(
 %>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
 <%   } } %>
 ): Promise<<%= viewType %>[]> {
-const model = new ReadModel<<%= viewType %>>(ctx.database, '<%= projectionType %>');
+const model = new ReadModel<<%= viewType %>>(ctx.database, '<%= collectionName %>');
 
 // ## IMPLEMENTATION INSTRUCTIONS ##
 // You can query the projection using the ReadModel API: