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

package/dist/codegen/templates/query/projection.specs.specs..ts

@@ -0,0 +1,276 @@
+import { describe, it, expect } from 'vitest';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+
+describe('projection.specs.ts.ejs', () => {
+  it('should generate a valid test spec for a query slice projection', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'listing-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'CreateListing',
+              stream: 'listing-${propertyId}',
+              client: { description: '', specs: [] },
+              server: {
+                description: '',
+                gwt: [
+                  {
+                    when: {
+                      commandRef: 'CreateListing',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                        title: 'Sea View Flat',
+                        pricePerNight: 120,
+                        location: 'Brighton',
+                        maxGuests: 4,
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'ListingCreated',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                          title: 'Sea View Flat',
+                          pricePerNight: 120,
+                          location: 'Brighton',
+                          maxGuests: 4,
+                        },
+                      },
+                    ],
+                  },
+                  {
+                    when: {
+                      commandRef: 'RemoveListing',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'ListingRemoved',
+                        exampleData: {},
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'query',
+              name: 'search-listings',
+              stream: 'listings',
+              client: { description: '', specs: [] },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'propertyId',
+                      name: 'AvailablePropertiesProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'AvailableListings',
+                    },
+                  },
+                ],
+                gwt: [
+                  {
+                    given: [
+                      {
+                        eventRef: 'ListingCreated',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                          title: 'Sea View Flat',
+                          pricePerNight: 120,
+                          location: 'Brighton',
+                          maxGuests: 4,
+                        },
+                      },
+                    ],
+                    then: [
+                      {
+                        stateRef: 'AvailableListings',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                          title: 'Sea View Flat',
+                          pricePerNight: 120,
+                          location: 'Brighton',
+                          maxGuests: 4,
+                        },
+                      },
+                    ],
+                  },
+                  {
+                    given: [
+                      {
+                        eventRef: 'ListingRemoved',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                        },
+                      },
+                    ],
+                    then: [
+                      {
+                        stateRef: 'AvailableListings',
+                        exampleData: {},
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      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: 'location', type: 'string', required: true },
+            { name: 'maxGuests', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'RemoveListing',
+          fields: [{ name: 'propertyId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'ListingCreated',
+          source: 'internal',
+          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 },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'ListingRemoved',
+          source: 'internal',
+          fields: [{ name: 'propertyId', type: 'string', required: true }],
+        },
+        {
+          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 specFile = plans.find((p) => p.outputPath.endsWith('projection.spec.ts'));
+
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+"import { describe, it, beforeEach, expect } from 'vitest';
+import { v4 as uuid } from 'uuid';
+import {
+  InMemoryProjectionSpec,
+  eventsInStream,
+  newEventsInStream
+} from '@event-driven-io/emmett';
+import { projection } from './projection';
+
+import type { ListingCreated, ListingRemoved } from '../create-listing/events';
+import type { AvailableListings } from './state';
+
+type AllEvents = ListingCreated | ListingRemoved;
+
+describe('AvailableListings projection', () => {
+  let given: InMemoryProjectionSpec<AllEvents>;
+  let propertyId: string;
+
+  beforeEach(() => {
+    propertyId = \`listing-\${uuid()}\`;
+    given = InMemoryProjectionSpec.for({ projection });
+  });
+
+  it('handles ListingCreated', () =>
+    given([])
+      .when([
+        {
+          type: 'ListingCreated',
+          data: {
+            propertyId,
+            title: 'Sea View Flat',
+            pricePerNight: 120,
+            location: 'Brighton',
+            maxGuests: 4
+          },
+          metadata: {
+            streamName: propertyId,
+            streamPosition: 1n,
+            globalPosition: 1n
+          }
+        }
+      ])
+      .then(async (state) => {
+        const document = await state.database
+          .collection<AvailableListings>('available-properties-projection')
+          .findOne((doc) => doc.propertyId === propertyId);
+
+        const expected: AvailableListings = {
+          propertyId,
+          title: 'Sea View Flat',
+          pricePerNight: 120,
+          location: 'Brighton',
+          maxGuests: 4
+        };
+
+        expect(document).toMatchObject(expected);
+      }));
+
+  it('handles ListingRemoved', () =>
+    given(
+      eventsInStream(propertyId, [
+        {
+          type: 'ListingCreated',
+          data: {
+            propertyId,
+            title: 'Sea View Flat',
+            pricePerNight: 120,
+            location: 'Brighton',
+            maxGuests: 4
+          }
+        }
+      ])
+    )
+      .when(
+        newEventsInStream(propertyId, [
+          {
+            type: 'ListingRemoved',
+            data: {
+              propertyId
+            }
+          }
+        ])
+      )
+      .then(async (state) => {
+        const document = await state.database
+          .collection<AvailableListings>('available-properties-projection')
+          .findOne((doc) => doc.propertyId === propertyId);
+        expect(document).toBeNull();
+      }));
+});
+`);
+  });
+});

package/dist/codegen/templates/query/projection.specs.ts

@@ -0,0 +1,348 @@
+import { describe, it, expect } from 'vitest';
+import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
+import { SpecsSchemaType as SpecsSchema } from '@auto-engineer/flow';
+
+describe('projection.ts.ejs', () => {
+  it('should generate a valid projection file with correct relative event import path from producing slice', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'listing-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'create-listing',
+              stream: 'listing-${propertyId}',
+              client: {
+                description: 'create listing UI',
+                specs: [],
+              },
+              server: {
+                description: 'handles create/remove listing',
+                gwt: [
+                  {
+                    when: {
+                      commandRef: 'CreateListing',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                        title: 'Sea View Flat',
+                        pricePerNight: 120,
+                        location: 'Brighton',
+                        maxGuests: 4,
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'ListingCreated',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                          title: 'Sea View Flat',
+                          pricePerNight: 120,
+                          location: 'Brighton',
+                          maxGuests: 4,
+                        },
+                      },
+                    ],
+                  },
+                  {
+                    when: {
+                      commandRef: 'RemoveListing',
+                      exampleData: {
+                        propertyId: 'listing_123',
+                      },
+                    },
+                    then: [
+                      {
+                        eventRef: 'ListingRemoved',
+                        exampleData: {},
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'query',
+              name: 'search-listings',
+              stream: 'listings',
+              client: {
+                description: 'search listings UI',
+                specs: [],
+              },
+              server: {
+                description: 'projection for available listings',
+                data: [
+                  {
+                    target: {
+                      type: 'State',
+                      name: 'AvailableListings',
+                    },
+                    origin: {
+                      type: 'projection',
+                      name: 'AvailablePropertiesProjection',
+                      idField: 'propertyId',
+                    },
+                  },
+                ],
+                gwt: [
+                  {
+                    given: [
+                      {
+                        eventRef: 'ListingCreated',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                          title: 'Sea View Flat',
+                          pricePerNight: 120,
+                          location: 'Brighton',
+                          maxGuests: 4,
+                        },
+                      },
+                    ],
+                    then: [
+                      {
+                        stateRef: 'AvailableListings',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                          title: 'Sea View Flat',
+                          pricePerNight: 120,
+                          location: 'Brighton',
+                          maxGuests: 4,
+                        },
+                      },
+                    ],
+                  },
+                  {
+                    given: [
+                      {
+                        eventRef: 'ListingRemoved',
+                        exampleData: {
+                          propertyId: 'listing_123',
+                        },
+                      },
+                    ],
+                    then: [
+                      {
+                        stateRef: 'AvailableListings',
+                        exampleData: {},
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      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: 'location', type: 'string', required: true },
+            { name: 'maxGuests', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'RemoveListing',
+          fields: [{ name: 'propertyId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'ListingCreated',
+          source: 'internal',
+          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 },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'ListingRemoved',
+          source: 'internal',
+          fields: [{ name: 'propertyId', type: 'string', required: true }],
+        },
+        {
+          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 projectionFile = plans.find((p) => p.outputPath.endsWith('projection.ts'));
+
+    expect(projectionFile?.contents).toMatchInlineSnapshot(`
+      "import {
+        inMemorySingleStreamProjection,
+        type ReadEvent,
+        type InMemoryReadEventMetadata,
+      } from '@event-driven-io/emmett';
+      import type { AvailableListings } from './state';
+      import type { ListingCreated, ListingRemoved } from '../create-listing/events';
+
+      type AllEvents = ListingCreated | ListingRemoved;
+
+      export const projection = inMemorySingleStreamProjection<AvailableListings, AllEvents>({
+        collectionName: 'AvailablePropertiesProjection',
+        canHandle: ['ListingCreated', 'ListingRemoved'],
+        getDocumentId: (event) => event.data.propertyId,
+        evolve: (
+          document: AvailableListings | null,
+          event: ReadEvent<AllEvents, InMemoryReadEventMetadata>,
+        ): AvailableListings | null => {
+          switch (event.type) {
+            case 'ListingCreated': {
+              /**
+               * ## IMPLEMENTATION INSTRUCTIONS ##
+               * This event adds or updates the document.
+               * Implement the correct fields as needed for your read model.
+               */
+              return {
+                propertyId: /* TODO: map from event.data */ '',
+                title: /* TODO: map from event.data */ '',
+                pricePerNight: /* TODO: map from event.data */ 0,
+                location: /* TODO: map from event.data */ '',
+                maxGuests: /* TODO: map from event.data */ 0,
+              };
+            }
+
+            case 'ListingRemoved': {
+              /**
+               * ## IMPLEMENTATION INSTRUCTIONS ##
+               * This event might indicate removal of a AvailableListings.
+               *
+               * - 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.
+               */
+              return null;
+            }
+            default:
+              return document;
+          }
+        },
+      });
+
+      export default projection;
+      "
+    `);
+  });
+  it('should generate a valid query resolver using ID type', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'wishlist-flow',
+          slices: [
+            {
+              type: 'query',
+              name: 'view-wishlist',
+              request: `
+              query GetWishlist($sessionId: ID!) {
+                wishlist(sessionId: $sessionId) {
+                  sessionId
+                  items
+                }
+              }
+            `,
+              client: {
+                description: '',
+                specs: [],
+              },
+              server: {
+                description: '',
+                data: [
+                  {
+                    origin: {
+                      type: 'projection',
+                      idField: 'sessionId',
+                      name: 'WishlistProjection',
+                    },
+                    target: {
+                      type: 'State',
+                      name: 'Wishlist',
+                    },
+                  },
+                ],
+                gwt: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'Wishlist',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'items', type: '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 Wishlist {
+        @Field(() => String)
+        sessionId!: string;
+
+        @Field(() => String)
+        items!: string;
+
+        [key: string]: unknown;
+      }
+
+      @Resolver()
+      export class ViewWishlistQueryResolver {
+        @Query(() => [Wishlist])
+        async wishlist(
+          @Ctx() ctx: GraphQLContext,
+          @Arg('sessionId', () => ID, { nullable: true }) sessionId?: string,
+        ): Promise<Wishlist[]> {
+          const model = new ReadModel<Wishlist>(ctx.eventStore, 'WishlistProjection');
+
+          // ## 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/dist/codegen/templates/query/projection.specs.ts.ejs

@@ -0,0 +1,71 @@
+<%_
+const idField = projectionIdField ?? 'id';
+const projectionType = states[0]?.type ?? 'UnknownState';
+const projectionCollection = projectionName ?? 'unknown-collection';
+const testCases = queryGwtMapping ?? [];
+const eventTypes = Array.from(new Set(events.map(e => e.type)));
+_%>
+
+import { describe, it, beforeEach, expect } from 'vitest';
+import {
+InMemoryProjectionSpec,
+} from '@event-driven-io/emmett';
+import { projection } from './projection';
+import type { <%= eventTypes.join(', ') %> } from '../<%= toKebabCase(events[0]?.sourceSliceName || 'unknown') %>/events';
+import { <%= projectionType %> } from './state';
+
+<% if (eventTypes.length > 0) { -%>
+    type ProjectionEvent = <%= eventTypes.join(' | ') %>;
+<% } else { -%>
+    type ProjectionEvent = never;
+<% } -%>
+
+describe('<%= projectionName %> Projection', () => {
+let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+    beforeEach(() => {
+    given = InMemoryProjectionSpec.for({ projection });
+    });
+
+    <%_ for (const [index, gwt] of testCases.entries()) {
+        const isRemoval = gwt.then[0]?.exampleData && Object.keys(gwt.then[0].exampleData).length === 0;
+        const expectedIdValue = JSON.stringify(gwt.then[0]?.exampleData?.[idField] ?? 'unknown-id');
+    _%>
+    it('<%= isRemoval ? 'removes' : 'creates or updates' %> <%= projectionType %> document - case <%= index + 1 %>', () =>
+    given([
+    <%_ for (const event of gwt.given) { _%>
+        {
+        type: '<%= event.eventRef %>',
+        data: {
+        <%_ for (const [key, val] of Object.entries(event.exampleData || {})) { _%>
+            <%= key %>: <%- formatTsValue(val, (events.find(e => e.type === event.eventRef)?.fields.find(f => f.name === key)?.tsType || 'string')) %>,
+        <%_ } _%>
+        },
+        metadata: {
+        streamName: 'ignored-stream',
+        streamPosition: 1n,
+        globalPosition: 1n,
+        },
+        },
+    <%_ } _%>
+    ])
+    .when([])
+    .then(async (state) => {
+    const document = await state.database
+    .collection<<%= projectionType %>>('<%= projectionCollection %>')
+    .findOne((doc) => doc.<%= idField %> === <%- expectedIdValue %>);
+
+    <%_ if (isRemoval) { _%>
+    expect(document).toBeNull();
+    <%_ } else { _%>
+        const expected: <%= projectionType %> = {
+        <%_ for (const [key, val] of Object.entries(gwt.then[0].exampleData || {})) { _%>
+            <%= key %>: <%- formatTsValue(val, (states[0]?.fields.find(f => f.name === key)?.tsType || 'string')) %>,
+        <%_ } _%>
+        };
+
+        expect(document).toMatchObject(expected);
+    <%_ } _%>
+    }));
+    <%_ } _%>
+    });