@auto-engineer/server-generator-apollo-emmett 0.12.1 → 0.13.1

package/src/codegen/extract/step-types.ts

@@ -0,0 +1,52 @@
+import type { Step, Slice } from '@auto-engineer/narrative';
+import type { StepWithDocStringSchema, StepWithErrorSchema } from '@auto-engineer/narrative';
+import type { z } from 'zod';
+
+export type StepWithDocString = z.infer<typeof StepWithDocStringSchema>;
+export type StepWithError = z.infer<typeof StepWithErrorSchema>;
+
+export type StepKeyword = StepWithDocString['keyword'];
+export type MajorKeyword = Exclude<StepKeyword, 'And'>;
+
+export type ErrorType = StepWithError['error']['type'];
+
+export type SliceType = Extract<Slice['type'], 'command' | 'query' | 'react'>;
+
+export function getSliceType(slice: Slice): SliceType {
+  if (slice.type === 'command' || slice.type === 'query' || slice.type === 'react') {
+    return slice.type;
+  }
+  return 'command';
+}
+
+export function isStepWithDocString(step: Step): step is StepWithDocString {
+  return 'text' in step;
+}
+
+export function isStepWithError(step: Step): step is StepWithError {
+  return 'error' in step;
+}
+
+export function resolveMajorKeyword(keyword: StepKeyword, current: MajorKeyword): MajorKeyword {
+  return keyword === 'And' ? current : keyword;
+}
+
+export interface CommandRef {
+  commandRef: string;
+  exampleData: Record<string, unknown>;
+}
+
+export interface EventRef {
+  eventRef: string;
+  exampleData: Record<string, unknown>;
+}
+
+export interface StateRef {
+  stateRef: string;
+  exampleData: Record<string, unknown>;
+}
+
+export interface ErrorRef {
+  errorType: ErrorType;
+  message?: string;
+}

package/src/codegen/scaffoldFromSchema.ts

@@ -34,21 +34,8 @@ import {
   createFieldUsesFloat,
   createCollectEnumNames,
 } from './extract';
-
-function extractGwtSpecs(slice: Slice) {
-  if (!('server' in slice)) return [];
-  const specs = slice.server?.specs;
-  const rules = specs?.rules;
-  return Array.isArray(rules) && rules.length > 0
-    ? rules.flatMap((rule) =>
-        rule.examples.map((example) => ({
-          given: example.given,
-          when: example.when,
-          then: example.then,
-        })),
-      )
-    : [];
-}
+import { extractGwtSpecsFromSlice, type GwtResult } from './extract/step-converter';
+import { normalizeSliceForTemplate } from './extract/slice-normalizer';
 import { Message, MessageDefinition, GwtCondition } from './types';
 import { parseGraphQlRequest } from './extract/graphql';
 import { getStreamFromSink } from './extract/data-sink';
@@ -529,7 +516,7 @@ async function prepareTemplateData(
   return {
     flowName: flow.name,
     sliceName: slice.name,
-    slice,
+    slice: normalizeSliceForTemplate(slice),
     stream: { pattern: streamPattern, id: streamId },
     commands: filteredCommands,
     events,
@@ -571,13 +558,8 @@ function annotateEventSources(
   }
 }
 
-function hasEventInGwtSpecs(gwtSpecs: ReturnType<typeof extractGwtSpecs>, eventType: string): boolean {
-  return gwtSpecs.some((g) =>
-    g.then.some(
-      (t) =>
-        typeof t === 'object' && t !== null && 'eventRef' in t && (t as { eventRef: string }).eventRef === eventType,
-    ),
-  );
+function hasEventInGwtSpecs(gwtSpecs: GwtResult[], eventType: string): boolean {
+  return gwtSpecs.some((g) => g.then.some((t) => 'eventRef' in t && t.eventRef === eventType));
 }
 
 function canSliceProduceEvent(slice: Slice): boolean {
@@ -591,7 +573,7 @@ function findEventSource(flows: Narrative[], eventType: string): { flowName: str
     for (const slice of flow.slices) {
       if (!canSliceProduceEvent(slice)) continue;
 
-      const gwtSpecs = extractGwtSpecs(slice);
+      const gwtSpecs = extractGwtSpecsFromSlice(slice);
       if (hasEventInGwtSpecs(gwtSpecs, eventType)) {
         debugSlice('  Found event source in flow: %s, slice: %s', flow.name, slice.name);
         return { flowName: flow.name, sliceName: slice.name };
@@ -624,27 +606,8 @@ function findCommandSource(flows: Narrative[], commandType: string): { flowName:
     for (const slice of flow.slices) {
       if (slice.type !== 'command') continue;
 
-      const specs = slice.server?.specs;
-      const rules = specs?.rules;
-      const gwtSpecs =
-        Array.isArray(rules) && rules.length > 0
-          ? rules.flatMap((rule) =>
-              rule.examples.map((example) => ({
-                given: example.given,
-                when: example.when,
-                then: example.then,
-              })),
-            )
-          : [];
-      if (
-        gwtSpecs.some(
-          (g) =>
-            g.when !== undefined &&
-            !Array.isArray(g.when) &&
-            'commandRef' in g.when &&
-            g.when.commandRef === commandType,
-        )
-      ) {
+      const gwtSpecs = extractGwtSpecsFromSlice(slice);
+      if (gwtSpecs.some((g) => !Array.isArray(g.when) && 'commandRef' in g.when && g.when.commandRef === commandType)) {
         debugSlice('  Found command source in flow: %s, slice: %s', flow.name, slice.name);
         return { flowName: flow.name, sliceName: slice.name };
       }

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

@@ -18,35 +18,40 @@ describe('commands.ts.ejs', () => {
               },
               server: {
                 description: 'test',
-                specs: {
-                  name: 'Create listing command',
-                  rules: [
-                    {
-                      description: 'Should accept valid listing data',
-                      examples: [
-                        {
-                          description: 'User creates listing with valid data',
-                          when: {
-                            commandRef: 'CreateListing',
-                            exampleData: {
-                              propertyId: 'listing_123',
-                              title: 'nice apartment',
-                              pricePerNight: 250,
-                              maxGuests: 4,
-                              amenities: ['wifi', 'kitchen', 'parking'],
-                              available: true,
-                              tags: ['sea view', 'balcony'],
-                              rating: 4.8,
-                              metadata: { petsAllowed: true },
-                              listedAt: '2024-01-15T10:00:00Z',
-                            },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Create listing command',
+                    rules: [
+                      {
+                        name: 'Should accept valid listing data',
+                        examples: [
+                          {
+                            name: 'User creates listing with valid data',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'CreateListing',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  title: 'nice apartment',
+                                  pricePerNight: 250,
+                                  maxGuests: 4,
+                                  amenities: ['wifi', 'kitchen', 'parking'],
+                                  available: true,
+                                  tags: ['sea view', 'balcony'],
+                                  rating: 4.8,
+                                  metadata: { petsAllowed: true },
+                                  listedAt: '2024-01-15T10:00:00Z',
+                                },
+                              },
+                            ],
                           },
-                          then: [],
-                        },
-                      ],
-                    },
-                  ],
-                },
+                        ],
+                      },
+                    ],
+                  },
+                ],
               },
             },
           ],

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

@@ -16,45 +16,50 @@ describe('spec.ts.ejs', () => {
               client: { specs: [] },
               server: {
                 description: '',
-                specs: {
-                  name: 'Create listing spec',
-                  rules: [
-                    {
-                      description: 'Should create listing successfully',
-                      examples: [
-                        {
-                          description: 'User creates listing with valid data',
-                          when: {
-                            commandRef: 'CreateListing',
-                            exampleData: {
-                              propertyId: 'listing_123',
-                              title: 'blah',
-                              pricePerNight: 250,
-                              maxGuests: 4,
-                              amenities: ['wifi', 'kitchen'],
-                              available: true,
-                              tags: ['some tag'],
-                              rating: 4.8,
-                              metadata: { foo: 'bar' },
-                              listedAt: '2024-01-15T10:00:00Z',
-                            },
-                          },
-                          then: [
-                            {
-                              eventRef: 'ListingCreated',
-                              exampleData: {
-                                propertyId: 'listing_123',
-                                listedAt: '2024-01-15T10:00:00Z',
-                                rating: 4.8,
-                                metadata: { foo: 'bar' },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Create listing spec',
+                    rules: [
+                      {
+                        name: 'Should create listing successfully',
+                        examples: [
+                          {
+                            name: 'User creates listing with valid data',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'CreateListing',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  title: 'blah',
+                                  pricePerNight: 250,
+                                  maxGuests: 4,
+                                  amenities: ['wifi', 'kitchen'],
+                                  available: true,
+                                  tags: ['some tag'],
+                                  rating: 4.8,
+                                  metadata: { foo: 'bar' },
+                                  listedAt: '2024-01-15T10:00:00Z',
+                                },
                               },
-                            },
-                          ],
-                        },
-                      ],
-                    },
-                  ],
-                },
+                              {
+                                keyword: 'Then',
+                                text: 'ListingCreated',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  listedAt: '2024-01-15T10:00:00Z',
+                                  rating: 4.8,
+                                  metadata: { foo: 'bar' },
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
               },
             },
           ],
@@ -160,45 +165,49 @@ describe('spec.ts.ejs', () => {
               client: { specs: [] },
               server: {
                 description: '',
-                specs: {
-                  name: 'Remove listing spec',
-                  rules: [
-                    {
-                      description: 'Should remove existing listing',
-                      examples: [
-                        {
-                          description: 'Existing listing can be removed',
-                          given: [
-                            {
-                              eventRef: 'ListingCreated',
-                              exampleData: {
-                                propertyId: 'listing_123',
-                                listedAt: '2024-01-15T10:00:00Z',
-                                rating: 4.8,
-                                metadata: { foo: 'bar' },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Remove listing spec',
+                    rules: [
+                      {
+                        name: 'Should remove existing listing',
+                        examples: [
+                          {
+                            name: 'Existing listing can be removed',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'ListingCreated',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  listedAt: '2024-01-15T10:00:00Z',
+                                  rating: 4.8,
+                                  metadata: { foo: 'bar' },
+                                },
                               },
-                            },
-                          ],
-                          when: {
-                            commandRef: 'RemoveListing',
-                            exampleData: {
-                              propertyId: 'listing_123',
-                            },
-                          },
-                          then: [
-                            {
-                              eventRef: 'ListingRemoved',
-                              exampleData: {
-                                propertyId: 'listing_123',
-                                removedAt: '2024-01-16T10:00:00Z',
+                              {
+                                keyword: 'When',
+                                text: 'RemoveListing',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                },
                               },
-                            },
-                          ],
-                        },
-                      ],
-                    },
-                  ],
-                },
+                              {
+                                keyword: 'Then',
+                                text: 'ListingRemoved',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  removedAt: '2024-01-16T10:00:00Z',
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
               },
             },
           ],
@@ -302,73 +311,79 @@ describe('spec.ts.ejs', () => {
               client: { specs: [] },
               server: {
                 description: '',
-                specs: {
-                  name: 'Answer question spec',
-                  rules: [
-                    {
-                      description: 'answers are allowed while the questionnaire has not been submitted',
-                      examples: [
-                        {
-                          description: 'no questions have been answered yet',
-                          when: {
-                            commandRef: 'AnswerQuestion',
-                            exampleData: {
-                              questionnaireId: 'q-001',
-                              participantId: 'participant-abc',
-                              questionId: 'q1',
-                              answer: 'Yes',
-                            },
-                          },
-                          then: [
-                            {
-                              eventRef: 'QuestionAnswered',
-                              exampleData: {
-                                questionnaireId: 'q-001',
-                                participantId: 'participant-abc',
-                                questionId: 'q1',
-                                answer: 'Yes',
-                                savedAt: '2030-01-01T09:05:00.000Z',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Answer question spec',
+                    rules: [
+                      {
+                        name: 'answers are allowed while the questionnaire has not been submitted',
+                        examples: [
+                          {
+                            name: 'no questions have been answered yet',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'AnswerQuestion',
+                                docString: {
+                                  questionnaireId: 'q-001',
+                                  participantId: 'participant-abc',
+                                  questionId: 'q1',
+                                  answer: 'Yes',
+                                },
                               },
-                            },
-                          ],
-                        },
-                        {
-                          description: 'all questions have already been answered and submitted',
-                          given: [
-                            {
-                              eventRef: 'QuestionnaireSubmitted',
-                              exampleData: {
-                                questionnaireId: 'q-001',
-                                participantId: 'participant-abc',
-                                submittedAt: '2030-01-01T09:00:00.000Z',
+                              {
+                                keyword: 'Then',
+                                text: 'QuestionAnswered',
+                                docString: {
+                                  questionnaireId: 'q-001',
+                                  participantId: 'participant-abc',
+                                  questionId: 'q1',
+                                  answer: 'Yes',
+                                  savedAt: '2030-01-01T09:05:00.000Z',
+                                },
                               },
-                            },
-                          ],
-                          when: {
-                            commandRef: 'AnswerQuestion',
-                            exampleData: {
-                              questionnaireId: 'q-001',
-                              participantId: 'participant-abc',
-                              questionId: 'q1',
-                              answer: 'Yes',
-                            },
+                            ],
                           },
-                          then: [
-                            {
-                              eventRef: 'QuestionnaireEditRejected',
-                              exampleData: {
-                                questionnaireId: 'q-001',
-                                participantId: 'participant-abc',
-                                reason: 'Questionnaire already submitted',
-                                attemptedAt: '2030-01-01T09:05:00.000Z',
+                          {
+                            name: 'all questions have already been answered and submitted',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'QuestionnaireSubmitted',
+                                docString: {
+                                  questionnaireId: 'q-001',
+                                  participantId: 'participant-abc',
+                                  submittedAt: '2030-01-01T09:00:00.000Z',
+                                },
                               },
-                            },
-                          ],
-                        },
-                      ],
-                    },
-                  ],
-                },
+                              {
+                                keyword: 'When',
+                                text: 'AnswerQuestion',
+                                docString: {
+                                  questionnaireId: 'q-001',
+                                  participantId: 'participant-abc',
+                                  questionId: 'q1',
+                                  answer: 'Yes',
+                                },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'QuestionnaireEditRejected',
+                                docString: {
+                                  questionnaireId: 'q-001',
+                                  participantId: 'participant-abc',
+                                  reason: 'Questionnaire already submitted',
+                                  attemptedAt: '2030-01-01T09:05:00.000Z',
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
               },
             },
           ],