@auto-engineer/server-generator-apollo-emmett 1.110.4 → 1.110.5

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @auto-engineer/server-generator-apollo-emmett@1.110.4 build /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
+> @auto-engineer/server-generator-apollo-emmett@1.110.5 build /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
 > tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src
 
 Fixed ESM imports in dist/

package/.turbo/turbo-test.log

@@ -1,14 +1,14 @@
 
-> @auto-engineer/server-generator-apollo-emmett@1.110.3 test /home/runner/work/auto-engineer/auto-engineer/packages/server-generator-apollo-emmett
+> @auto-engineer/server-generator-apollo-emmett@1.110.4 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  34 passed | 1 skipped (35)
-      Tests  247 passed | 1 skipped (248)
-   Start at  19:15:03
-   Duration  28.80s (transform 4.13s, setup 0ms, collect 60.01s, tests 11.22s, environment 8ms, prepare 5.24s)
+      Tests  248 passed | 1 skipped (249)
+   Start at  19:20:24
+   Duration  37.15s (transform 6.96s, setup 0ms, collect 76.28s, tests 18.25s, environment 21ms, prepare 5.95s)
 

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

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

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @auto-engineer/server-generator-apollo-emmett
 
+## 1.110.5
+
+### Patch Changes
+
+- [`0e1e74c`](https://github.com/BeOnAuto/auto-engineer/commit/0e1e74ce67838d17108d50173d7f435d38307fca) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: add test for query arg exclusion with differing values
+
+- [`31f4711`](https://github.com/BeOnAuto/auto-engineer/commit/31f47112be977b55d13bfcf24f3c38f5511d8307) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: add ketchup plan for projection spec query arg fix
+
+- [`24756e3`](https://github.com/BeOnAuto/auto-engineer/commit/24756e3c626032108e0a7d4fb5e9fa4792853f53) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **global**: increase express.json body size limit to 10mb
+  - **server-implementer**: exclude spec files from AI context in implement-slice
+  - **server-generator-apollo-emmett**: enrich missing event data in react specs template
+
+- [`bf35e68`](https://github.com/BeOnAuto/auto-engineer/commit/bf35e68a2e76d6943c97c5036b899b087bc68a32) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: add CONSTRAINTS block to evolve.ts template
+
+- [`437d8cc`](https://github.com/BeOnAuto/auto-engineer/commit/437d8ccd999f8a6dd606f1b3767c9c3af7d11edf) Thanks [@github-actions[bot]](https://github.com/github-actions%5Bbot%5D)! - - **global**: version packages
+  - **pipeline**: remove redundant client checks from pipeline events
+
+- [`9e2ccac`](https://github.com/BeOnAuto/auto-engineer/commit/9e2ccacccff33c9693829178af4eab28cf709e9f) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: exclude query arg fields from projection spec expected state
+
+- [`d5d7a36`](https://github.com/BeOnAuto/auto-engineer/commit/d5d7a368505d6450909589c43bf8033a11e55e5a) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: add CONSTRAINTS block to react.ts template
+
+- [`8be0b53`](https://github.com/BeOnAuto/auto-engineer/commit/8be0b53f9e6f51aeb4759e461e8511de3c601885) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **global**: add ketchup plan for post-implementation fixes round 2
+
+- [`b2614ef`](https://github.com/BeOnAuto/auto-engineer/commit/b2614ef82c97b4766fdc606737ae6d5ab481c2e5) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **global**: mark all round 2 fix bursts as done in ketchup plan
+
+- [`142abac`](https://github.com/BeOnAuto/auto-engineer/commit/142abacab3ea4e0357372850ff8bdf0b55cd8f7a) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: add CONSTRAINTS block to projection.ts and fix cast guidance
+
+- [`9684c1f`](https://github.com/BeOnAuto/auto-engineer/commit/9684c1f1e45791b7bc6542229ef48ca76b8eef80) Thanks [@SamHatoum](https://github.com/SamHatoum)! - - Fixed missing dependencies in React client generation to ensure proper optimization support
+
+- [`aa189ea`](https://github.com/BeOnAuto/auto-engineer/commit/aa189eaa1d6309126c2554b717ddd51cc11b16b7) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: broaden cast prohibition and add field constraint in decide.ts
+
+- [`4646433`](https://github.com/BeOnAuto/auto-engineer/commit/4646433ec25262d042001e5fd127a9b24003dfea) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: filter command .when() data to schema fields in decide.specs
+
+- [`b64ef2e`](https://github.com/BeOnAuto/auto-engineer/commit/b64ef2e679462a8389b27e7fd0b59d2db516d10f) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: use NOTE instead of TODO for non-matching query args
+
+- [`3b0afad`](https://github.com/BeOnAuto/auto-engineer/commit/3b0afad3754c7a89bfb5c83fab8138ca97eb7b21) Thanks [@rami-hatoum](https://github.com/rami-hatoum)! - - **server-generator-apollo-emmett**: add CONSTRAINTS block to register.ts template
+
+- Updated dependencies [[`0e1e74c`](https://github.com/BeOnAuto/auto-engineer/commit/0e1e74ce67838d17108d50173d7f435d38307fca), [`31f4711`](https://github.com/BeOnAuto/auto-engineer/commit/31f47112be977b55d13bfcf24f3c38f5511d8307), [`24756e3`](https://github.com/BeOnAuto/auto-engineer/commit/24756e3c626032108e0a7d4fb5e9fa4792853f53), [`bf35e68`](https://github.com/BeOnAuto/auto-engineer/commit/bf35e68a2e76d6943c97c5036b899b087bc68a32), [`437d8cc`](https://github.com/BeOnAuto/auto-engineer/commit/437d8ccd999f8a6dd606f1b3767c9c3af7d11edf), [`9e2ccac`](https://github.com/BeOnAuto/auto-engineer/commit/9e2ccacccff33c9693829178af4eab28cf709e9f), [`d5d7a36`](https://github.com/BeOnAuto/auto-engineer/commit/d5d7a368505d6450909589c43bf8033a11e55e5a), [`8be0b53`](https://github.com/BeOnAuto/auto-engineer/commit/8be0b53f9e6f51aeb4759e461e8511de3c601885), [`b2614ef`](https://github.com/BeOnAuto/auto-engineer/commit/b2614ef82c97b4766fdc606737ae6d5ab481c2e5), [`142abac`](https://github.com/BeOnAuto/auto-engineer/commit/142abacab3ea4e0357372850ff8bdf0b55cd8f7a), [`9684c1f`](https://github.com/BeOnAuto/auto-engineer/commit/9684c1f1e45791b7bc6542229ef48ca76b8eef80), [`aa189ea`](https://github.com/BeOnAuto/auto-engineer/commit/aa189eaa1d6309126c2554b717ddd51cc11b16b7), [`4646433`](https://github.com/BeOnAuto/auto-engineer/commit/4646433ec25262d042001e5fd127a9b24003dfea), [`b64ef2e`](https://github.com/BeOnAuto/auto-engineer/commit/b64ef2e679462a8389b27e7fd0b59d2db516d10f), [`3b0afad`](https://github.com/BeOnAuto/auto-engineer/commit/3b0afad3754c7a89bfb5c83fab8138ca97eb7b21)]:
+  - @auto-engineer/message-bus@1.110.5
+  - @auto-engineer/narrative@1.110.5
+
 ## 1.110.4
 
 ### Patch Changes

package/dist/src/codegen/templates/command/decide.specs.ts

@@ -97,13 +97,14 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - Inspect the current domain \`_state\` to determine if the command is allowed
-      * - If State is a discriminated union, NEVER use \`as any\` to bypass type checking.
-      *   Narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If State is a discriminated union, narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
       *   After narrowing, access variant fields directly — TypeScript infers the correct type.
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
       *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
 
       * Business rules:
@@ -235,13 +236,14 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - Inspect the current domain \`_state\` to determine if the command is allowed
-      * - If State is a discriminated union, NEVER use \`as any\` to bypass type checking.
-      *   Narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If State is a discriminated union, narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
       *   After narrowing, access variant fields directly — TypeScript infers the correct type.
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
       *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
 
       * Business rules:
@@ -399,13 +401,14 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - Inspect the current domain \`_state\` to determine if the command is allowed
-      * - If State is a discriminated union, NEVER use \`as any\` to bypass type checking.
-      *   Narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If State is a discriminated union, narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
       *   After narrowing, access variant fields directly — TypeScript infers the correct type.
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`, \`ValidationError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message, ValidationError takes a string message
       * - If valid, return one or more events with the correct structure
       *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
 
       * Business rules:
@@ -601,14 +604,15 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - Inspect the current domain \`_state\` to determine if the command is allowed
-      * - If State is a discriminated union, NEVER use \`as any\` to bypass type checking.
-      *   Narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If State is a discriminated union, narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
       *   After narrowing, access variant fields directly — TypeScript infers the correct type.
           * - Use \`products\` (integration result) to enrich or filter the output
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
       *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
           *
           * Integration result shape (Products):

package/dist/src/codegen/templates/command/decide.specs.ts.ejs

@@ -145,8 +145,13 @@ describe('<%= ruleDescription %>', () => {
     ])
       .when({
         type: '<%= example.commandRef %>',
-        data: <%- formatDataObject(example.exampleData, schema) %>,
 <%  const commandFieldNames = new Set(schema?.fields?.map(f => f.name) || []);
+    const filteredCmdData = Object.fromEntries(
+      Object.entries(example.exampleData || {}).filter(([key]) => commandFieldNames.has(key))
+    );
+-%>
+        data: <%- formatDataObject(filteredCmdData, schema) %>,
+<%
     const { date: derivedDate, fields: derivedDateFieldNames } = findDerivedDateInfo(eventResults, commandFieldNames, gwt.given);
     const keepFieldNames = buildKeepFieldNames(eventResults, commandFieldNames, derivedDateFieldNames, gwt.given);
 -%>

package/dist/src/codegen/templates/command/decide.ts.ejs

@@ -61,8 +61,8 @@ case '<%= command %>': {
 * You should:
 * - Validate the command input fields
 * - Inspect the current domain `_state` to determine if the command is allowed
-* - If State is a discriminated union, NEVER use `as any` to bypass type checking.
-*   Narrow with the discriminant: `if (_state.status !== 'active') throw new IllegalStateError('...');`
+* - NEVER use `as SomeType` type assertions — not `as any`, not `as EventType`, no casts at all. Use typed variable declarations.
+* - If State is a discriminated union, narrow with the discriminant: `if (_state.status !== 'active') throw new IllegalStateError('...');`
 *   After narrowing, access variant fields directly — TypeScript infers the correct type.
 <% if (integrationReturnType) { -%>
     * - Use `<%= camelCase(integrationReturnType) %>` (integration result) to enrich or filter the output
@@ -71,6 +71,7 @@ case '<%= command %>': {
 *   ⚠️ Error constructors: IllegalStateError takes a string message<% if (usedErrors.includes('ValidationError')) { %>, ValidationError takes a string message<% } %><% if (usedErrors.includes('NotFoundError')) { %>, NotFoundError takes { id, type, message? }<% } %>
 * - If valid, return one or more events with the correct structure
 *
+* - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
 * ⚠️ Only read from inputs — never mutate them. `evolve.ts` handles state updates.
 <% if (integrationReturnFields.length > 0) { -%>
     *

package/dist/src/codegen/templates/command/evolve.specs.ts

@@ -102,6 +102,11 @@ describe('evolve.ts.ejs', () => {
        *   [ ] Every return (except \`return state;\`) matches a variant from state.ts
        *   [ ] Every return includes the discriminant field
        *   [ ] No spread operators in return statements
+       *
+       * CONSTRAINTS:
+       * - NEVER use \`as SomeType\` type assertions. Return properly typed object literals.
+       * - Only reference event.data fields that exist on the event type (check imports above).
+       * - Only return fields that exist in the State type (check state.ts). Do NOT invent new fields.
        */
 
       export const evolve = (state: State, event: ListingCreated): State => {

package/dist/src/codegen/templates/command/evolve.ts.ejs

@@ -22,6 +22,11 @@
     *   [ ] Every return (except `return state;`) matches a variant from state.ts
     *   [ ] Every return includes the discriminant field
     *   [ ] No spread operators in return statements
+    *
+    * CONSTRAINTS:
+    * - NEVER use `as SomeType` type assertions. Return properly typed object literals.
+    * - Only reference event.data fields that exist on the event type (check imports above).
+    * - Only return fields that exist in the State type (check state.ts). Do NOT invent new fields.
     */
 
     export const evolve = (

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

@@ -1202,8 +1202,7 @@ describe('projection.specs.ts.ejs', () => {
                 .collection<WorkoutHistory>('WorkoutHistoryProjection')
                 .findOne((doc) => doc.memberId === 'mem_001');
 
-              const expected: WorkoutHistory = {
-                memberId: 'mem_001',
+              const expected = {
                 totalCalories: 250,
               };
 
@@ -1214,6 +1213,224 @@ describe('projection.specs.ts.ejs', () => {
     `);
   });
 
+  it('should exclude query arg fields that differ from projection-computed values', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'fart-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'log-fart',
+              stream: 'farts-${userId}',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log fart command',
+                    rules: [
+                      {
+                        name: 'Should record farts',
+                        examples: [
+                          {
+                            name: 'User logs fart',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogFart',
+                                docString: { userId: 'usr_123', intensity: 7 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'FartLogged',
+                                docString: { userId: 'usr_123', fartId: 'fart_456', intensity: 7 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'query',
+              name: 'view-fart-history',
+              stream: 'farts',
+              request:
+                'query GetFartHistory($userId: ID!, $minIntensity: Int) { fartHistory(userId: $userId, minIntensity: $minIntensity) { farts { fartId intensity } } }',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'State', name: 'FartHistory' },
+                      origin: { type: 'projection', name: 'FartHistoryProjection', idField: 'userId' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'View fart history query',
+                    rules: [
+                      {
+                        name: 'Fart history projection',
+                        examples: [
+                          {
+                            name: 'Shows farts after logging',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'FartLogged',
+                                docString: { userId: 'usr_123', fartId: 'fart_456', intensity: 7 },
+                              },
+                              {
+                                keyword: 'Given',
+                                text: 'FartLogged',
+                                docString: { userId: 'usr_123', fartId: 'fart_789', intensity: 9 },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'GetFartHistory',
+                                docString: { userId: 'usr_123', minIntensity: 6 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'FartHistory',
+                                docString: {
+                                  userId: 'usr_123',
+                                  farts: [
+                                    { fartId: 'fart_456', intensity: 7 },
+                                    { fartId: 'fart_789', intensity: 9 },
+                                  ],
+                                  minIntensity: 6,
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogFart',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'intensity', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'FartLogged',
+          source: 'internal',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'fartId', type: 'string', required: true },
+            { name: 'intensity', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'query',
+          name: 'GetFartHistory',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'minIntensity', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'FartHistory',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'farts', type: 'Array<{ fartId: string; intensity: number }>', required: true },
+            { name: 'minIntensity', type: 'number', required: true },
+          ],
+        },
+      ],
+    } as SpecsSchema;
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('view-fart-history/projection.specs.ts'));
+
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, it, beforeEach, expect } from 'vitest';
+      import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
+      import { projection } from './projection';
+      import type { FartLogged } from '../log-fart/events';
+      import { FartHistory } from './state';
+
+      type ProjectionEvent = FartLogged;
+
+      describe('Fart history projection', () => {
+        let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+        beforeEach(() => {
+          given = InMemoryProjectionSpec.for({ projection });
+        });
+
+        it('Shows farts after logging', () =>
+          given([
+            {
+              type: 'FartLogged',
+              data: {
+                userId: 'usr_123',
+                fartId: 'fart_456',
+                intensity: 7,
+              },
+              metadata: {
+                streamName: 'farts',
+                streamPosition: 1n,
+                globalPosition: 1n,
+              },
+            },
+            {
+              type: 'FartLogged',
+              data: {
+                userId: 'usr_123',
+                fartId: 'fart_789',
+                intensity: 9,
+              },
+              metadata: {
+                streamName: 'farts',
+                streamPosition: 1n,
+                globalPosition: 1n,
+              },
+            },
+          ])
+            .when([])
+            .then(async (state) => {
+              const document = await state.database
+                .collection<FartHistory>('FartHistoryProjection')
+                .findOne((doc) => doc.userId === 'usr_123');
+
+              const expected = {
+                farts: [
+                  { fartId: 'fart_456', intensity: 7 },
+                  { fartId: 'fart_789', intensity: 9 },
+                ],
+              };
+
+              expect(document).toMatchObject(expected);
+            }));
+      });
+      "
+    `);
+  });
+
   it('should serialize inline objects and arrays with Date sub-fields correctly', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
@@ -1572,6 +1789,11 @@ describe('projection.specs.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * Implement how this event updates the projection.
           *
@@ -1584,11 +1806,12 @@ describe('projection.specs.ts.ejs', () => {
           *      internalField: SomeType;
           *    }
           *
-          * 2. Cast document parameter to extended type:
+          * 2. Assign document to extended type:
           *    const current: InternalWorkoutHistory = document ?? { ...defaults };
           *
-          * 3. Cast return values to extended type:
-          *    return { ...allFields, internalField } as InternalWorkoutHistory;
+          * 3. Return via typed variable (preserves internal state for next event):
+          *    const result: InternalWorkoutHistory = { ...allFields, internalField };
+          *    return result;
           *
           * This keeps internal state separate from the public GraphQL schema.
 

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

@@ -244,6 +244,11 @@ describe('projection.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * Implement how this event updates the projection.
           *
@@ -256,11 +261,12 @@ describe('projection.ts.ejs', () => {
           *      internalField: SomeType;
           *    }
           *
-          * 2. Cast document parameter to extended type:
+          * 2. Assign document to extended type:
           *    const current: InternalAvailableListings = document ?? { ...defaults };
           *
-          * 3. Cast return values to extended type:
-          *    return { ...allFields, internalField } as InternalAvailableListings;
+          * 3. Return via typed variable (preserves internal state for next event):
+          *    const result: InternalAvailableListings = { ...allFields, internalField };
+          *    return result;
           *
           * This keeps internal state separate from the public GraphQL schema.
 
@@ -284,6 +290,11 @@ describe('projection.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * This event might indicate removal of a AvailableListings.
           *
@@ -588,6 +599,11 @@ describe('projection.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * **SINGLETON AGGREGATION PATTERN**
           *
@@ -810,6 +826,11 @@ describe('projection.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * **COMPOSITE KEY PROJECTION**
           *

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

@@ -277,13 +277,23 @@ if (isCompositeKey) {
 }
 %>
 
-        const expected: <%= TargetType %> = {
-<% const stateKeys = Object.keys(expectedState.exampleData || {});
+<%
+   const stateKeys = Object.keys(expectedState.exampleData || {});
+   const queryArgs = isQueryActionTest
+     ? (testCase.when?.args
+       || (Array.isArray(testCase.when) && testCase.when[0]?.exampleData)
+       || {})
+     : {};
+   const queryArgKeys = new Set(Object.keys(queryArgs));
+   const assertionKeys = stateKeys.filter(k => !queryArgKeys.has(k));
    const stateMessage = messages.find(m => m.name === targetName);
-   for (let i = 0; i < stateKeys.length; i++) {
-     const key = stateKeys[i];
+   const isPartial = assertionKeys.length < stateKeys.length;
+-%>
+        const expected<%= isPartial ? '' : `: ${TargetType}` %> = {
+<% for (let i = 0; i < assertionKeys.length; i++) {
+     const key = assertionKeys[i];
      const value = expectedState.exampleData[key];
-     const isLast = i === stateKeys.length - 1;
+     const isLast = i === assertionKeys.length - 1;
      const field = stateMessage?.fields?.find(f => f.name === key);
      const tsType = field?.tsType || field?.type || 'string';
      const formattedValue = formatSpecValue(value, tsType);

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

@@ -132,6 +132,11 @@ case '<%= event.type %>': {
 * Preserve all import paths above — they are generated from the model.
 * ⚠️ `document` may be null (first event for this entity). Guard before accessing properties.
 *
+* CONSTRAINTS:
+* - NEVER use `as SomeType` type assertions. Declare typed variables instead: `const x: Type = value;`
+* - Only reference event.data fields listed in the "Event fields:" line below.
+* - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
+*
 <% if (isSingleton) { -%>
     * **SINGLETON AGGREGATION PATTERN**
     *
@@ -188,11 +193,12 @@ case '<%= event.type %>': {
     *      internalField: SomeType;
     *    }
     *
-    * 2. Cast document parameter to extended type:
+    * 2. Assign document to extended type:
     *    const current: Internal<%= pascalCase(targetName || 'State') %> = document ?? { ...defaults };
     *
-    * 3. Cast return values to extended type:
-    *    return { ...allFields, internalField } as Internal<%= pascalCase(targetName || 'State') %>;
+    * 3. Return via typed variable (preserves internal state for next event):
+    *    const result: Internal<%= pascalCase(targetName || 'State') %> = { ...allFields, internalField };
+    *    return result;
     *
     * This keeps internal state separate from the public GraphQL schema.
 <% } -%>