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

package/dist/codegen/templates/command/mutation.resolver.specs.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+
+describe('mutation.resolver.ts.ejs', () => {
+  it('should generate a valid mutation resolver file', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'Host creates a listing',
+          slices: [
+            {
+              type: 'command',
+              name: 'Create listing',
+              client: {
+                description: 'A form that allows users to add a new listing',
+                specs: [],
+              },
+              server: {
+                description: 'Handles listing creation',
+                gwt: [
+                  {
+                    when: {
+                      commandRef: 'CreateListing',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                        title: 'Modern Downtown Apartment',
+                        pricePerNight: 250,
+                        maxGuests: 4,
+                        amenities: ['wifi', 'kitchen'],
+                        available: true,
+                        tags: ['sea view', 'balcony'],
+                        rating: 4.8,
+                        metadata: { petsAllowed: true },
+                        listedAt: '2024-01-15T10:00:00Z',
+                      },
+                    },
+                    then: [],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'CreateListing',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'title', type: 'string', required: true },
+            { name: 'pricePerNight', type: 'number', required: true },
+            { name: 'maxGuests', type: 'number', required: true },
+            { name: 'amenities', type: 'string[]', required: true },
+            { name: 'available', type: 'boolean', required: true },
+            { name: 'tags', type: 'string[]', required: true },
+            { name: 'rating', type: 'number', required: true },
+            { name: 'metadata', type: 'object', required: true },
+            { name: 'listedAt', type: 'Date', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const mutationFile = plans.find((p) => p.outputPath.endsWith('mutation.resolver.ts'));
+
+    expect(mutationFile?.contents).toMatchInlineSnapshot(`
+      "import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
+      import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+
+      @InputType()
+      export class CreateListingInput {
+        @Field(() => String)
+        propertyId!: string;
+        @Field(() => String)
+        title!: string;
+        @Field(() => Number)
+        pricePerNight!: number;
+        @Field(() => Number)
+        maxGuests!: number;
+        @Field(() => [String])
+        amenities!: string[];
+        @Field(() => Boolean)
+        available!: boolean;
+        @Field(() => [String])
+        tags!: string[];
+        @Field(() => Number)
+        rating!: number;
+        @Field(() => Object)
+        metadata!: object;
+        @Field(() => Date)
+        listedAt!: Date;
+      }
+
+      @Resolver()
+      export class CreateListingResolver {
+        @Mutation(() => MutationResponse)
+        async createListing(
+          @Arg('input', () => CreateListingInput) input: CreateListingInput,
+          @Ctx() ctx: GraphQLContext,
+        ): Promise<MutationResponse> {
+          return await sendCommand(ctx.messageBus, {
+            type: 'CreateListing',
+            kind: 'Command',
+            data: { ...input },
+          });
+        }
+      }
+      "
+    `);
+  });
+});

package/dist/codegen/templates/command/mutation.resolver.ts.ejs

@@ -0,0 +1,25 @@
+import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
+import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+
+@InputType()
+export class <%= pascalCase(commands[0].type) %>Input {
+<% for (const field of commands[0].fields) { -%>
+    @Field(() => <%= graphqlType(field.tsType) %><%= field.required === false ? ', { nullable: true }' : '' %>)
+    <%= field.name %><%= field.required === false ? '?' : '' %><%= field.required !== false ? '!' : '' %>: <%- field.tsType %>;
+<% } -%>
+}
+
+@Resolver()
+export class <%= pascalCase(commands[0].type) %>Resolver {
+@Mutation(() => MutationResponse)
+async <%= camelCase(commands[0].type) %>(
+@Arg('input', () => <%= pascalCase(commands[0].type) %>Input) input: <%= pascalCase(commands[0].type) %>Input,
+@Ctx() ctx: GraphQLContext
+): Promise<MutationResponse> {
+    return await sendCommand(ctx.messageBus, {
+    type: '<%= commands[0].type %>',
+    kind: 'Command',
+    data: { ...input },
+    });
+    }
+    }

package/dist/codegen/templates/command/register.specs.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+
+describe('generateScaffoldFilePlans', () => {
+  it('should generate a valid register file', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'Host creates a listing',
+          slices: [
+            {
+              type: 'command',
+              name: 'Create listing',
+              stream: 'listings-${propertyId}',
+              client: {
+                description: 'test',
+                specs: [],
+              },
+              server: {
+                description: 'test',
+                gwt: [
+                  {
+                    when: {
+                      commandRef: 'CreateListing',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                        title: 'Modern Downtown Apartment',
+                        listedAt: '2024-01-15T10:00:00Z',
+                        rating: 4.8,
+                        metadata: { foo: 'bar' },
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'ListingCreated',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                          title: 'Modern Downtown Apartment',
+                          listedAt: '2024-01-15T10:00:00Z',
+                          rating: 4.8,
+                          metadata: { foo: 'bar' },
+                        },
+                      },
+                    ],
+                  },
+                ],
+                data: [
+                  {
+                    target: {
+                      type: 'Event',
+                      name: 'ListingCreated',
+                    },
+                    destination: {
+                      type: 'stream',
+                      pattern: 'listings-${propertyId}',
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'CreateListing',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'title', type: 'string', required: true },
+            { name: 'listedAt', type: 'Date', required: true },
+            { name: 'rating', type: 'number', required: true },
+            { name: 'metadata', type: 'object', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'ListingCreated',
+          source: 'internal',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'title', type: 'string', required: true },
+            { name: 'listedAt', type: 'Date', required: true },
+            { name: 'rating', type: 'number', required: true },
+            { name: 'metadata', type: 'object', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const registerFile = plans.find((p) => p.outputPath.endsWith('register.ts'));
+
+    expect(registerFile?.contents).toMatchInlineSnapshot(`
+          "import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
+          import { handle } from './handle';
+          import type { CreateListing } from './commands';
+
+          export function register(messageBus: CommandProcessor, eventStore: EventStore) {
+            messageBus.handle((command: CreateListing) => handle(eventStore, command), 'CreateListing');
+          }
+          "
+        `);
+  });
+});

package/dist/codegen/templates/command/register.ts.ejs

@@ -0,0 +1,12 @@
+import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
+import { handle } from './handle';
+import type { <%= commands.map(c => pascalCase(c.type)).join(', ') %> } from './commands';
+
+export function register(messageBus: CommandProcessor, eventStore: EventStore) {
+<% for (const command of commands) { -%>
+    messageBus.handle(
+    (command: <%= pascalCase(command.type) %>) => handle(eventStore, command),
+    '<%= command.type %>'
+    );
+<% } -%>
+}

package/dist/codegen/templates/command/state.specs.ts

@@ -0,0 +1,127 @@
+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 an initial state', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'Host creates a listing',
+          slices: [
+            {
+              type: 'command',
+              name: 'Create listing',
+              client: {
+                description: 'test',
+                specs: [],
+              },
+              server: {
+                description: 'test',
+                gwt: [
+                  {
+                    when: {
+                      commandRef: 'CreateListing',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                        title: 'nice apartment',
+                        pricePerNight: 250,
+                        available: true,
+                        rating: 4.8,
+                        metadata: { foo: 'bar' },
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'ListingCreated',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                          listedAt: '2024-01-15T10:00:00Z',
+                          rating: 4.8,
+                          metadata: { foo: 'bar' },
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'CreateListing',
+          fields: [],
+        },
+        {
+          type: 'event',
+          name: 'ListingCreated',
+          source: 'internal',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'listedAt', type: 'Date', required: true },
+            { name: 'rating', type: 'number', required: true },
+            { name: 'metadata', type: 'object', 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(`
+          "/**
+           * ## IMPLEMENTATION INSTRUCTIONS ##
+           *
+           * Define the shape of the domain state for the current slice below. This state is used by \`decide.ts\`
+           * to determine whether a command is valid.
+           *
+           * The state is evolved over time by applying domain events (in \`evolve.ts\`).
+           * Each event updates the state incrementally based on business rules.
+           *
+           * Guidelines:
+           * - Include only fields that are **read** during command validation.
+           * - Use discriminated unions (e.g., \`status: 'Pending' | 'Done'\`) to model state transitions.
+           * - Prefer primitive types: \`string\`, \`boolean\`, \`number\`.
+           * - Use objects or maps only when structure is essential for decision logic.
+           *
+           * Do NOT include:
+           * - Redundant data already emitted in events unless required to enforce business rules.
+           * - Fields used only for projections, UI, or query purposes.
+           *
+           * ### Example (for a Task domain):
+           *
+           * \`\`\`ts
+           * export type PendingTask = {
+           *   status: 'Pending';
+           * };
+           *
+           * export type InProgressTask = {
+           *   status: 'InProgress';
+           *   startedAt: string;
+           * };
+           *
+           * export type CompletedTask = {
+           *   status: 'Completed';
+           *   completedAt: string;
+           * };
+           *
+           * export type State = PendingTask | InProgressTask | CompletedTask;
+           * \`\`\`
+           */
+
+          // TODO: Replace with a discriminated union of domain states for the current slice
+          export type State = {};
+
+          // TODO: Replace the Return with the initial domain state of the current slice
+          export const initialState = (): State => {
+            return {};
+          };
+          "
+        `);
+  });
+});

package/dist/codegen/templates/command/state.ts.ejs

@@ -0,0 +1,47 @@
+/**
+* ## IMPLEMENTATION INSTRUCTIONS ##
+*
+* Define the shape of the domain state for the current slice below. This state is used by `decide.ts`
+* to determine whether a command is valid.
+*
+* The state is evolved over time by applying domain events (in `evolve.ts`).
+* Each event updates the state incrementally based on business rules.
+*
+* Guidelines:
+* - Include only fields that are **read** during command validation.
+* - Use discriminated unions (e.g., `status: 'Pending' | 'Done'`) to model state transitions.
+* - Prefer primitive types: `string`, `boolean`, `number`.
+* - Use objects or maps only when structure is essential for decision logic.
+*
+* Do NOT include:
+* - Redundant data already emitted in events unless required to enforce business rules.
+* - Fields used only for projections, UI, or query purposes.
+*
+* ### Example (for a Task domain):
+*
+* ```ts
+* export type PendingTask = {
+*   status: 'Pending';
+* };
+*
+* export type InProgressTask = {
+*   status: 'InProgress';
+*   startedAt: string;
+* };
+*
+* export type CompletedTask = {
+*   status: 'Completed';
+*   completedAt: string;
+* };
+*
+* export type State = PendingTask | InProgressTask | CompletedTask;
+* ```
+*/
+
+// TODO: Replace with a discriminated union of domain states for the current slice
+export type State = {};
+
+// TODO: Replace the Return with the initial domain state of the current slice
+export const initialState = (): State => {
+return {};
+};