@postxl/generator 0.38.1 → 0.39.0

package/dist/generator.js

@@ -60,7 +60,9 @@ const seed_service_generator_1 = require("./generators/indices/seed-service.gene
 const seed_template_generator_1 = require("./generators/indices/seed-template.generator");
 const seed_template_decoder_generator_1 = require("./generators/indices/seed-template-decoder.generator");
 const seeddata_type_generator_1 = require("./generators/indices/seeddata-type.generator");
+const selectors_generator_1 = require("./generators/indices/selectors.generator");
 const stubs_generator_1 = require("./generators/indices/stubs.generator");
+const testdata_service_generator_1 = require("./generators/indices/testdata-service.generator");
 const types_generator_2 = require("./generators/indices/types.generator");
 const businesslogic_update_generator_1 = require("./generators/models/businesslogic-update.generator");
 const businesslogic_view_generator_1 = require("./generators/models/businesslogic-view.generator");
@@ -81,6 +83,7 @@ const CONFIG_SCHEMA = zod_1.z
     pathToTypes: zod_1.z.string().optional(),
     pathToDataLib: zod_1.z.string().optional(),
     pathToCypress: zod_1.z.string().optional(),
+    pathToE2ELib: zod_1.z.string().optional(),
     pathToActions: zod_1.z.string().optional(),
     pathToBusinessLogic: zod_1.z.string().optional(),
     pathToSeedLib: zod_1.z.string().optional(),
@@ -103,6 +106,7 @@ const CONFIG_SCHEMA = zod_1.z
         paths: {
             dataLibPath: (0, types_1.toPath)(s.pathToDataLib || 'repos'),
             cypressPath: (0, types_1.toPath)(s.pathToCypress || './e2e/cypress/'),
+            e2eLibPath: (0, types_1.toPath)(s.pathToE2ELib || './e2e/src/'),
             actionsPath: (0, types_1.toPath)(s.pathToActions || 'actions'),
             businessLogicPath: (0, types_1.toPath)(s.pathToBusinessLogic || 'business-logic'),
             reactFolderPath: (0, types_1.toPath)(s.reactFolderOutput || 'react'),
@@ -211,6 +215,8 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             generated.write(`/${meta.data.dataModuleFilePath}.ts`, (0, datamodule_generator_1.generateDataModule)({ models, meta }));
             generated.write(`/${meta.data.dataServiceFilePath}.ts`, (0, dataservice_generator_1.generateDataService)({ models, meta }));
             generated.write(`/${meta.data.dataMockerFilePath}.ts`, (0, datamocker_generator_1.generateDataMocker)({ models, meta }));
+            generated.write(`/${meta.data.selectorsFilePath}.ts`, (0, selectors_generator_1.generateSelectors)());
+            generated.write(`/${meta.data.testDataServiceFilePath}.ts`, (0, testdata_service_generator_1.generateTestDataService)({ models, meta }));
             generated.write(`/${meta.data.dataMockerStubIndexFilePath}.ts`, (0, stubs_generator_1.generateDataMockerStubsIndex)({ models, meta }));
             generated.write(`/${meta.data.repositoriesConstFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesArray)({ models, meta }));
             generated.write(`/${meta.data.repositoriesIndexFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesIndex)({ models, meta }));

package/dist/generators/enums/types.generator.js

@@ -23,7 +23,7 @@ function generateEnumType({ enumerator, meta, prismaClientPath, }) {
         }
         return `'${v}'`;
     });
-    return `
+    return /* ts */ `
     /* eslint-disable @typescript-eslint/no-unused-vars */
     import * as Prisma from '${prismaClientPath}'
 

package/dist/generators/indices/businesslogic-actiontypes.generator.js

@@ -21,7 +21,7 @@ function generateBusinessLogicActionTypes({ models, meta }) {
         actionsTypeElements.push(modelMeta.businessLogic.update.actionName);
         actionResultTypeElements.push(`${modelMeta.businessLogic.update.actionModelDiscriminantName}: ${modelMeta.businessLogic.update.actionResultName}`);
     }
-    return `
+    return /* ts */ `
 ${imports.generate()}
 
 /**

package/dist/generators/indices/businesslogic-update-module.generator.js

@@ -24,7 +24,7 @@ function generateBusinessLogicUpdateModule({ models, meta }) {
         providers.push(meta.businessLogic.update.serviceClassName);
     }
     const moduleName = meta.businessLogic.update.moduleName;
-    return `
+    return /* ts */ `
 import { DynamicModule } from '@${meta.config.project}/common'
   
 ${imports.generate()}

package/dist/generators/indices/businesslogic-update-service.generator.js

@@ -20,7 +20,7 @@ function generateBusinessLogicUpdateService({ models, meta, }) {
     const constructor = mm
         .map(({ meta }) => `@Inject(forwardRef(() => ${meta.businessLogic.update.serviceClassName}))  public readonly ${meta.businessLogic.update.serviceVariableName} :${meta.businessLogic.update.serviceClassName}`)
         .join(',\n');
-    return `
+    return /* ts */ `
   import { Inject, Injectable, forwardRef } from '@nestjs/common'
 
   ${imports.generate()}

package/dist/generators/indices/businesslogic-view-module.generator.js

@@ -23,7 +23,7 @@ function generateBusinessLogicViewModule({ models, meta }) {
         providers.push(meta.businessLogic.view.serviceClassName);
     }
     const moduleName = meta.businessLogic.view.moduleName;
-    return `
+    return /* ts */ `
 import { DynamicModule } from '@${meta.config.project}/common'
   
 ${imports.generate()}

package/dist/generators/indices/businesslogic-view-service.generator.js

@@ -20,7 +20,7 @@ function generateBusinessLogicViewService({ models, meta }) {
     const constructor = mm
         .map(({ meta }) => `@Inject(forwardRef(() => ${meta.businessLogic.view.serviceClassName}))  public readonly ${meta.businessLogic.view.serviceVariableName} :${meta.businessLogic.view.serviceClassName}`)
         .join(',\n');
-    return `
+    return /* ts */ `
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
 
 ${imports.generate()}

package/dist/generators/indices/datamock-module.generator.js

@@ -36,7 +36,7 @@ function generateDataMockModule({ models, meta }) {
         [meta.data.dataModuleFilePath]: [Types.toVariableName('DataModule')],
         [meta.data.dataServiceFilePath]: [Types.toVariableName('DataService')],
         // we need to import the file directly instead via the normal index file as this would cause a circular dependency else
-        [meta.actions.actionExecutionInterfaceFilePath]: [meta.actions.actionExecutionMock],
+        [meta.actions.importPath]: [meta.actions.actionExecutionMock],
     });
     for (const { model, meta } of mm) {
         imports.addImport({ items: [model.typeName], from: meta.types.importPath });
@@ -55,13 +55,13 @@ function generateDataMockModule({ models, meta }) {
           }
         }`)
         .join(', ');
-    return `
+    return /* ts */ `
 import { DynamicModule } from '@pxl/common'
 import { DbModule } from '@${meta.config.project}/db'
 
 ${imports.generate()}
 
-export class DataMockModule {
+export class ${meta.data.dataMockModuleName} {
   static mock(seed?: MockData): DynamicModule {
     const execution = new MockActionExecution()
 
@@ -71,7 +71,7 @@ export class DataMockModule {
     ]
 
     const cachedModule = {
-      module: DataModule,
+      module: ${meta.data.moduleName},
       imports: [DbModule.provideMock()],
       providers: providers,
       exports: providers,
@@ -84,7 +84,7 @@ export class DataMockModule {
   }
 }
 
-export interface MockData {
+export interface ${meta.data.dataMockDataType} {
   ${mm.map(({ model, meta }) => `${meta.data.mockDataPropertyName}?: ${model.typeName}[]`).join('\n')}
 }
 `;

package/dist/generators/indices/datamocker.generator.js

@@ -71,7 +71,7 @@ function generateAddDataFunction(model, meta) {
     `;
     });
     // TODO: Move the publicly accessible function's name to the metadata definition!
-    return `
+    return /* ts */ `
   public add${model.typeName}(
     item?: Partial<Omit<${model.typeName}, '${idField.name}'> & { ${idField.name}: ${idField.unbrandedTypeName} }>
   ): DataMocker {

package/dist/generators/indices/datamodule.generator.js

@@ -34,6 +34,7 @@ function generateDataModule({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
     const imports = imports_1.ImportsGenerator.from(meta.data.dataModuleFilePath).addImports({
         [meta.data.dataServiceFilePath]: [Types.toVariableName('DataService')],
+        [meta.data.dataMockModuleFilePath]: [meta.data.dataMockModuleName],
     });
     for (const { meta } of mm) {
         imports.addImport({
@@ -42,9 +43,12 @@ function generateDataModule({ models, meta }) {
         });
     }
     const moduleName = meta.data.moduleName;
-    return `
+    return /* ts */ `
+import { FactoryProvider } from '@nestjs/common'
+  
 import { DynamicModule } from '@${meta.config.project}/common'
-import { DbModule } from '@${meta.config.project}/db'
+import { DbModule, DbService } from '@${meta.config.project}/db'
+import { E2EConfig } from '@${meta.config.project}/e2e'
 
 ${imports.generate()}
 
@@ -75,47 +79,46 @@ export class ${moduleName} {
   /**
    * The forRoot method should only be called once by the root module.
    */
-  static forRoot(): DynamicModule {
+  static forRoot(options: E2EConfig): DynamicModule {
     if (${moduleName}.cachedModule) {
       throw new Error('${moduleName} is already instantiated, please call .forRoot only once from root...')
     }
 
-    const repositoryProviders = [
-      ${mm.map(({ meta }) => meta.data.repositoryClassName).join(',')}
-    ]
-
-    ${moduleName}.cachedModule = {
-      module: ${moduleName},
-      global: true,
-      imports: [DbModule.forRoot()],
-      providers: [DataService, ...repositoryProviders],
-      exports: [DataService, ...repositoryProviders],
+    if (options.isE2ETest && !options.useDatabaseForE2E) {
+      return ${meta.data.dataMockModuleName}.mock()
     }
 
-    return ${moduleName}.cachedModule
-  }
-
-  static provideE2E(): DynamicModule {
-    if (${moduleName}.cachedModule) {
-      console.warn('${moduleName} is already instantiated, skipping...')
-      return ${moduleName}.cachedModule
+    // We need to initialize the user repository right at the beginning,
+    // so that we have the rootUser available for the other modules - including
+    // the action and seed modules which will ensure that seed data is created.
+    const userRepository: FactoryProvider<UserRepository> = {
+      provide: UserRepository,
+      inject: [DbService],
+      useFactory: async (dbService: DbService) => {
+        const repository = new UserRepository(dbService)
+        await repository.init()
+        return repository
+      },
     }
 
-    const providers = [
-      ${mm.map(({ meta }) => meta.data.repositoryClassName).join(',')}
+    const repositoryProviders = [
+      userRepository,
+      ${mm
+        .filter((mm) => mm.model.name !== 'User')
+        .map(({ meta }) => meta.data.repositoryClassName)
+        .join(',')}
     ]
-    
+
     ${moduleName}.cachedModule = {
       module: ${moduleName},
       global: true,
       imports: [DbModule.forRoot()],
-      providers,
-      exports: providers,
+      providers: [DataService, ...repositoryProviders],
+      exports: [DataService, ...repositoryProviders],
     }
 
     return ${moduleName}.cachedModule
   }
-}
-`;
+}`;
 }
 exports.generateDataModule = generateDataModule;

package/dist/generators/indices/dataservice.generator.js

@@ -23,7 +23,7 @@ function generateDataService({ models, meta }) {
         .map(({ meta }) => `${meta.data.excelExportTableName}: mapValues(await this.${meta.data.dataServiceName}.getAll()),`)
         .join('\n');
     const isEmptyChecks = mm.map(({ meta }) => `(await this.${meta.data.dataServiceName}.count()) === 0`).join(' &&');
-    return `
+    return /* ts */ `
 import { Injectable } from '@nestjs/common'
 
 import { mapValues } from '@pxl/common'
@@ -31,7 +31,7 @@ import { mapValues } from '@pxl/common'
 ${imports.generate()}
 
 @Injectable()
-export class DataService {
+export class ${meta.data.dataServiceClassName} {
   constructor(${constructor}) {}
 
   public async prepareExcelExport() {

package/dist/generators/indices/dispatcher-service.generator.js

@@ -17,7 +17,7 @@ function generateActionsDispatcherService({ models, meta }) {
         const modelMeta = (0, meta_1.getModelMetadata)({ model });
         dataLoader.push(`await this.upload({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}, repo: this.dataService.${modelMeta.data.dataServiceName}, log })`);
     }
-    return `
+    return /* ts */ `
   import { Injectable } from '@nestjs/common'
 
 import { ExhaustiveSwitchCheck } from '@pxl/common'
@@ -25,7 +25,7 @@ import { DbService } from '@pxl/db'
 
 ${imports.generate()}
 
-import { ActionExecution, createActionExecution } from './actionExecution.class'
+import { ActionExecutionFactory, IActionExecution } from './actionExecution'
 import { Action, ResultOfAction } from './actions.types'
 
 
@@ -37,14 +37,15 @@ export class DispatcherService {
   public seedService: ${meta.seed.serviceClassName} = {} as unknown as any
   constructor(
     private readonly updateService: ${meta.businessLogic.update.serviceClassName}, 
-    private readonly dbService: DbService
+    private readonly dbService: DbService,
+    private readonly actionExecutionFactory: ActionExecutionFactory,
   ) {}
 
   public async dispatch<A extends Action>({ action, user }: { 
     action: A; 
     user: ${meta.config.userType} 
   }): Promise<ResultOfAction<A>> {
-    const execution = await createActionExecution({ action, dbService: this.dbService, user })
+    const execution = await this.actionExecutionFactory.create({ action, dbService: this.dbService, user })
 
     try {
       const result = await (this.execute({ action, execution }) as Promise<ResultOfAction<A>>)
@@ -58,7 +59,7 @@ export class DispatcherService {
     }
   }
 
-  private async execute({ action, execution }: { action: Action; execution: ActionExecution }) {
+  private async execute({ action, execution }: { action: Action; execution: IActionExecution }) {
     switch (action.scope) {
       ${models
         .map((model) => {

package/dist/generators/indices/emptydatabasemigration.generator.d.ts

@@ -2,6 +2,8 @@ import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
  * Generates a the Prisma migration to create the `emptyDatabase` stored procedure.
+ *
+ * The routine is used in e2e tests to empty the database before each test.
  */
 export declare function generateEmptyDatabaseStoredProcedure({ models }: {
     models: Model[];

package/dist/generators/indices/emptydatabasemigration.generator.js

@@ -7,13 +7,20 @@ exports.prismaMigrationExists = exports.deriveEmptyDatabaseMigrationFilePath = e
 const fs_1 = __importDefault(require("fs"));
 /**
  * Generates a the Prisma migration to create the `emptyDatabase` stored procedure.
+ *
+ * The routine is used in e2e tests to empty the database before each test.
  */
 function generateEmptyDatabaseStoredProcedure({ models }) {
-    const tables = models
-        .map((model) => `\t${model.sourceSchemaName !== undefined ? `"${model.sourceSchemaName}".` : ''}"${model.sourceName}"`)
-        .join(',\n');
-    const useSchemas = models.some((model) => model.sourceSchemaName !== undefined);
-    const configTableName = useSchemas ? ' "Configuration"."Config"' : '"Config"';
+    const modelTables = models
+        .map((model) => `\t${model.sourceSchemaName !== undefined ? `"${model.sourceSchemaName}".` : ''}"${model.sourceName}"`);
+    // We determine the schema used for all system tables by looking at the User model's schema.
+    const userModel = models.find((model) => model.name === 'User');
+    if (!userModel) {
+        throw new Error('Model definition for "User" could not be found - hence schema for system table cannot be derived!');
+    }
+    const configSchema = userModel.sourceSchemaName !== undefined ? `"${userModel.sourceSchemaName}".` : '';
+    const systemTables = ["Action", "Mutation"].map((table) => `\t${configSchema}"${table}"`);
+    const configTableName = `${configSchema}"Config"`;
     return `
 CREATE OR REPLACE PROCEDURE "emptyDatabase"() AS $BODY$ BEGIN IF EXISTS (
     SELECT
@@ -22,8 +29,8 @@ CREATE OR REPLACE PROCEDURE "emptyDatabase"() AS $BODY$ BEGIN IF EXISTS (
 ) THEN RETURN;
 END IF;
 TRUNCATE TABLE 
-${tables};
-UPDATE ${configTableName} SET "isSeeded"=false;
+${[...systemTables, ...modelTables].join(',\n')};
+
 END;
 $BODY$ LANGUAGE plpgsql;
   `;

package/dist/generators/indices/repositories.generator.js

@@ -29,7 +29,7 @@ function generateRepositoriesArray({ models, meta }) {
             from: meta.data.repoFilePath,
         });
     }
-    return `  
+    return /* ts */ `  
     ${imports.generate()}
 
     export const repositories = [${models

package/dist/generators/indices/seed-migration.generator.js

@@ -17,7 +17,7 @@ function generateSeedMigration({ models, meta }) {
         });
         modelTypes.push(`${modelMeta.seed.constantName}: { create: ${modelMeta.seed.constantName} }`);
     }
-    return `
+    return /* ts */ `
 import { createActionSeedData } from '${meta.seed.importPath}'
 ${imports.generate()}
 

package/dist/generators/indices/seed-service.generator.js

@@ -17,15 +17,14 @@ function generateSeedService({ models }) {
         upserts.push(`await this.upsert({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.upsert, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
         deletes.push(`await this.delete({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.delete, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
     }
-    return `
+    return /* ts */ `
 import { Injectable, Logger } from '@nestjs/common'
 import { ExhaustiveSwitchCheck, format, pluralize } from '@pxl/common'
 import { DataService, Repository } from '@pxl/data'
 import { DbService } from '@pxl/db'
 import { XlPortService } from '@pxl/xlport'
 
-import { ActionExecution, DispatcherService } from '@pxl/actions'
-import { RootUserService } from '@pxl/root-user'
+import { IActionExecution, DispatcherService } from '@pxl/actions'
 
 import {
   ActionPreparation_Seed,
@@ -53,7 +52,6 @@ export class SeedService {
     private readonly xlPortService: XlPortService,
     private readonly dbService: DbService,
     private readonly dispatcherService: DispatcherService,
-    private readonly rootUserService: RootUserService,
   ) {
     dispatcherService.seedService = this
   }
@@ -79,7 +77,7 @@ export class SeedService {
       const action = await this.convertToAction(migration)
 
       this.logger.log(\`Executing seed migration \${migration.order} - \${migration.name}\`)
-      await this.dispatcherService.dispatch({ action, user: this.rootUserService.rootUser })
+      await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
 
       executed++
     }
@@ -117,7 +115,7 @@ export class SeedService {
   /**
    * Will be call by the dispatcher service to dispatch the given action.
    */
-  public async dispatch({ action, execution }: { action: Action_Seed; execution: ActionExecution }) {
+  public async dispatch({ action, execution }: { action: Action_Seed; execution: IActionExecution }) {
     switch (action.type) {
       case 'data':
         return this.uploadDataSteps({ steps: action.payload, execution })
@@ -175,7 +173,7 @@ export class SeedService {
    * Executes the custom logic of the given migration.
    * To do this, we retrieve the handler from the migration and call it, injecting the data service into the handler.
    */
-  private handleCustomLogic({ action, execution }: { action: Action_Seed_CustomLogic; execution: ActionExecution }) {
+  private handleCustomLogic({ action, execution }: { action: Action_Seed_CustomLogic; execution: IActionExecution }) {
     const actionPreparation = SEED_MIGRATIONS.find((m) => m.order === action.order)
     if (!actionPreparation) {
       throw new Error(\`Cannot find custom handler for migration with order \${action.order}\`)
@@ -188,7 +186,7 @@ export class SeedService {
   /**
    * Executes the data loading step by step
    */
-  private async uploadDataSteps({ steps, execution }: { steps: SeedData[]; execution: ActionExecution }) {
+  private async uploadDataSteps({ steps, execution }: { steps: SeedData[]; execution: IActionExecution }) {
     let index = 0
     for (const step of steps) {
       this.logger.log(\`Uploading data step \${++index}/\${steps.length}\`)
@@ -196,7 +194,7 @@ export class SeedService {
     }
   }
 
-  private async uploadData({ data, execution }: { data: SeedData; execution: ActionExecution }) {
+  private async uploadData({ data, execution }: { data: SeedData; execution: IActionExecution }) {
     // NOTE: the order of these calls is important, because of foreign key constraints
     // The current order is based on the order of the models in the schema
     // Change the order based on your needs.
@@ -221,7 +219,7 @@ export class SeedService {
     name: string
     data: CreateDTO<T, ID>[] | undefined
     repo: Repository<T, ID>
-    execution: ActionExecution
+    execution: IActionExecution
   }): Promise<void> {
     if (!data) {
       return
@@ -253,7 +251,7 @@ export class SeedService {
     name: string
     data: UpdateDTO<T, ID>[] | undefined
     repo: Repository<T, ID>
-    execution: ActionExecution
+    execution: IActionExecution
   }): Promise<void> {
     if (!data) {
       return
@@ -285,7 +283,7 @@ export class SeedService {
     name: string
     data: (CreateDTO<T, ID> | UpdateDTO<T, ID>)[] | undefined
     repo: Repository<T, ID>
-    execution: ActionExecution
+    execution: IActionExecution
   }): Promise<void> {
     if (!data) {
       return
@@ -317,7 +315,7 @@ export class SeedService {
     name: string
     data: ID[] | undefined
     repo: Repository<T, ID>
-    execution: ActionExecution
+    execution: IActionExecution
   }): Promise<void> {
     if (!data) {
       return

package/dist/generators/indices/seed-template-decoder.generator.js

@@ -22,7 +22,7 @@ function generateSeedTemplateDecoder({ models, meta }) {
         tableDecoders.push(`${modelMeta.seed.excel.tableName}: ${modelMeta.seed.decoder.decoderName}`);
         renameTransforms.push(`${modelMeta.seed.decoder.dataName}: item['${modelMeta.seed.excel.tableName}']`);
     }
-    return `
+    return /* ts */ `
   import * as z from 'zod'
   
   ${imports.generate()}

package/dist/generators/indices/seeddata-type.generator.js

@@ -26,14 +26,14 @@ function generateSeedDataType({ models, meta }) {
     }`);
         mockConverters.push(`${modelMeta.seed.constantName}: { create: data.${modelMeta.seed.constantName} }`);
     }
-    return `
+    return /* ts */ `
 ${imports.generate()}
 
 export type SeedData = {
   ${modelTypes.join('\n')}
 }
 
-export function mockDataToCreate(data: MockData): SeedData {
+export function ${meta.seed.mockDataToCreateFunction}(data: ${meta.data.dataMockDataType}): SeedData {
   return {
     ${mockConverters.join(',\n')}
   }

package/dist/generators/indices/selectors.generator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates list of component selectors for Cypress tests.
+ *
+ * Note: This generator does not need the models or meta data passed in.
+ * Instead it uses the SelectorCollector singleton that already collected all ids during the generation process of the individual models.
+ */
+export declare function generateSelectors(): string;

package/dist/generators/indices/selectors.generator.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSelectors = void 0;
+const id_collector_1 = require("../../lib/id-collector");
+/**
+ * List of ids that are not generated but hardcoded across the template.
+ */
+const HARDCODED_IDS = [
+    'indexPage-buttons-create',
+    'confirmationModal-buttons-confirm',
+    'confirmationModal-buttons-cancel',
+];
+/**
+ * Generates list of component selectors for Cypress tests.
+ *
+ * Note: This generator does not need the models or meta data passed in.
+ * Instead it uses the SelectorCollector singleton that already collected all ids during the generation process of the individual models.
+ */
+function generateSelectors() {
+    // SelectorCollector is a static singleton that collects all ids during the generation process. We flush it here to get all ids.
+    const collectedIds = id_collector_1.SelectorCollector.flush();
+    const object = {};
+    const ids = [...HARDCODED_IDS, ...collectedIds];
+    ids.sort();
+    ids.map((id) => {
+        addCypressSelectorToNestedObject({ object, id });
+    });
+    const selectors = JSON.stringify(object, null, 2);
+    return /* ts */ `
+  export const SELECTORS =
+  ${selectors}
+  `;
+}
+exports.generateSelectors = generateSelectors;
+/**
+ * Converts an id like `post-create-name` to a nested object like `{post: {create: {name: '[data-cy=post-create-name]'}}}`.
+ */
+function addCypressSelectorToNestedObject({ object, id, }) {
+    const keys = id.split('-');
+    extendObject(object, keys, `[data-cy=${id}]`);
+}
+/**
+ * Recursively traverses the keys and adds the value to the object in a nested way.
+ * E.g. `{object, keys: ['post', 'create', 'name'], value}` will extend `object` with `{post: {create: {name: value}}}`.
+ *
+ */
+function extendObject(object, keys, value) {
+    const key = keys.shift();
+    // no item left -> we are at the end of the recursion
+    if (!key) {
+        return;
+    }
+    // create the nested object if it does not exist yet
+    object[key] = object[key] || {};
+    // In case the object already has a value, we check if it is a string (and not a nested object).
+    // If it is a string, it we check if the value is the same as the new value. In this case is is a duplicate and hence fine.
+    // However, if it is a string and a different value, it means we have an inconsistent ID structure.
+    // E.g. this can happen when we have three entries: "post-create", "post-create-name", "post-create-description".
+    // In this case, the "post-create" entry will be a string - and we cannot nest `{name: ..., description: ...}` in it.
+    if (key in object && typeof object[key] === 'string') {
+        if (keys.length !== 0) {
+            throw new Error(`Key ${key} already exists with value: ${object[key]} but we are trying to nest ${keys.join('-')}`);
+        }
+        if (object[key] !== value) {
+            throw new Error(`Duplicate key ${key} with different values: ${object[key]} and ${value}`);
+        }
+        return;
+    }
+    // If there are still keys left, we recursively call this function with the nested object and the remaining keys.
+    if (keys.length !== 0) {
+        extendObject(object[key], keys, value);
+        return;
+    }
+    // If there are no keys left, we need to verify that the object might not already have a nested object.
+    // This can happen, e.g. when we have two entries: "post-create-name" and "post-create".
+    // In this case, the `post.create` entry will be a nested object`{name: ...}`.
+    // If we would set `post.create` to a string, we would lose the nested object.
+    if (key in object && typeof object[key] !== 'string' && Object.keys(object[key]).length !== 0) {
+        throw new Error(`Key ${key} already has nested object ${JSON.stringify(object[key])} but we are trying to set it to ${value}`);
+    }
+    object[key] = value;
+}

package/dist/generators/indices/testdata-service.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates the TestDataService class.
+ */
+export declare function generateTestDataService({ models, meta: schemaMeta, }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/generators/indices/testdata-service.generator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTestDataService = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/schema/types");
+/**
+ * Generates the TestDataService class.
+ */
+function generateTestDataService({ models, meta: schemaMeta, }) {
+    const imports = imports_1.ImportsGenerator.from(schemaMeta.data.testDataServiceFilePath);
+    imports.addImports({
+        [schemaMeta.actions.importPath]: [(0, types_1.toClassName)('ActionExecutionFactory')],
+        [schemaMeta.data.importPath]: [schemaMeta.data.dataServiceClassName, schemaMeta.data.dataMockDataType],
+        [schemaMeta.seed.importPath]: [(0, types_1.toClassName)('createActionSeedData'), schemaMeta.seed.mockDataToCreateFunction],
+    });
+    const reInitCalls = [];
+    const modelMetas = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    for (const { model, meta } of modelMetas) {
+        if (model.defaultField) {
+            imports.addImport({ items: [meta.data.stubGenerationFnName], from: meta.data.importPath });
+            const stubDefault = `${meta.data.stubGenerationFnName}({ ${model.defaultField.name}: true })`;
+            reInitCalls.push(`await this.dataService.${meta.data.dataServiceName}.reInit({ items: mockData.${meta.seed.constantName}?.create ?? [${stubDefault}], execution: actionExecution })`);
+        }
+        else {
+            reInitCalls.push(`await this.dataService.${meta.data.dataServiceName}.reInit({ items: mockData.${meta.seed.constantName}?.create ?? [], execution: actionExecution })`);
+        }
+    }
+    return /* ts */ `
+import { Injectable, Logger } from '@nestjs/common'
+
+import { DbService } from '@pxl/db'
+${imports.generate()}
+
+@Injectable()
+export class TestDataService {
+  private logger = new Logger(TestDataService.name)
+
+  constructor(
+    private db: DbService,
+    private dataService: ${schemaMeta.data.dataServiceClassName},
+    private actionExecutionFactory: ActionExecutionFactory,
+  ) {}
+
+  public async resetTestData(data: MockData) {
+    await this.db.emptyDatabase()
+
+    // We need to init the user repository first so the root user is created
+    await this.dataService.users.init()
+
+    const mockData = ${schemaMeta.seed.mockDataToCreateFunction}(data)
+    const action = createActionSeedData({ name: 'E2E', order: 0, data: [] })
+    const actionExecution = await this.actionExecutionFactory.create({
+      action,
+      dbService: this.db,
+      user: this.dataService.users.rootUser,
+    })
+    try {
+      ${reInitCalls.join('\n')}
+      
+      await actionExecution.success()
+      this.logger.log(\`✅ Reset test data\`)
+    } catch (e) {
+      await actionExecution.error(e)
+      throw e
+    }
+  }
+}`;
+}
+exports.generateTestDataService = generateTestDataService;

package/dist/generators/models/businesslogic-update.generator.js

@@ -41,7 +41,7 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
     const methodTypeSignatures = (0, repository_generator_1.getRepositoryMethodsTypeSignatures)({ model, meta });
-    return `
+    return /* ts */ `
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
 import { ExhaustiveSwitchCheck } from '@pxl/common'
 

package/dist/generators/models/businesslogic-view.generator.js

@@ -92,7 +92,7 @@ function generateModelBusinessLogicView({ model, meta }) {
       return item
     }
   `;
-    return `
+    return /* ts */ `
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
 import { FilterOperator } from '@pxl/common'

package/dist/generators/models/react.generator/library.generator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateModelLibraryComponents = void 0;
+const id_collector_1 = require("../../../lib/id-collector");
 const imports_1 = require("../../../lib/imports");
 /**
  * Generates components that may be used to list all entries of a given data type.
@@ -10,6 +11,7 @@ const imports_1 = require("../../../lib/imports");
  */
 function generateModelLibraryComponents({ model, meta }) {
     const { react: { context, components }, } = meta;
+    const selectorCollector = id_collector_1.SelectorCollector.from(meta.seed.constantName + '-card');
     const imports = imports_1.ImportsGenerator.from(meta.react.folderPath)
         .addImport({
         items: [model.typeName],
@@ -58,11 +60,13 @@ function generateModelLibraryComponents({ model, meta }) {
                   label: 'Edit',
                   icon: 'pencil-on-paper',
                   onClick: () => setIsEditModalOpen(true),
+                  __cypress_action_selector__: "${selectorCollector.idFor('edit', { typePrefix: 'actions' })}",
                 },
                 {
                   label: 'Delete',
                   icon: 'trash',
                   onClick: () => setIsDeleteModalOpen(true),
+                  __cypress_action_selector__: "${selectorCollector.idFor('delete', { typePrefix: 'actions' })}",
                 },
               ]}
             />

package/dist/generators/models/react.generator/modals.generator.js

@@ -24,6 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDeleteModalModelComponent = exports.generateEditModalModelComponent = exports.generateModelCreateModalComponent = void 0;
+const id_collector_1 = require("../../../lib/id-collector");
 const imports_1 = require("../../../lib/imports");
 const meta_1 = require("../../../lib/meta");
 const fields_1 = require("../../../lib/schema/fields");
@@ -36,6 +37,7 @@ const StringUtils = __importStar(require("../../../lib/utils/string"));
 function generateModelCreateModalComponent({ model, meta }) {
     const { fields } = model;
     const { react: { components: { modals }, }, trpc, } = meta;
+    const selectorCollector = id_collector_1.SelectorCollector.from(meta.seed.constantName + '-createModal');
     return `
 /* eslint-disable @typescript-eslint/no-unused-vars */
 ${getFormImports({ model, meta })}
@@ -130,9 +132,10 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
               fill="fill"
               onClick={submitForm}
               loading={isSubmitting}
+              __cypress_selector__="${selectorCollector.idFor('submit', { typePrefix: 'buttons' })}"
             />
 					}>
-						${getFormFieldComponents({ model })}
+						${getFormFieldComponents({ model, selectorCollector })}
           </ModalWithActions>
         )}
       </Typed.Formik>
@@ -149,6 +152,7 @@ exports.generateModelCreateModalComponent = generateModelCreateModalComponent;
 function generateEditModalModelComponent({ model, meta }) {
     const { fields } = model;
     const { react: { components }, trpc, } = meta;
+    const selectorCollector = id_collector_1.SelectorCollector.from(meta.seed.constantName + '-editModal');
     return `
 /* eslint-disable @typescript-eslint/no-unused-vars */
 ${getFormImports({ model, meta })}
@@ -257,10 +261,11 @@ export const ${components.modals.editComponentName} = ({
                 color="primary"
                 onClick={submitForm}
                 loading={isSubmitting}
+                __cypress_selector__="${selectorCollector.idFor('submit', { typePrefix: 'buttons' })}"
               />
             }
           >
-            ${getFormFieldComponents({ model })}
+            ${getFormFieldComponents({ model, selectorCollector })}
           </ModalWithActions>
         )}
       </Typed.Formik>
@@ -528,7 +533,7 @@ function getEditFormikMutationData({ model: { fields } }) {
 /**
  * Returns a string containing all the components that should appear in the Formik form for this model.
  */
-function getFormFieldComponents({ model }) {
+function getFormFieldComponents({ model, selectorCollector, }) {
     var _a;
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
@@ -550,7 +555,11 @@ function getFormFieldComponents({ model }) {
                         form.append(`
               <div>
                 <Label>${label}</Label>
-                <Typed.TextField placeholder="Type..." name="${formikFieldName}" />
+                <Typed.TextField 
+                  name="${formikFieldName}"
+                  placeholder="Type..."
+                  __cypress_field_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+                />
               </div>
             `);
                         break scalar;
@@ -563,7 +572,12 @@ function getFormFieldComponents({ model }) {
                         form.append(`
               <div>
                 <Label>${label}</Label>
-                <Typed.NumberField placeholder="2511" name="${formikFieldName}" decimals={${decimals}}/>
+                <Typed.NumberField 
+                  name="${formikFieldName}"
+                  placeholder="2511"
+                  decimals={${decimals}}
+                  __cypress_field_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+                />
               </div>
             `);
                         break scalar;
@@ -572,7 +586,11 @@ function getFormFieldComponents({ model }) {
                         form.append(`
               <div>
                 <Label>Is ${label}</Label>
-                <Typed.CheckBoxField label="${label}" name="${formikFieldName}" />
+                <Typed.CheckBoxField 
+                  name="${formikFieldName}" 
+                  label="${label}" 
+                  __cypress_field_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+                />
               </div>
             `);
                         break scalar;
@@ -593,7 +611,12 @@ function getFormFieldComponents({ model }) {
                 form.append(`
           <div>
             <Label>${refMeta.userFriendlyName}</Label>
-            <Typed.${refMeta.react.components.forms.searchFieldName} name="${formikFieldName}" placeholder="Search..." />
+            <Typed.${refMeta.react.components.forms.searchFieldName} 
+              name="${formikFieldName}" 
+              placeholder="Search..." 
+              __cypress_options_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'options' })}"
+              __cypress_combobox_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+            />
           </div>
         `);
                 break;
@@ -603,7 +626,11 @@ function getFormFieldComponents({ model }) {
                 form.append(`
           <div>
             <Label>${label}</Label>
-            <Typed.${enumMeta.react.selectFieldName} name="${formikFieldName}" placeholder="Search..." />
+            <Typed.${enumMeta.react.selectFieldName} 
+              name="${formikFieldName}" 
+              placeholder="Search..." 
+              __cypress_field_selector__="${selectorCollector.idFor(field.name, { typePrefix: 'fields' })}"
+            />
           </div>
         `);
                 break;

package/dist/generators/models/repository.generator.js

@@ -55,6 +55,7 @@ function generateRepository({ model, meta }) {
             model,
             meta,
             schemaMeta,
+            imports,
             blocks: {
                 uniqueStringFieldsBlocks,
                 defaultValueBlocks,
@@ -101,6 +102,10 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
 		
   ${indexBlocks.nestedMapDeclarations.join('\n')}
 
+  ${mainBlocks.userRepositorySpecificBlocks.rootUserNameConst}
+
+  ${mainBlocks.userRepositorySpecificBlocks.getterBlock}
+
   ${mainBlocks.constructorCode}
   
   ${mainBlocks.initCode}
@@ -109,6 +114,8 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
 
   ${mainBlocks.deleteAllCode}
 
+  ${mainBlocks.userRepositorySpecificBlocks.rootUserInitializeBlock}
+
   public async get(id: ${model.brandedIdType} | null): Promise<${model.typeName} | null> {
     if (id === null) { 
       return Promise.resolve(null)
@@ -205,10 +212,12 @@ exports.generateMockRepository = generateMockRepository;
 /**
  * Generates the main building blocks of the repository for in-memory model.
  */
-function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
+function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, imports, blocks, }) {
     const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
+    const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, imports });
     return {
         constructorCode: '',
+        userRepositorySpecificBlocks,
         initCode: `
       public async init() {
         this.data.clear()
@@ -218,6 +227,8 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
     
         ${blocks.indexBlocks.initCode.join('\n')}
     
+        ${userRepositorySpecificBlocks.initCall}
+
         return Promise.resolve()
       }`,
         reInitCode: `
@@ -446,8 +457,10 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         .map((part) => `"${part}"`)
         .join('.');
     const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
+    const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports });
     return {
         constructorCode: `constructor(protected db: DbService) {}`,
+        userRepositorySpecificBlocks,
         initCode: `
       public async init() {
         this.data.clear()
@@ -471,6 +484,8 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
 
         ${blocks.defaultValueBlocks.init.checkCode}
 
+        ${userRepositorySpecificBlocks.initCall}
+
         this.logger.log(\`\${format(this.data.size)} \${pluralize('${model.typeName}', this.data.size)} loaded\`)
         ${blocks.indexBlocks.initLogCode.join('\n')}
       }`,
@@ -741,6 +756,100 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       }`,
     };
 }
+function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports, }) {
+    if (model.name !== 'User') {
+        return {
+            rootUserNameConst: '',
+            getterBlock: '',
+            initCall: '',
+            rootUserInitializeBlock: '',
+        };
+    }
+    imports.addImport({
+        from: meta.types.importPath,
+        items: [(0, types_1.toTypeName)('UserRole')],
+    });
+    return {
+        rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}('root')`,
+        getterBlock: `
+      // We initialize the root user in the init() function
+      private _rootUser!: ${meta.types.typeName}
+      public get rootUser(): ${meta.types.typeName} {
+        return this._rootUser
+      }`,
+        initCall: `await this.initializeRootUser()`,
+        rootUserInitializeBlock: `
+      private async initializeRootUser(): Promise<void> {
+        const existingRootUser = await this.get(${meta.data.repositoryClassName}.ROOT_USER_ID)
+        if (existingRootUser) {
+          this._rootUser = existingRootUser
+          return
+        }
+    
+        const rawUser = await this.db.user.create({
+          data: {
+            id: ${meta.data.repositoryClassName}.ROOT_USER_ID,
+            name: 'System',
+            email: 'system@postxl.com',
+            role: UserRole.Admin,
+            login: 'not-set',
+            familyName: 'System user',
+            age: 0,
+            countryId: null,
+          },
+        })
+        const newRootUser = this.toUser(rawUser)
+        this.set(newRootUser)
+        this._rootUser = newRootUser
+      }`,
+    };
+}
+function generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, imports, }) {
+    if (model.name !== 'User') {
+        return {
+            rootUserNameConst: '',
+            getterBlock: '',
+            initCall: '',
+            rootUserInitializeBlock: '',
+        };
+    }
+    imports.addImport({
+        from: meta.types.importPath,
+        items: [(0, types_1.toTypeName)('UserRole')],
+    });
+    return {
+        rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}('root')`,
+        getterBlock: `
+      // We initialize the root user in the init() function
+      private _rootUser!: ${meta.types.typeName}
+      public get rootUser(): ${meta.types.typeName} {
+        return this._rootUser
+      }`,
+        initCall: `await this.initializeRootUser()`,
+        rootUserInitializeBlock: `
+      private async initializeRootUser(): Promise<void> {
+        const existingRootUser = await this.get(${meta.data.repositoryClassName}.ROOT_USER_ID)
+        if (existingRootUser) {
+          this._rootUser = existingRootUser
+          return
+        }
+    
+        const rawUser = {
+          id: ${meta.data.repositoryClassName}.ROOT_USER_ID,
+          name: 'System',
+          email: 'system@postxl.com',
+          role: UserRole.Admin,
+          login: 'not-set',
+          familyName: 'System user',
+          age: 0,
+          countryId: null, 
+        }
+        const newRootUser = this.verifyItem (rawUser)
+        this.set(newRootUser)
+        this._rootUser = newRootUser
+      }`,
+    };
+}
 /**
  * Generates code chunks responsible for verifying the ID validity of a model instance and generating the id
  * value of a model with auto-generated id.

package/dist/generators/models/route.generator.js

@@ -31,7 +31,7 @@ function generateRoute({ model, meta }) {
             meta.businessLogic.update.createActionFunctionNameDeleteMany,
         ],
     });
-    return `
+    return /* ts */ `
 import { z } from 'zod'
 import { procedure, router } from '../trpc'
 
@@ -107,7 +107,7 @@ function generateRoutesIndex({ models, meta }) {
     for (const { meta } of mm) {
         imports.addImport({ items: [meta.trpc.routerName], from: meta.trpc.routerFilePath });
     }
-    return `
+    return /* ts */ `
     ${imports.generate()}
 
     /**

package/dist/generators/models/stub.generator.js

@@ -20,7 +20,7 @@ function generateStub({ model, meta }) {
         modelName: model.name,
         imports,
     });
-    return `
+    return /* ts */ `
 ${imports.generate()}
 
 /**

package/dist/generators/models/types.generator.js

@@ -40,7 +40,7 @@ function generateModelTypes({ model, meta }) {
         from: schemaMeta.types.dto.path,
     });
     const decoderNames = meta.types.zodDecoderFnNames;
-    return `
+    return /* ts */ `
 import { z } from 'zod'
 
 ${imports.generate()}

package/dist/lib/id-collector.d.ts

@@ -0,0 +1,43 @@
+type ElementId = string & {
+    __brand: 'ElementId';
+};
+/**
+ * The SelectorCollector is used to generate and track HTML element IDs.
+ * The idea is that it is instantiated once and then used to generate IDs throughout the generators.
+ * After the files are generated, all generated IDs can be serialized to a file.
+ *
+ * An ID can for instance be something like `post-create-name, `${model.name}-${componentType}-${fieldName}`.
+ *
+ * Each code generator can instantiate an SelectorCollector - the constructor will require the current model & component type.
+ * All generated Ids will be stored in a global static Set so we can serialize them later.
+ */
+export declare class SelectorCollector {
+    private _prefix;
+    /**
+     * We store all generated IDs in a global static Set so we can serialize them later.
+     */
+    private static _ids;
+    constructor(_prefix: string);
+    /**
+     * Creates a new instance of the SelectorCollector.
+     */
+    static from(prefix: string): SelectorCollector;
+    /**
+     * Generates a new ID for an element and stores it in the collector
+     */
+    idFor(
+    /**
+     * The name of the element, e.g. `age`, `submit`.
+     */
+    elementName: string, options?: {
+        /**
+         * Optional prefix for the type of the element, e.g. `field` or `button`.
+         */
+        typePrefix?: string;
+    }): string;
+    /**
+     * Returns all generated IDs and resets the stored IDs.
+     */
+    static flush(): ElementId[];
+}
+export {};

package/dist/lib/id-collector.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectorCollector = void 0;
+/**
+ * The SelectorCollector is used to generate and track HTML element IDs.
+ * The idea is that it is instantiated once and then used to generate IDs throughout the generators.
+ * After the files are generated, all generated IDs can be serialized to a file.
+ *
+ * An ID can for instance be something like `post-create-name, `${model.name}-${componentType}-${fieldName}`.
+ *
+ * Each code generator can instantiate an SelectorCollector - the constructor will require the current model & component type.
+ * All generated Ids will be stored in a global static Set so we can serialize them later.
+ */
+class SelectorCollector {
+    constructor(_prefix) {
+        this._prefix = _prefix;
+    }
+    /**
+     * Creates a new instance of the SelectorCollector.
+     */
+    static from(prefix) {
+        return new SelectorCollector(prefix);
+    }
+    /**
+     * Generates a new ID for an element and stores it in the collector
+     */
+    idFor(
+    /**
+     * The name of the element, e.g. `age`, `submit`.
+     */
+    elementName, options) {
+        const { typePrefix } = options !== null && options !== void 0 ? options : {};
+        const id = [this._prefix, typePrefix, elementName].filter((x) => x !== undefined && x !== '').join('-');
+        if (SelectorCollector._ids.has(id)) {
+            throw new Error(`ID ${id} already exists.`);
+        }
+        SelectorCollector._ids.add(id);
+        return id;
+    }
+    /**
+     * Returns all generated IDs and resets the stored IDs.
+     */
+    static flush() {
+        const result = [...SelectorCollector._ids.values()];
+        SelectorCollector._ids.clear();
+        return result;
+    }
+}
+exports.SelectorCollector = SelectorCollector;
+/**
+ * We store all generated IDs in a global static Set so we can serialize them later.
+ */
+SelectorCollector._ids = new Set();

package/dist/lib/meta.d.ts

@@ -51,10 +51,22 @@ export type SchemaMetaData = {
          * Path to the file containing the mock data for the database.
          */
         dataMockModuleFilePath: Types.Path;
+        /**
+         * Name of the mock data module class.
+         */
+        dataMockModuleName: Types.ClassName;
+        /**
+         * Name of the data mock type/interface.
+         */
+        dataMockDataType: Types.TypeName;
         /**
          * Path to the file containing data service class definitions.
          */
         dataServiceFilePath: Types.Path;
+        /**
+         * Name of the data service class.
+         */
+        dataServiceClassName: Types.ClassName;
         /**
          * Path to the file containing the repository type definition.
          */
@@ -67,6 +79,14 @@ export type SchemaMetaData = {
          * Path to the file containing data mocker class definitions.
          */
         dataMockerFilePath: Types.Path;
+        /**
+         * Path to the file containing component selectors for e2e tests.
+         */
+        selectorsFilePath: Types.Path;
+        /**
+         * Path to the file containing the testDataService class definition.
+         */
+        testDataServiceFilePath: Types.Path;
         /**
          * Path to the file containing data mocker class definitions.
          */
@@ -207,6 +227,10 @@ export type SchemaMetaData = {
          * Path that may be used in the import statement.
          */
         importPath: Types.Path;
+        /**
+         * Name of the function that converts mock data to seed data.
+         */
+        mockDataToCreateFunction: Types.Fnction;
     };
     trpc: {
         /**

package/dist/lib/meta.js

@@ -45,10 +45,15 @@ function getSchemaMetadata({ config }) {
             importPath: Types.toPath(`@${config.project}/data`),
             dataModuleFilePath: Types.toPath(`${config.paths.dataLibPath}data.module`),
             dataMockModuleFilePath: Types.toPath(`${config.paths.dataLibPath}data.mock.module`),
+            dataMockModuleName: Types.toClassName(`DataMockModule`),
+            dataMockDataType: Types.toTypeName(`MockData`),
             dataServiceFilePath: Types.toPath(`${config.paths.dataLibPath}data.service`),
+            dataServiceClassName: Types.toClassName(`DataService`),
             repositoryTypeFilePath: Types.toPath(`${config.paths.dataLibPath}repository.type`),
             repositoryTypeName: Types.toTypeName(`Repository`),
             dataMockerFilePath: Types.toPath(`${config.paths.cypressPath}support/data-mocker.class`),
+            selectorsFilePath: Types.toPath(`${config.paths.cypressPath}support/selectors`),
+            testDataServiceFilePath: Types.toPath(`${config.paths.e2eLibPath}test-data.service`),
             dataMockerStubImportPath: Types.toPath(`${config.paths.cypressPath}support/stubs`),
             dataMockerStubIndexFilePath: Types.toPath(`${config.paths.cypressPath}support/stubs/index`),
             repositoriesConstFilePath: Types.toPath(`${config.paths.dataLibPath}repositories/repositories`),
@@ -94,6 +99,7 @@ function getSchemaMetadata({ config }) {
             serviceFilePath: Types.toPath(`${config.paths.seedLibPath}seed.service`),
             serviceClassName: Types.toClassName(`SeedService`),
             importPath: Types.toPath(`@${config.project}/seed`),
+            mockDataToCreateFunction: Types.toFunction(`mockDataToCreate`),
         },
         types: {
             indexFilePath: Types.toPath(`${config.paths.modelTypeDefinitionsPath}index`),

package/dist/lib/schema/schema.d.ts

@@ -63,6 +63,10 @@ export type SchemaConfig = {
          * Path to the directory containing Cypress project.
          */
         cypressPath: Types.Path;
+        /**
+         * Path to the directory containing e2e tests.
+         */
+        e2eLibPath: Types.Path;
         /**
          * Path to the directory containing actions.
          *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.38.1",
+  "version": "0.39.0",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -34,7 +34,7 @@
     "@types/eslint": "^8.44.7",
     "@types/jest": "^29.5.0",
     "@types/node": "18.15.10",
-    "jest": "29.5.0",
+    "jest": "29.7.0",
     "prisma": "5.2.0",
     "ts-jest": "29.0.5",
     "ts-node": "10.9.1",