@auto-engineer/server-generator-apollo-emmett 0.8.14 → 0.9.0

package/package.json

@@ -28,8 +28,8 @@
     "graphql-type-json": "^0.3.2",
     "uuid": "^10.0.0",
     "web-streams-polyfill": "^4.1.0",
-    "@auto-engineer/flow": "0.8.14",
-    "@auto-engineer/message-bus": "0.8.14"
+    "@auto-engineer/flow": "0.9.0",
+    "@auto-engineer/message-bus": "0.9.0"
   },
   "publishConfig": {
     "access": "public"
@@ -37,9 +37,9 @@
   "devDependencies": {
     "@types/ejs": "^3.1.5",
     "@types/fs-extra": "^11.0.4",
-    "@auto-engineer/cli": "0.8.14"
+    "@auto-engineer/cli": "0.9.0"
   },
-  "version": "0.8.14",
+  "version": "0.9.0",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src",

package/src/codegen/extract/data-sink.ts

@@ -50,6 +50,7 @@ function extractExampleDataFromSpecs(
 }
 
 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
@@ -89,6 +90,7 @@ function processStreamSink(item: unknown, exampleData: Record<string, unknown>)
 }
 
 export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
+  if (!('server' in slice)) return {};
   const gwtSpecs = extractGwtSpecs(slice);
   const exampleData = extractExampleDataFromSpecs(slice, gwtSpecs);
   const serverData = slice.server?.data;

package/src/codegen/extract/gwt.ts

@@ -1,4 +1,4 @@
-import { Slice, CommandExample, EventExample, StateExample } from '@auto-engineer/flow';
+import { Slice, CommandExample, EventExample, StateExample, Example } from '@auto-engineer/flow';
 import { GwtCondition } from '../types';
 
 export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
@@ -12,11 +12,12 @@ export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtConditi
 }
 
 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) => ({
+        rule.examples.map((example: Example) => ({
           given: example.given,
           when: example.when,
           then: example.then,

package/src/codegen/extract/projection.ts

@@ -24,6 +24,7 @@ function isProjectionOrigin(origin: unknown): origin is ProjectionOrigin {
 }
 
 function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Slice, fieldName: K): string | undefined {
+  if (!('server' in slice)) return undefined;
   const dataSource = slice.server?.data?.[0];
   if (!hasOrigin(dataSource)) return undefined;
 

package/src/codegen/extract/query.ts

@@ -23,7 +23,7 @@ export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
       : [];
 
   return gwtSpecs.map((gwt) => ({
-    given: gwt.given,
+    given: gwt.given.filter((item): item is EventExample => 'eventRef' in item),
     then: gwt.then.filter(
       (item): item is { stateRef: string; exampleData: Record<string, unknown> } => 'stateRef' in item,
     ),

package/src/codegen/extract/states.ts

@@ -10,14 +10,18 @@ function createStateMessage(stateName: string, allMessages: MessageDefinition[])
 }
 
 export function extractStatesFromTarget(slice: Slice, allMessages: MessageDefinition[]): Message[] {
-  const targets = slice.server?.data?.map((d) => d.target?.name).filter(Boolean) as string[];
+  if (!('server' in slice) || !slice.server?.data) {
+    return [];
+  }
+
+  const targets = slice.server.data.map((d) => d.target?.name).filter((name): name is string => Boolean(name));
   const uniqueTargets = Array.from(new Set(targets));
 
   return uniqueTargets.map((name) => createStateMessage(name, allMessages));
 }
 
 export function extractStatesFromData(slice: Slice, allMessages: MessageDefinition[]): Message[] {
-  if (!slice.server?.data) {
+  if (!('server' in slice) || !slice.server?.data) {
     return [];
   }
 

package/src/codegen/scaffoldFromSchema.query-slice-register.specs.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect } from 'vitest';
+import { generateScaffoldFilePlans } from './scaffoldFromSchema';
+import type { Model } from '@auto-engineer/flow';
+
+describe('Query slice register file generation', () => {
+  it('should not generate register.ts for query slices with data projections', async () => {
+    // Create a minimal model with a query slice that has data projections
+    const model: Model = {
+      variant: 'specs',
+      messages: [], // Empty messages array to avoid undefined error
+      flows: [
+        {
+          id: 'flow-1',
+          name: 'Questionnaire Flow',
+          slices: [
+            {
+              id: 'AUTO-V7n8Rq5M',
+              type: 'query',
+              name: 'views the questionnaire',
+              client: {
+                description: 'Client for viewing questionnaire',
+              },
+              server: {
+                description: 'Views questionnaire progress',
+                specs: {
+                  name: 'questionnaire progress specs',
+                  rules: [
+                    {
+                      id: 'AUTO-r1A3Bp9W',
+                      description: 'questionnaires show current progress',
+                      examples: [
+                        {
+                          description: 'a question has already been answered',
+                          given: [
+                            {
+                              eventRef: 'QuestionnaireLinkSent',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                              },
+                            },
+                          ],
+                          when: {
+                            eventRef: 'ViewQuestionnaire',
+                            exampleData: { questionnaireId: 'q-001' },
+                          },
+                          then: [
+                            {
+                              stateRef: 'QuestionnaireProgress',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                                status: 'in_progress',
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+                data: [
+                  {
+                    target: {
+                      type: 'State',
+                      name: 'QuestionnaireProgress',
+                    },
+                    origin: {
+                      type: 'projection',
+                      name: 'Questionnaires',
+                      idField: 'questionnaireId',
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    // Generate scaffold plans for the model
+    const plans = await generateScaffoldFilePlans(model.flows, model.messages, model.integrations, '/tmp/test');
+
+    // Extract just the filenames from the generated files
+    const generatedFileNames = plans.map((plan) => {
+      const parts = plan.outputPath.split('/');
+      return parts[parts.length - 1];
+    });
+
+    // Query slices should NOT generate register.ts files
+    expect(generatedFileNames).not.toContain('register.ts');
+
+    // Query slices should generate projection-related files
+    expect(generatedFileNames).toContain('projection.ts');
+    expect(generatedFileNames).toContain('query.resolver.ts');
+
+    // Query slices should NOT generate command-related files
+    expect(generatedFileNames).not.toContain('commands.ts');
+    expect(generatedFileNames).not.toContain('handle.ts');
+    expect(generatedFileNames).not.toContain('decide.ts');
+    expect(generatedFileNames).not.toContain('mutation.resolver.ts');
+  });
+
+  it('should generate register.ts for command slices', async () => {
+    // Create a minimal model with a command slice
+    const model: Model = {
+      variant: 'specs',
+      messages: [], // Empty messages array to avoid undefined error
+      flows: [
+        {
+          id: 'flow-2',
+          name: 'Command Flow',
+          slices: [
+            {
+              id: 'AUTO-CMD123',
+              type: 'command',
+              name: 'submit answer',
+              client: {
+                description: 'Submit answer client',
+              },
+              server: {
+                description: 'Submits an answer',
+                specs: {
+                  name: 'submit answer specs',
+                  rules: [
+                    {
+                      id: 'AUTO-rule123',
+                      description: 'should accept valid answers',
+                      examples: [
+                        {
+                          description: 'valid answer submission',
+                          when: {
+                            commandRef: 'AnswerQuestion',
+                            exampleData: {
+                              questionnaireId: 'q-001',
+                              answer: 'Yes',
+                            },
+                          },
+                          then: [
+                            {
+                              eventRef: 'QuestionAnswered',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                answer: 'Yes',
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    // Generate scaffold plans for the model
+    const plans = await generateScaffoldFilePlans(model.flows, model.messages, model.integrations, '/tmp/test');
+
+    // Extract just the filenames from the generated files
+    const generatedFileNames = plans.map((plan) => {
+      const parts = plan.outputPath.split('/');
+      return parts[parts.length - 1];
+    });
+
+    // Command slices SHOULD generate register.ts files
+    expect(generatedFileNames).toContain('register.ts');
+
+    // Command slices should generate command-related files
+    expect(generatedFileNames).toContain('commands.ts');
+    expect(generatedFileNames).toContain('handle.ts');
+    expect(generatedFileNames).toContain('decide.ts');
+    expect(generatedFileNames).toContain('mutation.resolver.ts');
+  });
+});

package/src/codegen/scaffoldFromSchema.ts

@@ -22,6 +22,21 @@ import {
   extractMessagesFromSpecs,
   extractProjectionName,
 } 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 { Message, MessageDefinition, GwtCondition } from './types';
 import { parseGraphQlRequest } from './extract/graphql';
 import { getStreamFromSink } from './extract/data-sink';
@@ -298,30 +313,34 @@ 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 canSliceProduceEvent(slice: Slice): boolean {
+  return ['command', 'react'].includes(slice.type) && 'server' in slice && Boolean(slice.server?.specs);
+}
+
 function findEventSource(flows: Flow[], eventType: string): { flowName: string; sliceName: string } | null {
   debugSlice('Finding source for event: %s', eventType);
+
   for (const flow of flows) {
     for (const slice of flow.slices) {
-      if (!['command', 'react'].includes(slice.type)) continue;
+      if (!canSliceProduceEvent(slice)) 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.then.some((t) => 'eventRef' in t && t.eventRef === eventType))) {
+      const gwtSpecs = extractGwtSpecs(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 };
       }
     }
   }
+
   debugSlice('  No source found for event: %s', eventType);
   return null;
 }

package/.turbo/turbo-format.log

@@ -1,4 +0,0 @@
-
-> @auto-engineer/server-generator-apollo-emmett@0.8.13 format /Users/sam/WebstormProjects/top/auto-engineer/packages/server-generator-apollo-emmett
-> prettier --write "**/*.{js,ts,json,md,yml,yaml}" --ignore-path ../../.prettierignore --log-level warn
-

package/.turbo/turbo-lint.log

@@ -1,4 +0,0 @@
-
-> @auto-engineer/server-generator-apollo-emmett@0.8.13 lint /Users/sam/WebstormProjects/top/auto-engineer/packages/server-generator-apollo-emmett
-> eslint 'src/**/*.ts' --ignore-pattern '**/*.specs.ts' --ignore-pattern '**/.tmp/**' --max-warnings 0 --config ../../eslint.config.ts
-

package/.turbo/turbo-test.log

@@ -1,14 +0,0 @@
-
-> @auto-engineer/server-generator-apollo-emmett@0.8.14 test /Users/sam/WebstormProjects/top/auto-engineer/packages/server-generator-apollo-emmett
-> vitest run --reporter=dot
-
-
- RUN  v3.2.4 /Users/sam/WebstormProjects/top/auto-engineer/packages/server-generator-apollo-emmett
-
-·························-
-
- Test Files  15 passed | 1 skipped (16)
-      Tests  25 passed | 1 skipped (26)
-   Start at  18:28:14
-   Duration  1.66s (transform 406ms, setup 0ms, collect 4.50s, tests 3.69s, environment 1ms, prepare 2.77s)
-

package/.turbo/turbo-type-check.log

@@ -1,4 +0,0 @@
-
-> @auto-engineer/server-generator-apollo-emmett@0.8.14 type-check /Users/sam/WebstormProjects/top/auto-engineer/packages/server-generator-apollo-emmett
-> tsc --noEmit --project tsconfig.json
-