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

package/src/codegen/templates/command/mutation.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('mutation.resolver.ts.ejs', () => {
   it('should generate a valid mutation resolver file', async () => {
@@ -15,7 +15,6 @@ describe('mutation.resolver.ts.ejs', () => {
               name: 'Create listing',
               client: {
                 description: 'A form that allows users to add a new listing',
-                specs: [],
               },
               server: {
                 description: 'Handles listing creation',
@@ -77,30 +76,40 @@ 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 } from 'type-graphql';
+      "import { Mutation, Resolver, Arg, Ctx, Field, InputType, GraphQLISODateTime } from 'type-graphql';
+      import { GraphQLJSON } from 'graphql-type-json';
       import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
 
       @InputType()
       export class CreateListingInput {
         @Field(() => String)
         propertyId!: string;
+
         @Field(() => String)
         title!: string;
-        @Field(() => Number)
+
+        @Field(() => Float)
         pricePerNight!: number;
-        @Field(() => Number)
+
+        @Field(() => Float)
         maxGuests!: number;
+
         @Field(() => [String])
         amenities!: string[];
+
         @Field(() => Boolean)
         available!: boolean;
+
         @Field(() => [String])
         tags!: string[];
-        @Field(() => Number)
+
+        @Field(() => Float)
         rating!: number;
-        @Field(() => Object)
+
+        @Field(() => JSON)
         metadata!: object;
-        @Field(() => Date)
+
+        @Field(() => GraphQLISODateTime)
         listedAt!: Date;
       }
 
@@ -121,4 +130,234 @@ describe('mutation.resolver.ts.ejs', () => {
       "
     `);
   });
+
+  it('should generate the mutation resolver for AnswerQuestion', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'Questionnaires',
+          slices: [
+            {
+              name: 'submits a questionnaire answer',
+              type: 'command',
+              client: {
+                description: '',
+                specs: {
+                  name: '',
+                  rules: [
+                    'display a success message when the answer is submitted',
+                    'display an error message when the answer submission is rejected',
+                  ],
+                },
+              },
+              request:
+                'mutation AnswerQuestion($input: AnswerQuestionInput!) {\\n  answerQuestion(input: $input) {\\n    success\\n  }\\n}',
+              server: {
+                description: '',
+                data: [
+                  {
+                    target: { type: 'Event', name: 'QuestionAnswered' },
+                    destination: { type: 'stream', pattern: 'questionnaire-participantId' },
+                  },
+                  {
+                    target: { type: 'Event', name: 'QuestionnaireEditRejected' },
+                    destination: { type: 'stream', pattern: 'questionnaire-participantId' },
+                  },
+                ],
+                specs: {
+                  name: '',
+                  rules: [
+                    {
+                      description: 'answers are allowed while the questionnaire has not been submitted',
+                      examples: [
+                        {
+                          description: 'no questions have been answered yet',
+                          when: {
+                            commandRef: 'AnswerQuestion',
+                            exampleData: {
+                              questionnaireId: 'q-001',
+                              participantId: 'participant-abc',
+                              questionId: 'q1',
+                              answer: 'Yes',
+                            },
+                          },
+                          then: [
+                            {
+                              eventRef: 'QuestionAnswered',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                                questionId: 'q1',
+                                answer: 'Yes',
+                                savedAt: '2030-01-01T09:05:00.000Z',
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'AnswerQuestion',
+          fields: [
+            { name: 'questionnaireId', type: 'string', required: true },
+            { name: 'participantId', type: 'string', required: true },
+            { name: 'questionId', type: 'string', required: true },
+            { name: 'answer', type: 'unknown', required: true },
+          ],
+          metadata: { version: 1 },
+        },
+      ],
+      integrations: [],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const mutationFile = plans.find(
+      (p) =>
+        p.outputPath.endsWith('mutation.resolver.ts') && p.contents.includes('export class AnswerQuestionResolver'),
+    );
+
+    expect(mutationFile?.contents).toMatchInlineSnapshot(`
+      "import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
+      import { GraphQLJSON } from 'graphql-type-json';
+      import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+
+      @InputType()
+      export class AnswerQuestionInput {
+        @Field(() => String)
+        questionnaireId!: string;
+
+        @Field(() => String)
+        participantId!: string;
+
+        @Field(() => String)
+        questionId!: string;
+
+        @Field(() => GraphQLJSON)
+        answer!: unknown;
+      }
+
+      @Resolver()
+      export class AnswerQuestionResolver {
+        @Mutation(() => MutationResponse)
+        async answerQuestion(
+          @Arg('input', () => AnswerQuestionInput) input: AnswerQuestionInput,
+          @Ctx() ctx: GraphQLContext,
+        ): Promise<MutationResponse> {
+          return await sendCommand(ctx.messageBus, {
+            type: 'AnswerQuestion',
+            kind: 'Command',
+            data: { ...input },
+          });
+        }
+      }
+      "
+    `);
+  });
+
+  it('generates nested input types for inline object arrays in a mutation', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'Cart',
+          slices: [
+            {
+              type: 'command',
+              name: 'Add items to cart',
+              client: { description: '' },
+              server: {
+                description: '',
+                specs: {
+                  name: '',
+                  rules: [
+                    {
+                      description: 'add items',
+                      examples: [
+                        {
+                          description: 'happy path',
+                          when: {
+                            commandRef: 'AddItemsToCart',
+                            exampleData: {
+                              sessionId: 's-1',
+                              items: [{ productId: 'p1', quantity: 2 }],
+                            },
+                          },
+                          then: [],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'AddItemsToCart',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'items', type: 'Array<{ productId: string; quantity: number }>', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const mutationFile = plans.find(
+      (p) =>
+        p.outputPath.endsWith('mutation.resolver.ts') && p.contents.includes('export class AddItemsToCartResolver'),
+    );
+
+    expect(mutationFile?.contents).toMatchInlineSnapshot(`
+"import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
+import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+
+@InputType()
+export class AddItemsToCartItemsInput {
+  @Field(() => String)
+  productId!: string;
+
+  @Field(() => Float)
+  quantity!: number;
+}
+
+@InputType()
+export class AddItemsToCartInput {
+  @Field(() => String)
+  sessionId!: string;
+
+  @Field(() => [AddItemsToCartItemsInput])
+  items!: AddItemsToCartItemsInput[];
+}
+
+@Resolver()
+export class AddItemsToCartResolver {
+  @Mutation(() => MutationResponse)
+  async addItemsToCart(
+    @Arg('input', () => AddItemsToCartInput) input: AddItemsToCartInput,
+    @Ctx() ctx: GraphQLContext,
+  ): Promise<MutationResponse> {
+    return await sendCommand(ctx.messageBus, {
+      type: 'AddItemsToCart',
+      kind: 'Command',
+      data: { ...input },
+    });
+  }
+}
+"
+`);
+  });
 });

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) => {