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

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @auto-engineer/server-generator-apollo-emmett@0.11.15 build /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
+> @auto-engineer/server-generator-apollo-emmett@0.11.17 build /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
 > 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
 
 Fixed ESM imports in dist/

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @auto-engineer/server-generator-apollo-emmett
 
+## 0.11.17
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @auto-engineer/narrative@0.11.17
+  - @auto-engineer/message-bus@0.11.17
+
+## 0.11.16
+
+### Patch Changes
+
+- version bump
+
+- Updated dependencies []:
+  - @auto-engineer/message-bus@0.11.16
+  - @auto-engineer/narrative@0.11.16
+
 ## 0.11.15
 
 ### Patch Changes

package/dist/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/dist/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/dist/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/dist/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;
 });
 }
+<% } %>
 }