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

package/dist/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');
 }
-};
+};

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

@@ -80,46 +80,224 @@ describe('evolve.ts.ejs', () => {
     const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
     const evolveFile = plans.find((p) => p.outputPath.endsWith('evolve.ts'));
 
-    expect(evolveFile?.contents).toMatchInlineSnapshot(`
-      "import type { State } from './state';
-      import type { ListingCreated } from './events';
+    const contents = evolveFile?.contents ?? '';
+    expect(contents).toContain('import type { State }');
+    expect(contents).toContain('ListingCreated');
+    expect(contents).toContain('export const evolve');
+    expect(contents).toContain('default:');
+    expect(contents).toContain('return state;');
+  });
+
+  it('should include sibling events from shared stream in evolve', 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 session',
+                    rules: [
+                      {
+                        name: 'Start session rule',
+                        examples: [
+                          {
+                            name: 'Start session example',
+                            steps: [
+                              { keyword: 'When', text: 'StartSession', docString: { userId: 'u1' } },
+                              {
+                                keyword: 'Then',
+                                text: 'SessionStarted',
+                                docString: { id: 's1', userId: 'u1' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'command',
+              name: 'Add exercise',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'ExerciseAdded' },
+                      destination: { type: 'stream', pattern: 'sessions-${sessionId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Add exercise',
+                    rules: [
+                      {
+                        name: 'Add exercise rule',
+                        examples: [
+                          {
+                            name: 'Add exercise example',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'ActiveSession',
+                                docString: { status: 'active' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'AddExercise',
+                                docString: { sessionId: 's1', exercise: 'pushup' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'ExerciseAdded',
+                                docString: { sessionId: 's1', exercise: 'pushup' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              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 session',
+                    rules: [
+                      {
+                        name: 'Complete session rule',
+                        examples: [
+                          {
+                            name: 'Complete session example',
+                            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: 'AddExercise',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'exercise', 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: 'ExerciseAdded',
+          source: 'internal',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'exercise', 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');
 
-      /**
-       * ## IMPLEMENTATION INSTRUCTIONS ##
-       *
-       * Evolve domain state in response to events.
-       * Only track fields needed for future decisions in decide.ts.
-       *
-       * RULES:
-       * - Return a new object literal for state transitions.
-       *   For no-op (event doesn’t affect state), return the existing \`state\`.
-       * - If State is a discriminated union (check state.ts), EVERY return
-       *   MUST include the discriminant field as a string literal.
-       *   Example: \`return { status: ‘active’, field: event.data.field };\`
-       * - NEVER spread ...event.data or ...state — list each field explicitly.
-       *
-       * VERIFY before finalizing:
-       *   [ ] 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.
-       */
+    const addExerciseEvolve = plans.find(
+      (p) => p.outputPath.includes('add-exercise') && p.outputPath.endsWith('evolve.ts'),
+    );
+    expect(addExerciseEvolve?.contents).toContain("import type { SessionStarted } from '../start-session/events';");
+    expect(addExerciseEvolve?.contents).toContain(
+      "import type { SessionCompleted } from '../complete-session/events';",
+    );
+    expect(addExerciseEvolve?.contents).toContain("case 'SessionStarted'");
+    expect(addExerciseEvolve?.contents).toContain("case 'ExerciseAdded'");
+    expect(addExerciseEvolve?.contents).toContain("case 'SessionCompleted'");
 
-      export const evolve = (state: State, event: ListingCreated): State => {
-        switch (event.type) {
-          case 'ListingCreated': {
-            // TODO: Return { status: 'variant', field1: ..., field2: ... } matching state.ts.
-            return state;
-          }
-          default:
-            return state;
-        }
-      };
-      "
-    `);
+    const completeSessionEvolve = plans.find(
+      (p) => p.outputPath.includes('complete-session') && p.outputPath.endsWith('evolve.ts'),
+    );
+    expect(completeSessionEvolve?.contents).toContain("import type { SessionStarted } from '../start-session/events';");
+    expect(completeSessionEvolve?.contents).toContain("import type { ExerciseAdded } from '../add-exercise/events';");
+    expect(completeSessionEvolve?.contents).toContain("case 'SessionStarted'");
+    expect(completeSessionEvolve?.contents).toContain("case 'ExerciseAdded'");
+    expect(completeSessionEvolve?.contents).toContain("case 'SessionCompleted'");
   });
 });

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

@@ -1,6 +1,6 @@
-<% if (events.length) { -%>
+<% if (allStreamEvents.length) { -%>
     import type { State } from './state';
-    <% for (const group of eventImportGroups) { -%>
+    <% for (const group of allStreamEventImportGroups) { -%>
         import type { <%= group.eventTypes.map(name => pascalCase(name)).join(', ') %> } from '<%= group.importPath %>';
     <% } -%>
 
@@ -12,10 +12,10 @@
     *
     * RULES:
     * - Return a new object literal for state transitions.
-    *   For no-op (event doesn’t affect state), return the existing `state`.
+    *   For no-op (event doesn't affect state), return the existing `state`.
     * - If State is a discriminated union (check state.ts), EVERY return
     *   MUST include the discriminant field as a string literal.
-    *   Example: `return { status: ‘active’, field: event.data.field };`
+    *   Example: `return { status: 'active', field: event.data.field };`
     * - NEVER spread ...event.data or ...state — list each field explicitly.
     *
     * VERIFY before finalizing:
@@ -31,10 +31,10 @@
 
     export const evolve = (
     state: State,
-    event: <%= events.map(e => pascalCase(e.type)).join(' | ') %>
+    event: <%= allStreamEvents.map(e => pascalCase(e.type)).join(' | ') %>
     ): State => {
     switch (event.type) {
-    <% events.forEach(event => { -%>
+    <% allStreamEvents.forEach(event => { -%>
         case '<%= event.type %>': {
         // TODO: Return { status: 'variant', field1: ..., field2: ... } matching state.ts.
         return state;
@@ -46,4 +46,4 @@
     };
 <% } else { -%>
     // No events defined yet. Evolve logic will be generated once events exist.
-<% } -%>
+<% } -%>

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

@@ -323,8 +323,10 @@ describe('generateScaffoldFilePlans', () => {
         // });
 
         await handler(eventStore, streamId, (state) =>
-          // TODO: add products as a parameter to decide once implemented above
-          decide(command, state /* products */),
+          // TODO: pass products in context once the integration call above is implemented
+          decide(command, state, {
+            /* products */
+          }),
         );
         return undefined;
       };
@@ -571,9 +573,10 @@ describe('generateScaffoldFilePlans', () => {
       });
 
       export const handle = async (eventStore: EventStore, command: LogWorkout): Promise<MessageHandlerResult> => {
-        const streamId = \`workouts-\${randomUUID()}\`;
+        const workoutId = randomUUID();
+        const streamId = \`workouts-\${workoutId}\`;
 
-        await handler(eventStore, streamId, (state) => decide(command, state));
+        await handler(eventStore, streamId, (state) => decide(command, state, { generated: { workoutId } }));
         return undefined;
       };
       "

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

@@ -65,7 +65,6 @@ const allCmdFieldSets = commands.map(c => new Set((c.fields ?? []).map(f => f.na
 const needsStreamGuard = streamVars.length > 0 && !allCmdFieldSets.every(fs => streamVars.every(v => fs.has(v)));
 const varInAnyCommand = (v) => allCmdFieldSets.some(fs => fs.has(v));
 const guardVars = needsStreamGuard ? streamVars.filter(v => varInAnyCommand(v)) : [];
-const uuidVars = needsStreamGuard ? streamVars.filter(v => !varInAnyCommand(v)) : [];
 %>
 
 <% if (uuidVars.length > 0) { -%>
@@ -102,6 +101,9 @@ eventStore: EventStore,
 command: <%= commands.map(c => pascalCase(c.type)).join(' | ') %>
 ): Promise<MessageHandlerResult> => {
     <% if (stream?.pattern?.includes('${')) { -%>
+        <% for (const v of uuidVars) { -%>
+            const <%= v %> = randomUUID();
+        <% } -%>
         <% if (!needsStreamGuard) { -%>
             const streamId = `<%= stream.pattern.replace(/\$\{([^}]+)\}/g, (_, key) => `\${command.data.${key}}`) %>`;
         <% } else { -%>
@@ -115,7 +117,7 @@ command: <%= commands.map(c => pascalCase(c.type)).join(' | ') %>
             <% } -%>
             const streamId = `<%= stream.pattern.replace(/\$\{([^}]+)\}/g, (_, key) => {
                 if (varInAnyCommand(key)) return '${commandData.' + key + '}';
-                return '${randomUUID()}';
+                return '${' + key + '}';
             }) %>`;
         <% } -%>
     <% } else { -%>
@@ -126,10 +128,20 @@ command: <%= commands.map(c => pascalCase(c.type)).join(' | ') %>
         <%= call %>
 
     <% }) -%>
+<%
+const hasGenerated = uuidVars.length > 0;
+const hasIntegration = needsReturnValue;
+const hasContext = hasGenerated || hasIntegration;
+const ctxParts = [];
+if (hasGenerated) ctxParts.push(`generated: { ${uuidVars.join(', ')} }`);
+if (hasIntegration) ctxParts.push(`/* ${resultVarName} */`);
+const contextStr = hasContext ? `, { ${ctxParts.join(', ')} }` : '';
+-%>
     await handler(eventStore, streamId, (state) =>
-    <%- needsReturnValue
-            ? `      // TODO: add ${resultVarName} as a parameter to decide once implemented above\n      decide(command, state, /* ${resultVarName} */)`
-            : `      decide(command, state)` %>
+<% if (hasIntegration) { -%>
+      // TODO: pass <%= resultVarName %> in context once the integration call above is implemented
+<% } -%>
+      decide(command, state<%= contextStr %>)
     );
     return undefined;
     };