@auto-engineer/server-generator-apollo-emmett 0.11.9 → 0.11.10

package/package.json

@@ -31,8 +31,8 @@
     "graphql-type-json": "^0.3.2",
     "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
-    "@auto-engineer/flow": "0.11.9",
-    "@auto-engineer/message-bus": "0.11.9"
+    "@auto-engineer/flow": "0.11.10",
+    "@auto-engineer/message-bus": "0.11.10"
   },
   "publishConfig": {
     "access": "public"
@@ -43,9 +43,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "0.11.9"
+    "@auto-engineer/cli": "0.11.10"
   },
-  "version": "0.11.9",
+  "version": "0.11.10",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src",

package/src/codegen/extract/index.ts

@@ -6,3 +6,4 @@ export * from './messages';
 export * from './query';
 export * from './projection';
 export * from './imports';
+export * from './type-helpers';

package/src/codegen/extract/type-helpers.ts

@@ -0,0 +1,102 @@
+export function isInlineObject(ts: string): boolean {
+  return /^\{[\s\S]*\}$/.test((ts ?? '').trim());
+}
+
+export function isInlineObjectArray(ts: string): boolean {
+  const t = (ts ?? '').trim();
+  return /^Array<\{[\s\S]*\}>$/.test(t) || /^\{[\s\S]*\}\[\]$/.test(t);
+}
+
+export function baseTs(ts: string): string {
+  return (ts ?? 'string').replace(/\s*\|\s*null\b/g, '').trim();
+}
+
+export function createIsEnumType(toTsFieldType: (ts: string) => string) {
+  return (tsType: string): boolean => {
+    const converted = toTsFieldType(tsType);
+    const base = converted
+      .replace(/\s*\|\s*null\b/g, '')
+      .replace(/\[\]$/, '')
+      .trim();
+    return (
+      /^[A-Z][a-zA-Z0-9]*$/.test(base) &&
+      ![
+        'String',
+        'Number',
+        'Boolean',
+        'Date',
+        'ID',
+        'Int',
+        'Float',
+        'GraphQLISODateTime',
+        'GraphQLJSON',
+        'JSON',
+      ].includes(base)
+    );
+  };
+}
+
+export function createFieldUsesDate(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('GraphQLISODateTime')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*Date\b/.test(b);
+    return false;
+  };
+}
+
+export function createFieldUsesJSON(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('GraphQLJSON') || gqlType.includes('JSON')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*(unknown|any|object)\b/.test(b);
+    return false;
+  };
+}
+
+export function createFieldUsesFloat(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('Float')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) {
+      const inner = b.trim().startsWith('Array<')
+        ? b
+            .trim()
+            .replace(/^Array<\{/, '{')
+            .replace(/}>$/, '}')
+        : b.trim().replace(/\[\]$/, '');
+      const match = inner.match(/^\{([\s\S]*)\}$/);
+      const body = match ? match[1] : '';
+      const rawFields = body.split(/[,;]\s*/).filter(Boolean);
+      return rawFields.some((f) => {
+        const parts = f.split(':');
+        const type = parts.slice(1).join(':').trim();
+        return type.length > 0 && graphqlType(type).includes('Float');
+      });
+    }
+    return false;
+  };
+}
+
+export function extractEnumName(tsType: string, toTsFieldType: (ts: string) => string): string {
+  return toTsFieldType(tsType)
+    .replace(/\s*\|\s*null\b/g, '')
+    .replace(/\[\]$/, '')
+    .trim();
+}
+
+export function createCollectEnumNames(isEnumType: (tsType: string) => boolean, toTsFieldType: (ts: string) => string) {
+  return (fields: Array<{ type?: string; tsType?: string }>): string[] => {
+    const enumNames = new Set<string>();
+    for (const field of fields) {
+      const fieldType = field.type ?? field.tsType;
+      if (fieldType !== undefined && fieldType !== null && fieldType.length > 0 && isEnumType(fieldType)) {
+        enumNames.add(extractEnumName(fieldType, toTsFieldType));
+      }
+    }
+    return Array.from(enumNames).sort();
+  };
+}

package/src/codegen/scaffoldFromSchema.ts

@@ -25,6 +25,14 @@ import {
   getAllEventTypes,
   getLocalEvents,
   createEventUnionType,
+  isInlineObject as isInlineObjectHelper,
+  isInlineObjectArray as isInlineObjectArrayHelper,
+  baseTs,
+  createIsEnumType,
+  createFieldUsesDate,
+  createFieldUsesJSON,
+  createFieldUsesFloat,
+  createCollectEnumNames,
 } from './extract';
 
 function extractGwtSpecs(slice: Slice) {
@@ -61,12 +69,214 @@ const defaultFilesByType: Record<string, string[]> = {
   react: ['react.ts.ejs', 'react.specs.ts.ejs', 'register.ts.ejs'],
 };
 
+interface EnumDefinition {
+  name: string;
+  values: string[];
+  unionString: string;
+}
+
+interface EnumContext {
+  enums: EnumDefinition[];
+  unionToEnumName: Map<string, string>;
+}
+
+function isStringLiteralUnion(s: string): boolean {
+  return /^"[^"]+"(\s*\|\s*"[^"]+")+$/.test(s.trim()) || /^'[^']+'(\s*\|\s*'[^']+)+$/.test(s.trim());
+}
+
+function extractStringLiteralValues(unionString: string): string[] {
+  const doubleQuoted = unionString.match(/"([^"]+)"/g);
+  const singleQuoted = unionString.match(/'([^']+)'/g);
+  const matches = doubleQuoted ?? singleQuoted;
+  if (matches === null) return [];
+  return matches.map((m) => m.slice(1, -1));
+}
+
+function normalizeUnionString(values: string[]): string {
+  return values
+    .slice()
+    .sort()
+    .map((v) => `'${v}'`)
+    .join(' | ');
+}
+
+function generateEnumName(fieldName: string, existingNames: Set<string>): string {
+  const baseName = pascalCase(fieldName);
+  if (!existingNames.has(baseName)) {
+    return baseName;
+  }
+  let counter = 2;
+  while (existingNames.has(`${baseName}${counter}`)) {
+    counter++;
+  }
+  return `${baseName}${counter}`;
+}
+
+function processFieldForEnum(
+  field: { name: string; type: string },
+  messageName: string,
+  unionToEnumName: Map<string, string>,
+  existingEnumNames: Set<string>,
+): EnumDefinition | null {
+  const tsType = field.type;
+  debug('    Field: %s, type: %O', field.name, tsType);
+  if (tsType === null || tsType === undefined) return null;
+
+  const cleanType = tsType.replace(/\s*\|\s*null\b/g, '').trim();
+  const isUnion = isStringLiteralUnion(cleanType);
+  debug('      cleanType: %O, isStringLiteralUnion: %s', cleanType, isUnion);
+  if (!isUnion) return null;
+
+  const values = extractStringLiteralValues(cleanType);
+  debug('      extracted values: %O', values);
+  if (values.length === 0) return null;
+
+  const normalized = normalizeUnionString(values);
+
+  if (unionToEnumName.has(normalized)) {
+    debug('      already has enum for this union, skipping');
+    return null;
+  }
+
+  const enumName = generateEnumName(`${messageName}${pascalCase(field.name)}`, existingEnumNames);
+  existingEnumNames.add(enumName);
+  debug('      ✓ Creating enum: %s with values %O', enumName, values);
+
+  const enumDef: EnumDefinition = {
+    name: enumName,
+    values,
+    unionString: normalized,
+  };
+
+  unionToEnumName.set(normalized, enumName);
+  return enumDef;
+}
+
+function extractEnumsFromMessages(messages: MessageDefinition[]): EnumContext {
+  const unionToEnumName = new Map<string, string>();
+  const enums: EnumDefinition[] = [];
+  const existingEnumNames = new Set<string>();
+
+  debug('extractEnumsFromMessages: processing %d messages', messages.length);
+
+  for (const message of messages) {
+    debug('  Message: %s, has fields: %s', message.name, message.fields !== undefined && message.fields !== null);
+    if (message.fields === undefined || message.fields === null) continue;
+
+    for (const field of message.fields) {
+      const enumDef = processFieldForEnum(field, message.name, unionToEnumName, existingEnumNames);
+      if (enumDef !== null) {
+        enums.push(enumDef);
+      }
+    }
+  }
+
+  debug('extractEnumsFromMessages: found %d enums total', enums.length);
+  debug(
+    '  Enum names: %O',
+    enums.map((e) => e.name),
+  );
+  debug('  unionToEnumName map size: %d', unionToEnumName.size);
+  for (const [union, enumName] of unionToEnumName.entries()) {
+    debug('    "%s" -> %s', union, enumName);
+  }
+  return { enums, unionToEnumName };
+}
+
+function generateEnumTypeScript(enumDef: EnumDefinition): string {
+  const entries = enumDef.values.map((val) => {
+    const key = val.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+    return `  ${key} = '${val}',`;
+  });
+
+  return `export enum ${enumDef.name} {
+${entries.join('\n')}
+}
+
+registerEnumType(${enumDef.name}, {
+  name: '${enumDef.name}',
+});`;
+}
+
+async function appendEnumsToSharedTypes(baseDir: string, enums: EnumDefinition[]): Promise<void> {
+  if (enums.length === 0) return;
+
+  const sharedTypesPath = path.join(baseDir, 'shared', 'types.ts');
+
+  let existingContent = '';
+  try {
+    existingContent = await fs.readFile(sharedTypesPath, 'utf8');
+  } catch {
+    debug('Types file does not exist yet at %s, will create it', sharedTypesPath);
+  }
+
+  const enumsToAdd = enums.filter((e) => {
+    const enumPattern = new RegExp(`export\\s+enum\\s+${e.name}\\s*\\{`, 'm');
+    return !enumPattern.test(existingContent);
+  });
+
+  if (enumsToAdd.length === 0) {
+    debug('All enums already exist in %s, skipping', sharedTypesPath);
+    return;
+  }
+
+  debug('Adding %d new enums to %s', enumsToAdd.length, sharedTypesPath);
+
+  const hasRegisterEnumImport = existingContent.includes('registerEnumType');
+  const enumCode = enumsToAdd.map((e) => generateEnumTypeScript(e)).join('\n\n');
+
+  let newContent: string;
+  if (hasRegisterEnumImport) {
+    newContent = `${existingContent.trimEnd()}\n\n${enumCode}\n`;
+  } else {
+    const importMatch = existingContent.match(/^([\s\S]*?)(import.*from\s+['"]type-graphql['"];?\s*\n)/m);
+    if (importMatch !== null) {
+      const beforeImport = importMatch[1];
+      const typeGraphqlImport = importMatch[2];
+      const afterImport = existingContent.slice(beforeImport.length + typeGraphqlImport.length);
+
+      const updatedImport = typeGraphqlImport.replace(
+        /^import\s*\{([^}]*)\}\s*from\s*['"]type-graphql['"];?\s*$/m,
+        (_match: string, imports: string): string => {
+          const importsList = imports
+            .split(',')
+            .map((s) => s.trim())
+            .filter((item) => item.length > 0);
+          if (!importsList.includes('registerEnumType')) {
+            importsList.push('registerEnumType');
+          }
+          return `import { ${importsList.join(', ')} } from 'type-graphql';`;
+        },
+      );
+
+      newContent = `${beforeImport}${updatedImport}${afterImport.trimEnd()}\n\n${enumCode}\n`;
+    } else {
+      newContent = `import { registerEnumType } from 'type-graphql';\n\n${existingContent.trimEnd()}\n\n${enumCode}\n`;
+    }
+  }
+
+  const prettierConfig = await prettier.resolveConfig(sharedTypesPath);
+  const formatted = await prettier.format(newContent, {
+    ...prettierConfig,
+    parser: 'typescript',
+    filepath: sharedTypesPath,
+  });
+
+  await fs.mkdir(path.dirname(sharedTypesPath), { recursive: true });
+  await fs.writeFile(sharedTypesPath, formatted, 'utf8');
+  debug('Appended %d enums to %s', enums.length, sharedTypesPath);
+}
+
 export interface FilePlan {
   outputPath: string;
   contents: string;
 }
 
-async function renderTemplate(templatePath: string, data: Record<string, unknown>): Promise<string> {
+async function renderTemplate(
+  templatePath: string,
+  data: Record<string, unknown>,
+  unionToEnumName: Map<string, string> = new Map(),
+): Promise<string> {
   debugTemplate('Rendering template: %s', templatePath);
   debugTemplate('Data keys: %o', Object.keys(data));
 
@@ -78,14 +288,13 @@ async function renderTemplate(templatePath: string, data: Record<string, unknown
   });
   debugTemplate('Template compiled successfully');
 
-  const isInlineObject = (s: string) => /^\{[\s\S]*\}$/.test(s.trim());
-  const isStringLiteralUnion = (s: string) => /^"(?:[^"]+)"\s*(\|\s*"(?:[^"]+)")+$/.test(s.trim());
+  const isInlineObject = isInlineObjectHelper;
+  const isInlineObjectArray = isInlineObjectArrayHelper;
+
   const convertPrimitiveType = (base: string): string => {
-    // GraphQL-native scalars
     if (base === 'ID') return 'ID';
     if (base === 'Int') return 'Int';
     if (base === 'Float') return 'Float';
-    // TS primitives
     if (base === 'string') return 'String';
     if (base === 'number') return 'Float';
     if (base === 'boolean') return 'Boolean';
@@ -93,33 +302,58 @@ async function renderTemplate(templatePath: string, data: Record<string, unknown
     return 'String';
   };
 
+  const resolveEnumOrString = (base: string): string => {
+    if (!isStringLiteralUnion(base)) return 'String';
+    const values = extractStringLiteralValues(base);
+    const normalized = normalizeUnionString(values);
+    const enumName = unionToEnumName.get(normalized);
+    return enumName ?? 'String';
+  };
+
   const graphqlType = (rawTs: string): string => {
     const t = (rawTs ?? '').trim();
     if (!t) return 'String';
     const base = t.replace(/\s*\|\s*null\b/g, '').trim();
-    // arrays
+
     const arr1 = base.match(/^Array<(.*)>$/);
     const arr2 = base.match(/^(.*)\[\]$/);
-    if (arr1) return `[${graphqlType(arr1[1].trim())}]`;
-    if (arr2) return `[${graphqlType(arr2[1].trim())}]`;
-    // JSON
+    if (arr1 !== null) return `[${graphqlType(arr1[1].trim())}]`;
+    if (arr2 !== null) return `[${graphqlType(arr2[1].trim())}]`;
+
     if (base === 'unknown' || base === 'any') return 'GraphQLJSON';
     if (base === 'object') return 'JSON';
     if (isInlineObject(base)) return 'JSON';
-    if (isStringLiteralUnion(base)) return 'String';
+    if (isStringLiteralUnion(base)) return resolveEnumOrString(base);
+
     return convertPrimitiveType(base);
   };
 
   const toTsFieldType = (ts: string): string => {
     if (!ts) return 'string';
     const t = ts.trim();
-    const arr = t.match(/^Array<(.*)>$/);
-    if (arr) return `${arr[1].trim()}[]`;
+    const cleanType = t.replace(/\s*\|\s*null\b/g, '').trim();
+
+    const arr = cleanType.match(/^Array<(.*)>$/);
+    if (arr !== null) return `${toTsFieldType(arr[1].trim())}[]`;
+
+    if (isStringLiteralUnion(cleanType)) {
+      const values = extractStringLiteralValues(cleanType);
+      const normalized = normalizeUnionString(values);
+      const enumName = unionToEnumName.get(normalized);
+      if (enumName !== undefined) return enumName;
+    }
+
     return t;
   };
 
   const isNullable = (rawTs: string): boolean => /\|\s*null\b/.test(rawTs);
 
+  const isEnumType = createIsEnumType(toTsFieldType);
+  const fieldUsesDate = createFieldUsesDate(graphqlType);
+  const fieldUsesJSON = createFieldUsesJSON(graphqlType);
+  const fieldUsesFloat = createFieldUsesFloat(graphqlType);
+  const collectEnumNames = createCollectEnumNames(isEnumType, toTsFieldType);
+
   const result = await template({
     ...data,
     pascalCase,
@@ -132,6 +366,14 @@ async function renderTemplate(templatePath: string, data: Record<string, unknown
     formatDataObject,
     messages: data.messages,
     message: data.message,
+    isInlineObject,
+    isInlineObjectArray,
+    baseTs,
+    isEnumType,
+    fieldUsesDate,
+    fieldUsesJSON,
+    fieldUsesFloat,
+    collectEnumNames,
   });
 
   debugTemplate('Template rendered, output size: %d bytes', result.length);
@@ -188,6 +430,7 @@ async function generateFileForTemplate(
   slice: Slice,
   sliceDir: string,
   templateData: Record<string, unknown>,
+  unionToEnumName: Map<string, string> = new Map(),
 ): Promise<FilePlan> {
   debugFiles('Generating file from template: %s', templateFile);
   debugFiles('  Slice type: %s', slice.type);
@@ -201,7 +444,7 @@ async function generateFileForTemplate(
   debugFiles('  Template path: %s', templatePath);
   debugFiles('  Output path: %s', outputPath);
 
-  const contents = await renderTemplate(templatePath, templateData);
+  const contents = await renderTemplate(templatePath, templateData, unionToEnumName);
   debugFiles('  Rendered content size: %d bytes', contents.length);
 
   debugFiles('  Formatting with Prettier...');
@@ -407,6 +650,7 @@ async function generateFilesForSlice(
   sliceDir: string,
   messages: MessageDefinition[],
   flows: Flow[],
+  unionToEnumName: Map<string, string>,
   integrations?: Model['integrations'],
 ): Promise<FilePlan[]> {
   debugSlice('Generating files for slice: %s (type: %s)', slice.name, slice.type);
@@ -447,7 +691,7 @@ async function generateFilesForSlice(
 
   debugSlice('  Generating %d files from templates', templates.length);
   const plans = await Promise.all(
-    templates.map((template) => generateFileForTemplate(template, slice, sliceDir, templateData)),
+    templates.map((template) => generateFileForTemplate(template, slice, sliceDir, templateData, unionToEnumName)),
   );
   debugSlice('  Generated %d file plans for slice: %s', plans.length, slice.name);
   return plans;
@@ -464,6 +708,12 @@ export async function generateScaffoldFilePlans(
   debug('  Number of messages: %d', messages?.length ?? 0);
   debug('  Base directory: %s', baseDir);
 
+  const { enums, unionToEnumName } = extractEnumsFromMessages(messages ?? []);
+  debug('  Extracted %d enums from messages', enums.length);
+
+  const domainBaseDir = baseDir.replace(/\/flows$/, '');
+  await appendEnumsToSharedTypes(domainBaseDir, enums);
+
   const allPlans: FilePlan[] = [];
 
   for (const flow of flows) {
@@ -476,7 +726,15 @@ export async function generateScaffoldFilePlans(
       debugFlow('  Processing slice: %s (type: %s)', slice.name, slice.type);
       const sliceDir = ensureDirPath(flowDir, toKebabCase(slice.name));
       debugFlow('    Slice directory: %s', sliceDir);
-      const plans = await generateFilesForSlice(slice, flow, sliceDir, messages, flows, integrations);
+      const plans = await generateFilesForSlice(
+        slice,
+        flow,
+        sliceDir,
+        messages ?? [],
+        flows,
+        unionToEnumName,
+        integrations,
+      );
       debugFlow('    Generated %d plans for slice', plans.length);
       allPlans.push(...plans);
     }

package/src/codegen/templates/command/commands.ts.ejs

@@ -1,11 +1,16 @@
-import { Command } from "@event-driven-io/emmett";
+<%
+const enumList = collectEnumNames(commands.flatMap(c => c.fields));
+%>import { Command } from "@event-driven-io/emmett";
+<% if (enumList.length > 0) { -%>
+import { <%= enumList.join(', ') %> } from '../../../shared';
+<% } -%>
 <% for (const command of commands) { -%>
-    export type <%= pascalCase(command.type) %> = Command<
-    '<%= command.type %>',
-    {
-    <% for (const field of command.fields) { -%>
-        <%- field.name %>: <%- field.tsType %>;
-    <% } -%>
-    }
-    >;
+export type <%= pascalCase(command.type) %> = Command<
+  '<%= command.type %>',
+  {
+  <% for (const field of command.fields) { -%>
+    <%- field.name %>: <%- toTsFieldType(field.tsType) %>;
+  <% } -%>
+  }
+>;
 <% } -%>

package/src/codegen/templates/command/decide.specs.specs.ts

@@ -95,57 +95,57 @@ describe('spec.ts.ejs', () => {
     const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
 
     expect(specFile?.contents).toMatchInlineSnapshot(`
-          "import { describe, it } from 'vitest';
-          import { DeciderSpecification } from '@event-driven-io/emmett';
-          import { decide } from './decide';
-          import { evolve } from './evolve';
-          import { initialState, State } from './state';
-          import type { ListingCreated } from './events';
-          import type { CreateListing } from './commands';
+      "import { describe, it } from 'vitest';
+      import { DeciderSpecification } from '@event-driven-io/emmett';
+      import { decide } from './decide';
+      import { evolve } from './evolve';
+      import { initialState, State } from './state';
+      import type { ListingCreated } from './events';
+      import type { CreateListing } from './commands';
 
-          describe('Should create listing successfully', () => {
-            type Events = ListingCreated;
+      describe('Should create listing successfully', () => {
+        type Events = ListingCreated;
 
-            const given = DeciderSpecification.for<CreateListing, Events, State>({
-              decide,
-              evolve,
-              initialState,
-            });
+        const given = DeciderSpecification.for<CreateListing, Events, State>({
+          decide,
+          evolve,
+          initialState,
+        });
 
-            it('User creates listing with valid data', () => {
-              given([])
-                .when({
-                  type: 'CreateListing',
-                  data: {
-                    propertyId: 'listing_123',
-                    title: 'blah',
-                    pricePerNight: 250,
-                    maxGuests: 4,
-                    amenities: ['wifi', 'kitchen'],
-                    available: true,
-                    tags: ['some tag'],
-                    rating: 4.8,
-                    metadata: { foo: 'bar' },
-                    listedAt: new Date('2024-01-15T10:00:00Z'),
-                  },
-                  metadata: { now: new Date() },
-                })
+        it('User creates listing with valid data', () => {
+          given([])
+            .when({
+              type: 'CreateListing',
+              data: {
+                propertyId: 'listing_123',
+                title: 'blah',
+                pricePerNight: 250,
+                maxGuests: 4,
+                amenities: ['wifi', 'kitchen'],
+                available: true,
+                tags: ['some tag'],
+                rating: 4.8,
+                metadata: { foo: 'bar' },
+                listedAt: new Date('2024-01-15T10:00:00Z'),
+              },
+              metadata: { now: new Date() },
+            })
 
-                .then([
-                  {
-                    type: 'ListingCreated',
-                    data: {
-                      propertyId: 'listing_123',
-                      listedAt: new Date('2024-01-15T10:00:00Z'),
-                      rating: 4.8,
-                      metadata: { foo: 'bar' },
-                    },
-                  },
-                ]);
-            });
-          });
-          "
-        `);
+            .then([
+              {
+                type: 'ListingCreated',
+                data: {
+                  propertyId: 'listing_123',
+                  listedAt: new Date('2024-01-15T10:00:00Z'),
+                  rating: 4.8,
+                  metadata: { foo: 'bar' },
+                },
+              },
+            ]);
+        });
+      });
+      "
+    `);
   });
   it('should include given events in the spec file when provided', async () => {
     const spec: SpecsSchema = {