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

package/src/codegen/templates/query/projection.ts.ejs

@@ -0,0 +1,121 @@
+import {
+inMemorySingleStreamProjection,
+type ReadEvent,
+type InMemoryReadEventMetadata,
+} from '@event-driven-io/emmett';
+import type { <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %> } from './state';<%
+if (events.length > 0) {
+    const importGroups = new Map();
+    for (const event of events) {
+        const fromSameFlow = event.sourceFlowName === flowName;
+        const basePath = fromSameFlow
+                ? `../${toKebabCase(event.sourceSliceName ?? 'unknown')}/events`
+                : `../${toKebabCase(event.sourceFlowName ?? 'unknown')}/${toKebabCase(event.sourceSliceName ?? 'unknown')}/events`;
+
+        if (!importGroups.has(basePath)) {
+            importGroups.set(basePath, []);
+        }
+        importGroups.get(basePath).push(event.type);
+    }
+
+        for (const [importPath, typeNames] of importGroups.entries()) {
+%>
+    import type { <%= typeNames.join(', ') %> } from '<%= importPath %>';
+<%
+}
+} -%>
+
+type AllEvents = <%= events.length > 0 ? events.map(e => e.type).join(' | ') : 'never' %>;
+
+export const projection = inMemorySingleStreamProjection<
+<%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %>,
+AllEvents
+>({
+collectionName: '<%= pascalCase(slice.server?.data?.[0]?.origin?.name || "unknown-collection") %>',
+canHandle: [<%- events.map(e => `'${e.type}'`).join(', ') %>],
+getDocumentId: (event) => event.data.<%= slice.server?.data?.[0]?.origin?.idField ?? 'id' %>,
+evolve: (
+document: <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %> | null,
+event: ReadEvent<AllEvents, InMemoryReadEventMetadata>
+): <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %> | null => {
+switch (event.type) {
+<% for (const event of events) {
+    const targetName = slice.server?.data?.[0]?.target?.name;
+    const queryGwt = slice.type === 'query'
+            ? queryGwtMapping.find(gwt =>
+                    gwt.given.some(g => g.eventRef === event.type)
+            )
+            : undefined;
+    const example = slice.type === 'query'
+            ? queryGwt?.then.find(t => t.stateRef === targetName)?.exampleData
+            : gwtMapping[event.type]?.[0]?.then?.[0]?.exampleData;
+    const targetDef = messages.find(m => m.name === slice.server?.data?.[0]?.target?.name);
+    const targetFields = Object.fromEntries((targetDef?.fields ?? []).map(f => [f.name, f]));
+    let usedFields = [];
+    let isRemovalEvent = false;
+    if (typeof example !== 'undefined') {
+        if (example && Object.keys(example).length > 0) {
+            usedFields = Object.keys(example);
+        } else {
+            isRemovalEvent = true;
+        }
+    } else if (targetFields) {
+        usedFields = Object.keys(targetFields);
+    }
+    const eventNameSuggestsRemoval = event.type.toLowerCase().includes('remove') ||
+            event.type.toLowerCase().includes('delete');
+%>
+case '<%= event.type %>': {
+/**
+* ## IMPLEMENTATION INSTRUCTIONS ##
+<% if (isRemovalEvent || eventNameSuggestsRemoval) { -%>
+    * This event might indicate removal of a <%= targetName || 'document' %>.
+    *
+    * - If the intent is to **remove the document**, return `null`.
+    * - If the intent is to **soft delete**, consider adding a `status` field (e.g., `status: 'removed'`).
+    * - Ensure consumers of this projection (e.g., UI) handle the chosen approach appropriately.
+<% } else { -%>
+    * This event adds or updates the document.
+    * Implement the correct fields as needed for your read model.
+<% } -%>
+*/
+<% if (isRemovalEvent) { -%>
+    return null;
+<% } else if (usedFields.length === 0) { -%>
+    // No fields specified - returning null
+    return null;
+<% } else { -%>
+    return {
+    <% for (let i = 0; i < usedFields.length; i++) {
+        const field = usedFields[i];
+        const isLast = i === usedFields.length - 1;
+        const def = (targetFields ?? {})[field];
+        const type = def?.type ?? 'string';
+
+        let placeholder = 'undefined';
+        if (type === 'string' || type === 'ID') {
+            placeholder = "''";
+        } else if (type === 'number') {
+            placeholder = '0';
+        } else if (type === 'boolean') {
+            placeholder = 'false';
+        } else if (type === 'Date') {
+            placeholder = 'new Date()';
+        } else if (type.startsWith('Array<')) {
+            placeholder = '[]';
+        } else {
+            placeholder = '{} as any';
+        }
+    %>          <%= field %>: /* TODO: map from event.data */ <%- placeholder %><%= isLast ? '' : ',' %>
+    <% } -%>
+    };
+<% } -%>
+}
+<% } -%>
+default:
+return document;
+}
+},
+});
+
+export default projection;

package/src/codegen/templates/query/query.resolver.specs.ts

@@ -0,0 +1,254 @@
+import { describe, it, expect } from 'vitest';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+
+describe('query.resolver.ts.ejs', () => {
+  it('should generate a valid query resolver from request field', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'listing-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'search-listings',
+              request: `
+                query SearchProperties($location: String, $maxPrice: Float, $minGuests: Int) {
+                  searchProperties(location: $location, maxPrice: $maxPrice, minGuests: $minGuests) {
+                    propertyId
+                    title
+                    pricePerNight
+                    location
+                    maxGuests
+                  }
+                }
+              `,
+              client: {
+                description: '',
+                specs: [],
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'propertyId',
+                      name: 'AvailablePropertiesProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'AvailableListings',
+                    },
+                  },
+                ],
+                gwt: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'AvailableListings',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'title', type: 'string', required: true },
+            { name: 'pricePerNight', type: 'number', required: true },
+            { name: 'location', type: 'string', required: true },
+            { name: 'maxGuests', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toMatchInlineSnapshot(`
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field } from 'type-graphql';
+      import { type GraphQLContext, ReadModel } from '../../../shared';
+
+      @ObjectType()
+      export class AvailableListings {
+        @Field(() => String)
+        propertyId!: string;
+
+        @Field(() => String)
+        title!: string;
+
+        @Field(() => Number)
+        pricePerNight!: number;
+
+        @Field(() => String)
+        location!: string;
+
+        @Field(() => Number)
+        maxGuests!: number;
+
+        [key: string]: unknown;
+      }
+
+      @Resolver()
+      export class SearchListingsQueryResolver {
+        @Query(() => [AvailableListings])
+        async searchProperties(
+          @Ctx() ctx: GraphQLContext,
+          @Arg('location', () => String, { nullable: true }) location?: string,
+          @Arg('maxPrice', () => Number, { nullable: true }) maxPrice?: number,
+          @Arg('minGuests', () => Number, { nullable: true }) minGuests?: number,
+        ): Promise<AvailableListings[]> {
+          const model = new ReadModel<AvailableListings>(ctx.eventStore, 'AvailablePropertiesProjection');
+
+          // ## IMPLEMENTATION INSTRUCTIONS ##
+          // You can query the projection using the ReadModel API:
+          //
+          // - model.getAll() — fetch all documents
+          // - model.getById(id) — fetch a single document by ID (default key: 'id')
+          // - model.find(filterFn) — filter documents using a predicate
+          // - model.first(filterFn) — fetch the first document matching a predicate
+          //
+          // Example below uses \`.find()\` to filter
+          // change the logic for the query as needed to meet the requirements for the current slice.
+
+          return model.find((item) => {
+            if (location !== undefined && item.location !== location) return false;
+
+            if (maxPrice !== undefined && item.maxPrice !== maxPrice) return false;
+
+            if (minGuests !== undefined && item.minGuests !== minGuests) return false;
+
+            return true;
+          });
+        }
+      }
+      "
+    `);
+  });
+  it('should generate a valid query resolver with array of inline object field', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'assistant-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'views-suggested-items',
+              request: `
+              query GetSuggestedItems($sessionId: ID!) {
+                suggestedItems(sessionId: $sessionId) {
+                  sessionId
+                  items {
+                    productId
+                    name
+                    quantity
+                    reason
+                  }
+                }
+              }
+            `,
+              client: { description: '', specs: [] },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'sessionId',
+                      name: 'SuggestedItemsProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'SuggestedItems',
+                    },
+                  },
+                ],
+                gwt: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'SuggestedItems',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            {
+              name: 'items',
+              type: 'Array<{ productId: string; name: string; quantity: number; reason: string }>',
+              required: true,
+            },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toMatchInlineSnapshot(`
+      "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID } from 'type-graphql';
+      import { type GraphQLContext, ReadModel } from '../../../shared';
+
+      @ObjectType()
+      export class SuggestedItems {
+        @Field(() => String)
+        sessionId!: string;
+
+        @Field(() => [SuggestedItemsItems])
+        items!: SuggestedItemsItems[];
+
+        [key: string]: unknown;
+      }
+
+      @ObjectType()
+      export class SuggestedItemsItems {
+        @Field(() => String)
+        productId!: string;
+
+        @Field(() => String)
+        name!: string;
+
+        @Field(() => Number)
+        quantity!: number;
+
+        @Field(() => String)
+        reason!: string;
+      }
+
+      @Resolver()
+      export class ViewsSuggestedItemsQueryResolver {
+        @Query(() => [SuggestedItems])
+        async suggestedItems(
+          @Ctx() ctx: GraphQLContext,
+          @Arg('sessionId', () => ID, { nullable: true }) sessionId?: string,
+        ): Promise<SuggestedItems[]> {
+          const model = new ReadModel<SuggestedItems>(ctx.eventStore, 'SuggestedItemsProjection');
+
+          // ## IMPLEMENTATION INSTRUCTIONS ##
+          // You can query the projection using the ReadModel API:
+          //
+          // - model.getAll() — fetch all documents
+          // - model.getById(id) — fetch a single document by ID (default key: 'id')
+          // - model.find(filterFn) — filter documents using a predicate
+          // - model.first(filterFn) — fetch the first document matching a predicate
+          //
+          // Example below uses \`.find()\` to filter
+          // change the logic for the query as needed to meet the requirements for the current slice.
+
+          return model.find((item) => {
+            if (sessionId !== undefined && item.sessionId !== sessionId) return false;
+
+            return true;
+          });
+        }
+      }
+      "
+    `);
+  });
+});

package/src/codegen/templates/query/query.resolver.ts.ejs

@@ -0,0 +1,98 @@
+<%
+const target = slice?.server?.data?.[0]?.target;
+const projection = slice?.server?.data?.[0]?.origin;
+const queryName = parsedRequest?.queryName ?? camelCase(sliceName);
+const viewType = target?.name ? pascalCase(target.name) : 'UnknownView';
+const projectionType = projection?.name ? pascalCase(projection.name) : 'UnknownProjection';
+const message = messages?.find(m => m.name === viewType);
+const resolverClassName = `${pascalCase(slice.name)}QueryResolver`;
+const usesID = parsedRequest?.args?.some(arg => graphqlType(arg.tsType) === 'ID');
+
+const embeddedTypes = [];
+function getEmbeddedObjectTypeName(parentName, fieldName) {
+    return `${parentName}${pascalCase(fieldName)}`;
+}
+%>
+import { Query, Resolver, Arg, Ctx, ObjectType, Field<% if (usesID) { %>, ID<% } %> } from 'type-graphql';
+import { type GraphQLContext, ReadModel } from '../../../shared';
+
+@ObjectType()
+export class <%= viewType %> {
+<% if (message?.fields?.length) {
+        for (const field of message.fields) {
+    const gqlType = graphqlType(field.type ?? 'string');
+    const tsType = field.type ?? 'string';
+    const isInlineArray = tsType.startsWith('Array<{') || tsType.startsWith('{') || tsType.includes('[]');
+    const fieldTypeName = getEmbeddedObjectTypeName(viewType, field.name);
+
+if (isInlineArray) {
+    embeddedTypes.push({ parentName: viewType, fieldName: field.name, typeName: fieldTypeName, tsType });
+%>
+@Field(() => [<%= fieldTypeName %>])
+<%= field.name %>!: <%= fieldTypeName %>[];
+<%      } else { %>
+    @Field(() => <%= gqlType %>)
+    <%= field.name %>!: <%= tsType %>;
+<%      }
+} %>
+[key: string]: unknown;
+<% } else { %>
+    [key: string]: unknown;
+<% } %>
+}
+
+<% for (const { typeName, tsType } of embeddedTypes) {
+    const match = tsType.match(/Array<\{([^}]*)\}>/);
+    const rawFields = match?.[1]?.split(/[,;]/) ?? [];
+    const parsedFields = rawFields
+            .map(f => {
+                const [name, type] = f.trim().split(':').map(x => x.trim());
+                if (!name || !type) return null;
+                return { name, tsType: type, gqlType: graphqlType(type) };
+            })
+            .filter(Boolean);
+%>
+
+@ObjectType()
+export class <%= typeName %> {
+<% for (const f of parsedFields) { %>
+    @Field(() => <%= f.gqlType %>)
+    <%= f.name %>!: <%= f.tsType %>;
+<% } %>
+}
+<% } %>
+
+@Resolver()
+export class <%= resolverClassName %> {
+@Query(() => [<%= viewType %>])
+async <%= queryName %>(
+@Ctx() ctx: GraphQLContext<% if (parsedRequest?.args?.length) { %>,
+<%     for (let i = 0; i < parsedRequest.args.length; i++) {
+    const arg = parsedRequest.args[i];
+    const gqlType = graphqlType(arg.tsType);
+    const tsType = arg.tsType === 'ID' ? 'string' : arg.tsType;
+%>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
+<%     } } %>
+): Promise<<%= viewType %>[]> {
+const model = new ReadModel<<%= viewType %>>(ctx.eventStore, '<%= projectionType %>');
+
+// ## IMPLEMENTATION INSTRUCTIONS ##
+// You can query the projection using the ReadModel API:
+//
+// - model.getAll() — fetch all documents
+// - model.getById(id) — fetch a single document by ID (default key: 'id')
+// - model.find(filterFn) — filter documents using a predicate
+// - model.first(filterFn) — fetch the first document matching a predicate
+//
+// Example below uses `.find()` to filter
+// change the logic for the query as needed to meet the requirements for the current slice.
+
+return model.find((item) => {
+<% if (parsedRequest?.args?.length) {
+        for (const arg of parsedRequest.args) { %>
+    if (<%= arg.name %> !== undefined && item.<%= arg.name %> !== <%= arg.name %>) return false;
+<%    } } %>
+return true;
+});
+}
+}

package/src/codegen/templates/query/state.specs.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+
+describe('state.ts.ejs', () => {
+  it('should generate a valid state definition file for a query slice with a state message', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'Inventory management',
+          slices: [
+            {
+              type: 'query',
+              name: 'Get available items',
+              client: {
+                description: 'Client view of available items',
+                specs: [],
+              },
+              server: {
+                description: 'Projects available items',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      name: 'ItemCreated',
+                      idField: 'id',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'AvailableItems',
+                    },
+                  },
+                ],
+                gwt: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'AvailableItems',
+          fields: [
+            { name: 'id', type: 'string', required: true },
+            { name: 'name', type: 'string', required: true },
+            { name: 'price', type: 'number', required: true },
+            { name: 'inStock', type: 'boolean', required: true },
+            { name: 'addedAt', type: 'Date', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const stateFile = plans.find((p) => p.outputPath.endsWith('state.ts'));
+
+    expect(stateFile?.contents).toMatchInlineSnapshot(`
+      "export type AvailableItems = {
+        id: string;
+        name: string;
+        price: number;
+        inStock: boolean;
+        addedAt: Date;
+      };
+      "
+    `);
+  });
+});

package/src/codegen/templates/query/state.ts.ejs

@@ -0,0 +1,7 @@
+<% for (const state of states) { -%>
+    export type <%= pascalCase(state.type) %> = {
+    <% for (const field of state.fields) { -%>
+        <%- field.name %><%= field.required ? '' : '?' %>: <%- field.tsType %>;
+    <% } -%>
+    };
+<% } -%>