@auto-engineer/server-generator-apollo-emmett 0.1.1

package/dist/server.ts

@@ -0,0 +1,43 @@
+import 'reflect-metadata';
+import { ApolloServer } from 'apollo-server';
+import { buildSchema } from 'type-graphql';
+import { loadProjections, loadRegisterFiles, loadResolvers } from './utils';
+import {
+  getInMemoryEventStore,
+  getInMemoryMessageBus,
+  projections,
+  forwardToMessageBus,
+} from '@event-driven-io/emmett';
+
+async function start() {
+  const loadedProjections = await loadProjections('src/domain/flows/**/projection.{ts,js}');
+  const registrations = await loadRegisterFiles('src/domain/flows/**/register.{ts,js}');
+
+  const messageBus = getInMemoryMessageBus();
+
+  const eventStore = getInMemoryEventStore({
+    projections: projections.inline(loadedProjections),
+    hooks: {
+      onAfterCommit: forwardToMessageBus(messageBus),
+    },
+  });
+
+  await Promise.all(registrations.map((r) => r.register(messageBus, eventStore)));
+
+  const resolvers = await loadResolvers('src/domain/flows/**/*.resolver.{ts,js}');
+  const schema = await buildSchema({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resolvers: resolvers as unknown as [(...args: any[]) => any, ...Array<(...args: any[]) => any>],
+  });
+  const server = new ApolloServer({
+    schema,
+    context: () => ({
+      eventStore,
+      messageBus,
+    }),
+  });
+  const { url } = await server.listen({ port: 4000 });
+  console.log(`🚀 GraphQL server ready at ${url}`);
+}
+
+void start();

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './loadResolvers';
+export * from './loadRegisterFiles';
+export * from './loadProjections';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,4 @@
+export * from './loadResolvers.js';
+export * from './loadRegisterFiles.js';
+export * from './loadProjections.js';
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/dist/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './loadResolvers';
+export * from './loadRegisterFiles';
+export * from './loadProjections';

package/dist/utils/loadProjections.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectionDefinition } from '@event-driven-io/emmett';
+export declare function loadProjections(source: string): Promise<ProjectionDefinition[]>;
+//# sourceMappingURL=loadProjections.d.ts.map

package/dist/utils/loadProjections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadProjections.d.ts","sourceRoot":"","sources":["../../src/utils/loadProjections.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAoBrF"}

package/dist/utils/loadProjections.js

@@ -0,0 +1,23 @@
+import fg from 'fast-glob';
+import path from 'path';
+export async function loadProjections(source) {
+    const files = await fg(source, { absolute: true });
+    const modules = await Promise.all(files.map(async (file) => {
+        const mod = await import(pathToFileUrl(file).href);
+        if (typeof mod === 'object' && mod !== null && 'projection' in mod) {
+            const projectionModule = mod;
+            if (projectionModule.projection == null) {
+                console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
+            }
+            return projectionModule.projection;
+        }
+        console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
+        return undefined;
+    }));
+    return modules.filter((p) => p != null);
+}
+function pathToFileUrl(filePath) {
+    const resolved = path.resolve(filePath);
+    return new URL(`file://${resolved}`);
+}
+//# sourceMappingURL=loadProjections.js.map

package/dist/utils/loadProjections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadProjections.js","sourceRoot":"","sources":["../../src/utils/loadProjections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,WAAW,CAAC;AAC3B,OAAO,IAAI,MAAM,MAAM,CAAC;AAGxB,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,MAAc;IAClD,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAEnD,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QACvB,MAAM,GAAG,GAAY,MAAM,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;QAE5D,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,IAAI,YAAY,IAAI,GAAG,EAAE,CAAC;YACnE,MAAM,gBAAgB,GAAG,GAA4C,CAAC;YACtE,IAAI,gBAAgB,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;gBACxC,OAAO,CAAC,IAAI,CAAC,uBAAuB,IAAI,gCAAgC,CAAC,CAAC;YAC5E,CAAC;YACD,OAAO,gBAAgB,CAAC,UAAU,CAAC;QACrC,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,uBAAuB,IAAI,gCAAgC,CAAC,CAAC;QAC1E,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CACH,CAAC;IAEF,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAA6B,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,aAAa,CAAC,QAAgB;IACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACxC,OAAO,IAAI,GAAG,CAAC,UAAU,QAAQ,EAAE,CAAC,CAAC;AACvC,CAAC"}

package/dist/utils/loadProjections.ts

@@ -0,0 +1,30 @@
+import fg from 'fast-glob';
+import path from 'path';
+import type { ProjectionDefinition } from '@event-driven-io/emmett';
+
+export async function loadProjections(source: string): Promise<ProjectionDefinition[]> {
+  const files = await fg(source, { absolute: true });
+
+  const modules = await Promise.all(
+    files.map(async (file) => {
+      const mod: unknown = await import(pathToFileUrl(file).href);
+
+      if (typeof mod === 'object' && mod !== null && 'projection' in mod) {
+        const projectionModule = mod as { projection?: ProjectionDefinition };
+        if (projectionModule.projection == null) {
+          console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
+        }
+        return projectionModule.projection;
+      }
+      console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
+      return undefined;
+    }),
+  );
+
+  return modules.filter((p): p is ProjectionDefinition => p != null);
+}
+
+function pathToFileUrl(filePath: string): URL {
+  const resolved = path.resolve(filePath);
+  return new URL(`file://${resolved}`);
+}

package/dist/utils/loadRegisterFiles.d.ts

@@ -0,0 +1,6 @@
+import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
+export interface SliceRegistration {
+    register: (messageBus: CommandProcessor, eventStore: EventStore) => Promise<unknown> | void;
+}
+export declare function loadRegisterFiles(source: string): Promise<SliceRegistration[]>;
+//# sourceMappingURL=loadRegisterFiles.d.ts.map

package/dist/utils/loadRegisterFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadRegisterFiles.d.ts","sourceRoot":"","sources":["../../src/utils/loadRegisterFiles.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE5E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,CAAC,UAAU,EAAE,gBAAgB,EAAE,UAAU,EAAE,UAAU,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC7F;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA2BpF"}

package/dist/utils/loadRegisterFiles.js

@@ -0,0 +1,28 @@
+import fg from 'fast-glob';
+import path from 'path';
+export async function loadRegisterFiles(source) {
+    const files = await fg(source, { absolute: true });
+    const modules = await Promise.all(files.map(async (file) => {
+        try {
+            const mod = await import(pathToFileUrl(file).href);
+            if (typeof mod === 'object' &&
+                mod !== null &&
+                'register' in mod &&
+                typeof mod.register === 'function') {
+                return mod;
+            }
+            console.warn('⚠️ Skipping invalid register.ts at', file);
+            return null;
+        }
+        catch (error) {
+            console.error('❌ Failed to import', file, ':', error);
+            return null;
+        }
+    }));
+    return modules.filter((m) => m !== null);
+}
+function pathToFileUrl(filePath) {
+    const resolved = path.resolve(filePath);
+    return new URL(`file://${resolved}`);
+}
+//# sourceMappingURL=loadRegisterFiles.js.map

package/dist/utils/loadRegisterFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadRegisterFiles.js","sourceRoot":"","sources":["../../src/utils/loadRegisterFiles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,WAAW,CAAC;AAC3B,OAAO,IAAI,MAAM,MAAM,CAAC;AAOxB,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,MAAc;IACpD,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAEnD,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QACvB,IAAI,CAAC;YACH,MAAM,GAAG,GAAY,MAAM,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;YAE5D,IACE,OAAO,GAAG,KAAK,QAAQ;gBACvB,GAAG,KAAK,IAAI;gBACZ,UAAU,IAAI,GAAG;gBACjB,OAAQ,GAAyB,CAAC,QAAQ,KAAK,UAAU,EACzD,CAAC;gBACD,OAAO,GAAwB,CAAC;YAClC,CAAC;YAED,OAAO,CAAC,IAAI,CAAC,oCAAoC,EAAE,IAAI,CAAC,CAAC;YACzD,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YACtD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC,CAAC,CACH,CAAC;IAEF,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAA0B,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;AACnE,CAAC;AAED,SAAS,aAAa,CAAC,QAAgB;IACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACxC,OAAO,IAAI,GAAG,CAAC,UAAU,QAAQ,EAAE,CAAC,CAAC;AACvC,CAAC"}

package/dist/utils/loadRegisterFiles.ts

@@ -0,0 +1,41 @@
+import fg from 'fast-glob';
+import path from 'path';
+import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
+
+export interface SliceRegistration {
+  register: (messageBus: CommandProcessor, eventStore: EventStore) => Promise<unknown> | void;
+}
+
+export async function loadRegisterFiles(source: string): Promise<SliceRegistration[]> {
+  const files = await fg(source, { absolute: true });
+
+  const modules = await Promise.all(
+    files.map(async (file) => {
+      try {
+        const mod: unknown = await import(pathToFileUrl(file).href);
+
+        if (
+          typeof mod === 'object' &&
+          mod !== null &&
+          'register' in mod &&
+          typeof (mod as SliceRegistration).register === 'function'
+        ) {
+          return mod as SliceRegistration;
+        }
+
+        console.warn('⚠️ Skipping invalid register.ts at', file);
+        return null;
+      } catch (error) {
+        console.error('❌ Failed to import', file, ':', error);
+        return null;
+      }
+    }),
+  );
+
+  return modules.filter((m): m is SliceRegistration => m !== null);
+}
+
+function pathToFileUrl(filePath: string): URL {
+  const resolved = path.resolve(filePath);
+  return new URL(`file://${resolved}`);
+}

package/dist/utils/loadResolvers.d.ts

@@ -0,0 +1,5 @@
+export interface Resolver {
+    (...args: unknown[]): unknown;
+}
+export declare function loadResolvers(source: string): Promise<Resolver[]>;
+//# sourceMappingURL=loadResolvers.d.ts.map

package/dist/utils/loadResolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadResolvers.d.ts","sourceRoot":"","sources":["../../src/utils/loadResolvers.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,QAAQ;IACvB,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;CAC/B;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CA6BvE"}

package/dist/utils/loadResolvers.js

@@ -0,0 +1,27 @@
+import fg from 'fast-glob';
+export async function loadResolvers(source) {
+    const files = await fg(source, {
+        absolute: true,
+    });
+    const modules = await Promise.all(files.map((file) => import(file)));
+    const allResolvers = [];
+    for (const mod of modules) {
+        if (typeof mod !== 'object' || mod === null) {
+            continue;
+        }
+        for (const key of Object.keys(mod)) {
+            const exported = mod[key];
+            if (typeof exported === 'function') {
+                allResolvers.push(exported);
+            }
+            if (Array.isArray(exported) && exported.every((r) => typeof r === 'function')) {
+                allResolvers.push(...exported);
+            }
+        }
+    }
+    if (allResolvers.length === 0) {
+        throw new Error('❌ No resolvers found for any slices.');
+    }
+    return allResolvers;
+}
+//# sourceMappingURL=loadResolvers.js.map

package/dist/utils/loadResolvers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadResolvers.js","sourceRoot":"","sources":["../../src/utils/loadResolvers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,WAAW,CAAC;AAM3B,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,MAAc;IAChD,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE;QAC7B,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IACH,MAAM,OAAO,GAAc,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAChF,MAAM,YAAY,GAAe,EAAE,CAAC;IAEpC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YAC5C,SAAS;QACX,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,MAAM,QAAQ,GAAI,GAA+B,CAAC,GAAG,CAAC,CAAC;YAEvD,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;gBACnC,YAAY,CAAC,IAAI,CAAC,QAAoB,CAAC,CAAC;YAC1C,CAAC;YAED,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,UAAU,CAAC,EAAE,CAAC;gBAC9E,YAAY,CAAC,IAAI,CAAC,GAAI,QAAuB,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IACD,OAAO,YAAY,CAAC;AACtB,CAAC"}

package/dist/utils/loadResolvers.ts

@@ -0,0 +1,36 @@
+import fg from 'fast-glob';
+
+export interface Resolver {
+  (...args: unknown[]): unknown;
+}
+
+export async function loadResolvers(source: string): Promise<Resolver[]> {
+  const files = await fg(source, {
+    absolute: true,
+  });
+  const modules: unknown[] = await Promise.all(files.map((file) => import(file)));
+  const allResolvers: Resolver[] = [];
+
+  for (const mod of modules) {
+    if (typeof mod !== 'object' || mod === null) {
+      continue;
+    }
+
+    for (const key of Object.keys(mod)) {
+      const exported = (mod as Record<string, unknown>)[key];
+
+      if (typeof exported === 'function') {
+        allResolvers.push(exported as Resolver);
+      }
+
+      if (Array.isArray(exported) && exported.every((r) => typeof r === 'function')) {
+        allResolvers.push(...(exported as Resolver[]));
+      }
+    }
+  }
+
+  if (allResolvers.length === 0) {
+    throw new Error('❌ No resolvers found for any slices.');
+  }
+  return allResolvers;
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@auto-engineer/server-generator-apollo-emmett",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@auto-engineer/flow": "^0.1.1",
+    "@auto-engineer/message-bus": "^0.5.2",
+    "@event-driven-io/emmett": "^0.38.2",
+    "apollo-server": "^3.13.0",
+    "apollo-server-express": "^3.13.0",
+    "change-case": "^5.4.4",
+    "ejs": "^3.1.10",
+    "execa": "^9.6.0",
+    "express": "^4.21.2",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.0",
+    "graphql": "^16.11.0",
+    "graphql-scalars": "^1.24.2",
+    "prettier": "^3.6.1",
+    "reflect-metadata": "^0.2.2",
+    "type-fest": "^4.41.0",
+    "type-graphql": "^2.0.0-rc.2",
+    "uuid": "^10.0.0",
+    "web-streams-polyfill": "^4.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@auto-engineer/cli": "^0.7.2",
+    "@types/ejs": "^3.1.5",
+    "@types/fs-extra": "^11.0.4"
+  },
+  "scripts": {
+    "generate:server": "tsx src/cli/index.ts",
+    "build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/codegen/templates && mkdir -p dist/codegen && cp -r src/codegen/templates dist/codegen/templates && cp src/server.ts dist/ && cp -r src/utils dist/ && cp -r src/domain dist/",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "type-check": "tsc --noEmit --project tsconfig.json",
+    "lint": "eslint 'src/**/*.ts' --ignore-pattern '**/*.specs.ts' --ignore-pattern '**/.tmp/**' --max-warnings 0 --config ../../eslint.config.ts",
+    "format": "prettier --write \"**/*.{js,ts,json,md,yml,yaml}\" --ignore-path ../../.prettierignore",
+    "lint:fix": "eslint 'src/**/*.ts' --ignore-pattern '**/*.specs.ts' --ignore-pattern '**/.tmp/**' --fix --config ../../eslint.config.ts",
+    "format:fix": "prettier --write \"**/*.{js,ts,json,md,yml,yaml}\" --ignore-path ../../.prettierignore",
+    "link:dev": "pnpm build && pnpm link --global",
+    "unlink:dev": "pnpm unlink --global"
+  }
+}

package/src/cli-manifest.ts

@@ -0,0 +1,9 @@
+import type { CliManifest } from '@auto-engineer/cli/manifest-types';
+import { generateServerManifest } from './commands/generate-server';
+
+export const CLI_MANIFEST: CliManifest = {
+  category: '@auto-engineer/server-generator-apollo-emmett',
+  commands: {
+    'generate:server': generateServerManifest,
+  },
+};

package/src/codegen/extract/commands.ts

@@ -0,0 +1,79 @@
+import { CommandExample, EventExample } from '@auto-engineer/flow';
+import { Message, MessageDefinition } from '../types';
+import { extractFieldsFromMessage } from './fields';
+import { ReactGwtSpec } from './messages';
+
+function createCommandMessage(
+  commandRef: string,
+  allMessages: MessageDefinition[],
+  source: 'when' | 'then',
+): Message | undefined {
+  const fields = extractFieldsFromMessage(commandRef, 'command', allMessages);
+
+  if (fields.length === 0 && source === 'then') {
+    return undefined;
+  }
+
+  return {
+    type: commandRef,
+    fields,
+    source,
+  };
+}
+
+export function extractCommandsFromGwt(
+  gwtSpecs: Array<{
+    given?: EventExample[];
+    when: CommandExample;
+    then: Array<EventExample | { errorType: string; message?: string }>;
+  }>,
+  allMessages: MessageDefinition[],
+): { commands: Message[]; commandSchemasByName: Record<string, Message> } {
+  const commandSchemasByName: Record<string, Message> = {};
+
+  const commands: Message[] = gwtSpecs
+    .map((gwt): Message | undefined => {
+      const cmd = gwt.when;
+      if (!cmd.commandRef) return undefined;
+
+      const command = createCommandMessage(cmd.commandRef, allMessages, 'when');
+      if (command) {
+        commandSchemasByName[cmd.commandRef] = command;
+      }
+      return command;
+    })
+    .filter((cmd): cmd is Message => cmd !== undefined);
+
+  return { commands, commandSchemasByName };
+}
+
+export function extractCommandsFromThen(
+  gwtSpecs: ReactGwtSpec[],
+  allMessages: MessageDefinition[],
+): { commands: Message[]; commandSchemasByName: Record<string, Message> } {
+  const commands: Message[] = [];
+  const commandSchemasByName: Record<string, Message> = {};
+
+  for (const gwt of gwtSpecs) {
+    if (!Array.isArray(gwt.then)) {
+      continue;
+    }
+
+    for (const commandExample of gwt.then) {
+      if (!commandExample.commandRef) {
+        continue;
+      }
+
+      const commandRef = commandExample.commandRef;
+      if (!(commandRef in commandSchemasByName)) {
+        const command = createCommandMessage(commandRef, allMessages, 'then');
+        if (command) {
+          commands.push(command);
+          commandSchemasByName[commandRef] = command;
+        }
+      }
+    }
+  }
+
+  return { commands, commandSchemasByName };
+}

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

@@ -0,0 +1,45 @@
+import { CommandExample, DataSink, Slice } from '@auto-engineer/flow';
+import { CommandGwtSpec, QueryGwtSpec, ReactGwtSpec } from './messages';
+
+function resolveStreamId(stream: string, exampleData: Record<string, unknown>): string {
+  return stream.replace(/\$\{([^}]+)\}/g, (_, key: string) => String(exampleData?.[key] ?? 'unknown'));
+}
+
+// eslint-disable-next-line complexity
+export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
+  let streamPattern: string | undefined;
+  let streamId: string | undefined;
+  const gwtSpecs =
+    slice.type === 'command'
+      ? (slice.server?.gwt as CommandGwtSpec[])
+      : slice.type === 'query'
+        ? (slice.server?.gwt as QueryGwtSpec[])
+        : slice.type === 'react'
+          ? (slice.server?.gwt as ReactGwtSpec[])
+          : [];
+  let exampleData: Record<string, unknown> = {};
+  switch (slice.type) {
+    case 'react':
+      exampleData = (gwtSpecs as ReactGwtSpec[])[0].when?.[0]?.exampleData ?? {};
+      break;
+    case 'command': {
+      const then = (gwtSpecs as CommandGwtSpec[])[0]?.then as (CommandExample | { errorType: string })[];
+      const firstExample = then.find((t): t is CommandExample => 'exampleData' in t);
+      exampleData = firstExample?.exampleData ?? {};
+      break;
+    }
+    case 'query':
+      exampleData = (gwtSpecs as QueryGwtSpec[])[0]?.given?.[0]?.exampleData ?? {};
+      break;
+  }
+  const sink = (slice.server?.data ?? []).find((item) => (item as DataSink)?.destination?.type === 'stream') as
+    | DataSink
+    | undefined;
+  if (sink && sink.destination.type === 'stream' && 'pattern' in sink.destination) {
+    streamPattern = sink.destination.pattern;
+    if (streamPattern != null) {
+      streamId = resolveStreamId(streamPattern, exampleData);
+    }
+  }
+  return { streamPattern, streamId };
+}

package/src/codegen/extract/events.ts

@@ -0,0 +1,46 @@
+import { EventExample } from '@auto-engineer/flow';
+import { Message, MessageDefinition } from '../types';
+import { extractFieldsFromMessage } from './fields';
+import { ReactGwtSpec } from './messages';
+
+function createEventMessage(
+  eventRef: string | undefined,
+  source: 'given' | 'then' | 'when',
+  allMessages: MessageDefinition[],
+): Message | undefined {
+  if (eventRef == null) return undefined;
+  const fields = extractFieldsFromMessage(eventRef, 'event', allMessages);
+  return { type: eventRef, fields, source };
+}
+
+export function extractEventsFromThen(
+  thenItems: Array<EventExample | { errorType: string; message?: string }>,
+  allMessages: MessageDefinition[],
+): Message[] {
+  return thenItems
+    .map((then): Message | undefined => {
+      if (!('eventRef' in then)) return undefined;
+      return createEventMessage(then.eventRef, 'then', allMessages);
+    })
+    .filter((event): event is Message => event !== undefined);
+}
+
+export function extractEventsFromGiven(
+  givenEvents: EventExample[] | undefined,
+  allMessages: MessageDefinition[],
+): Message[] {
+  if (!givenEvents) return [];
+
+  return givenEvents
+    .map((given) => createEventMessage(given.eventRef, 'given', allMessages))
+    .filter((event): event is Message => event !== undefined);
+}
+
+export function extractEventsFromWhen(gwtSpecs: ReactGwtSpec[], allMessages: MessageDefinition[]): Message[] {
+  return gwtSpecs.flatMap((gwt) => {
+    if (!Array.isArray(gwt.when)) {
+      return [];
+    }
+    return gwt.when.flatMap((eventExample) => extractEventsFromGiven([eventExample], allMessages));
+  });
+}

package/src/codegen/extract/fields.ts

@@ -0,0 +1,17 @@
+import { Field, MessageDefinition } from '../types';
+
+export function extractFieldsFromMessage(
+  messageName: string,
+  messageType: 'command' | 'event' | 'state',
+  allMessages: MessageDefinition[],
+): Field[] {
+  const messageDef = allMessages.find((m) => m.type === messageType && m.name === messageName);
+
+  return (
+    messageDef?.fields?.map((f) => ({
+      name: f.name,
+      tsType: f.type,
+      required: f.required ?? true,
+    })) ?? []
+  );
+}

package/src/codegen/extract/graphql.ts

@@ -0,0 +1,103 @@
+import { parse, OperationDefinitionNode, TypeNode, print } from 'graphql';
+
+export interface ParsedArg {
+  name: string;
+  tsType: string;
+  graphqlType: string;
+  nullable: boolean;
+}
+
+export interface ParsedGraphQlQuery {
+  queryName: string;
+  args: ParsedArg[];
+  returnType: string;
+  tsReturnType: string;
+}
+
+function getTypeName(typeNode: TypeNode): { graphqlType: string; nullable: boolean } {
+  if (typeNode.kind === 'NamedType') {
+    return { graphqlType: typeNode.name.value, nullable: true };
+  } else if (typeNode.kind === 'NonNullType') {
+    const inner = getTypeName(typeNode.type);
+    return { ...inner, nullable: false };
+  } else {
+    return getTypeName(typeNode.type);
+  }
+}
+
+function graphqlToTs(type: string): string {
+  switch (type) {
+    case 'String':
+      return 'string';
+    case 'Int':
+    case 'Float':
+    case 'Number':
+      return 'number';
+    case 'Boolean':
+      return 'boolean';
+    case 'Date':
+      return 'Date';
+    default:
+      return type;
+  }
+}
+
+function convertJsonAstToSdl(request: string): string {
+  // Handle JSON-serialized AST
+  if (request.startsWith('{') && request.includes('"kind"')) {
+    try {
+      const ast = JSON.parse(request) as unknown;
+      if (typeof ast === 'object' && ast !== null && 'kind' in ast && ast.kind === 'Document') {
+        // Convert AST to SDL string - cast is safe here as we've validated it's a Document
+        return print(ast as Parameters<typeof print>[0]);
+      }
+    } catch {
+      // If parsing fails, assume it's already a GraphQL string
+    }
+  }
+  return request;
+}
+
+export function parseGraphQlRequest(request: string): ParsedGraphQlQuery {
+  const sdlRequest = convertJsonAstToSdl(request);
+
+  const ast = parse(sdlRequest);
+  const op = ast.definitions.find(
+    (d): d is OperationDefinitionNode => d.kind === 'OperationDefinition' && d.operation === 'query',
+  );
+
+  if (!op) throw new Error('No query operation found');
+
+  const queryName = op.name?.value;
+  if (queryName == null) throw new Error('Query must have a name');
+
+  const args: ParsedArg[] = (op.variableDefinitions ?? []).map((def) => {
+    const varName = def.variable.name.value;
+    const { graphqlType, nullable } = getTypeName(def.type);
+    return {
+      name: varName,
+      graphqlType,
+      tsType: graphqlToTs(graphqlType),
+      nullable,
+    };
+  });
+
+  const field = op.selectionSet.selections[0];
+  if (field?.kind !== 'Field' || !field.name.value) {
+    throw new Error('Query selection must be a field');
+  }
+
+  const baseName = field.name.value;
+  const returnType = pascalCase(baseName) + 'View';
+
+  return {
+    queryName: baseName,
+    args,
+    returnType,
+    tsReturnType: `${returnType}[]`,
+  };
+}
+
+function pascalCase(input: string): string {
+  return input.replace(/(^\w|_\w)/g, (match) => match.replace('_', '').toUpperCase());
+}