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

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',

package/src/commands/generate-server.ts

@@ -6,18 +6,18 @@ import { resolve, join } from 'path';
 import { existsSync } from 'fs';
 import { generateScaffoldFilePlans, writeScaffoldFilePlans } from '../codegen/scaffoldFromSchema';
 import { ensureDirExists } from '../codegen/utils/path';
-import { SpecsSchemaType } from '@auto-engineer/flow';
+import { Model } from '@auto-engineer/flow';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { execa } from 'execa';
 import createDebug from 'debug';
 import { defineCommandHandler } from '@auto-engineer/message-bus';
 
-const debug = createDebug('emmett:generate-server');
-const debugSchema = createDebug('emmett:generate-server:schema');
-const debugFiles = createDebug('emmett:generate-server:files');
-const debugDeps = createDebug('emmett:generate-server:deps');
-const debugScaffold = createDebug('emmett:generate-server:scaffold');
+const debug = createDebug('auto:generate-server');
+const debugSchema = createDebug('auto:generate-server:schema');
+const debugFiles = createDebug('auto:generate-server:files');
+const debugDeps = createDebug('auto:generate-server:deps');
+const debugScaffold = createDebug('auto:generate-server:scaffold');
 
 type DefaultRecord = Record<string, unknown>;
 export type Command<CommandType extends string = string, CommandData extends DefaultRecord = DefaultRecord> = Readonly<{
@@ -117,12 +117,12 @@ async function validateSchemaFile(
   return null;
 }
 
-async function readAndParseSchema(absSchema: string): Promise<SpecsSchemaType> {
+async function readAndParseSchema(absSchema: string): Promise<Model> {
   debugSchema('Reading schema file from %s', absSchema);
   const content = await readFile(absSchema, 'utf8');
 
   debugSchema('Schema content length: %d bytes', content.length);
-  const spec = JSON.parse(content) as SpecsSchemaType;
+  const spec = JSON.parse(content) as Model;
 
   debugSchema('Parsed schema:');
   debugSchema('  Flows: %d', spec.flows?.length || 0);
@@ -133,7 +133,7 @@ async function readAndParseSchema(absSchema: string): Promise<SpecsSchemaType> {
   return spec;
 }
 
-function logFlowDetails(spec: SpecsSchemaType): void {
+function logFlowDetails(spec: Model): void {
   if (spec.flows !== undefined && spec.flows.length > 0) {
     debugSchema(
       'Flow names: %o',
@@ -148,7 +148,7 @@ function logFlowDetails(spec: SpecsSchemaType): void {
   }
 }
 
-async function generateAndWriteScaffold(spec: SpecsSchemaType, serverDir: string): Promise<void> {
+async function generateAndWriteScaffold(spec: Model, serverDir: string): Promise<void> {
   const domainFlowsPath = join(serverDir, 'src', 'domain', 'flows');
   debugScaffold('Generating scaffold file plans');
   debugScaffold('  Domain flows path: %s', domainFlowsPath);
@@ -169,7 +169,7 @@ async function generateAndWriteScaffold(spec: SpecsSchemaType, serverDir: string
 }
 
 async function copyAllFiles(serverDir: string): Promise<void> {
-  const packageRoot = path.resolve(__dirname, '..');
+  const packageRoot = path.resolve(__dirname, '../../../src');
   debugFiles('Package root: %s', packageRoot);
 
   debugFiles('Copying utility files...');
@@ -183,16 +183,16 @@ async function copyAllFiles(serverDir: string): Promise<void> {
 }
 
 async function writeConfigurationFiles(serverDir: string, absDest: string): Promise<void> {
-  debugFiles('Writing package.json...');
+  debugFiles(`Writing package.json... to ${serverDir}`);
   await writePackage(serverDir);
 
-  debugFiles('Writing tsconfig.json...');
+  debugFiles(`Writing tsconfig.json... to ${serverDir}`);
   await writeTsconfig(serverDir);
 
-  debugFiles('Writing vitest config...');
+  debugFiles(`Writing vitest config... to ${serverDir}`);
   await writeVitestConfig(serverDir);
 
-  debugFiles('Generating GraphQL schema script...');
+  debugFiles(`Generating GraphQL schema script... ${serverDir} to ${absDest}`);
   await generateSchemaScript(serverDir, absDest);
 }
 
@@ -338,19 +338,20 @@ async function copySharedAndRootFiles(from: string, to: string): Promise<void> {
 async function writePackage(dest: string): Promise<void> {
   debugFiles('Writing package.json to %s', dest);
 
-  const packageRoot = path.resolve(__dirname, '../..');
+  const packageRoot = path.resolve(__dirname, '../../..');
   const localPkgPath = path.resolve(packageRoot, 'package.json');
   const rootPkgPath = path.resolve(packageRoot, '../../package.json');
 
+  debugFiles('  package root: %s', packageRoot);
   debugFiles('  Local package path: %s', localPkgPath);
   debugFiles('  Root package path: %s', rootPkgPath);
 
-  const localPkg = (await fs.readJson(localPkgPath).catch(() => ({}))) as {
+  const localPkg = (await fs.readJson(localPkgPath)) as {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
   };
 
-  const rootPkg = (await fs.readJson(rootPkgPath).catch(() => ({}))) as {
+  const rootPkg = (await fs.readJson(rootPkgPath)) as {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
   };
@@ -392,6 +393,7 @@ async function writePackage(dest: string): Promise<void> {
     dependencies: resolveDeps([
       '@event-driven-io/emmett',
       'type-graphql',
+      'graphql-type-json',
       'graphql',
       'fast-glob',
       'reflect-metadata',
@@ -402,7 +404,12 @@ async function writePackage(dest: string): Promise<void> {
     devDependencies: resolveDeps(['typescript', 'vitest', 'tsx']),
   } as const;
 
-  const existingPkg = (await fs.readJson(path.join(dest, 'package.json')).catch(() => ({}))) as Record<string, unknown>;
+  debugFiles('Loading package.json from', path.join(dest, 'package.json'));
+  const existingPkg = (await fs.readJson(path.join(dest, 'package.json')).catch(() => {
+    debugFiles('Failed to load package.json, using empty object');
+    return {};
+  })) as Record<string, unknown>;
+  debugFiles('Existing package.json:', existingPkg);
   const mergedDeps = {
     ...(existingPkg.dependencies as Record<string, string>),
     ...packageJson.dependencies,
@@ -417,6 +424,7 @@ async function writeTsconfig(dest: string): Promise<void> {
       module: 'ESNext',
       moduleResolution: 'bundler',
       strict: true,
+      outDir: './dist',
       skipLibCheck: true,
       emitDecoratorMetadata: true,
       experimentalDecorators: true,
@@ -488,29 +496,29 @@ main().catch((err) => {
 }
 
 async function installDependenciesAndGenerateSchema(serverDir: string, workingDir: string): Promise<void> {
-  debugDeps('📦 Installing dependencies...');
+  debugDeps('Installing dependencies...');
   debugDeps('Starting dependency installation in %s', serverDir);
+  debugDeps('Hint: You can debug by manually running: cd server && pnpm install && npx tsx scripts/generate-schema.ts');
 
   try {
-    debugDeps('Running: pnpm install');
-    await execa('pnpm', ['install'], { cwd: serverDir });
-    debugDeps('✅ Dependencies installed successfully');
+    debugDeps('Running pnpm install');
+    await execa('pnpm', ['install', '--ignore-workspace'], { cwd: serverDir });
     debugDeps('Dependencies installed successfully');
+  } catch (error) {
+    debugDeps('Failed to pnpm install: %s', error instanceof Error ? error.message : 'Unknown error');
+  }
 
-    debugDeps('🔄 Generating GraphQL schema...');
-    debugDeps('Running: tsx scripts/generate-schema.ts');
+  try {
+    debugDeps('Generating GraphQL schema...');
+    debugDeps('Running: tsx scripts/generate-schema.ts', serverDir + '/scripts/generate-schema.ts');
     await execa('tsx', ['scripts/generate-schema.ts'], { cwd: serverDir });
-
     const schemaPath = join(workingDir, '.context', 'schema.graphql');
-    debugDeps('✅ GraphQL schema generated at: %s', schemaPath);
     debugDeps('GraphQL schema generated at: %s', schemaPath);
   } catch (error) {
-    debugDeps('Failed to install dependencies or generate schema: %O', error);
     debugDeps(
-      '⚠️  Failed to install dependencies or generate schema: %s',
+      'Failed to run tsx scripts/generate-schema.ts: %s',
       error instanceof Error ? error.message : 'Unknown error',
     );
-    debugDeps('You can manually run: cd server && pnpm install && npx tsx scripts/generate-schema.ts');
   }
 }
 

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": false,
+    "types": ["vitest/globals", "node"]
+  },
+  "include": ["src/**/*", "**/*.specs.ts", "**/*.spec.ts", "**/*.test.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/.turbo/turbo-test.log

@@ -1,14 +0,0 @@
-
-> @auto-engineer/server-generator-apollo-emmett@0.8.5 test /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
-> vitest run --reporter=dot
-
-
- RUN  v3.2.4 /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
-
-···················-···
-
- Test Files  15 passed | 1 skipped (16)
-      Tests  22 passed | 1 skipped (23)
-   Start at  14:02:58
-   Duration  6.14s (transform 770ms, setup 0ms, collect 5.05s, tests 5.57s, environment 4ms, prepare 2.21s)
-

package/.turbo/turbo-type-check.log

@@ -1,4 +0,0 @@
-
-> @auto-engineer/server-generator-apollo-emmett@0.8.5 type-check /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
-> tsc --noEmit --project tsconfig.json
-

package/dist/codegen/templates/command/mutation.resolver.specs.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
-
-describe('mutation.resolver.ts.ejs', () => {
-  it('should generate a valid mutation resolver file', async () => {
-    const spec: SpecsSchema = {
-      variant: 'specs',
-      flows: [
-        {
-          name: 'Host creates a listing',
-          slices: [
-            {
-              type: 'command',
-              name: 'Create listing',
-              client: {
-                description: 'A form that allows users to add a new listing',
-                specs: [],
-              },
-              server: {
-                description: 'Handles listing creation',
-                specs: {
-                  name: 'Create listing command',
-                  rules: [
-                    {
-                      description: 'Should create listing successfully',
-                      examples: [
-                        {
-                          description: 'User creates listing with valid data',
-                          when: {
-                            commandRef: 'CreateListing',
-                            exampleData: {
-                              propertyId: 'listing_123',
-                              title: 'Modern Downtown Apartment',
-                              pricePerNight: 250,
-                              maxGuests: 4,
-                              amenities: ['wifi', 'kitchen'],
-                              available: true,
-                              tags: ['sea view', 'balcony'],
-                              rating: 4.8,
-                              metadata: { petsAllowed: true },
-                              listedAt: '2024-01-15T10:00:00Z',
-                            },
-                          },
-                          then: [],
-                        },
-                      ],
-                    },
-                  ],
-                },
-              },
-            },
-          ],
-        },
-      ],
-      messages: [
-        {
-          type: 'command',
-          name: 'CreateListing',
-          fields: [
-            { name: 'propertyId', type: 'string', required: true },
-            { name: 'title', type: 'string', required: true },
-            { name: 'pricePerNight', type: 'number', required: true },
-            { name: 'maxGuests', type: 'number', required: true },
-            { name: 'amenities', type: 'string[]', required: true },
-            { name: 'available', type: 'boolean', required: true },
-            { name: 'tags', type: 'string[]', required: true },
-            { name: 'rating', type: 'number', required: true },
-            { name: 'metadata', type: 'object', required: true },
-            { name: 'listedAt', type: 'Date', 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'));
-
-    expect(mutationFile?.contents).toMatchInlineSnapshot(`
-      "import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
-      import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
-
-      @InputType()
-      export class CreateListingInput {
-        @Field(() => String)
-        propertyId!: string;
-        @Field(() => String)
-        title!: string;
-        @Field(() => Number)
-        pricePerNight!: number;
-        @Field(() => Number)
-        maxGuests!: number;
-        @Field(() => [String])
-        amenities!: string[];
-        @Field(() => Boolean)
-        available!: boolean;
-        @Field(() => [String])
-        tags!: string[];
-        @Field(() => Number)
-        rating!: number;
-        @Field(() => Object)
-        metadata!: object;
-        @Field(() => Date)
-        listedAt!: Date;
-      }
-
-      @Resolver()
-      export class CreateListingResolver {
-        @Mutation(() => MutationResponse)
-        async createListing(
-          @Arg('input', () => CreateListingInput) input: CreateListingInput,
-          @Ctx() ctx: GraphQLContext,
-        ): Promise<MutationResponse> {
-          return await sendCommand(ctx.messageBus, {
-            type: 'CreateListing',
-            kind: 'Command',
-            data: { ...input },
-          });
-        }
-      }
-      "
-    `);
-  });
-});

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

@@ -1,25 +0,0 @@
-import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
-import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
-
-@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 %>;
-<% } -%>
-}
-
-@Resolver()
-export class <%= pascalCase(commands[0].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
-): Promise<MutationResponse> {
-    return await sendCommand(ctx.messageBus, {
-    type: '<%= commands[0].type %>',
-    kind: 'Command',
-    data: { ...input },
-    });
-    }
-    }