@auto-engineer/server-generator-apollo-emmett 1.104.0 → 1.105.0

package/src/codegen/templates/react/react.specs.specs.ts

@@ -72,14 +72,6 @@ describe('react.specs.ts.ejs (react slice)', () => {
               name: 'Send notification to host',
               server: {
                 description: 'Sends a host notification command in response to BookingRequested',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'NotifyHost' },
-                      destination: { type: 'stream', pattern: 'booking-${hostId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',
@@ -291,14 +283,6 @@ describe('react.specs.ts.ejs (react slice)', () => {
               name: 'Process tip after completion',
               server: {
                 description: 'Processes tip command after appointment completion',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'ProcessTip' },
-                      destination: { type: 'stream', pattern: 'tips-${appointmentId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',
@@ -409,14 +393,6 @@ describe('react.specs.ts.ejs (react slice)', () => {
               name: 'notify milestone',
               server: {
                 description: 'Notifies on milestone',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'SendNotification' },
-                      destination: { type: 'stream', pattern: 'notif-${memberId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',
@@ -532,14 +508,6 @@ describe('react.specs.ts.ejs (react slice)', () => {
               name: 'notify barber of cancellation',
               server: {
                 description: 'Notifies barber when appointment is cancelled',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'NotifyBarber' },
-                      destination: { type: 'stream', pattern: 'barber-${barberId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',

package/src/codegen/templates/react/react.ts.specs.ts

@@ -15,14 +15,6 @@ describe('react.ts.ejs', () => {
               name: 'missing-when-slice',
               server: {
                 description: 'A react slice with no When step',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'DoSomething' },
-                      destination: { type: 'stream', pattern: 'things-${id}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',
@@ -113,14 +105,6 @@ describe('react.ts.ejs', () => {
               name: 'Send order confirmation',
               server: {
                 description: 'Sends confirmation after order placed',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'SendConfirmation' },
-                      destination: { type: 'stream', pattern: 'confirmations-${orderId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',
@@ -238,14 +222,6 @@ describe('react.ts.ejs', () => {
               name: 'Notify Barber of Cancellation',
               server: {
                 description: 'Notifies barber when appointment is cancelled',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'NotifyBarber' },
-                      destination: { type: 'stream', pattern: 'barber-${barberId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',
@@ -335,7 +311,6 @@ describe('react.ts.ejs', () => {
                   items: [
                     {
                       target: { type: 'Event', name: 'BarberNotified' },
-                      destination: { type: 'stream', pattern: 'barber-${barberId}' },
                     },
                   ],
                 },
@@ -466,14 +441,6 @@ export type BarberNotified = Event<
               name: 'notify barber of cancellation',
               server: {
                 description: 'Notifies barber when appointment is cancelled',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'NotifyBarber' },
-                      destination: { type: 'stream', pattern: 'barber-${barberId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',
@@ -607,14 +574,6 @@ export type BarberNotified = Event<
               name: 'notify milestone',
               server: {
                 description: 'Notifies on milestone',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'SendNotification' },
-                      destination: { type: 'stream', pattern: 'notif-${memberId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',
@@ -728,14 +687,6 @@ export type BarberNotified = Event<
               name: 'check record updates',
               server: {
                 description: 'Updates records after workout',
-                data: {
-                  items: [
-                    {
-                      target: { type: 'Command', name: 'UpdateRecord' },
-                      destination: { type: 'stream', pattern: 'records-${memberId}' },
-                    },
-                  ],
-                },
                 specs: [
                   {
                     type: 'gherkin',

package/src/commands/generate-server.specs.ts

@@ -5,9 +5,11 @@ import { join } from 'node:path';
 import type { CommandSlice, Model, Narrative, QuerySlice } from '@auto-engineer/narrative';
 import fs from 'fs-extra';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ScaffoldError, TemplateRenderError } from '../codegen/scaffoldFromSchema';
 import type { GenerateServerCommand, GenerateServerEvents, GenerationState } from './generate-server';
 import {
   cleanServerDir,
+  createServerFailureEvent,
   createSliceGeneratedEvent,
   deriveModelPath,
   emitSliceGeneratedForAffected,
@@ -472,3 +474,72 @@ describe('emitSliceGenerationFailedForDuplicates', () => {
     ]);
   });
 });
+
+describe('createServerFailureEvent', () => {
+  it('extracts flow/slice/type and template from ScaffoldError wrapping TemplateRenderError', () => {
+    const rootCause = new TypeError('Cannot read properties of undefined');
+    const templateErr = new TemplateRenderError('decide.ts.ejs', rootCause);
+    const scaffoldErr = new ScaffoldError('Checkout', 'PlaceOrder', 'command', templateErr);
+
+    const event = createServerFailureEvent(makeCommand(), scaffoldErr);
+
+    expect(event).toEqual({
+      type: 'ServerGenerationFailed',
+      data: {
+        modelPath: path.join(path.resolve('.'), '.context', 'schema.json'),
+        destination: '.',
+        error: expect.stringContaining('[template=decide.ts.ejs]'),
+        model: makeModel(),
+        flowName: 'Checkout',
+        sliceName: 'PlaceOrder',
+        sliceType: 'command',
+      },
+      timestamp: expect.any(Date),
+      requestId: 'req-1',
+      correlationId: 'cor-1',
+    });
+    expect(event.data.error).toContain('Cannot read properties of undefined');
+  });
+
+  it('returns undefined flow/slice/type for plain Error', () => {
+    const plainError = new Error('something went wrong');
+
+    const event = createServerFailureEvent(makeCommand(), plainError);
+
+    expect(event).toEqual({
+      type: 'ServerGenerationFailed',
+      data: {
+        modelPath: path.join(path.resolve('.'), '.context', 'schema.json'),
+        destination: '.',
+        error: expect.stringContaining('something went wrong'),
+        model: makeModel(),
+        flowName: undefined,
+        sliceName: undefined,
+        sliceType: undefined,
+      },
+      timestamp: expect.any(Date),
+      requestId: 'req-1',
+      correlationId: 'cor-1',
+    });
+  });
+
+  it('returns Unknown error for non-Error value', () => {
+    const event = createServerFailureEvent(makeCommand(), 'string error');
+
+    expect(event).toEqual({
+      type: 'ServerGenerationFailed',
+      data: {
+        modelPath: path.join(path.resolve('.'), '.context', 'schema.json'),
+        destination: '.',
+        error: 'Unknown error occurred',
+        model: makeModel(),
+        flowName: undefined,
+        sliceName: undefined,
+        sliceType: undefined,
+      },
+      timestamp: expect.any(Date),
+      requestId: 'req-1',
+      correlationId: 'cor-1',
+    });
+  });
+});

package/src/commands/generate-server.ts

@@ -11,6 +11,8 @@ import {
   type DuplicateCommandInfo,
   type FieldIssue,
   generateScaffoldFilePlans,
+  ScaffoldError,
+  TemplateRenderError,
   writeScaffoldFilePlans,
 } from '../codegen/scaffoldFromSchema';
 import { ensureDirExists, ensureDirPath, toKebabCase } from '../codegen/utils/path';
@@ -80,6 +82,9 @@ export type ServerGenerationFailedEvent = Event<
     destination: string;
     error: string;
     model: Model;
+    flowName?: string;
+    sliceName?: string;
+    sliceType?: string;
   }
 >;
 
@@ -309,9 +314,36 @@ function stripAnsiCodes(text: string): string {
   return text.replace(/\x1B\[[0-9;]*m/g, '');
 }
 
-function createServerFailureEvent(command: GenerateServerCommand, error: unknown): ServerGenerationFailedEvent {
+export function createServerFailureEvent(command: GenerateServerCommand, error: unknown): ServerGenerationFailedEvent {
   debug('Server generation failed with error: %O', error);
-  const errorMessage = error instanceof Error ? stripAnsiCodes(error.stack ?? error.message) : 'Unknown error occurred';
+
+  let flowName: string | undefined;
+  let sliceName: string | undefined;
+  let sliceType: string | undefined;
+  let templateFile: string | undefined;
+  let errorMessage: string;
+
+  if (error instanceof Error) {
+    let current: unknown = error;
+    while (current instanceof Error) {
+      if (current instanceof ScaffoldError) {
+        flowName = current.flowName;
+        sliceName = current.sliceName;
+        sliceType = current.sliceType;
+      }
+      if (current instanceof TemplateRenderError) {
+        templateFile = current.templateFile;
+      }
+      current = current.cause;
+    }
+
+    const rootError = findRootCause(error);
+    const baseMessage = stripAnsiCodes(rootError.stack ?? rootError.message);
+    errorMessage = templateFile !== undefined ? `[template=${templateFile}] ${baseMessage}` : baseMessage;
+  } else {
+    errorMessage = 'Unknown error occurred';
+  }
+
   return {
     type: 'ServerGenerationFailed',
     data: {
@@ -319,6 +351,9 @@ function createServerFailureEvent(command: GenerateServerCommand, error: unknown
       destination: command.data.destination,
       error: errorMessage,
       model: command.data.model,
+      flowName,
+      sliceName,
+      sliceType,
     },
     timestamp: new Date(),
     requestId: command.requestId,
@@ -326,6 +361,14 @@ function createServerFailureEvent(command: GenerateServerCommand, error: unknown
   };
 }
 
+function findRootCause(error: Error): Error {
+  let current: Error = error;
+  while (current.cause instanceof Error) {
+    current = current.cause;
+  }
+  return current;
+}
+
 export function createSliceGeneratedEvent(
   flow: Narrative,
   slice: Slice,