@auto-engineer/server-generator-apollo-emmett 0.1.4 → 0.8.1

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

@@ -1,5 +1,13 @@
 <%
-const gwtList = slice.server?.gwt ?? [];
+// Extract all examples from specs/rules structure
+const specs = slice.server?.specs;
+const gwtList = specs?.rules?.flatMap(rule => 
+  rule.examples.map(example => ({
+    given: example.given,
+    when: example.when,
+    then: example.then
+  }))
+) ?? [];
 const firstGwt = gwtList[0];
 const firstWhen = Array.isArray(firstGwt?.when) ? firstGwt.when[0] : firstGwt?.when;
 const firstThen = Array.isArray(firstGwt?.then) ? firstGwt.then[0] : firstGwt?.then;

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

@@ -1,5 +1,12 @@
 <%
-const gwt = slice.server?.gwt?.[0];
+// Extract the first example from specs/rules structure
+const specs = slice.server?.specs;
+const firstExample = specs?.rules?.flatMap(rule => rule.examples)[0] ?? null;
+const gwt = firstExample ? {
+  given: firstExample.given,
+  when: firstExample.when,
+  then: firstExample.then
+} : null;
 const when = Array.isArray(gwt?.when) ? gwt.when[0] : gwt?.when;
 const then = Array.isArray(gwt?.then) ? gwt.then[0] : gwt?.then;
 

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

@@ -16,41 +16,50 @@ describe('register.ts.ejs (react slice)', () => {
               client: { description: '', specs: [] },
               server: {
                 description: '',
-                gwt: [
-                  {
-                    when: {
-                      commandRef: 'RequestBooking',
-                      exampleData: {
-                        propertyId: 'listing_123',
-                        hostId: 'host_123',
-                        guestId: 'guest_456',
-                        checkIn: '2025-07-15',
-                        checkOut: '2025-07-18',
-                        guests: 2,
-                        message: 'Looking forward to my stay!',
-                        metadata: { now: 'bar', bookingId: '123' },
-                      },
-                    },
-                    then: [
-                      {
-                        eventRef: 'BookingRequested',
-                        exampleData: {
-                          bookingId: 'book_xyz789',
-                          hostId: 'host_123',
-                          propertyId: 'prop_789',
-                          guestId: 'guest_456',
-                          checkIn: '2025-07-15',
-                          checkOut: '2025-07-18',
-                          guests: 2,
-                          message: 'Hey',
-                          status: 'pending_host_approval',
-                          requestedAt: '2025-06-10T16:30:00.000Z',
-                          expiresAt: '2025-06-11T16:30:00.000Z',
+                specs: {
+                  name: 'Guest submits booking request command',
+                  rules: [
+                    {
+                      description: 'Should handle booking request successfully',
+                      examples: [
+                        {
+                          description: 'User submits booking request successfully',
+                          when: {
+                            commandRef: 'RequestBooking',
+                            exampleData: {
+                              propertyId: 'listing_123',
+                              hostId: 'host_123',
+                              guestId: 'guest_456',
+                              checkIn: '2025-07-15',
+                              checkOut: '2025-07-18',
+                              guests: 2,
+                              message: 'Looking forward to my stay!',
+                              metadata: { now: 'bar', bookingId: '123' },
+                            },
+                          },
+                          then: [
+                            {
+                              eventRef: 'BookingRequested',
+                              exampleData: {
+                                bookingId: 'book_xyz789',
+                                hostId: 'host_123',
+                                propertyId: 'prop_789',
+                                guestId: 'guest_456',
+                                checkIn: '2025-07-15',
+                                checkOut: '2025-07-18',
+                                guests: 2,
+                                message: 'Hey',
+                                status: 'pending_host_approval',
+                                requestedAt: '2025-06-10T16:30:00.000Z',
+                                expiresAt: '2025-06-11T16:30:00.000Z',
+                              },
+                            },
+                          ],
                         },
-                      },
-                    ],
-                  },
-                ],
+                      ],
+                    },
+                  ],
+                },
               },
             },
             {
@@ -58,41 +67,50 @@ describe('register.ts.ejs (react slice)', () => {
               name: 'Send notification to host',
               server: {
                 description: 'Sends a host notification command in response to BookingRequested',
-                gwt: [
-                  {
-                    when: [
-                      {
-                        eventRef: 'BookingRequested',
-                        exampleData: {
-                          bookingId: 'book_xyz789',
-                          hostId: 'host_123',
-                          propertyId: 'prop_789',
-                          guestId: 'guest_456',
-                          checkIn: '2025-07-15',
-                          checkOut: '2025-07-18',
-                          guests: 2,
-                          message: 'Hey',
-                          status: 'pending_host_approval',
-                          requestedAt: '2025-06-10T16:30:00.000Z',
-                          expiresAt: '2025-06-11T16:30:00.000Z',
-                        },
-                      },
-                    ],
-                    then: [
-                      {
-                        commandRef: 'NotifyHost',
-                        exampleData: {
-                          hostId: 'host_123',
-                          notificationType: 'booking_request',
-                          priority: 'high',
-                          channels: ['email', 'push'],
-                          message: 'A guest has requested to book your place.',
-                          actionRequired: true,
+                specs: {
+                  name: 'Send notification to host reaction',
+                  rules: [
+                    {
+                      description: 'Should send host notification on booking request',
+                      examples: [
+                        {
+                          description: 'Booking request triggers host notification',
+                          when: [
+                            {
+                              eventRef: 'BookingRequested',
+                              exampleData: {
+                                bookingId: 'book_xyz789',
+                                hostId: 'host_123',
+                                propertyId: 'prop_789',
+                                guestId: 'guest_456',
+                                checkIn: '2025-07-15',
+                                checkOut: '2025-07-18',
+                                guests: 2,
+                                message: 'Hey',
+                                status: 'pending_host_approval',
+                                requestedAt: '2025-06-10T16:30:00.000Z',
+                                expiresAt: '2025-06-11T16:30:00.000Z',
+                              },
+                            },
+                          ],
+                          then: [
+                            {
+                              commandRef: 'NotifyHost',
+                              exampleData: {
+                                hostId: 'host_123',
+                                notificationType: 'booking_request',
+                                priority: 'high',
+                                channels: ['email', 'push'],
+                                message: 'A guest has requested to book your place.',
+                                actionRequired: true,
+                              },
+                            },
+                          ],
                         },
-                      },
-                    ],
-                  },
-                ],
+                      ],
+                    },
+                  ],
+                },
               },
             },
             {
@@ -101,35 +119,44 @@ describe('register.ts.ejs (react slice)', () => {
               client: { description: '', specs: [] },
               server: {
                 description: '',
-                gwt: [
-                  {
-                    when: {
-                      commandRef: 'NotifyHost',
-                      exampleData: {
-                        hostId: 'host_123',
-                        notificationType: 'booking_request',
-                        priority: 'high',
-                        channels: ['email', 'push'],
-                        message: 'A guest has requested to book your place.',
-                        actionRequired: true,
-                      },
-                    },
-                    then: [
-                      {
-                        eventRef: 'HostNotified',
-                        exampleData: {
-                          bookingId: 'book_xyz789',
-                          hostId: 'host_123',
-                          notificationType: 'booking_request',
-                          channels: ['email', 'push'],
-                          message: 'hi.',
-                          notifiedAt: '2025-06-10T16:30:00.000Z',
-                          actionRequired: true,
+                specs: {
+                  name: 'Notify host command',
+                  rules: [
+                    {
+                      description: 'Should notify host successfully',
+                      examples: [
+                        {
+                          description: 'Host notification sent successfully',
+                          when: {
+                            commandRef: 'NotifyHost',
+                            exampleData: {
+                              hostId: 'host_123',
+                              notificationType: 'booking_request',
+                              priority: 'high',
+                              channels: ['email', 'push'],
+                              message: 'A guest has requested to book your place.',
+                              actionRequired: true,
+                            },
+                          },
+                          then: [
+                            {
+                              eventRef: 'HostNotified',
+                              exampleData: {
+                                bookingId: 'book_xyz789',
+                                hostId: 'host_123',
+                                notificationType: 'booking_request',
+                                channels: ['email', 'push'],
+                                message: 'hi.',
+                                notifiedAt: '2025-06-10T16:30:00.000Z',
+                                actionRequired: true,
+                              },
+                            },
+                          ],
                         },
-                      },
-                    ],
-                  },
-                ],
+                      ],
+                    },
+                  ],
+                },
               },
             },
           ],

package/src/codegen/templates/react/register.ts.ejs

@@ -1,5 +1,12 @@
 <%
-const gwt = slice.server?.gwt?.[0];
+// Extract the first example from specs/rules structure
+const specs = slice.server?.specs;
+const firstExample = specs?.rules?.flatMap(rule => rule.examples)[0] ?? null;
+const gwt = firstExample ? {
+  given: firstExample.given,
+  when: firstExample.when,
+  then: firstExample.then
+} : null;
 const when = Array.isArray(gwt?.when) ? gwt.when[0] : gwt?.when;
 const then = Array.isArray(gwt?.then) ? gwt.then[0] : gwt?.then;
 

package/src/codegen/test-data/specVariant1.ts

@@ -19,27 +19,36 @@ const specVariant1: SpecsSchema = {
 
           server: {
             description: 'Handles creation logic',
-            gwt: [
-              {
-                when: {
-                  commandRef: 'CreateItem',
-                  exampleData: {
-                    itemId: 'item_123',
-                    description: 'A new item',
-                  },
-                },
-                then: [
-                  {
-                    eventRef: 'ItemCreated',
-                    exampleData: {
-                      id: 'item_123',
-                      description: 'A new item',
-                      addedAt: '2024-01-15T10:00:00.000Z',
+            specs: {
+              name: 'User can create an item',
+              rules: [
+                {
+                  description: 'Valid item data should create item successfully',
+                  examples: [
+                    {
+                      description: 'User creates a new item with valid data',
+                      when: {
+                        commandRef: 'CreateItem',
+                        exampleData: {
+                          itemId: 'item_123',
+                          description: 'A new item',
+                        },
+                      },
+                      then: [
+                        {
+                          eventRef: 'ItemCreated',
+                          exampleData: {
+                            id: 'item_123',
+                            description: 'A new item',
+                            addedAt: '2024-01-15T10:00:00.000Z',
+                          },
+                        },
+                      ],
                     },
-                  },
-                ],
-              },
-            ],
+                  ],
+                },
+              ],
+            },
           },
         },
         {
@@ -70,30 +79,39 @@ const specVariant1: SpecsSchema = {
                 },
               },
             ],
-            gwt: [
-              {
-                given: [
-                  {
-                    eventRef: 'ItemCreated',
-                    exampleData: {
-                      id: 'item_123',
-                      description: 'A new item',
-                      addedAt: '2024-01-15T10:00:00.000Z',
+            specs: {
+              name: 'Items are available for viewing',
+              rules: [
+                {
+                  description: 'Item becomes available after creation event',
+                  examples: [
+                    {
+                      description: 'ItemCreated event makes item available',
+                      when: [
+                        {
+                          eventRef: 'ItemCreated',
+                          exampleData: {
+                            id: 'item_123',
+                            description: 'A new item',
+                            addedAt: '2024-01-15T10:00:00.000Z',
+                          },
+                        },
+                      ],
+                      then: [
+                        {
+                          stateRef: 'AvailableItems',
+                          exampleData: {
+                            id: 'item_123',
+                            description: 'A new item',
+                            addedAt: '2024-01-15T10:00:00.000Z',
+                          },
+                        },
+                      ],
                     },
-                  },
-                ],
-                then: [
-                  {
-                    stateRef: 'AvailableItems',
-                    exampleData: {
-                      id: 'item_123',
-                      description: 'A new item',
-                      addedAt: '2024-01-15T10:00:00.000Z',
-                    },
-                  },
-                ],
-              },
-            ],
+                  ],
+                },
+              ],
+            },
           },
         },
         {
@@ -102,29 +120,38 @@ const specVariant1: SpecsSchema = {
           description: 'Sends a notification command when a new item is created',
           server: {
             description: 'Triggers NotifyNewItem command in response to ItemCreated',
-            gwt: [
-              {
-                when: [
-                  {
-                    eventRef: 'ItemCreated',
-                    exampleData: {
-                      id: 'item_123',
-                      description: 'A new item',
-                      addedAt: '2024-01-15T10:00:00.000Z',
-                    },
-                  },
-                ],
-                then: [
-                  {
-                    commandRef: 'NotifyNewItem',
-                    exampleData: {
-                      itemId: 'item_123',
-                      message: 'A new item was added to the system.',
+            specs: {
+              name: 'Notify on new item creation',
+              rules: [
+                {
+                  description: 'Should send notification when item is created',
+                  examples: [
+                    {
+                      description: 'ItemCreated event triggers notification command',
+                      when: [
+                        {
+                          eventRef: 'ItemCreated',
+                          exampleData: {
+                            id: 'item_123',
+                            description: 'A new item',
+                            addedAt: '2024-01-15T10:00:00.000Z',
+                          },
+                        },
+                      ],
+                      then: [
+                        {
+                          commandRef: 'NotifyNewItem',
+                          exampleData: {
+                            itemId: 'item_123',
+                            message: 'A new item was added to the system.',
+                          },
+                        },
+                      ],
                     },
-                  },
-                ],
-              },
-            ],
+                  ],
+                },
+              ],
+            },
           },
         },
       ],

package/src/codegen/types.ts

@@ -1,4 +1,4 @@
-import { CommandExample, EventExample } from '@auto-engineer/flow';
+import { CommandExample, EventExample, StateExample } from '@auto-engineer/flow';
 
 export interface Message {
   type: string;
@@ -29,7 +29,7 @@ export interface MessageDefinition {
 }
 
 export interface GwtCondition {
-  given?: EventExample[];
-  when: CommandExample;
-  then: Array<EventExample | { errorType: string; message?: string }>;
+  given?: Array<EventExample | StateExample>;
+  when: CommandExample | EventExample[];
+  then: Array<EventExample | StateExample | CommandExample | { errorType: string; message?: string }>;
 }

package/src/commands/generate-server.ts

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { execa } from 'execa';
 import createDebug from 'debug';
+import { defineCommandHandler } from '@auto-engineer/message-bus';
 
 const debug = createDebug('emmett:generate-server');
 const debugSchema = createDebug('emmett:generate-server:schema');
@@ -18,17 +19,6 @@ const debugFiles = createDebug('emmett:generate-server:files');
 const debugDeps = createDebug('emmett:generate-server:deps');
 const debugScaffold = createDebug('emmett:generate-server:scaffold');
 
-export const generateServerManifest = {
-  handler: () => Promise.resolve({ default: generateServerCommandHandler }),
-  description: 'Generate server from schema.json',
-  usage: 'generate:server <schema> <dest>',
-  examples: ['$ auto generate:server .context/schema.json .'],
-  args: [
-    { name: 'schema', description: 'Path to schema.json file', required: true },
-    { name: 'dest', description: 'Destination directory for generated server', required: true },
-  ],
-};
-
 type DefaultRecord = Record<string, unknown>;
 export type Command<CommandType extends string = string, CommandData extends DefaultRecord = DefaultRecord> = Readonly<{
   type: CommandType;
@@ -79,6 +69,33 @@ export type ServerGenerationFailedEvent = Event<
   }
 >;
 
+export const commandHandler = defineCommandHandler<GenerateServerCommand>({
+  name: 'GenerateServer',
+  alias: 'generate:server',
+  description: 'Generate server from schema.json',
+  category: 'generate',
+  fields: {
+    schemaPath: {
+      description: 'Path to schema.json file',
+      required: true,
+    },
+    destination: {
+      description: 'Destination directory for generated server',
+      required: true,
+    },
+  },
+  examples: ['$ auto generate:server --schema-path=.context/schema.json --destination=.'],
+  handle: async (command: GenerateServerCommand): Promise<ServerGeneratedEvent | ServerGenerationFailedEvent> => {
+    const result = await handleGenerateServerCommandInternal(command);
+    if (result.type === 'ServerGenerated') {
+      debug('Server generated at %s', result.data.serverDir);
+    } else {
+      debug('Failed to generate server: %s', result.data.error);
+    }
+    return result;
+  },
+});
+
 async function validateSchemaFile(
   absSchema: string,
   command: GenerateServerCommand,
@@ -267,22 +284,6 @@ async function handleGenerateServerCommandInternal(
   }
 }
 
-export const generateServerCommandHandler: CommandHandler<
-  GenerateServerCommand,
-  ServerGeneratedEvent | ServerGenerationFailedEvent
-> = {
-  name: 'GenerateServer',
-  handle: async (command: GenerateServerCommand): Promise<ServerGeneratedEvent | ServerGenerationFailedEvent> => {
-    const result = await handleGenerateServerCommandInternal(command);
-    if (result.type === 'ServerGenerated') {
-      debug('Server generated at %s', result.data.serverDir);
-    } else {
-      debug('Failed to generate server: %s', result.data.error);
-    }
-    return result;
-  },
-};
-
 async function copyRootFilesFromSrc(from: string, to: string): Promise<void> {
   debugFiles('copyRootFilesFromSrc: from=%s, to=%s', from, to);
 
@@ -514,4 +515,4 @@ async function installDependenciesAndGenerateSchema(serverDir: string, workingDi
 }
 
 // Default export is the command handler
-export default generateServerCommandHandler;
+export default commandHandler;

package/src/index.ts

@@ -1,2 +1,8 @@
-export * from './commands/generate-server';
-export { CLI_MANIFEST } from './cli-manifest';
+import { commandHandler as generateServerHandler } from './commands/generate-server';
+
+export const COMMANDS = [generateServerHandler];
+export {
+  type GenerateServerCommand,
+  type ServerGeneratedEvent,
+  type ServerGenerationFailedEvent,
+} from './commands/generate-server';