@postxl/generator 0.38.2 → 0.40.0

package/dist/generator.js

@@ -48,22 +48,27 @@ const businesslogic_update_service_generator_1 = require("./generators/indices/b
 const businesslogic_view_index_generator_1 = require("./generators/indices/businesslogic-view-index.generator");
 const businesslogic_view_module_generator_1 = require("./generators/indices/businesslogic-view-module.generator");
 const businesslogic_view_service_generator_1 = require("./generators/indices/businesslogic-view-service.generator");
+const data_types_generator_1 = require("./generators/indices/data-types.generator");
 const datamock_module_generator_1 = require("./generators/indices/datamock-module.generator");
 const datamocker_generator_1 = require("./generators/indices/datamocker.generator");
 const datamodule_generator_1 = require("./generators/indices/datamodule.generator");
 const dataservice_generator_1 = require("./generators/indices/dataservice.generator");
 const dispatcher_service_generator_1 = require("./generators/indices/dispatcher-service.generator");
 const emptydatabasemigration_generator_1 = require("./generators/indices/emptydatabasemigration.generator");
+const importexport_convert_import_functions_generator_1 = require("./generators/indices/importexport-convert-import-functions.generator");
+const importexport_exporter_class_generator_1 = require("./generators/indices/importexport-exporter-class.generator");
+const importexport_import_service_generator_1 = require("./generators/indices/importexport-import-service.generator");
+const importexport_types_generator_1 = require("./generators/indices/importexport-types.generator");
 const repositories_generator_1 = require("./generators/indices/repositories.generator");
 const seed_migration_generator_1 = require("./generators/indices/seed-migration.generator");
-const seed_service_generator_1 = require("./generators/indices/seed-service.generator");
 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");
+const importexport_decoder_generator_1 = require("./generators/models/importexport-decoder.generator");
 const react_generator_2 = require("./generators/models/react.generator");
 const repository_generator_1 = require("./generators/models/repository.generator");
 const route_generator_1 = require("./generators/models/route.generator");
@@ -78,13 +83,15 @@ const parse_1 = require("./prisma/parse");
 const CONFIG_SCHEMA = zod_1.z
     .object({
     project: zod_1.z.string(),
-    pathToTypes: zod_1.z.string().optional(),
     pathToDataLib: zod_1.z.string().optional(),
     pathToCypress: zod_1.z.string().optional(),
+    pathToE2ELib: zod_1.z.string().optional(),
+    pathToImportExport: zod_1.z.string().optional(),
     pathToActions: zod_1.z.string().optional(),
     pathToBusinessLogic: zod_1.z.string().optional(),
-    pathToSeedLib: zod_1.z.string().optional(),
     pathToSeedData: zod_1.z.string().optional(),
+    pathToSeedLib: zod_1.z.string().optional(),
+    pathToTypes: zod_1.z.string().optional(),
     trpcRoutesFolder: zod_1.z.string().optional(),
     reactFolderOutput: zod_1.z.string().optional(),
     migrationsFolder: zod_1.z.string().optional(),
@@ -103,25 +110,28 @@ 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/'),
+            importExportPath: (0, types_1.toPath)(s.pathToImportExport || 'import-export'),
             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'),
+            migrationsFolderPath: (0, types_1.toPath)(s.migrationsFolder || 'migrations'),
             modelTypeDefinitionsPath: (0, types_1.toPath)(s.pathToTypes || 'types'),
-            seedLibPath: (0, types_1.toPath)(s.pathToSeedLib || 'seed'),
+            reactFolderPath: (0, types_1.toPath)(s.reactFolderOutput || 'react'),
             seedDataPath: (0, types_1.toPath)(s.pathToSeedData || 'seed-data'),
+            seedLibPath: (0, types_1.toPath)(s.pathToSeedLib || 'seed'),
             trpcRoutesFolderPath: (0, types_1.toPath)(s.trpcRoutesFolder || 'trpc'),
-            migrationsFolderPath: (0, types_1.toPath)(s.migrationsFolder || 'migrations'),
         },
         randomSeed: s.randomSeed,
         force: s.force,
         disableGenerators: {
-            types: s.pathToTypes === undefined,
-            data: s.pathToDataLib === undefined,
             actions: s.pathToActions === undefined,
             businessLogic: s.pathToBusinessLogic === undefined,
+            data: s.pathToDataLib === undefined,
+            importExport: s.pathToImportExport === undefined,
+            react: s.reactFolderOutput === undefined,
             seed: s.pathToSeedLib === undefined,
             trpc: s.trpcRoutesFolder === undefined,
-            react: s.reactFolderOutput === undefined,
+            types: s.pathToTypes === undefined,
         },
         userType: (0, types_1.toTypeName)(`User`),
     };
@@ -172,13 +182,17 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             if (!config.disableGenerators.seed) {
                 generated.write(`/${meta.seed.filePath}.ts`, (0, seed_generator_1.generateSeedModel)({ model, itemCount: 5, meta }));
             }
-            // Generate Repositories
+            // Data
             if (!config.disableGenerators.data) {
                 generated.write(`/${meta.data.stubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
-                generated.write(`/${meta.data.repoFilePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
-                generated.write(`/${meta.data.mockRepoFilePath}.ts`, (0, repository_generator_1.generateMockRepository)({ model, meta }));
+                generated.write(`/${meta.data.repository.filePath}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
+                generated.write(`/${meta.data.mockRepository.filePath}.ts`, (0, repository_generator_1.generateMockRepository)({ model, meta }));
                 generated.write(`/${meta.data.dataMockerStubFilePath}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
             }
+            // Import-Export
+            if (!config.disableGenerators.importExport) {
+                generated.write(`/${meta.importExport.decoder.filePath}.ts`, (0, importexport_decoder_generator_1.generateModelImportExportDecoder)({ model, meta }));
+            }
             // Business Logic
             if (!config.disableGenerators.businessLogic) {
                 generated.write(`/${meta.businessLogic.view.serviceFilePath}.ts`, (0, businesslogic_view_generator_1.generateModelBusinessLogicView)({ model, meta }));
@@ -209,12 +223,15 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         if (!config.disableGenerators.data) {
             generated.write(`/${meta.data.dataMockModuleFilePath}.ts`, (0, datamock_module_generator_1.generateDataMockModule)({ models, meta }));
             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.dataService.filePath}.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 }));
+            generated.write(`/${meta.data.repository.constFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesArray)({ models, meta }));
+            generated.write(`/${meta.data.repository.indexFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesIndex)({ models, meta }));
             generated.write(`/${meta.data.stubIndexFilePath}.ts`, (0, stubs_generator_1.generateStubsIndex)({ models, meta }));
+            generated.write(`/${meta.data.types.filePath}.ts`, (0, data_types_generator_1.generateDataTypes)({ models, meta }));
             // We only generate the empty database migration if the migration folder already has an existing migration
             // Else we would generate a migration that deletes from tables that have not yet been created in the database
             // We include this check here as the template does not come with any migration - hence this migration should also not be generated
@@ -222,8 +239,16 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
                 generated.write((0, emptydatabasemigration_generator_1.deriveEmptyDatabaseMigrationFilePath)(meta), (0, emptydatabasemigration_generator_1.generateEmptyDatabaseStoredProcedure)({ models, meta }));
             }
         }
+        if (!config.disableGenerators.importExport) {
+            generated.write(`/${meta.importExport.types.filePath}.ts`, (0, importexport_types_generator_1.generateImportExportTypes)({ models, meta }));
+            generated.write(`/${meta.importExport.exporterClass.filePath}.ts`, (0, importexport_exporter_class_generator_1.generateImportExportExporterClass)({ models, meta }));
+            generated.write(`/${meta.importExport.importService.filePath}.ts`, (0, importexport_import_service_generator_1.generateImportExportImportService)({ models, meta }));
+            generated.write(`/${meta.importExport.decoder.indexFilePath}.ts`, (0, importexport_decoder_generator_1.generateImportExportDecoderIndex)({ models, meta }));
+            generated.write(`/${meta.importExport.decoder.fullDecoderFilePath}.ts`, (0, importexport_decoder_generator_1.generateImportExportDecoder)({ models, meta }));
+            generated.write(`/${meta.importExport.converterFunctions.filePath}.ts`, (0, importexport_convert_import_functions_generator_1.generateImportExportConvertImportFunctions)({ models, meta }));
+        }
         if (!config.disableGenerators.actions) {
-            generated.write(`/${meta.actions.dispatcherServiceFilePath}.ts`, (0, dispatcher_service_generator_1.generateActionsDispatcherService)({ models, meta }));
+            generated.write(`/${meta.actions.dispatcherService.filePath}.ts`, (0, dispatcher_service_generator_1.generateActionsDispatcherService)({ models, meta }));
         }
         if (!config.disableGenerators.businessLogic) {
             generated.write(`/${meta.businessLogic.view.indexFilePath}.ts`, (0, businesslogic_view_index_generator_1.generateBusinessLogicViewIndex)({ models, meta }));
@@ -235,11 +260,8 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
             generated.write(`/${meta.businessLogic.update.actionTypesFilePath}.ts`, (0, businesslogic_actiontypes_generator_1.generateBusinessLogicActionTypes)({ models, meta }));
         }
         if (!config.disableGenerators.seed) {
-            generated.write(`/${meta.seed.seedDataTypeFilePath}.ts`, (0, seeddata_type_generator_1.generateSeedDataType)({ models, meta }));
-            generated.write(`/${meta.seed.serviceFilePath}.ts`, (0, seed_service_generator_1.generateSeedService)({ models, meta }));
             generated.write(`/${meta.seedData.initialMigrationFilePath}.ts`, (0, seed_migration_generator_1.generateSeedMigration)({ models, meta }));
             generated.write(`/${meta.seedData.templateExcelFilePath}`, yield (0, seed_template_generator_1.generateSeedExcelTemplate)({ models }));
-            generated.write(`/${meta.seedData.templateDecoderFilePath}.ts`, (0, seed_template_decoder_generator_1.generateSeedTemplateDecoder)({ models, meta }));
         }
         if (!config.disableGenerators.trpc) {
             generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, route_generator_1.generateRoutesIndex)({ 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()}
@@ -41,7 +41,7 @@ export class ${moduleName} {
    */
   static getInstance(): DynamicModule {
     if (!${moduleName}.cachedModule) {
-      throw new Error('${moduleName} must be called via .provide first!')
+      throw new Error('${moduleName} must be called via .forRoot first!')
     }
     return ${moduleName}.cachedModule
   }

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()}
@@ -40,7 +40,7 @@ export class ${moduleName} {
    */
   static getInstance(): DynamicModule {
     if (!${moduleName}.cachedModule) {
-      throw new Error('${moduleName} must be called via .provide first!')
+      throw new Error('${moduleName} must be called via .forRoot first!')
     }
     return ${moduleName}.cachedModule
   }

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/{seed-service.generator.d.ts → data-types.generator.d.ts}

@@ -1,9 +1,9 @@
 import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
- * Generates index file for all seed files.
+ * Generates type for BulkMutations.
  */
-export declare function generateSeedService({ models }: {
+export declare function generateDataTypes({ models, meta }: {
     models: Model[];
     meta: SchemaMetaData;
 }): string;

package/dist/generators/indices/data-types.generator.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataTypes = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates type for BulkMutations.
+ */
+function generateDataTypes({ models, meta }) {
+    const { types } = meta.data;
+    const imports = imports_1.ImportsGenerator.from(types.filePath);
+    const dto = meta.types.dto;
+    imports.addImports({
+        [meta.types.importPath]: [dto.create, dto.update, dto.upsert, dto.genericModel, dto.idType],
+    });
+    const modelTypes = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            items: [modelMeta.types.typeName, modelMeta.types.brandedIdType],
+            from: modelMeta.types.importPath,
+        });
+        modelTypes.push(`${modelMeta.seed.constantName}?: ${types.bulkMutationForModel}<${modelMeta.types.typeName}, ${modelMeta.types.brandedIdType}>`);
+    }
+    return /* ts */ `
+${imports.generate()}
+
+/**
+ * Generic type for BulkMutation for a model.
+ */
+export type ${types.bulkMutationForModel}<
+  Model extends ${dto.genericModel}<ID>, 
+  ID extends ${dto.idType}
+> = {
+  create?: ${dto.create}<Model, ID>[]
+  update?: ${dto.update}<Model, ID>[]
+  upsert?: ${dto.upsert}<Model, ID>[]
+  delete?: ID[]
+}
+
+/**
+ * Bulk changes for all models.
+ */
+export type ${types.bulkMutation} = {
+  ${modelTypes.join('\n')}
+}`;
+}
+exports.generateDataTypes = generateDataTypes;

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

@@ -34,20 +34,20 @@ function generateDataMockModule({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
     const imports = imports_1.ImportsGenerator.from(meta.data.dataMockModuleFilePath).addImports({
         [meta.data.dataModuleFilePath]: [Types.toVariableName('DataModule')],
-        [meta.data.dataServiceFilePath]: [Types.toVariableName('DataService')],
+        [meta.data.dataService.filePath]: [meta.data.dataService.class],
         // 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.actionExecution.mock],
     });
     for (const { model, meta } of mm) {
         imports.addImport({ items: [model.typeName], from: meta.types.importPath });
-        imports.addImport({ items: [meta.data.repositoryClassName], from: meta.data.repoFilePath });
-        imports.addImport({ items: [meta.data.mockRepositoryClassName], from: meta.data.mockRepoFilePath });
+        imports.addImport({ items: [meta.data.repository.className], from: meta.data.repository.filePath });
+        imports.addImport({ items: [meta.data.mockRepository.className], from: meta.data.mockRepository.filePath });
     }
     const providers = mm
         .map(({ meta }) => `{ 
-          provide: ${meta.data.repositoryClassName},
+          provide: ${meta.data.repository.className},
           useFactory: async () => {
-            const repository = new ${meta.data.mockRepositoryClassName}()
+            const repository = new ${meta.data.mockRepository.className}()
             if (!!seed && !!seed.${meta.seed.constantName}) {
               await repository.reInit({items: seed.${meta.seed.constantName}, execution })
             }
@@ -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,9 +71,9 @@ export class DataMockModule {
     ]
 
     const cachedModule = {
-      module: DataModule,
+      module: ${meta.data.moduleName},
       imports: [DbModule.provideMock()],
-      providers: providers,
+      providers,
       exports: providers,
       global: true,
     }
@@ -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

@@ -1,50 +1,30 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDataModule = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
-const Types = __importStar(require("../../lib/schema/types"));
 /**
  * Generates a data module class.
  */
 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.dataService.filePath]: [meta.data.dataService.class],
+        [meta.data.dataMockModuleFilePath]: [meta.data.dataMockModuleName],
     });
     for (const { meta } of mm) {
         imports.addImport({
-            items: [meta.data.repositoryClassName],
-            from: meta.data.repoFilePath,
+            items: [meta.data.repository.className],
+            from: meta.data.repository.filePath,
         });
     }
     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()}
 
@@ -59,7 +39,7 @@ export class ${moduleName} {
    */
   static getInstance(): DynamicModule {
     if (!${moduleName}.cachedModule) {
-      throw new Error('${moduleName} must be called via .provide first!')
+      throw new Error('${moduleName} must be called via .forRoot first!')
     }
     return ${moduleName}.cachedModule
   }
@@ -75,36 +55,39 @@ 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 userRepositoryProvider: 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(',')}
+      DataService,
+      
+      userRepositoryProvider,
+      
+      ${mm
+        .filter((mm) => mm.model.name !== 'User')
+        .map(({ meta }) => meta.data.repository.className)
+        .join(',')}
     ]
-    
+
     ${moduleName}.cachedModule = {
       module: ${moduleName},
       global: true,
@@ -115,7 +98,6 @@ export class ${moduleName} {
 
     return ${moduleName}.cachedModule
   }
-}
-`;
+}`;
 }
 exports.generateDataModule = generateDataModule;