@auto-engineer/server-generator-apollo-emmett 1.154.0 → 1.156.0

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

@@ -593,7 +593,7 @@ describe('decide.ts.ejs', () => {
       import type { ItemsSuggested } from './events';
       import type { Products } from '@auto-engineer/product-catalogue-integration';
 
-      export const decide = (command: SuggestItems, _state: State, products?: Products): ItemsSuggested => {
+      export const decide = (command: SuggestItems, _state: State, context?: { products?: Products }): ItemsSuggested => {
         switch (command.type) {
           case 'SuggestItems': {
             /**
@@ -604,7 +604,7 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
-          * - Use \`products\` (integration result) to enrich or filter the output
+          * - Use \`context?.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
@@ -613,7 +613,7 @@ describe('decide.ts.ejs', () => {
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
           *
           * Integration result shape (Products):
-          * products?.data = {
+          * context?.products?.data = {
           *   products: Array<{
       *     id: string;
       *     name: string;
@@ -648,4 +648,259 @@ describe('decide.ts.ejs', () => {
       "
     `);
   });
+
+  it('should generate context parameter and uuid assignment for stream uuid vars that are event fields', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Fitness tracker',
+          moments: [
+            {
+              type: 'command',
+              name: 'Log workout',
+              stream: 'workouts-${workoutId}',
+              client: { specs: [] },
+              server: {
+                description: 'test',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Workout logged',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { exercise: 'squat', reps: 10 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: { workoutId: 'wk-1', exercise: 'squat', reps: 10 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'WorkoutLogged' },
+                      destination: { type: 'stream', pattern: 'workouts-${workoutId}' },
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogWorkout',
+          fields: [
+            { name: 'exercise', type: 'string', required: true },
+            { name: 'reps', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'WorkoutLogged',
+          source: 'internal',
+          fields: [
+            { name: 'workoutId', type: 'string', required: true },
+            { name: 'exercise', type: 'string', required: true },
+            { name: 'reps', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find((p) => p.outputPath.endsWith('decide.ts'));
+
+    expect(decideFile?.contents).toMatchInlineSnapshot(`
+      "import { randomUUID } from 'node:crypto';
+      import { IllegalStateError } from '@event-driven-io/emmett';
+      import type { State } from './state';
+      import type { LogWorkout } from './commands';
+      import type { WorkoutLogged } from './events';
+
+      export const decide = (
+        command: LogWorkout,
+        _state: State,
+        context?: { generated?: { workoutId: string } },
+      ): WorkoutLogged => {
+        switch (command.type) {
+          case 'LogWorkout': {
+            /**
+      * ## IMPLEMENTATION INSTRUCTIONS ##
+      *
+      * This command can directly emit one or more events based on the input.
+      *
+      * You should:
+      * - Validate the command input fields
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - 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:
+      *   - Should log workout
+      */
+
+            const workoutId = context?.generated?.workoutId ?? randomUUID();
+
+            // IMPLEMENT: Use a typed variable to prevent type widening:
+            // const result: WorkoutLogged = {
+            //   type: 'WorkoutLogged',
+            //   data: { ...command.data, workoutId },
+            // };
+            // return result;
+
+            throw new IllegalStateError('Not yet implemented: ' + command.type);
+          }
+          default:
+            throw new IllegalStateError('Unexpected command type');
+        }
+      };
+      "
+    `);
+  });
+
+  it('should say Inspect _state for state-ref Given with preceding siblings', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Gym session',
+          moments: [
+            {
+              type: 'command',
+              name: 'Start session',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'SessionStarted' },
+                      destination: { type: 'stream', pattern: 'sessions-${id}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Start',
+                    rules: [
+                      {
+                        name: 'Start',
+                        examples: [
+                          {
+                            name: 'Start',
+                            steps: [
+                              { keyword: 'When', text: 'StartSession', docString: { userId: 'u1' } },
+                              { keyword: 'Then', text: 'SessionStarted', docString: { id: 's1', userId: 'u1' } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'command',
+              name: 'Complete session',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'SessionCompleted' },
+                      destination: { type: 'stream', pattern: 'sessions-${sessionId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Complete',
+                    rules: [
+                      {
+                        name: 'Complete',
+                        examples: [
+                          {
+                            name: 'Complete',
+                            steps: [
+                              { keyword: 'Given', text: 'ActiveSession', docString: { status: 'active' } },
+                              { keyword: 'When', text: 'CompleteSession', docString: { sessionId: 's1' } },
+                              {
+                                keyword: 'Then',
+                                text: 'SessionCompleted',
+                                docString: { sessionId: 's1', completedAt: '2024-01-15' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        { type: 'command', name: 'StartSession', fields: [{ name: 'userId', type: 'string', required: true }] },
+        { type: 'command', name: 'CompleteSession', fields: [{ name: 'sessionId', type: 'string', required: true }] },
+        {
+          type: 'event',
+          name: 'SessionStarted',
+          source: 'internal',
+          fields: [
+            { name: 'id', type: 'string', required: true },
+            { name: 'userId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'SessionCompleted',
+          source: 'internal',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'completedAt', type: 'string', required: true },
+          ],
+        },
+        { type: 'state', name: 'ActiveSession', fields: [{ name: 'status', type: 'string', required: true }] },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find(
+      (p) => p.outputPath.includes('complete-session') && p.outputPath.endsWith('decide.ts'),
+    );
+    const contents = decideFile?.contents ?? '';
+
+    expect(contents).toContain('requires evaluating prior state');
+    expect(contents).toContain('Inspect the current domain');
+    expect(contents).not.toContain('succeed from initial state');
+  });
 });

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

@@ -1,6 +1,7 @@
 <%
 const allEvents = [];
 const ruleGroups = new Map();
+const _stateRefGivenSeen = new Set();
 for (const commandName in gwtMapping) {
     const cases = gwtMapping[commandName];
     for (const gwt of cases) {
@@ -12,8 +13,17 @@ for (const commandName in gwtMapping) {
         if (gwt.given && gwt.given.length) {
             for (const g of gwt.given) {
                 if (g.eventRef) {
-                    const event = events.find(e => e.type === g.eventRef);
-                    if (event) allEvents.push(event);
+                    const event = allStreamEvents.find(e => e.type === g.eventRef);
+                    if (event) {
+                        allEvents.push(event);
+                    } else if (precedingSiblingEvents.length > 0 && !_stateRefGivenSeen.has(g.eventRef)) {
+                        _stateRefGivenSeen.add(g.eventRef);
+                        for (const se of precedingSiblingEvents) {
+                            if (!allEvents.some(e => e.type === se.type)) {
+                                allEvents.push(se);
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -33,7 +43,7 @@ const testEventsByPath = new Map();
 
 for (const event of allEvents) {
     if (!event.type) continue;
-    const importGroup = eventImportGroups.find(group =>
+    const importGroup = allStreamEventImportGroups.find(group =>
         group.eventTypes.includes(event.type)
     );
 
@@ -64,7 +74,7 @@ for (const commandName in gwtMapping) {
         const eventResults = gwt.then.filter(t => 'eventRef' in t);
         const errorResult = gwt.then.find(t => 'errorType' in t);
         if (errorResult) continue;
-        const givenEventRefs = (gwt.given || []).filter(g => events.some(ev => ev.type === g.eventRef));
+        const givenEventRefs = (gwt.given || []).filter(g => allStreamEvents.some(ev => ev.type === g.eventRef));
         for (const e of eventResults) {
             const dedupeKey = `${commandName}::${e.eventRef}`;
             if (seenCommandEvents.has(dedupeKey)) continue;
@@ -116,12 +126,22 @@ describe('<%= escapeJsString(ruleDescription) %>', () => {
 %>
   it('<%= escapeJsString(testDescription) %>', () => {
     given([
-<%_ const givenEvents = (gwt.given || []).filter(g => events.some(e => e.type === g.eventRef)); _%>
+<%_
+    let givenEvents = (gwt.given || []).filter(g => allStreamEvents.some(e => e.type === g.eventRef));
+    const hasStateRefGiven = (gwt.given || []).some(g => !allStreamEvents.some(e => e.type === g.eventRef));
+    if (givenEvents.length === 0 && hasStateRefGiven && precedingSiblingEvents.length > 0) {
+        givenEvents = precedingSiblingEvents;
+    }
+_%>
 <%_ if (givenEvents.length) { _%>
-      <%- givenEvents.map(g => `{
-        type: '${g.eventRef}',
-        data: ${formatDataObject(g.exampleData, events.find(e => e.type === g.eventRef))}
-      }`).join(',\n      ') %>
+      <%- givenEvents.map(g => {
+          const schema = allStreamEvents.find(e => e.type === (g.eventRef || g.type));
+          const data = g.exampleData || siblingExampleData[g.type] || {};
+          return `{
+        type: '${g.eventRef || g.type}',
+        data: ${formatDataObject(data, schema)}
+      }`;
+      }).join(',\n      ') %>
 <%_ } _%>
     ])
       .when({
@@ -171,7 +191,11 @@ describe('field completeness', () => {
     const firstScenario = scenarios[0];
     const gwt = firstScenario.gwt;
     const schema = commandSchemasByName[cmdName];
-    const givenEvents = (gwt.given || []).filter(g => events.some(e => e.type === g.eventRef));
+    let givenEvents = (gwt.given || []).filter(g => allStreamEvents.some(e => e.type === g.eventRef));
+    const hasStateRefGiven = (gwt.given || []).some(g => !allStreamEvents.some(e => e.type === g.eventRef));
+    if (givenEvents.length === 0 && hasStateRefGiven && precedingSiblingEvents.length > 0) {
+        givenEvents = precedingSiblingEvents;
+    }
     const example = gwt.when;
     const cmdFieldNames = firstScenario.cmdFieldNames;
     const filteredCmdData = Object.fromEntries(
@@ -181,10 +205,14 @@ describe('field completeness', () => {
   it('should include all required fields in <%= scenarios.map(s => s.eventRef).join(', ') %>', () => {
 <%_ if (givenEvents.length) { _%>
     const state = [
-      <%- givenEvents.map(g => `{
-        type: '${g.eventRef}' as const,
-        data: ${formatDataObject(g.exampleData, events.find(e => e.type === g.eventRef))}
-      }`).join(',\n      ') %>
+      <%- givenEvents.map(g => {
+          const schema = allStreamEvents.find(e => e.type === (g.eventRef || g.type));
+          const data = g.exampleData || siblingExampleData[g.type] || {};
+          return `{
+        type: '${g.eventRef || g.type}' as const,
+        data: ${formatDataObject(data, schema)}
+      }`;
+      }).join(',\n      ') %>
     ].reduce((s, e) => evolve(s, e), initialState());
 <%_ } else { _%>
     const state = initialState();

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

@@ -1,3 +1,24 @@
+<%
+const needsRandomUuidImport = (() => {
+    for (const cmdName of Object.keys(gwtMapping)) {
+        const cmdFieldSet = new Set((commandSchemasByName?.[cmdName]?.fields || []).map(f => f.name));
+        const scenarios = gwtMapping?.[cmdName] ?? [];
+        for (const v of (uuidVars || [])) {
+            if (cmdFieldSet.has(v)) continue;
+            for (const scenario of scenarios) {
+                for (const t of scenario.then.filter(t => 'eventRef' in t)) {
+                    const eventMsg = (messages || []).find(m => m.name === t.eventRef && m.type === 'event');
+                    if ((eventMsg?.fields || []).some(f => f.name === v)) return true;
+                }
+            }
+        }
+    }
+    return false;
+})();
+-%>
+<% if (needsRandomUuidImport) { -%>
+import { randomUUID } from 'node:crypto';
+<% } -%>
 import {
 IllegalStateError<% if (usedErrors.includes('ValidationError')) { %>, ValidationError<% } %><% if (usedErrors.includes('NotFoundError')) { %>, NotFoundError<% } %>
 } from '@event-driven-io/emmett';
@@ -16,6 +37,19 @@ const integrationReturnSystem = integration?._withState?.origin?.systems?.[0];
 const integrationReturnImportSource = integrations?.find(i => i.name === integrationReturnSystem)?.source;
 const integrationReturnFields = messages?.find(m => m.name === integrationReturnType && m.type === 'state')?.fields ?? [];
 
+const hasContextGenerated = (uuidVars || []).length > 0;
+const hasContextIntegration = !!integrationReturnType;
+const hasContext = hasContextGenerated || hasContextIntegration;
+const contextTypeParts = [];
+if (hasContextGenerated) {
+    const generatedFields = (uuidVars || []).map(v => `${v}: string`).join('; ');
+    contextTypeParts.push(`generated?: { ${generatedFields} }`);
+}
+if (hasContextIntegration) {
+    contextTypeParts.push(`${camelCase(integrationReturnType)}?: ${integrationReturnType}`);
+}
+const contextTypeStr = contextTypeParts.join('; ');
+
 function formatFieldDocLine(field) {
     const optional = field.required ? '' : '?';
     const name = `${field.name}${optional}`;
@@ -39,7 +73,7 @@ function formatFieldDocLine(field) {
 
 export const decide = (
 command: <%= Object.keys(gwtMapping).map(pascalCase).join(' | ') %>,
-_state: State<%= integrationReturnType ? `,\n  ${camelCase(integrationReturnType)}?: ${integrationReturnType}` : '' %>
+_state: State<%= hasContext ? `,\ncontext?: { ${contextTypeStr} }` : '' %>
 ): <%= uniqueEventTypes.length === 0
         ? 'never'
         : uniqueEventTypes.length === 1
@@ -49,11 +83,13 @@ switch (command.type) {
 <% for (const command of Object.keys(gwtMapping)) {
     const scenarios = gwtMapping?.[command] ?? [];
     const hasGivenEvents = scenarios.some(s =>
-        (s.given || []).some(g => events.some(e => e.type === g.eventRef))
+        (s.given || []).some(g => allStreamEvents.some(e => e.type === g.eventRef))
     );
     const hasGivenStates = scenarios.some(s =>
-        (s.given || []).some(g => !events.some(e => e.type === g.eventRef))
+        (s.given || []).some(g => !allStreamEvents.some(e => e.type === g.eventRef))
     );
+    const hasPrecedingSiblings = precedingSiblingEvents.length > 0;
+    const effectiveHasGivenEvents = hasGivenEvents || (hasGivenStates && hasPrecedingSiblings);
     const fallbackEvents = scenarios.flatMap(s => s.then.filter(t => 'eventRef' in t));
     const fallbackEventTypes = [...new Set(fallbackEvents.map(e => e.eventRef))];
 -%>
@@ -61,22 +97,22 @@ case '<%= command %>': {
 /**
 * ## IMPLEMENTATION INSTRUCTIONS ##
 *
-* This command <%= hasGivenEvents ? 'requires evaluating prior state to determine if it can proceed' : 'can directly emit one or more events based on the input' %>.
+* This command <%= effectiveHasGivenEvents ? 'requires evaluating prior state to determine if it can proceed' : 'can directly emit one or more events based on the input' %>.
 *
 * You should:
 * - Validate the command input fields
-<% if (hasGivenEvents) { -%>
+<% if (effectiveHasGivenEvents) { -%>
 * - Inspect the current domain `_state` to determine if the command is allowed
 <% } -%>
 * - NEVER use `as SomeType` type assertions — not `as any`, not `as EventType`, no casts at all. Use typed variable declarations.
-<% if (hasGivenEvents) { -%>
+<% if (effectiveHasGivenEvents) { -%>
 * - 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.
 <% } else if (hasGivenStates) { -%>
 * - The test uses given([]) with initialState(). Do not narrow or guard on _state — the command should succeed from initial state.
 <% } -%>
 <% if (integrationReturnType) { -%>
-    * - Use `<%= camelCase(integrationReturnType) %>` (integration result) to enrich or filter the output
+    * - Use `context?.<%= camelCase(integrationReturnType) %>` (integration result) to enrich or filter the output
 <% } -%>
 * - If invalid, throw one of the following domain errors: `IllegalStateError`<% if (usedErrors.includes('ValidationError')) { %>, `ValidationError`<% } %><% if (usedErrors.includes('NotFoundError')) { %>, `NotFoundError`<% } %>
 *   ⚠️ 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? }<% } %>
@@ -87,7 +123,7 @@ case '<%= command %>': {
 <% if (integrationReturnFields.length > 0) { -%>
     *
     * Integration result shape (<%= integrationReturnType %>):
-    * <%= camelCase(integrationReturnType) %>?.data = {
+    * context?.<%= camelCase(integrationReturnType) %>?.data = {
     <%= integrationReturnFields.flatMap(formatFieldDocLine).join('\n') %>
     * }
 <% } -%>
@@ -123,28 +159,39 @@ for (const scenario of scenarios) {
         }
     }
 }
+const uuidAssignments = (uuidVars || []).filter(v => nonCommandFields.some(f => f.name === v));
+const filteredNonCommandFields = nonCommandFields.filter(f => !(uuidVars || []).includes(f.name));
 const eventResults = scenarios.flatMap(s => s.then.filter(t => 'eventRef' in t));
-const givenEventsForCmd = scenarios.flatMap(s =>
-    (s.given || []).filter(g => events.some(e => e.type === g.eventRef))
+let givenEventsForCmd = scenarios.flatMap(s =>
+    (s.given || []).filter(g => allStreamEvents.some(e => e.type === g.eventRef))
 );
+if (givenEventsForCmd.length === 0 && hasGivenStates && hasPrecedingSiblings) {
+    givenEventsForCmd = precedingSiblingEvents.map(e => ({
+        eventRef: e.type,
+        exampleData: siblingExampleData[e.type] || {},
+    }));
+}
 const { fields: derivedDateFieldNames } = findDerivedDateInfo(eventResults, cmdFieldSet, givenEventsForCmd);
 const derivedDateFields = new Set(derivedDateFieldNames);
 const keepFieldNamesSet = buildKeepFieldNames(eventResults, cmdFieldSet, derivedDateFieldNames, givenEventsForCmd);
 -%>
-<% if (nonCommandFields.length > 0) { -%>
+<% for (const v of uuidAssignments) { -%>
+const <%= v %> = context?.generated?.<%= v %> ?? randomUUID();
+<% } -%>
+<% if (filteredNonCommandFields.length > 0) { -%>
 // ⚠️ REQUIRED: Your return value MUST include ALL fields defined in the event type.
 // Tests use partial matching and may not check every field — passing tests does NOT mean all fields are present.
 // Do NOT use 'as <%= fallbackEventTypes[0] ? pascalCase(fallbackEventTypes[0]) : 'EventType' %>' to silence missing fields.
 //
 // Fields from command input → use ...command.data or command.data.<fieldName>
 // Fields NOT in command input → produce dynamically (never hardcode):
-<% for (const f of nonCommandFields) {
+<% for (const f of filteredNonCommandFields) {
     const isDerivedDate = derivedDateFields.has(f.name);
     const isAssertedByTest = keepFieldNamesSet.has(f.name);
 -%>
 <% if (isDerivedDate) { -%>
 //   <%= f.name %>: <%= f.type || f.tsType %> — derive from command.metadata?.now (convert Date to ISO string, e.g., .toISOString().substring(0, 10))
-<% } else if (hasGivenEvents) { -%>
+<% } else if (effectiveHasGivenEvents) { -%>
 //   <%= f.name %>: <%= f.type || f.tsType %> — derive from _state, generate at runtime (e.g., crypto.randomUUID()), or compute from command.data
 <% } else if (!isAssertedByTest) { -%>
 //   <%= f.name %>: <%= f.type || f.tsType %> — not asserted by test; produce a valid runtime value (e.g., crypto.randomUUID() for IDs, '' for other strings)
@@ -152,14 +199,14 @@ const keepFieldNamesSet = buildKeepFieldNames(eventResults, cmdFieldSet, derived
 //   <%= f.name %>: <%= f.type || f.tsType %> — generate at runtime (e.g., crypto.randomUUID()), or compute from command.data
 <% } -%>
 <% } -%>
-<% } else { -%>
+<% } else if (uuidAssignments.length === 0) { -%>
 // All event fields come from command input — use ...command.data to pass them through.
 <% } -%>
 
 // IMPLEMENT: Use a typed variable to prevent type widening:
 // const result: <%= pascalCase(fallbackEventTypes[0] ?? 'TODO_EVENT_TYPE') %> = {
 //   type: '<%= fallbackEventTypes[0] %>',
-//   data: { ...command.data<%= nonCommandFields.length > 0 ? `, /* + produce: ${nonCommandFields.map(f => f.name).join(', ')} */` : '' %> },
+//   data: { ...command.data<%= uuidAssignments.length > 0 ? `, ${uuidAssignments.join(', ')}` : '' %><%= filteredNonCommandFields.length > 0 ? `, /* + produce: ${filteredNonCommandFields.map(f => f.name).join(', ')} */` : '' %> },
 // };
 // return result;
 
@@ -169,4 +216,4 @@ throw new IllegalStateError('Not yet implemented: ' + command.type);
 default:
 throw new IllegalStateError('Unexpected command type');
 }
-};
+};