@auto-engineer/server-generator-apollo-emmett 0.11.14 → 0.11.16

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/message-bus": "0.11.14",
-    "@auto-engineer/narrative": "0.11.14"
+    "@auto-engineer/narrative": "0.11.16",
+    "@auto-engineer/message-bus": "0.11.16"
   },
   "publishConfig": {
     "access": "public"
@@ -43,9 +43,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "0.11.14"
+    "@auto-engineer/cli": "0.11.16"
   },
-  "version": "0.11.14",
+  "version": "0.11.16",
   "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/command/mutation.resolver.specs.ts

@@ -76,7 +76,7 @@ describe('mutation.resolver.ts.ejs', () => {
     const mutationFile = plans.find((p) => p.outputPath.endsWith('mutation.resolver.ts'));
 
     expect(mutationFile?.contents).toMatchInlineSnapshot(`
-      "import { Mutation, Resolver, Arg, Ctx, Field, InputType, GraphQLISODateTime } from 'type-graphql';
+      "import { Mutation, Resolver, Arg, Ctx, Field, InputType, Float, GraphQLISODateTime } from 'type-graphql';
       import { GraphQLJSON } from 'graphql-type-json';
       import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
 
@@ -322,7 +322,7 @@ describe('mutation.resolver.ts.ejs', () => {
     );
 
     expect(mutationFile?.contents).toMatchInlineSnapshot(`
-"import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
+"import { Mutation, Resolver, Arg, Ctx, Field, InputType, Float } from 'type-graphql';
 import { GraphQLJSON } from 'graphql-type-json';
 import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
 
@@ -361,4 +361,68 @@ export class AddItemsToCartResolver {
 "
 `);
   });
+
+  it('should import Float when Float fields are used', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'product-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'update-product-price',
+              client: {
+                description: '',
+              },
+              server: {
+                description: '',
+                specs: {
+                  name: '',
+                  rules: [
+                    {
+                      description: 'update price',
+                      examples: [
+                        {
+                          description: 'happy path',
+                          when: {
+                            commandRef: 'UpdateProductPrice',
+                            exampleData: {
+                              productId: 'p-1',
+                              price: 99.99,
+                              discount: 10.5,
+                            },
+                          },
+                          then: [],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'UpdateProductPrice',
+          fields: [
+            { name: 'productId', type: 'string', required: true },
+            { name: 'price', type: 'number', required: true },
+            { name: 'discount', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const mutationFile = plans.find((p) => p.outputPath.endsWith('mutation.resolver.ts'));
+
+    expect(mutationFile?.contents).toContain(
+      "import { Mutation, Resolver, Arg, Ctx, Field, InputType, Float } from 'type-graphql';",
+    );
+    expect(mutationFile?.contents).toContain('@Field(() => Float)');
+  });
 });

package/src/codegen/templates/command/mutation.resolver.ts.ejs

@@ -1,12 +1,13 @@
 <%
 const cmd = commands[0];
-const usesDate = cmd.fields.some(f => fieldUsesDate(f.tsType));
-const usesJSON = cmd.fields.some(f => fieldUsesJSON(f.tsType));
+const usesDate = cmd.fields.some(f => fieldUsesDate(f.type ?? f.tsType));
+const usesJSON = cmd.fields.some(f => fieldUsesJSON(f.type ?? f.tsType));
+const usesFloat = cmd.fields.some(f => fieldUsesFloat(f.type ?? f.tsType));
 const enumList = collectEnumNames(cmd.fields);
 
 const embeddedInputs = [];
 for (const f of cmd.fields) {
-    const tsType = f.tsType ?? 'string';
+    const tsType = f.type ?? f.tsType ?? 'string';
     if (isInlineObjectArray(tsType) || isInlineObject(tsType)) {
         embeddedInputs.push({
             typeName: `${pascalCase(cmd.type)}${pascalCase(f.name)}Input`,
@@ -15,7 +16,7 @@ for (const f of cmd.fields) {
     }
 }
 %>
-import { Mutation, Resolver, Arg, Ctx, Field, InputType<% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
+import { Mutation, Resolver, Arg, Ctx, Field, InputType<% if (usesFloat) { %>, Float<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
 <% if (usesJSON) { %>import { GraphQLJSON } from 'graphql-type-json';
 <% } %>import { type GraphQLContext, sendCommand, MutationResponse<% if (enumList.length > 0) { %>, <%= enumList.join(', ') %><% } %> } from '../../../shared';
 
@@ -46,7 +47,7 @@ export class <%= typeName %> {
 @InputType()
 export class <%= pascalCase(cmd.type) %>Input {
 <% for (const field of cmd.fields) {
-    const tsType = field.tsType ?? 'string';
+    const tsType = field.type ?? field.tsType ?? 'string';
     const gqlType = graphqlType(tsType);
     const nestedName = `${pascalCase(cmd.type)}${pascalCase(field.name)}Input`;
 

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

@@ -783,9 +783,7 @@ describe('projection.specs.ts.ejs', () => {
               },
             ])
             .then(async (state) => {
-              const document = await state.database
-                .collection<TodoSummary>('TodoSummaryProjection')
-                .findOne((doc) => doc.id === 'test-id');
+              const document = await state.database.collection<TodoSummary>('TodoSummaryProjection').findOne();
 
               const expected: TodoSummary = {
                 totalCount: 1,

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

@@ -239,7 +239,7 @@ describe('projection.ts.ejs', () => {
                *    }
                *
                * 2. Cast document parameter to extended type:
-               *    const current: InternalAvailableListings = (document as InternalAvailableListings) || { ...defaults };
+               *    const current: InternalAvailableListings = document ?? { ...defaults };
                *
                * 3. Cast return values to extended type:
                *    return { ...allFields, internalField } as InternalAvailableListings;
@@ -549,12 +549,16 @@ describe('projection.ts.ejs', () => {
                * CRITICAL: Use internal state to track individual entity information:
                *
                * 1. Access current state:
-               *    const current = (document as InternalTodoSummary) || { ...initialState, _entities: {} };
+               *    const current: InternalTodoSummary = document ?? { ...initialState, _entities: {} };
                *
                * 2. Track entity changes:
-               *    const entityId = event.data.todoId; // or relevant ID field
-               *    const prevStatus = current._entities?.[entityId]?.status;
-               *    current._entities[entityId] = { status: 'new_status', ...otherData };
+               *    // a) Extract the unique identifier that distinguishes this entity
+               *    //    Examine event.data to find the ID field (often 'id' or '<entity>Id')
+               *    const entityId = event.data.[ENTITY_ID_FIELD];
+               *
+               *    // b) Store/update entity state with relevant properties from event.data
+               *    //    Include only fields needed for aggregation calculations
+               *    current._entities[entityId] = { [field]: value, ... };
                *
                * 3. Calculate aggregates from entity states:
                *    const counts = Object.values(current._entities).reduce((acc, entity) => {

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

@@ -141,7 +141,9 @@ _%>
       .then(async (state) => {
         const document = await state.database
           .collection<<%= TargetType %>>('<%= projName %>')
-          .findOne((doc) => <%
+          .findOne(<% if (projectionSingleton) { %>);<%
+} else {
+%>(doc) => <%
 const idField = projectionIdField ?? 'id';
 if (idField.includes('-')) {
     // Handle composite keys
@@ -157,7 +159,9 @@ if (idField.includes('-')) {
     const valueStr = typeof value === 'string' ? `'${value}'` : value || "'test-id'";
 %>doc.<%= idField %> === <%= valueStr %><%
 }
-%>);
+%>);<%
+}
+%>
 
         const expected: <%= TargetType %> = {
 <% const stateKeys = Object.keys(expectedState.exampleData || {});

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

@@ -114,12 +114,16 @@ case '<%= event.type %>': {
     * CRITICAL: Use internal state to track individual entity information:
     *
     * 1. Access current state:
-    *    const current = (document as Internal<%= pascalCase(targetName || 'State') %>) || { ...initialState, _entities: {} };
+    *    const current: Internal<%= pascalCase(targetName || 'State') %> = document ?? { ...initialState, _entities: {} };
     *
     * 2. Track entity changes:
-    *    const entityId = event.data.todoId; // or relevant ID field
-    *    const prevStatus = current._entities?.[entityId]?.status;
-    *    current._entities[entityId] = { status: 'new_status', ...otherData };
+    *    // a) Extract the unique identifier that distinguishes this entity
+    *    //    Examine event.data to find the ID field (often 'id' or '<entity>Id')
+    *    const entityId = event.data.[ENTITY_ID_FIELD];
+    *
+    *    // b) Store/update entity state with relevant properties from event.data
+    *    //    Include only fields needed for aggregation calculations
+    *    current._entities[entityId] = { [field]: value, ... };
     *
     * 3. Calculate aggregates from entity states:
     *    const counts = Object.values(current._entities).reduce((acc, entity) => {
@@ -165,7 +169,7 @@ case '<%= event.type %>': {
     *    }
     *
     * 2. Cast document parameter to extended type:
-    *    const current: Internal<%= pascalCase(targetName || 'State') %> = (document as Internal<%= pascalCase(targetName || 'State') %>) || { ...defaults };
+    *    const current: Internal<%= pascalCase(targetName || 'State') %> = document ?? { ...defaults };
     *
     * 3. Cast return values to extended type:
     *    return { ...allFields, internalField } as Internal<%= pascalCase(targetName || 'State') %>;

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

@@ -610,4 +610,83 @@ describe('query.resolver.ts.ejs', () => {
     expect(resolverFile?.contents).toContain('Float');
     expect(resolverFile?.contents).toContain("@Arg('minPrice', () => Float");
   });
+
+  it('should generate a singleton query resolver that returns a single object', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'todo-list-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'views-completion-summary',
+              request: `
+                query TodoListSummary {
+                  todoListSummary {
+                    totalTodos
+                    pendingCount
+                    inProgressCount
+                    completedCount
+                    completionPercentage
+                  }
+                }
+              `,
+              client: {
+                description: '',
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      name: 'TodoSummary',
+                      singleton: true,
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'TodoListSummary',
+                    },
+                  },
+                ],
+                specs: { name: '', rules: [] },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'TodoListSummary',
+          fields: [
+            { 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 },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    // Should return single object, not array
+    expect(resolverFile?.contents).toContain('@Query(() => TodoListSummary)');
+    expect(resolverFile?.contents).not.toContain('@Query(() => [TodoListSummary])');
+
+    // Should use collection.findOne() pattern
+    expect(resolverFile?.contents).toContain("ctx.database.collection<TodoListSummary>('TodoSummary').findOne()");
+
+    expect(resolverFile?.contents).toContain('if (!result)');
+    expect(resolverFile?.contents).toContain('totalTodos: 0');
+    expect(resolverFile?.contents).toContain('pendingCount: 0');
+
+    // Should NOT import ReadModel (unused for singletons)
+    expect(resolverFile?.contents).toContain("import { type GraphQLContext } from '../../../shared'");
+    expect(resolverFile?.contents).not.toContain(', ReadModel');
+  });
 });

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

@@ -1,6 +1,7 @@
 <%
 const target = slice?.server?.data?.[0]?.target;
 const projection = slice?.server?.data?.[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';
@@ -32,7 +33,7 @@ const hasArgs = parsedRequest?.args?.length > 0;
 %>
 import { Query, Resolver<% if (hasArgs) { %>, Arg<% } %>, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesFloat) { %>, Float<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
 <% if (usesJSON) { %>import { GraphQLJSON } from 'graphql-type-json';
-<% } %>import { type GraphQLContext, ReadModel<% if (enumList.length > 0) { %>, <%= enumList.join(', ') %><% } %> } from '../../../shared';
+<% } %>import { type GraphQLContext<% if (!isSingleton) { %>, ReadModel<% } %><% if (enumList.length > 0) { %>, <%= enumList.join(', ') %><% } %> } from '../../../shared';
 
 <%
         for (const { typeName, tsType } of embeddedTypes) {
@@ -88,6 +89,48 @@ export class <%= viewType %> {
 
 @Resolver()
 export class <%= resolverClassName %> {
+<% if (isSingleton) { %>
+@Query(() => <%= viewType %>)
+async <%= queryName %>(
+@Ctx() ctx: GraphQLContext<% if (parsedRequest?.args?.length) { %>,
+<%   for (let i = 0; i < parsedRequest.args.length; i++) {
+    const arg = parsedRequest.args[i];
+    const gqlType = graphqlType(arg.tsType);
+    const tsType = arg.tsType === 'ID' ? 'string' : arg.tsType;
+%>    @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();
+
+  if (!result) {
+    return {
+<% for (let i = 0; i < messageFields.length; i++) {
+    const field = messageFields[i];
+    const tsType = field.type ?? 'string';
+    const baseType = tsType.replace(/\s*\|\s*null/g, '').trim();
+    let defaultValue = '0';
+
+    if (baseType === 'string' || baseType === 'ID') {
+      defaultValue = "''";
+    } else if (baseType === 'number') {
+      defaultValue = '0';
+    } else if (baseType === 'boolean') {
+      defaultValue = 'false';
+    } else if (baseType === 'Date') {
+      defaultValue = 'new Date()';
+    } else if (baseType.startsWith('Array<')) {
+      defaultValue = '[]';
+    } else if (baseType.includes('|') && (baseType.includes('"') || baseType.includes("'"))) {
+      const firstValue = baseType.match(/['"]([^'"]+)['"]/)?.[1] ?? '';
+      defaultValue = `'${firstValue}'`;
+    }
+%>      <%= field.name %>: <%= defaultValue %>,
+<% } %>    };
+  }
+
+  return result;
+}
+<% } else { %>
 @Query(() => [<%= viewType %>])
 async <%= queryName %>(
 @Ctx() ctx: GraphQLContext<% if (parsedRequest?.args?.length) { %>,
@@ -118,4 +161,5 @@ return model.find((<%= hasArgs ? 'item' : '_item' %>) => {
 return true;
 });
 }
+<% } %>
 }