@auto-engineer/server-generator-apollo-emmett 0.11.9 → 0.11.11

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

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { Model as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/narrative';
 
 describe('state.ts.ejs', () => {
   it('should generate an initial state', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'Host creates a listing',
           slices: [
@@ -78,58 +78,62 @@ describe('state.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const stateFile = plans.find((p) => p.outputPath.endsWith('state.ts'));
 
     expect(stateFile?.contents).toMatchInlineSnapshot(`
-          "/**
-           * ## IMPLEMENTATION INSTRUCTIONS ##
-           *
-           * Define the shape of the domain state for the current slice below. This state is used by \`decide.ts\`
-           * to determine whether a command is valid.
-           *
-           * The state is evolved over time by applying domain events (in \`evolve.ts\`).
-           * Each event updates the state incrementally based on business rules.
-           *
-           * Guidelines:
-           * - Include only fields that are **read** during command validation.
-           * - Use discriminated unions (e.g., \`status: 'Pending' | 'Done'\`) to model state transitions.
-           * - Prefer primitive types: \`string\`, \`boolean\`, \`number\`.
-           * - Use objects or maps only when structure is essential for decision logic.
-           *
-           * Do NOT include:
-           * - Redundant data already emitted in events unless required to enforce business rules.
-           * - Fields used only for projections, UI, or query purposes.
-           *
-           * ### Example (for a Task domain):
-           *
-           * \`\`\`ts
-           * export type PendingTask = {
-           *   status: 'Pending';
-           * };
-           *
-           * export type InProgressTask = {
-           *   status: 'InProgress';
-           *   startedAt: string;
-           * };
-           *
-           * export type CompletedTask = {
-           *   status: 'Completed';
-           *   completedAt: string;
-           * };
-           *
-           * export type State = PendingTask | InProgressTask | CompletedTask;
-           * \`\`\`
-           */
+      "/**
+       * ## IMPLEMENTATION INSTRUCTIONS ##
+       *
+       * Define the shape of the domain state for the current slice below. This state is used by \`decide.ts\`
+       * to determine whether a command is valid.
+       *
+       * The state is evolved over time by applying domain events (in \`evolve.ts\`).
+       * Each event updates the state incrementally based on business rules.
+       *
+       * Guidelines:
+       * - Include only fields that are **read** during command validation.
+       * - Use discriminated unions with string literal types (e.g., \`status: 'pending' | 'done'\`) to model state transitions.
+       * - IMPORTANT: If an enum exists in domain/shared/types.ts for your field (e.g., Status enum), use the enum constant type instead (e.g., \`status: Status.PENDING\`).
+       * - Prefer primitive types: \`string\`, \`boolean\`, \`number\`.
+       * - Use objects or maps only when structure is essential for decision logic.
+       *
+       * Do NOT include:
+       * - Redundant data already emitted in events unless required to enforce business rules.
+       * - Fields used only for projections, UI, or query purposes.
+       *
+       * ### Example (for a Task domain):
+       *
+       * \`\`\`ts
+       * export type PendingTask = {
+       *   status: 'pending';
+       * };
+       *
+       * export type InProgressTask = {
+       *   status: 'in_progress';
+       *   startedAt: string;
+       * };
+       *
+       * export type CompletedTask = {
+       *   status: 'completed';
+       *   completedAt: string;
+       * };
+       *
+       * export type State = PendingTask | InProgressTask | CompletedTask;
+       * \`\`\`
+       *
+       * Note: Status string literals should match your schema's enum values (usually snake_case).
+       * If an enum is defined in domain/shared/types.ts, reference the enum type instead of literals.
+       */
 
-          // TODO: Replace with a discriminated union of domain states for the current slice
-          export type State = {};
+      // TODO: Replace with a discriminated union of domain states for the current slice
+      export type State = {};
 
-          // TODO: Replace the Return with the initial domain state of the current slice
-          export const initialState = (): State => {
-            return {};
-          };
-          "
-        `);
+      // TODO: Replace the Return with the initial domain state of the current slice
+      export const initialState = (): State => {
+        return {};
+      };
+      "
+    `);
   });
 });

package/src/codegen/templates/command/state.ts.ejs

@@ -9,7 +9,8 @@
 *
 * Guidelines:
 * - Include only fields that are **read** during command validation.
-* - Use discriminated unions (e.g., `status: 'Pending' | 'Done'`) to model state transitions.
+* - Use discriminated unions with string literal types (e.g., `status: 'pending' | 'done'`) to model state transitions.
+* - IMPORTANT: If an enum exists in domain/shared/types.ts for your field (e.g., Status enum), use the enum constant type instead (e.g., `status: Status.PENDING`).
 * - Prefer primitive types: `string`, `boolean`, `number`.
 * - Use objects or maps only when structure is essential for decision logic.
 *
@@ -21,21 +22,24 @@
 *
 * ```ts
 * export type PendingTask = {
-*   status: 'Pending';
+*   status: 'pending';
 * };
 *
 * export type InProgressTask = {
-*   status: 'InProgress';
+*   status: 'in_progress';
 *   startedAt: string;
 * };
 *
 * export type CompletedTask = {
-*   status: 'Completed';
+*   status: 'completed';
 *   completedAt: string;
 * };
 *
 * export type State = PendingTask | InProgressTask | CompletedTask;
 * ```
+*
+* Note: Status string literals should match your schema's enum values (usually snake_case).
+* If an enum is defined in domain/shared/types.ts, reference the enum type instead of literals.
 */
 
 // TODO: Replace with a discriminated union of domain states for the current slice

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

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { Model as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/narrative';
 
 describe('projection.specs.ts.ejs', () => {
   it('should generate a valid test spec for a query slice projection', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'listing-flow',
           slices: [
@@ -180,7 +180,7 @@ describe('projection.specs.ts.ejs', () => {
       ],
     } as SpecsSchema;
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const specFile = plans.find((p) => p.outputPath.endsWith('projection.specs.ts'));
 
     expect(specFile?.contents).toMatchInlineSnapshot(`
@@ -241,7 +241,7 @@ describe('projection.specs.ts.ejs', () => {
   it('should generate a valid test spec for a model with given/when/then pattern', async () => {
     const questionnaireSpec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'Questionnaires',
           slices: [
@@ -363,7 +363,7 @@ describe('projection.specs.ts.ejs', () => {
     } as SpecsSchema;
 
     const plans = await generateScaffoldFilePlans(
-      questionnaireSpec.flows,
+      questionnaireSpec.narratives,
       questionnaireSpec.messages,
       undefined,
       'src/domain/flows',
@@ -380,7 +380,7 @@ describe('projection.specs.ts.ejs', () => {
   it('should include all events from both given and when clauses in projection imports and types', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'questionnaires',
           slices: [
@@ -569,7 +569,7 @@ describe('projection.specs.ts.ejs', () => {
     } as SpecsSchema;
 
     const plans = await generateScaffoldFilePlans(
-      spec.flows,
+      spec.narratives,
       [
         {
           type: 'command',

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

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { Model } from '@auto-engineer/flow';
+import { Model } from '@auto-engineer/narrative';
 
 describe('projection.ts.ejs', () => {
   it('should generate a valid projection file with correct relative event import path from producing slice', async () => {
     const flows: Model = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'listing-flow',
           slices: [
@@ -201,7 +201,7 @@ describe('projection.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(flows.flows, flows.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(flows.narratives, flows.messages, undefined, 'src/domain/flows');
     const projectionFile = plans.find((p) => p.outputPath.endsWith('projection.ts'));
 
     expect(projectionFile?.contents).toMatchInlineSnapshot(`
@@ -227,8 +227,24 @@ describe('projection.ts.ejs', () => {
             case 'ListingCreated': {
               /**
                * ## IMPLEMENTATION INSTRUCTIONS ##
-               * This event adds or updates the document.
-               * Implement the correct fields as needed for your read model.
+               * Implement how this event updates the projection.
+               *
+               * **IMPORTANT - Internal State Pattern:**
+               * If you need to track state beyond the public AvailableListings type (e.g., to calculate
+               * aggregations, track previous values, etc.), follow this pattern:
+               *
+               * 1. Define an extended interface BEFORE the projection:
+               *    interface InternalAvailableListings extends AvailableListings {
+               *      internalField: SomeType;
+               *    }
+               *
+               * 2. Cast document parameter to extended type:
+               *    const current: InternalAvailableListings = (document as InternalAvailableListings) || { ...defaults };
+               *
+               * 3. Cast return values to extended type:
+               *    return { ...allFields, internalField } as InternalAvailableListings;
+               *
+               * This keeps internal state separate from the public GraphQL schema.
                */
               return {
                 propertyId: /* TODO: map from event.data */ '',
@@ -263,7 +279,7 @@ describe('projection.ts.ejs', () => {
   it('should generate a valid query resolver using ID type', async () => {
     const spec: Model = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'wishlist-flow',
           slices: [
@@ -314,7 +330,7 @@ describe('projection.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toMatchInlineSnapshot(`
@@ -329,6 +345,7 @@ describe('projection.ts.ejs', () => {
         @Field(() => String)
         items!: string;
 
+        // IMPORTANT: Index signature required for ReadModel<T extends Record<string, unknown>> compatibility
         [key: string]: unknown;
       }
 

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

@@ -10,6 +10,30 @@ if (eventImportGroups.length > 0) {
 import type { <%= group.eventTypes.join(', ') %> } from '<%= group.importPath %>';
 <%
     }
+}
+
+// Collect enums used in state fields
+const stateEnums = [];
+const targetName = slice.server?.data?.[0]?.target?.name;
+if (targetName && messages) {
+    const targetDef = messages.find(m => m.name === targetName);
+    if (targetDef?.fields) {
+        for (const field of targetDef.fields) {
+            const fieldType = (field.type || '').replace(/\s*\|\s*null/g, '').trim();
+            if (fieldType.includes('|') && (fieldType.includes('"') || fieldType.includes("'"))) {
+                const enumName = toTsFieldType(field.type);
+                if (enumName && enumName !== 'String' && !stateEnums.includes(enumName)) {
+                    stateEnums.push(enumName);
+                }
+            }
+        }
+    }
+}
+
+if (stateEnums.length > 0) {
+%>
+import { <%= stateEnums.join(', ') %> } from '../../../shared';
+<%
 } -%>
 
 type AllEvents = <%= allEventTypes %>;
@@ -76,8 +100,24 @@ case '<%= event.type %>': {
     * - If the intent is to **soft delete**, consider adding a `status` field (e.g., `status: 'removed'`).
     * - Ensure consumers of this projection (e.g., UI) handle the chosen approach appropriately.
 <% } else { -%>
-    * This event adds or updates the document.
-    * Implement the correct fields as needed for your read model.
+    * Implement how this event updates the projection.
+    *
+    * **IMPORTANT - Internal State Pattern:**
+    * If you need to track state beyond the public <%= pascalCase(targetName || 'State') %> type (e.g., to calculate
+    * aggregations, track previous values, etc.), follow this pattern:
+    *
+    * 1. Define an extended interface BEFORE the projection:
+    *    interface Internal<%= pascalCase(targetName || 'State') %> extends <%= pascalCase(targetName || 'State') %> {
+    *      internalField: SomeType;
+    *    }
+    *
+    * 2. Cast document parameter to extended type:
+    *    const current: Internal<%= pascalCase(targetName || 'State') %> = (document as Internal<%= pascalCase(targetName || 'State') %>) || { ...defaults };
+    *
+    * 3. Cast return values to extended type:
+    *    return { ...allFields, internalField } as Internal<%= pascalCase(targetName || 'State') %>;
+    *
+    * This keeps internal state separate from the public GraphQL schema.
 <% } -%>
 */
 <% if (isRemovalEvent) { -%>
@@ -94,16 +134,28 @@ case '<%= event.type %>': {
         const type = def?.type ?? 'string';
 
         let placeholder = 'undefined';
-        if (type === 'string' || type === 'ID') {
-            placeholder = "/* TODO: map from event.data */ ''";
-        } else if (type === 'number') {
-            placeholder = '/* TODO: map from event.data */ 0';
-        } else if (type === 'boolean') {
-            placeholder = '/* TODO: map from event.data */ false';
-        } else if (type === 'Date') {
-            placeholder = '/* TODO: map from event.data */ new Date()';
-        } else if (type.startsWith('Array<')) {
-            placeholder = '/* TODO: map from event.data */ []';
+        const isNullable = type.includes('| null') || type.includes('|null');
+        const baseType = isNullable ? type.replace(/\s*\|\s*null/g, '').trim() : type;
+
+        if (baseType === 'string' || baseType === 'ID') {
+            placeholder = isNullable ? "/* TODO: map from event.data */ null" : "/* TODO: map from event.data */ ''";
+        } else if (baseType === 'number') {
+            placeholder = isNullable ? '/* TODO: map from event.data */ null' : '/* TODO: map from event.data */ 0';
+        } else if (baseType === 'boolean') {
+            placeholder = isNullable ? '/* TODO: map from event.data */ null' : '/* TODO: map from event.data */ false';
+        } else if (baseType === 'Date') {
+            placeholder = isNullable ? '/* TODO: map from event.data */ null' : '/* TODO: map from event.data */ new Date()';
+        } else if (baseType.startsWith('Array<')) {
+            placeholder = isNullable ? '/* TODO: map from event.data */ null' : '/* TODO: map from event.data */ []';
+        } else if (baseType.includes('|') && (baseType.includes('"') || baseType.includes("'"))) {
+            const enumName = toTsFieldType(type);
+            const firstValue = baseType.match(/['"]([^'"]+)['"]/)?.[1] ?? '';
+            const enumConstant = firstValue ? firstValue.toUpperCase().replace(/[^A-Z0-9]/g, '_') : '';
+            if (enumName && enumName !== 'String') {
+                placeholder = `${enumName}.${enumConstant} /* TODO: verify this enum constant is correct */`;
+            } else {
+                placeholder = `/* TODO: use enum constant from types.ts */ '${firstValue}'`;
+            }
         } else {
             placeholder = '/* TODO: map from event.data */ undefined as any';
         }

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

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { Model as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/narrative';
 
 describe('query.resolver.ts.ejs', () => {
   it('should generate a valid query resolver from request field', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'listing-flow',
           slices: [
@@ -63,7 +63,7 @@ describe('query.resolver.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toMatchInlineSnapshot(`
@@ -87,6 +87,7 @@ describe('query.resolver.ts.ejs', () => {
         @Field(() => Float)
         maxGuests!: number;
 
+        // IMPORTANT: Index signature required for ReadModel<T extends Record<string, unknown>> compatibility
         [key: string]: unknown;
       }
 
@@ -128,7 +129,7 @@ describe('query.resolver.ts.ejs', () => {
   it('should generate a valid query resolver with array of inline object field', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'assistant-flow',
           slices: [
@@ -186,7 +187,7 @@ describe('query.resolver.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toMatchInlineSnapshot(`
@@ -217,6 +218,7 @@ describe('query.resolver.ts.ejs', () => {
         @Field(() => [SuggestedItemsItems])
         items!: SuggestedItemsItems[];
 
+        // IMPORTANT: Index signature required for ReadModel<T extends Record<string, unknown>> compatibility
         [key: string]: unknown;
       }
 
@@ -252,7 +254,7 @@ describe('query.resolver.ts.ejs', () => {
   it('should generate the query resolver for "views the questionnaire"', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'Questionnaires',
           slices: [
@@ -352,7 +354,7 @@ describe('query.resolver.ts.ejs', () => {
       integrations: [],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const queryFile = plans.find(
       (p) => p.outputPath.endsWith('query.resolver.ts') && p.contents.includes('ViewsTheQuestionnaireQueryResolver'),
     );
@@ -360,7 +362,7 @@ describe('query.resolver.ts.ejs', () => {
     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';
+      import { type GraphQLContext, ReadModel, QuestionnaireProgressStatus } from '../../../shared';
 
       @ObjectType()
       export class QuestionnaireProgressAnswers {
@@ -379,8 +381,8 @@ describe('query.resolver.ts.ejs', () => {
         @Field(() => String)
         participantId!: string;
 
-        @Field(() => String)
-        status!: 'in_progress' | 'ready_to_submit' | 'submitted';
+        @Field(() => QuestionnaireProgressStatus)
+        status!: QuestionnaireProgressStatus;
 
         @Field(() => String, { nullable: true })
         currentQuestionId?: string | null;
@@ -391,6 +393,7 @@ describe('query.resolver.ts.ejs', () => {
         @Field(() => [QuestionnaireProgressAnswers])
         answers!: QuestionnaireProgressAnswers[];
 
+        // IMPORTANT: Index signature required for ReadModel<T extends Record<string, unknown>> compatibility
         [key: string]: unknown;
       }
 
@@ -426,7 +429,7 @@ describe('query.resolver.ts.ejs', () => {
   it('should import Float when Float fields are used', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'product-flow',
           slices: [
@@ -479,7 +482,7 @@ describe('query.resolver.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toContain(
@@ -490,7 +493,7 @@ describe('query.resolver.ts.ejs', () => {
   it('should import Float when array of numbers is used', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'stats-flow',
           slices: [
@@ -541,7 +544,7 @@ describe('query.resolver.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toContain('Float');
@@ -550,7 +553,7 @@ describe('query.resolver.ts.ejs', () => {
   it('should import Float when Float query arg is used', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'search-flow',
           slices: [
@@ -601,7 +604,7 @@ describe('query.resolver.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toContain('Float');

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

@@ -8,50 +8,6 @@ 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);
-    const gqlType = graphqlType(b);
-    if (gqlType.includes('GraphQLISODateTime')) return true;
-    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*Date\b/.test(b);
-    return false;
-}
-function fieldUsesJSON(ts) {
-    const b = baseTs(ts);
-    const gqlType = graphqlType(b);
-    if (gqlType.includes('GraphQLJSON') || gqlType.includes('JSON')) return true;
-    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*(unknown|any|object)\b/.test(b);
-    return false;
-}
-function fieldUsesFloat(ts) {
-    const b = baseTs(ts);
-    const gqlType = graphqlType(b);
-    if (gqlType.includes('Float')) return true;
-    if (isInlineObject(b) || isInlineObjectArray(b)) {
-        const inner = b.trim().startsWith('Array<')
-            ? b.trim().replace(/^Array<\{/, '{').replace(/}>$/, '}')
-            : b.trim().replace(/\[\]$/, '');
-        const match = inner.match(/^\{([\s\S]*)\}$/);
-        const body = match ? match[1] : '';
-        const rawFields = body.split(/[,;]\s*/).filter(Boolean);
-        return rawFields.some(f => {
-            const parts = f.split(':');
-            const type = parts.slice(1).join(':').trim();
-            return type && graphqlType(type).includes('Float');
-        });
-    }
-    return false;
-}
-
 const messageFields = message?.fields ?? [];
 const usesDate = messageFields.some(f => fieldUsesDate(f.type)) ||
         (parsedRequest?.args ?? []).some(a => fieldUsesDate(a.tsType));
@@ -60,6 +16,8 @@ const usesJSON = messageFields.some(f => fieldUsesJSON(f.type)) ||
 const usesFloat = messageFields.some(f => fieldUsesFloat(f.type)) ||
         (parsedRequest?.args ?? []).some(a => fieldUsesFloat(a.tsType));
 
+const enumList = collectEnumNames([...messageFields, ...(parsedRequest?.args ?? [])]);
+
 const embeddedTypes = [];
 for (const field of messageFields) {
     const tsType = field.type ?? 'string';
@@ -70,10 +28,11 @@ for (const field of messageFields) {
         });
     }
 }
+const hasArgs = parsedRequest?.args?.length > 0;
 %>
-import { Query, Resolver, Arg, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesFloat) { %>, Float<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
+import { Query, Resolver<% if (hasArgs) { %>, Arg<% } %>, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesFloat) { %>, Float<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
 <% if (usesJSON) { %>import { GraphQLJSON } from 'graphql-type-json';
-<% } %>import { type GraphQLContext, ReadModel } from '../../../shared';
+<% } %>import { type GraphQLContext, ReadModel<% if (enumList.length > 0) { %>, <%= enumList.join(', ') %><% } %> } from '../../../shared';
 
 <%
         for (const { typeName, tsType } of embeddedTypes) {
@@ -118,9 +77,12 @@ export class <%= viewType %> {
     @Field(() => <%= gqlType %><%= isNullable(tsType) ? ', { nullable: true }' : '' %>)
     <%= field.name %><%= isNullable(tsType) ? '?' : '!' %>: <%= toTsFieldType(tsType) %>;
 <% } } %>
-[key: string]: unknown;
+
+  // IMPORTANT: Index signature required for ReadModel<T extends Record<string, unknown>> compatibility
+  [key: string]: unknown;
 <% } else { %>
-    [key: string]: unknown;
+  // IMPORTANT: Index signature required for ReadModel<T extends Record<string, unknown>> compatibility
+  [key: string]: unknown;
 <% } %>
 }
 
@@ -148,7 +110,7 @@ const model = new ReadModel<<%= viewType %>>(ctx.database, '<%= projectionType %
 // 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) => {
+return model.find((<%= hasArgs ? 'item' : '_item' %>) => {
 <% if (parsedRequest?.args?.length) {
         for (const arg of parsedRequest.args) { %>
     if (<%= arg.name %> !== undefined && item.<%= arg.name %> !== <%= arg.name %>) return false;