@auto-engineer/server-generator-apollo-emmett 0.10.4 → 0.11.0

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

@@ -1,296 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
-import { Model 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: '' },
-              server: {
-                description: '',
-                specs: {
-                  name: 'CreateListing command',
-                  rules: [
-                    {
-                      description: 'Should handle listing operations',
-                      examples: [
-                        {
-                          description: 'User creates listing successfully',
-                          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,
-                              },
-                            },
-                          ],
-                        },
-                        {
-                          description: 'User removes listing successfully',
-                          when: {
-                            commandRef: 'RemoveListing',
-                            exampleData: {
-                              propertyId: 'listing_123',
-                            },
-                          },
-                          then: [
-                            {
-                              eventRef: 'ListingRemoved',
-                              exampleData: {},
-                            },
-                          ],
-                        },
-                      ],
-                    },
-                  ],
-                },
-              },
-            },
-            {
-              type: 'query',
-              name: 'search-listings',
-              stream: 'listings',
-              client: { description: '' },
-              server: {
-                description: '',
-                data: [
-                  {
-                    origin: {
-                      type: 'projection',
-                      idField: 'propertyId',
-                      name: 'AvailablePropertiesProjection',
-                    },
-                    target: {
-                      type: 'State',
-                      name: 'AvailableListings',
-                    },
-                  },
-                ],
-                specs: {
-                  name: 'Search listings query',
-                  rules: [
-                    {
-                      description: 'Should project listings correctly',
-                      examples: [
-                        {
-                          description: 'Listing created shows in search results',
-                          when: [
-                            {
-                              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,
-                              },
-                            },
-                          ],
-                        },
-                        {
-                          description: 'Listing removed disappears from search results',
-                          when: [
-                            {
-                              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/src/codegen/scaffoldFromSchema.query-slice-register.specs.ts

@@ -1,179 +0,0 @@
-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');
-  });
-});