@auto-engineer/server-generator-apollo-emmett 1.45.3 → 1.47.0

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

@@ -833,4 +833,250 @@ describe('query.resolver.ts.ejs', () => {
     expect(resolverFile?.contents).toContain('sets!: { reps: number; weight: number }[];');
     expect(resolverFile?.contents).toContain('@Field(() => [GraphQLJSON])');
   });
+
+  it('should use message type name in graphqlType and not treat it as enum', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'recipe-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'find-recipe-matches',
+              request: `
+                query FindRecipeMatches($pantryId: ID!) {
+                  recipeMatches(pantryId: $pantryId) {
+                    recipeName
+                    missingIngredients {
+                      name
+                      amount
+                    }
+                  }
+                }
+              `,
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      origin: {
+                        type: 'projection',
+                        idField: 'pantryId',
+                        name: 'RecipeMatchesProjection',
+                      },
+                      target: {
+                        type: 'State',
+                        name: 'RecipeMatchesRecipes',
+                      },
+                    },
+                  ],
+                },
+                specs: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'Ingredient',
+          fields: [
+            { name: 'name', type: 'string' },
+            { name: 'amount', type: 'number' },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'RecipeMatchesRecipes',
+          fields: [
+            { name: 'recipeName', type: 'string', required: true },
+            { name: 'missingIngredients', type: 'Array<Ingredient>', 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).toMatchInlineSnapshot(`
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID, Float } from 'type-graphql';
+      import { type GraphQLContext, ReadModel } from '../../../shared';
+
+      @ObjectType()
+      export class Ingredient {
+        @Field(() => String)
+        name!: string;
+
+        @Field(() => Float)
+        amount!: number;
+      }
+
+      @ObjectType()
+      export class RecipeMatchesRecipes {
+        @Field(() => String)
+        recipeName!: string;
+
+        @Field(() => [Ingredient])
+        missingIngredients!: Ingredient[];
+
+        // IMPORTANT: Index signature required for ReadModel<T extends Record<string, unknown>> compatibility
+        [key: string]: unknown;
+      }
+
+      @Resolver()
+      export class FindRecipeMatchesQueryResolver {
+        @Query(() => [RecipeMatchesRecipes])
+        async recipeMatches(
+          @Ctx() ctx: GraphQLContext,
+          @Arg('pantryId', () => ID, { nullable: true }) pantryId?: string,
+        ): Promise<RecipeMatchesRecipes[]> {
+          const model = new ReadModel<RecipeMatchesRecipes>(ctx.database, 'RecipeMatchesProjection');
+
+          // ## IMPLEMENTATION INSTRUCTIONS ##
+          // You can query the projection using the ReadModel API:
+          // - model.getAll() — fetch all documents
+          // - model.getById(id) — fetch a single document by ID (default key: 'id')
+          // - model.find(filterFn) — filter documents using a predicate
+          // - model.first(filterFn) — fetch the first document matching a predicate
+          //
+          // Example below uses \\\`.find()\\\` to filter
+          // change the logic for the query as needed to meet the requirements for the current slice.
+
+          return model.find((item) => {
+            if (pantryId !== undefined && item.pantryId !== pantryId) return false;
+
+            return true;
+          });
+        }
+      }
+      "
+    `);
+  });
+
+  it('should generate @ObjectType classes for referenced message types', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'recipe-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'find-recipe-matches',
+              request: `
+                query FindRecipeMatches($pantryId: ID!) {
+                  recipeMatches(pantryId: $pantryId) {
+                    recipeName
+                    missingIngredients {
+                      name
+                      amount
+                    }
+                  }
+                }
+              `,
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      origin: {
+                        type: 'projection',
+                        idField: 'pantryId',
+                        name: 'RecipeMatchesProjection',
+                      },
+                      target: {
+                        type: 'State',
+                        name: 'RecipeMatchesRecipes',
+                      },
+                    },
+                  ],
+                },
+                specs: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'Ingredient',
+          fields: [
+            { name: 'name', type: 'string' },
+            { name: 'amount', type: 'number' },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'RecipeMatchesRecipes',
+          fields: [
+            { name: 'recipeName', type: 'string', required: true },
+            { name: 'missingIngredients', type: 'Array<Ingredient>', 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).toMatchInlineSnapshot(`
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID, Float } from 'type-graphql';
+      import { type GraphQLContext, ReadModel } from '../../../shared';
+
+      @ObjectType()
+      export class Ingredient {
+        @Field(() => String)
+        name!: string;
+
+        @Field(() => Float)
+        amount!: number;
+      }
+
+      @ObjectType()
+      export class RecipeMatchesRecipes {
+        @Field(() => String)
+        recipeName!: string;
+
+        @Field(() => [Ingredient])
+        missingIngredients!: Ingredient[];
+
+        // IMPORTANT: Index signature required for ReadModel<T extends Record<string, unknown>> compatibility
+        [key: string]: unknown;
+      }
+
+      @Resolver()
+      export class FindRecipeMatchesQueryResolver {
+        @Query(() => [RecipeMatchesRecipes])
+        async recipeMatches(
+          @Ctx() ctx: GraphQLContext,
+          @Arg('pantryId', () => ID, { nullable: true }) pantryId?: string,
+        ): Promise<RecipeMatchesRecipes[]> {
+          const model = new ReadModel<RecipeMatchesRecipes>(ctx.database, 'RecipeMatchesProjection');
+
+          // ## IMPLEMENTATION INSTRUCTIONS ##
+          // You can query the projection using the ReadModel API:
+          // - model.getAll() — fetch all documents
+          // - model.getById(id) — fetch a single document by ID (default key: 'id')
+          // - model.find(filterFn) — filter documents using a predicate
+          // - model.first(filterFn) — fetch the first document matching a predicate
+          //
+          // Example below uses \\\`.find()\\\` to filter
+          // change the logic for the query as needed to meet the requirements for the current slice.
+
+          return model.find((item) => {
+            if (pantryId !== undefined && item.pantryId !== pantryId) return false;
+
+            return true;
+          });
+        }
+      }
+      "
+    `);
+  });
 });

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

@@ -10,14 +10,16 @@ const resolverClassName = `${pascalCase(slice.name)}QueryResolver`;
 const usesID = parsedRequest?.args?.some(arg => graphqlType(arg.tsType) === 'ID');
 
 const messageFields = message?.fields ?? [];
-const usesDate = messageFields.some(f => fieldUsesDate(f.type)) ||
+const refFields = (referencedTypes ?? []).flatMap(rt => rt.fields ?? []);
+const usesDate = [...messageFields, ...refFields].some(f => fieldUsesDate(f.type)) ||
         (parsedRequest?.args ?? []).some(a => fieldUsesDate(a.tsType));
-const usesJSON = messageFields.some(f => fieldUsesJSON(f.type)) ||
+const usesJSON = [...messageFields, ...refFields].some(f => fieldUsesJSON(f.type)) ||
         (parsedRequest?.args ?? []).some(a => fieldUsesJSON(a.tsType));
-const usesFloat = messageFields.some(f => fieldUsesFloat(f.type)) ||
+const usesFloat = [...messageFields, ...refFields].some(f => fieldUsesFloat(f.type)) ||
         (parsedRequest?.args ?? []).some(a => fieldUsesFloat(a.tsType));
 
-const enumList = collectEnumNames([...messageFields, ...(parsedRequest?.args ?? [])]);
+const enumList = collectEnumNames([...messageFields, ...(parsedRequest?.args ?? []), ...refFields]);
+const filteredReferencedTypes = (referencedTypes ?? []).filter(rt => rt.name !== viewType);
 
 const embeddedTypes = [];
 for (const field of messageFields) {
@@ -51,6 +53,23 @@ export class <%= typeName %> {
 <% } %>
 }
 <% } %>
+<% for (const ref of filteredReferencedTypes) {
+    const parsedRefFields = (ref.fields ?? []).map(f => ({
+        name: f.name,
+        tsType: f.type ?? 'string',
+        gqlType: graphqlType(f.type ?? 'string'),
+        nullable: isNullable(f.type ?? 'string'),
+    }));
+%>
+
+@ObjectType()
+export class <%= ref.name %> {
+<% for (const f of parsedRefFields) { %>
+    @Field(() => <%= f.gqlType %><%= f.nullable ? ', { nullable: true }' : '' %>)
+    <%= f.name %><%= f.nullable ? '?' : '!' %>: <%= toTsFieldType(f.tsType) %>;
+<% } %>
+}
+<% } %>
 
 @ObjectType()
 export class <%= viewType %> {
@@ -110,7 +129,9 @@ async <%= queryName %>(
       defaultValue = 'false';
     } else if (baseType === 'Date') {
       defaultValue = 'new Date()';
-    } else if (baseType.startsWith('Array<')) {
+    } else if (messageNames && messageNames.has(baseType)) {
+      defaultValue = '{}';
+    } else if (baseType.startsWith('Array<') || baseType.endsWith('[]')) {
       defaultValue = '[]';
     } else if (isEnumType(baseType)) {
       const firstValue = baseType.match(/['"]([^'"]+)['"]/)?.[1] ?? '';