@auto-engineer/server-generator-apollo-emmett 0.10.4 → 0.11.0

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

@@ -1,71 +1,195 @@
 <%_
+const targetName = slice?.server?.data?.[0]?.target?.name || 'UnknownState';
+const TargetType = pascalCase(targetName);
+const projName = projectionName || "UnknownProjection";
 const idField = projectionIdField ?? 'id';
-const projectionType = states[0]?.type ?? 'UnknownState';
-const projectionCollection = projectionName ?? 'unknown-collection';
-const testCases = queryGwtMapping ?? [];
-const eventTypes = Array.from(new Set(events.map(e => e.type)));
+const uniqueEventTypes = allEventTypesArray;
+
+const ruleGroups = new Map();
+const rules = slice?.server?.specs?.rules || [];
+for (const rule of rules) {
+    const ruleDescription = rule.description || `${flowName} | ${sliceName}`;
+    if (!ruleGroups.has(ruleDescription)) {
+        ruleGroups.set(ruleDescription, []);
+    }
+
+    for (const example of rule.examples || []) {
+        ruleGroups.get(ruleDescription).push({
+            description: example.description || 'should handle events correctly',
+            given: example.given || [],
+            when: example.when || [],
+            then: example.then || []
+        });
+    }
+}
 _%>
 
 import { describe, it, beforeEach, expect } from 'vitest';
-import {
-InMemoryProjectionSpec,
-} from '@event-driven-io/emmett';
+import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
 import { projection } from './projection';
-import type { <%= eventTypes.join(', ') %> } from '../<%= toKebabCase(events[0]?.sourceSliceName || 'unknown') %>/events';
-import { <%= projectionType %> } from './state';
-
-<% if (eventTypes.length > 0) { -%>
-    type ProjectionEvent = <%= eventTypes.join(' | ') %>;
-<% } else { -%>
-    type ProjectionEvent = never;
+<% for (const group of eventImportGroups) { -%>
+import type { <%= group.eventTypes.join(', ') %> } from '<%= group.importPath %>';
 <% } -%>
+import { <%= TargetType %> } from './state';
 
-describe('<%= projectionName %> Projection', () => {
-let given: InMemoryProjectionSpec<ProjectionEvent>;
+type ProjectionEvent = <%= uniqueEventTypes.length ? uniqueEventTypes.join(' | ') : 'never' %>;
 
-    beforeEach(() => {
+<% for (const [ruleDescription, ruleTests] of ruleGroups.entries()) { %>
+describe('<%= ruleDescription %>', () => {
+  let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+  beforeEach(() => {
     given = InMemoryProjectionSpec.for({ projection });
-    });
+  });
 
-    <%_ for (const [index, gwt] of testCases.entries()) {
-        const isRemoval = gwt.then[0]?.exampleData && Object.keys(gwt.then[0].exampleData).length === 0;
-        const expectedIdValue = JSON.stringify(gwt.then[0]?.exampleData?.[idField] ?? 'unknown-id');
-    _%>
-    it('<%= isRemoval ? 'removes' : 'creates or updates' %> <%= projectionType %> document - case <%= index + 1 %>', () =>
-    given([
-    <%_ for (const event of gwt.given) { _%>
-        {
-        type: '<%= event.eventRef %>',
+<% for (const testCase of ruleTests) {
+  const givenEvents = Array.isArray(testCase.given) ? testCase.given : [];
+  const whenEvents = Array.isArray(testCase.when) ? testCase.when : (testCase.when ? [testCase.when] : []);
+  const thenStates = Array.isArray(testCase.then) ? testCase.then : [];
+  const allTestEvents = [...givenEvents, ...whenEvents].filter(e => e.eventRef && e.eventRef !== '');
+
+  if (thenStates.length > 0) {
+    const expectedState = thenStates.find(t => t.stateRef === targetName);
+    if (!expectedState) continue;
+
+    const description = testCase.description || 'should handle events correctly';
+_%>
+
+  it('<%= description %>', () =>
+    given([<% if (givenEvents.length > 0) {
+      for (const evt of givenEvents) {
+        if (!evt.eventRef || evt.eventRef === '') continue;
+        const eventMessage = messages.find(m => m.name === evt.eventRef);
+        const streamNameValue = slice.stream ? `'${slice.stream}'` : "'test-stream'";
+_%>
+      {
+        type: '<%= evt.eventRef %>',
         data: {
-        <%_ for (const [key, val] of Object.entries(event.exampleData || {})) { _%>
-            <%= key %>: <%- formatTsValue(val, (events.find(e => e.type === event.eventRef)?.fields.find(f => f.name === key)?.tsType || 'string')) %>,
-        <%_ } _%>
+<% const dataKeys = Object.keys(evt.exampleData || {});
+   for (let i = 0; i < dataKeys.length; i++) {
+     const key = dataKeys[i];
+     const value = evt.exampleData[key];
+     const isLast = i === dataKeys.length - 1;
+     const field = eventMessage?.fields?.find(f => f.name === key);
+     const tsType = field?.tsType || field?.type || 'string';
+
+     let formattedValue;
+     if (value === null || value === undefined) {
+       formattedValue = 'null';
+     } else if (tsType === 'string' || tsType === 'ID') {
+       formattedValue = `'${value}'`;
+     } else if (tsType === 'number' || tsType === 'boolean') {
+       formattedValue = String(value);
+     } else if (tsType === 'Date') {
+       formattedValue = `new Date('${value}')`;
+     } else if (Array.isArray(value)) {
+       formattedValue = JSON.stringify(value);
+     } else {
+       formattedValue = `'${value}'`;
+     }
+-%>
+          <%= key %>: <%= formattedValue %><%= isLast ? '' : ',' %>
+<% } -%>
         },
         metadata: {
-        streamName: 'ignored-stream',
-        streamPosition: 1n,
-        globalPosition: 1n,
-        },
+          streamName: <%= streamNameValue %>,
+          streamPosition: 1n,
+          globalPosition: 1n,
         },
-    <%_ } _%>
-    ])
-    .when([])
-    .then(async (state) => {
-    const document = await state.database
-    .collection<<%= projectionType %>>('<%= projectionCollection %>')
-    .findOne((doc) => doc.<%= idField %> === <%- expectedIdValue %>);
+      },<% } } -%>])
+      .when([<% if (whenEvents.length > 0) {
+        for (const evt of whenEvents) {
+          if (!evt.eventRef || evt.eventRef === '') continue;
+          const eventMessage = messages.find(m => m.name === evt.eventRef);
+          const streamNameValue = slice.stream ? `'${slice.stream}'` : "'test-stream'";
+_%>
+        {
+          type: '<%= evt.eventRef %>',
+          data: {
+<% const dataKeys = Object.keys(evt.exampleData || {});
+   for (let i = 0; i < dataKeys.length; i++) {
+     const key = dataKeys[i];
+     const value = evt.exampleData[key];
+     const isLast = i === dataKeys.length - 1;
+     const field = eventMessage?.fields?.find(f => f.name === key);
+     const tsType = field?.tsType || field?.type || 'string';
 
-    <%_ if (isRemoval) { _%>
-    expect(document).toBeNull();
-    <%_ } else { _%>
-        const expected: <%= projectionType %> = {
-        <%_ for (const [key, val] of Object.entries(gwt.then[0].exampleData || {})) { _%>
-            <%= key %>: <%- formatTsValue(val, (states[0]?.fields.find(f => f.name === key)?.tsType || 'string')) %>,
-        <%_ } _%>
+     let formattedValue;
+     if (value === null || value === undefined) {
+       formattedValue = 'null';
+     } else if (tsType === 'string' || tsType === 'ID') {
+       formattedValue = `'${value}'`;
+     } else if (tsType === 'number' || tsType === 'boolean') {
+       formattedValue = String(value);
+     } else if (tsType === 'Date') {
+       formattedValue = `new Date('${value}')`;
+     } else if (Array.isArray(value)) {
+       formattedValue = JSON.stringify(value);
+     } else {
+       formattedValue = `'${value}'`;
+     }
+-%>
+            <%= key %>: <%= formattedValue %><%= isLast ? '' : ',' %>
+<% } -%>
+          },
+          metadata: {
+            streamName: <%= streamNameValue %>,
+            streamPosition: <%= givenEvents.length + whenEvents.indexOf(evt) + 1 %>n,
+            globalPosition: <%= givenEvents.length + whenEvents.indexOf(evt) + 1 %>n,
+          },
+        },<% } } -%>])
+      .then(async (state) => {
+        const document = await state.database
+          .collection<<%= TargetType %>>('<%= projName %>')
+          .findOne((doc) => <%
+const idField = projectionIdField ?? 'id';
+if (idField.includes('-')) {
+    // Handle composite keys
+    const parts = idField.split('-');
+    const conditions = parts.map(part => {
+        const value = expectedState.exampleData?.[part];
+        const valueStr = typeof value === 'string' ? `'${value}'` : value || "'test-value'";
+        return `doc.${part} === ${valueStr}`;
+    }).join(' && ');
+%><%= conditions %><%
+} else {
+    const value = expectedState.exampleData?.[idField];
+    const valueStr = typeof value === 'string' ? `'${value}'` : value || "'test-id'";
+%>doc.<%= idField %> === <%= valueStr %><%
+}
+%>);
+
+        const expected: <%= TargetType %> = {
+<% const stateKeys = Object.keys(expectedState.exampleData || {});
+   for (let i = 0; i < stateKeys.length; i++) {
+     const key = stateKeys[i];
+     const value = expectedState.exampleData[key];
+     const isLast = i === stateKeys.length - 1;
+     const stateMessage = messages.find(m => m.name === targetName);
+     const field = stateMessage?.fields?.find(f => f.name === key);
+     const tsType = field?.tsType || field?.type || 'string';
+
+     let formattedValue;
+     if (value === null || value === undefined) {
+       formattedValue = 'null';
+     } else if (tsType === 'string' || tsType === 'ID') {
+       formattedValue = `'${value}'`;
+     } else if (tsType === 'number' || tsType === 'boolean') {
+       formattedValue = String(value);
+     } else if (tsType === 'Date') {
+       formattedValue = `new Date('${value}')`;
+     } else if (Array.isArray(value)) {
+       formattedValue = JSON.stringify(value);
+     } else {
+       formattedValue = `'${value}'`;
+     }
+-%>
+          <%= key %>: <%= formattedValue %><%= isLast ? '' : ',' %>
+<% } -%>
         };
 
         expect(document).toMatchObject(expected);
-    <%_ } _%>
-    }));
-    <%_ } _%>
-    });
+      }));
+<% } } %>
+});
+<% } -%>

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

@@ -4,28 +4,15 @@ type ReadEvent,
 type InMemoryReadEventMetadata,
 } from '@event-driven-io/emmett';
 import type { <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %> } from './state';<%
-if (events.length > 0) {
-    const importGroups = new Map();
-    for (const event of events) {
-        const fromSameFlow = event.sourceFlowName === flowName;
-        const basePath = fromSameFlow
-                ? `../${toKebabCase(event.sourceSliceName ?? 'unknown')}/events`
-                : `../${toKebabCase(event.sourceFlowName ?? 'unknown')}/${toKebabCase(event.sourceSliceName ?? 'unknown')}/events`;
-
-        if (!importGroups.has(basePath)) {
-            importGroups.set(basePath, []);
-        }
-        importGroups.get(basePath).push(event.type);
-    }
-
-        for (const [importPath, typeNames] of importGroups.entries()) {
+if (eventImportGroups.length > 0) {
+    for (const group of eventImportGroups) {
 %>
-    import type { <%= typeNames.join(', ') %> } from '<%= importPath %>';
+import type { <%= group.eventTypes.join(', ') %> } from '<%= group.importPath %>';
 <%
-}
+    }
 } -%>
 
-type AllEvents = <%= events.length > 0 ? events.map(e => e.type).join(' | ') : 'never' %>;
+type AllEvents = <%= allEventTypes %>;
 
 export const projection = inMemorySingleStreamProjection<
 <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %>,
@@ -33,7 +20,19 @@ AllEvents
 >({
 collectionName: '<%= pascalCase(slice.server?.data?.[0]?.origin?.name || "unknown-collection") %>',
 canHandle: [<%- events.map(e => `'${e.type}'`).join(', ') %>],
-getDocumentId: (event) => event.data.<%= slice.server?.data?.[0]?.origin?.idField ?? 'id' %>,
+getDocumentId: (event) => <%
+const idField = slice.server?.data?.[0]?.origin?.idField ?? 'id';
+// Check if idField contains hyphen-separated composite keys
+if (idField.includes('-')) {
+    const parts = idField.split('-');
+    const template = parts.map((part, index) =>
+        index === 0 ? `\${event.data.${part}}` : `-\${event.data.${part}}`
+    ).join('');
+%>`<%= template %>`<%
+} else {
+%>event.data.<%= idField %><%
+}
+%>,
 evolve: (
 document: <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %> | null,
 event: ReadEvent<AllEvents, InMemoryReadEventMetadata>
@@ -42,9 +41,11 @@ switch (event.type) {
 <% for (const event of events) {
     const targetName = slice.server?.data?.[0]?.target?.name;
     const queryGwt = slice.type === 'query'
-            ? queryGwtMapping.find(gwt =>
-                    gwt.given.some(g => g.eventRef === event.type)
-            )
+            ? queryGwtMapping.find(gwt => {
+                    const inGiven = gwt.given && gwt.given.some(g => g.eventRef === event.type);
+                    const inWhen = gwt.when.some(g => g.eventRef === event.type);
+                    return inGiven || inWhen;
+            })
             : undefined;
     const example = slice.type === 'query'
             ? queryGwt?.then.find(t => t.stateRef === targetName)?.exampleData
@@ -94,19 +95,19 @@ case '<%= event.type %>': {
 
         let placeholder = 'undefined';
         if (type === 'string' || type === 'ID') {
-            placeholder = "''";
+            placeholder = "/* TODO: map from event.data */ ''";
         } else if (type === 'number') {
-            placeholder = '0';
+            placeholder = '/* TODO: map from event.data */ 0';
         } else if (type === 'boolean') {
-            placeholder = 'false';
+            placeholder = '/* TODO: map from event.data */ false';
         } else if (type === 'Date') {
-            placeholder = 'new Date()';
+            placeholder = '/* TODO: map from event.data */ new Date()';
         } else if (type.startsWith('Array<')) {
-            placeholder = '[]';
+            placeholder = '/* TODO: map from event.data */ []';
         } else {
-            placeholder = '{} as any';
+            placeholder = '/* TODO: map from event.data */ undefined as any';
         }
-    %>          <%= field %>: /* TODO: map from event.data */ <%- placeholder %><%= isLast ? '' : ',' %>
+    %>        <%= field %>: <%- placeholder %><%= isLast ? '' : ',' %>
     <% } -%>
     };
 <% } -%>

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

@@ -67,7 +67,7 @@ describe('query.resolver.ts.ejs', () => {
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toMatchInlineSnapshot(`
-      "import { Query, Resolver, Arg, Ctx, ObjectType, Field } from 'type-graphql';
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, Float } from 'type-graphql';
       import { type GraphQLContext, ReadModel } from '../../../shared';
 
       @ObjectType()
@@ -99,7 +99,7 @@ describe('query.resolver.ts.ejs', () => {
           @Arg('maxPrice', () => Float, { nullable: true }) maxPrice?: number,
           @Arg('minGuests', () => Float, { nullable: true }) minGuests?: number,
         ): Promise<AvailableListings[]> {
-          const model = new ReadModel<AvailableListings>(ctx.eventStore, 'AvailablePropertiesProjection');
+          const model = new ReadModel<AvailableListings>(ctx.database, 'AvailablePropertiesProjection');
 
           // ## IMPLEMENTATION INSTRUCTIONS ##
           // You can query the projection using the ReadModel API:
@@ -190,7 +190,8 @@ describe('query.resolver.ts.ejs', () => {
     const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
 
     expect(resolverFile?.contents).toMatchInlineSnapshot(`
-      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from 'type-graphql';
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID, Float } from 'type-graphql';
+      import { GraphQLJSON } from 'graphql-type-json';
       import { type GraphQLContext, ReadModel } from '../../../shared';
 
       @ObjectType()
@@ -226,7 +227,7 @@ describe('query.resolver.ts.ejs', () => {
           @Ctx() ctx: GraphQLContext,
           @Arg('sessionId', () => ID, { nullable: true }) sessionId?: string,
         ): Promise<SuggestedItems[]> {
-          const model = new ReadModel<SuggestedItems>(ctx.eventStore, 'SuggestedItemsProjection');
+          const model = new ReadModel<SuggestedItems>(ctx.database, 'SuggestedItemsProjection');
 
           // ## IMPLEMENTATION INSTRUCTIONS ##
           // You can query the projection using the ReadModel API:
@@ -400,7 +401,7 @@ describe('query.resolver.ts.ejs', () => {
           @Ctx() ctx: GraphQLContext,
           @Arg('participantId', () => ID, { nullable: true }) participantId?: string,
         ): Promise<QuestionnaireProgress[]> {
-          const model = new ReadModel<QuestionnaireProgress>(ctx.eventStore, 'Questionnaires');
+          const model = new ReadModel<QuestionnaireProgress>(ctx.database, 'Questionnaires');
 
           // ## IMPLEMENTATION INSTRUCTIONS ##
           // You can query the projection using the ReadModel API:
@@ -422,4 +423,188 @@ describe('query.resolver.ts.ejs', () => {
       "
     `);
   });
+  it('should import Float when Float fields are used', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'product-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'get-product-price',
+              request: `
+                query GetProductPrice($productId: ID!) {
+                  productPrice(productId: $productId) {
+                    productId
+                    price
+                    discount
+                  }
+                }
+              `,
+              client: {
+                description: '',
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'productId',
+                      name: 'ProductPricesProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'ProductPrice',
+                    },
+                  },
+                ],
+                specs: { name: '', rules: [] },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'ProductPrice',
+          fields: [
+            { name: 'productId', type: 'string', required: true },
+            { name: 'price', type: 'number', required: true },
+            { name: 'discount', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain(
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID, Float } from 'type-graphql';",
+    );
+    expect(resolverFile?.contents).toContain('@Field(() => Float)');
+  });
+  it('should import Float when array of numbers is used', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'stats-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'get-stats',
+              request: `
+                query GetStats($userId: ID!) {
+                  stats(userId: $userId) {
+                    userId
+                    scores
+                  }
+                }
+              `,
+              client: {
+                description: '',
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'userId',
+                      name: 'StatsProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'Stats',
+                    },
+                  },
+                ],
+                specs: { name: '', rules: [] },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'Stats',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'scores', type: 'Array<number>', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain('Float');
+    expect(resolverFile?.contents).toContain('@Field(() => [Float])');
+  });
+  it('should import Float when Float query arg is used', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'search-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'search-products',
+              request: `
+                query SearchProducts($minPrice: Float, $maxPrice: Float) {
+                  searchProducts(minPrice: $minPrice, maxPrice: $maxPrice) {
+                    productId
+                    name
+                  }
+                }
+              `,
+              client: {
+                description: '',
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'productId',
+                      name: 'ProductsProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'Product',
+                    },
+                  },
+                ],
+                specs: { name: '', rules: [] },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'Product',
+          fields: [
+            { name: 'productId', type: 'string', required: true },
+            { name: 'name', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain('Float');
+    expect(resolverFile?.contents).toContain("@Arg('minPrice', () => Float");
+  });
 });

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

@@ -20,23 +20,46 @@ function baseTs(ts) {
 }
 function fieldUsesDate(ts) {
     const b = baseTs(ts);
-    if (b === 'Date') return true;
+    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);
-    if (b === 'unknown' || b === 'any' || b === 'object') return true;
+    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 => baseTs(a.tsType) === 'Date');
-const usesJSON = messageFields.some(f => fieldUsesJSON(f.type));
+        (parsedRequest?.args ?? []).some(a => fieldUsesDate(a.tsType));
+const usesJSON = messageFields.some(f => fieldUsesJSON(f.type)) ||
+        (parsedRequest?.args ?? []).some(a => fieldUsesJSON(a.tsType));
+const usesFloat = messageFields.some(f => fieldUsesFloat(f.type)) ||
+        (parsedRequest?.args ?? []).some(a => fieldUsesFloat(a.tsType));
 
-// Collect embedded types up-front so we can emit them before the parent
 const embeddedTypes = [];
 for (const field of messageFields) {
     const tsType = field.type ?? 'string';
@@ -48,13 +71,12 @@ for (const field of messageFields) {
     }
 }
 %>
-import { Query, Resolver, Arg, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %><% if (usesDate) { %>, GraphQLISODateTime<% } %> } from 'type-graphql';
+import { Query, Resolver, 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';
 
-<% // 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(/\[\]$/, '');
@@ -114,7 +136,7 @@ async <%= queryName %>(
 %>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
 <%   } } %>
 ): Promise<<%= viewType %>[]> {
-const model = new ReadModel<<%= viewType %>>(ctx.eventStore, '<%= projectionType %>');
+const model = new ReadModel<<%= viewType %>>(ctx.database, '<%= projectionType %>');
 
 // ## IMPLEMENTATION INSTRUCTIONS ##
 // You can query the projection using the ReadModel API: