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

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

@@ -1,23 +1,97 @@
-import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
-import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+<%
+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 cmd = commands[0];
+const usesDate = cmd.fields.some(f => fieldUsesDate(f.tsType));
+const usesJSON = cmd.fields.some(f => fieldUsesJSON(f.tsType));
+
+const embeddedInputs = [];
+for (const f of cmd.fields) {
+    const tsType = f.tsType ?? 'string';
+    if (isInlineObjectArray(tsType) || isInlineObject(tsType)) {
+        embeddedInputs.push({
+            typeName: `${pascalCase(cmd.type)}${pascalCase(f.name)}Input`,
+            tsType,
+        });
+    }
+}
+%>
+import { Mutation, Resolver, Arg, Ctx, Field, InputType<% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
+<% if (usesJSON) { %>import { GraphQLJSON } from 'graphql-type-json';
+<% } %>import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+
+<% for (const { typeName, tsType } of embeddedInputs) {
+    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);
+%>
+@InputType()
+export class <%= typeName %> {
+<% for (const f of parsedFields) { %>
+    @Field(() => <%= f.gqlType %><%= f.nullable ? ', { nullable: true }' : '' %>)
+    <%= f.name %><%= f.nullable ? '?' : '!' %>: <%= toTsFieldType(f.tsType) %>;
+<% } %>
+}
+<% } %>
 
 @InputType()
-export class <%= pascalCase(commands[0].type) %>Input {
-<% for (const field of commands[0].fields) { -%>
-    @Field(() => <%= graphqlType(field.tsType) %><%= field.required === false ? ', { nullable: true }' : '' %>)
-    <%= field.name %><%= field.required === false ? '?' : '' %><%= field.required !== false ? '!' : '' %>: <%- field.tsType %>;
-<% } -%>
+export class <%= pascalCase(cmd.type) %>Input {
+<% for (const field of cmd.fields) {
+    const tsType = field.tsType ?? 'string';
+    const gqlType = graphqlType(tsType);
+    const nestedName = `${pascalCase(cmd.type)}${pascalCase(field.name)}Input`;
+
+if (isInlineObjectArray(tsType)) { %>
+    @Field(() => [<%= nestedName %>]<%= (field.required === false || isNullable(tsType)) ? ', { nullable: true }' : '' %>)
+    <%= field.name %><%= field.required === false ? '?' : '!' %>: <%= nestedName %>[];
+<% } else if (isInlineObject(tsType)) { %>
+    @Field(() => <%= nestedName %><%= (field.required === false || isNullable(tsType)) ? ', { nullable: true }' : '' %>)
+    <%= field.name %><%= field.required === false ? '?' : '!' %>: <%= nestedName %>;
+<% } else { %>
+    @Field(() => <%= gqlType %><%= (field.required === false || isNullable(tsType)) ? ', { nullable: true }' : '' %>)
+    <%= field.name %><%= field.required === false ? '?' : '!' %>: <%= toTsFieldType(tsType) %>;
+<% } } %>
 }
 
 @Resolver()
-export class <%= pascalCase(commands[0].type) %>Resolver {
+export class <%= pascalCase(cmd.type) %>Resolver {
 @Mutation(() => MutationResponse)
-async <%= camelCase(commands[0].type) %>(
-@Arg('input', () => <%= pascalCase(commands[0].type) %>Input) input: <%= pascalCase(commands[0].type) %>Input,
-@Ctx() ctx: GraphQLContext
+async <%= camelCase(cmd.type) %>(
+@Arg('input', () => <%= pascalCase(cmd.type) %>Input) input: <%= pascalCase(cmd.type) %>Input,
+@Ctx() ctx: GraphQLContext,
 ): Promise<MutationResponse> {
     return await sendCommand(ctx.messageBus, {
-    type: '<%= commands[0].type %>',
+    type: '<%= cmd.type %>',
     kind: 'Command',
     data: { ...input },
     });

package/src/codegen/templates/command/register.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('generateScaffoldFilePlans', () => {
   it('should generate a valid register file', async () => {
@@ -16,7 +16,6 @@ describe('generateScaffoldFilePlans', () => {
               stream: 'listings-${propertyId}',
               client: {
                 description: 'test',
-                specs: [],
               },
               server: {
                 description: 'test',

package/src/codegen/templates/command/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 an initial state', async () => {
@@ -15,7 +15,6 @@ describe('state.ts.ejs', () => {
               name: 'Create listing',
               client: {
                 description: 'test',
-                specs: [],
               },
               server: {
                 description: 'test',

package/src/codegen/templates/query/projection.specs.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('projection.specs.ts.ejs', () => {
   it('should generate a valid test spec for a query slice projection', async () => {
@@ -14,7 +14,7 @@ describe('projection.specs.ts.ejs', () => {
               type: 'command',
               name: 'CreateListing',
               stream: 'listing-${propertyId}',
-              client: { description: '', specs: [] },
+              client: { description: '' },
               server: {
                 description: '',
                 specs: {
@@ -73,7 +73,7 @@ describe('projection.specs.ts.ejs', () => {
               type: 'query',
               name: 'search-listings',
               stream: 'listings',
-              client: { description: '', specs: [] },
+              client: { description: '' },
               server: {
                 description: '',
                 data: [

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

@@ -1,10 +1,10 @@
 import { describe, it, expect } from 'vitest';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+import { Model } from '@auto-engineer/flow';
 
 describe('projection.ts.ejs', () => {
   it('should generate a valid projection file with correct relative event import path from producing slice', async () => {
-    const spec: SpecsSchema = {
+    const flows: Model = {
       variant: 'specs',
       flows: [
         {
@@ -16,7 +16,6 @@ describe('projection.ts.ejs', () => {
               stream: 'listing-${propertyId}',
               client: {
                 description: 'create listing UI',
-                specs: [],
               },
               server: {
                 description: 'handles create/remove listing',
@@ -78,7 +77,6 @@ describe('projection.ts.ejs', () => {
               stream: 'listings',
               client: {
                 description: 'search listings UI',
-                specs: [],
               },
               server: {
                 description: 'projection for available listings',
@@ -203,7 +201,7 @@ describe('projection.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(flows.flows, flows.messages, undefined, 'src/domain/flows');
     const projectionFile = plans.find((p) => p.outputPath.endsWith('projection.ts'));
 
     expect(projectionFile?.contents).toMatchInlineSnapshot(`
@@ -263,7 +261,7 @@ describe('projection.ts.ejs', () => {
     `);
   });
   it('should generate a valid query resolver using ID type', async () => {
-    const spec: SpecsSchema = {
+    const spec: Model = {
       variant: 'specs',
       flows: [
         {
@@ -282,7 +280,6 @@ describe('projection.ts.ejs', () => {
             `,
               client: {
                 description: '',
-                specs: [],
               },
               server: {
                 description: '',
@@ -346,13 +343,12 @@ describe('projection.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) => {

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;
+          });
+        }
+      }
+      "
+    `);
+  });
 });