@auto-engineer/server-generator-apollo-emmett 0.8.4 → 0.8.6

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/flow';
 
 describe('query.resolver.ts.ejs', () => {
   it('should generate a valid query resolver from request field', async () => {
@@ -26,7 +26,6 @@ describe('query.resolver.ts.ejs', () => {
               `,
               client: {
                 description: '',
-                specs: [],
               },
               server: {
                 description: '',
@@ -79,13 +78,13 @@ describe('query.resolver.ts.ejs', () => {
         @Field(() => String)
         title!: string;
 
-        @Field(() => Number)
+        @Field(() => Float)
         pricePerNight!: number;
 
         @Field(() => String)
         location!: string;
 
-        @Field(() => Number)
+        @Field(() => Float)
         maxGuests!: number;
 
         [key: string]: unknown;
@@ -97,20 +96,19 @@ describe('query.resolver.ts.ejs', () => {
         async searchProperties(
           @Ctx() ctx: GraphQLContext,
           @Arg('location', () => String, { nullable: true }) location?: string,
-          @Arg('maxPrice', () => Number, { nullable: true }) maxPrice?: number,
-          @Arg('minGuests', () => Number, { nullable: true }) minGuests?: number,
+          @Arg('maxPrice', () => Float, { nullable: true }) maxPrice?: number,
+          @Arg('minGuests', () => Float, { nullable: true }) minGuests?: number,
         ): Promise<AvailableListings[]> {
           const model = new ReadModel<AvailableListings>(ctx.eventStore, 'AvailablePropertiesProjection');
 
           // ## 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
+          // 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) => {
@@ -150,7 +148,7 @@ describe('query.resolver.ts.ejs', () => {
                 }
               }
             `,
-              client: { description: '', specs: [] },
+              client: { description: '' },
               server: {
                 description: '',
                 data: [
@@ -195,17 +193,6 @@ describe('query.resolver.ts.ejs', () => {
       "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from 'type-graphql';
       import { type GraphQLContext, ReadModel } from '../../../shared';
 
-      @ObjectType()
-      export class SuggestedItems {
-        @Field(() => String)
-        sessionId!: string;
-
-        @Field(() => [SuggestedItemsItems])
-        items!: SuggestedItemsItems[];
-
-        [key: string]: unknown;
-      }
-
       @ObjectType()
       export class SuggestedItemsItems {
         @Field(() => String)
@@ -214,13 +201,24 @@ describe('query.resolver.ts.ejs', () => {
         @Field(() => String)
         name!: string;
 
-        @Field(() => Number)
+        @Field(() => Float)
         quantity!: number;
 
         @Field(() => String)
         reason!: string;
       }
 
+      @ObjectType()
+      export class SuggestedItems {
+        @Field(() => String)
+        sessionId!: string;
+
+        @Field(() => [SuggestedItemsItems])
+        items!: SuggestedItemsItems[];
+
+        [key: string]: unknown;
+      }
+
       @Resolver()
       export class ViewsSuggestedItemsQueryResolver {
         @Query(() => [SuggestedItems])
@@ -232,13 +230,12 @@ describe('query.resolver.ts.ejs', () => {
 
           // ## 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
+          // 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) => {
@@ -251,4 +248,178 @@ describe('query.resolver.ts.ejs', () => {
       "
     `);
   });
+  it('should generate the query resolver for "views the questionnaire"', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'Questionnaires',
+          slices: [
+            {
+              name: 'views the questionnaire',
+              type: 'query',
+              client: {
+                description: '',
+                specs: {
+                  name: '',
+                  rules: [
+                    'focus on the current question based on the progress state',
+                    'display the list of answered questions',
+                    'display the list of remaining questions',
+                    'show a progress indicator that is always visible as the user scrolls',
+                  ],
+                },
+              },
+              request:
+                'query QuestionnaireProgress($participantId: ID!) {\n  questionnaireProgress(participantId: $participantId) {\n    questionnaireId\n    participantId\n    status\n    currentQuestionId\n    remainingQuestions\n    answers {\n      questionId\n      value\n    }\n  }\n}',
+              server: {
+                description: '',
+                data: [
+                  {
+                    target: { type: 'State', name: 'QuestionnaireProgress' },
+                    origin: { type: 'projection', name: 'Questionnaires', idField: 'questionnaire-participantId' },
+                  },
+                ],
+                specs: {
+                  name: '',
+                  rules: [
+                    {
+                      description: 'questionnaires show current progress',
+                      examples: [
+                        {
+                          description: 'a question has already been answered',
+                          given: [
+                            {
+                              eventRef: 'QuestionAnswered',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                                link: 'https://app.example.com/q/q-001?participant=participant-abc',
+                                sentAt: '2030-01-01T09:00:00.000Z',
+                              },
+                            },
+                            {
+                              eventRef: 'QuestionAnswered',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                                questionId: 'q1',
+                                answer: 'Yes',
+                                savedAt: '2030-01-01T09:05:00.000Z',
+                              },
+                            },
+                          ],
+                          when: { exampleData: {}, eventRef: 'QuestionnaireLinkSent' },
+                          then: [
+                            {
+                              stateRef: 'QuestionnaireProgress',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                                status: 'in_progress',
+                                currentQuestionId: 'q2',
+                                remainingQuestions: ['q2', 'q3'],
+                                answers: [{ questionId: 'q1', value: 'Yes' }],
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'QuestionnaireProgress',
+          fields: [
+            { name: 'questionnaireId', type: 'string', required: true },
+            { name: 'participantId', type: 'string', required: true },
+            { name: 'status', type: '"in_progress" | "ready_to_submit" | "submitted"', required: true },
+            { name: 'currentQuestionId', type: 'string | null', required: true },
+            { name: 'remainingQuestions', type: 'Array<string>', required: true },
+            { name: 'answers', type: 'Array<{ questionId: string; value: unknown }>', required: true },
+          ],
+          metadata: { version: 1 },
+        },
+      ],
+      integrations: [],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const queryFile = plans.find(
+      (p) => p.outputPath.endsWith('query.resolver.ts') && p.contents.includes('ViewsTheQuestionnaireQueryResolver'),
+    );
+
+    expect(queryFile?.contents).toMatchInlineSnapshot(`
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from 'type-graphql';
+      import { GraphQLJSON } from 'graphql-type-json';
+      import { type GraphQLContext, ReadModel } from '../../../shared';
+
+      @ObjectType()
+      export class QuestionnaireProgressAnswers {
+        @Field(() => String)
+        questionId!: string;
+
+        @Field(() => GraphQLJSON)
+        value!: unknown;
+      }
+
+      @ObjectType()
+      export class QuestionnaireProgress {
+        @Field(() => String)
+        questionnaireId!: string;
+
+        @Field(() => String)
+        participantId!: string;
+
+        @Field(() => String)
+        status!: 'in_progress' | 'ready_to_submit' | 'submitted';
+
+        @Field(() => String, { nullable: true })
+        currentQuestionId?: string | null;
+
+        @Field(() => [String])
+        remainingQuestions!: string[];
+
+        @Field(() => [QuestionnaireProgressAnswers])
+        answers!: QuestionnaireProgressAnswers[];
+
+        [key: string]: unknown;
+      }
+
+      @Resolver()
+      export class ViewsTheQuestionnaireQueryResolver {
+        @Query(() => [QuestionnaireProgress])
+        async questionnaireProgress(
+          @Ctx() ctx: GraphQLContext,
+          @Arg('participantId', () => ID, { nullable: true }) participantId?: string,
+        ): Promise<QuestionnaireProgress[]> {
+          const model = new ReadModel<QuestionnaireProgress>(ctx.eventStore, 'Questionnaires');
+
+          // ## 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 (participantId !== undefined && item.participantId !== participantId) return false;
+
+            return true;
+          });
+        }
+      }
+      "
+    `);
+  });
 });

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

@@ -8,90 +8,129 @@ const message = messages?.find(m => m.name === viewType);
 const resolverClassName = `${pascalCase(slice.name)}QueryResolver`;
 const usesID = parsedRequest?.args?.some(arg => graphqlType(arg.tsType) === 'ID');
 
+function isInlineObject(ts) {
+    return /^\{[\s\S]*\}$/.test((ts ?? '').trim());
+}
+function isInlineObjectArray(ts) {
+    const t = (ts ?? '').trim();
+    return /^Array<\{[\s\S]*\}>$/.test(t) || /^\{[\s\S]*\}\[\]$/.test(t);
+}
+function baseTs(ts) {
+    return (ts ?? 'string').replace(/\s*\|\s*null\b/g, '').trim();
+}
+function fieldUsesDate(ts) {
+    const b = baseTs(ts);
+    if (b === 'Date') return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*Date\b/.test(b);
+    return false;
+}
+function fieldUsesJSON(ts) {
+    const b = baseTs(ts);
+    if (b === 'unknown' || b === 'any' || b === 'object') return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*(unknown|any|object)\b/.test(b);
+    return false;
+}
+
+const messageFields = message?.fields ?? [];
+const usesDate = messageFields.some(f => fieldUsesDate(f.type)) ||
+        (parsedRequest?.args ?? []).some(a => baseTs(a.tsType) === 'Date');
+const usesJSON = messageFields.some(f => fieldUsesJSON(f.type));
+
+// Collect embedded types up-front so we can emit them before the parent
 const embeddedTypes = [];
-function getEmbeddedObjectTypeName(parentName, fieldName) {
-    return `${parentName}${pascalCase(fieldName)}`;
+for (const field of messageFields) {
+    const tsType = field.type ?? 'string';
+    if (isInlineObjectArray(tsType) || isInlineObject(tsType)) {
+        embeddedTypes.push({
+            typeName: `${viewType}${pascalCase(field.name)}`,
+            tsType,
+        });
+    }
 }
 %>
-import { Query, Resolver, Arg, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %> } from 'type-graphql';
-import { type GraphQLContext, ReadModel } from '../../../shared';
+import { Query, Resolver, Arg, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
+<% if (usesJSON) { %>import { GraphQLJSON } from 'graphql-type-json';
+<% } %>import { type GraphQLContext, ReadModel } from '../../../shared';
+
+<% // Emit embedded types FIRST — this matches your snapshot order
+        for (const { typeName, tsType } of embeddedTypes) {
+    // Extract inner "{ ... }" whether Array<{...}> or "{...}[]"
+    const inner = tsType.trim().startsWith('Array<')
+            ? tsType.trim().replace(/^Array<\{/, '{').replace(/}>$/, '}')
+            : tsType.trim().replace(/\[\]$/, '');
+    const match = inner.match(/^\{([\s\S]*)\}$/);
+    const body = match ? match[1] : '';
+    const rawFields = body.split(/[,;]\s*/).filter(Boolean);
+    const parsedFields = rawFields.map(f => {
+        const parts = f.split(':');
+        const name = parts[0]?.trim();
+        const type = parts.slice(1).join(':').trim();
+        if (!name || !type) return null;
+        return { name, tsType: type, gqlType: graphqlType(type), nullable: isNullable(type) };
+    }).filter(Boolean);
+%>
+@ObjectType()
+export class <%= typeName %> {
+<% for (const f of parsedFields) { %>
+    @Field(() => <%= f.gqlType %><%= f.nullable ? ', { nullable: true }' : '' %>)
+    <%= f.name %><%= f.nullable ? '?' : '!' %>: <%= toTsFieldType(f.tsType) %>;
+<% } %>
+}
+<% } %>
 
 @ObjectType()
 export class <%= viewType %> {
-<% if (message?.fields?.length) {
-        for (const field of message.fields) {
-    const gqlType = graphqlType(field.type ?? 'string');
+<% if (messageFields.length) {
+        for (const field of messageFields) {
     const tsType = field.type ?? 'string';
-    const isInlineArray = tsType.startsWith('Array<{') || tsType.startsWith('{') || tsType.includes('[]');
-    const fieldTypeName = getEmbeddedObjectTypeName(viewType, field.name);
-
-if (isInlineArray) {
-    embeddedTypes.push({ parentName: viewType, fieldName: field.name, typeName: fieldTypeName, tsType });
+    const gqlType = graphqlType(tsType);
+    const typeName = `${viewType}${pascalCase(field.name)}`;
 %>
-@Field(() => [<%= fieldTypeName %>])
-<%= field.name %>!: <%= fieldTypeName %>[];
-<%      } else { %>
-    @Field(() => <%= gqlType %>)
-    <%= field.name %>!: <%= tsType %>;
-<%      }
-} %>
+<% if (isInlineObjectArray(tsType)) { %>
+    @Field(() => [<%= typeName %>])
+    <%= field.name %>!: <%= typeName %>[];
+<% } else if (isInlineObject(tsType)) { %>
+    @Field(() => <%= typeName %>)
+    <%= field.name %>!: <%= typeName %>;
+<% } else { %>
+    @Field(() => <%= gqlType %><%= isNullable(tsType) ? ', { nullable: true }' : '' %>)
+    <%= field.name %><%= isNullable(tsType) ? '?' : '!' %>: <%= toTsFieldType(tsType) %>;
+<% } } %>
 [key: string]: unknown;
 <% } else { %>
     [key: string]: unknown;
 <% } %>
 }
 
-<% for (const { typeName, tsType } of embeddedTypes) {
-    const match = tsType.match(/Array<\{([^}]*)\}>/);
-    const rawFields = match?.[1]?.split(/[,;]/) ?? [];
-    const parsedFields = rawFields
-            .map(f => {
-                const [name, type] = f.trim().split(':').map(x => x.trim());
-                if (!name || !type) return null;
-                return { name, tsType: type, gqlType: graphqlType(type) };
-            })
-            .filter(Boolean);
-%>
-
-@ObjectType()
-export class <%= typeName %> {
-<% for (const f of parsedFields) { %>
-    @Field(() => <%= f.gqlType %>)
-    <%= f.name %>!: <%= f.tsType %>;
-<% } %>
-}
-<% } %>
-
 @Resolver()
 export class <%= resolverClassName %> {
 @Query(() => [<%= viewType %>])
 async <%= queryName %>(
 @Ctx() ctx: GraphQLContext<% if (parsedRequest?.args?.length) { %>,
-<%     for (let i = 0; i < parsedRequest.args.length; i++) {
+<%   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 model = new ReadModel<<%= viewType %>>(ctx.eventStore, '<%= projectionType %>');
 
 // ## 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
+// 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 (parsedRequest?.args?.length) {
         for (const arg of parsedRequest.args) { %>
     if (<%= arg.name %> !== undefined && item.<%= arg.name %> !== <%= arg.name %>) return false;
-<%    } } %>
+<% } } %>
 return true;
 });
 }

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/flow';
 
 describe('state.ts.ejs', () => {
   it('should generate a valid state definition file for a query slice with a state message', async () => {
@@ -15,7 +15,6 @@ describe('state.ts.ejs', () => {
               name: 'Get available items',
               client: {
                 description: 'Client view of available items',
-                specs: [],
               },
               server: {
                 description: 'Projects available items',

package/src/codegen/templates/react/react.specs.specs.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/flow';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
 
 describe('react.specs.ts.ejs (react slice)', () => {
@@ -13,7 +13,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
             {
               type: 'command',
               name: 'guest submits booking request',
-              client: { description: '', specs: [] },
+              client: { description: '' },
               server: {
                 description: '',
                 specs: {

package/src/codegen/templates/react/react.specs.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/flow';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
 
 describe('handle.ts.ejs (react slice)', () => {
@@ -13,7 +13,7 @@ describe('handle.ts.ejs (react slice)', () => {
             {
               type: 'command',
               name: 'guest submits booking request',
-              client: { description: '', specs: [] },
+              client: { description: '' },
               server: {
                 description: '',
                 specs: {
@@ -116,7 +116,7 @@ describe('handle.ts.ejs (react slice)', () => {
             {
               type: 'command',
               name: 'notify host',
-              client: { description: '', specs: [] },
+              client: { description: '' },
               server: {
                 description: '',
                 specs: {

package/src/codegen/templates/react/register.specs.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/flow';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
 
 describe('register.ts.ejs (react slice)', () => {
@@ -13,7 +13,7 @@ describe('register.ts.ejs (react slice)', () => {
             {
               type: 'command',
               name: 'guest submits booking request',
-              client: { description: '', specs: [] },
+              client: { description: '' },
               server: {
                 description: '',
                 specs: {
@@ -116,7 +116,7 @@ describe('register.ts.ejs (react slice)', () => {
             {
               type: 'command',
               name: 'notify host',
-              client: { description: '', specs: [] },
+              client: { description: '' },
               server: {
                 description: '',
                 specs: {

package/src/codegen/test-data/specVariant1.ts

@@ -1,4 +1,4 @@
-import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/flow';
 
 const specVariant1: SpecsSchema = {
   variant: 'specs',
@@ -14,7 +14,10 @@ const specVariant1: SpecsSchema = {
           description: 'Handles item creation',
           client: {
             description: 'A form that allows users to add items',
-            specs: ['have fields for id and description'],
+            specs: {
+              name: 'A form that allows users to add items',
+              rules: ['have fields for id and description'],
+            },
           },
 
           server: {
@@ -57,7 +60,6 @@ const specVariant1: SpecsSchema = {
           description: 'Projection of available items',
           client: {
             description: 'Show available items',
-            specs: [],
           },
           server: {
             description: 'Project items based on ItemCreated',