@postxl/generator 0.39.0 → 0.40.1

package/dist/generator.js

@@ -48,24 +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");
@@ -80,14 +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(),
@@ -107,25 +111,27 @@ const CONFIG_SCHEMA = zod_1.z
             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`),
     };
@@ -176,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 }));
@@ -213,14 +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
@@ -228,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 }));
@@ -241,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/indices/businesslogic-update-module.generator.js

@@ -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-view-module.generator.js

@@ -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/{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.importPath]: [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 })
             }
@@ -73,7 +73,7 @@ export class ${meta.data.dataMockModuleName} {
     const cachedModule = {
       module: ${meta.data.moduleName},
       imports: [DbModule.provideMock()],
-      providers: providers,
+      providers,
       exports: providers,
       global: true,
     }

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

@@ -1,45 +1,21 @@
 "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;
@@ -63,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
   }
@@ -91,7 +67,7 @@ export class ${moduleName} {
     // 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> = {
+    const userRepositoryProvider: FactoryProvider<UserRepository> = {
       provide: UserRepository,
       inject: [DbService],
       useFactory: async (dbService: DbService) => {
@@ -101,11 +77,14 @@ export class ${moduleName} {
       },
     }
 
-    const repositoryProviders = [
-      userRepository,
+    const providers = [
+      DataService,
+      
+      userRepositoryProvider,
+      
       ${mm
         .filter((mm) => mm.model.name !== 'User')
-        .map(({ meta }) => meta.data.repositoryClassName)
+        .map(({ meta }) => meta.data.repository.className)
         .join(',')}
     ]
 
@@ -113,8 +92,8 @@ export class ${moduleName} {
       module: ${moduleName},
       global: true,
       imports: [DbModule.forRoot()],
-      providers: [DataService, ...repositoryProviders],
-      exports: [DataService, ...repositoryProviders],
+      providers,
+      exports: providers,
     }
 
     return ${moduleName}.cachedModule

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

@@ -8,30 +8,55 @@ const meta_1 = require("../../lib/meta");
  */
 function generateDataService({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.dataServiceFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.data.dataService.filePath);
     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 constructor = mm
-        .map(({ meta }) => `public ${meta.data.dataServiceName} :${meta.data.repositoryClassName}`)
+        .map(({ meta }) => `public ${meta.data.dataServiceName} :${meta.data.repository.className}`)
         .join(',\n');
     const initializer = mm.map(({ meta }) => `await this.${meta.data.dataServiceName}.init()`).join('\n');
     const excelExports = mm
-        .map(({ meta }) => `${meta.data.excelExportTableName}: mapValues(await this.${meta.data.dataServiceName}.getAll()),`)
+        .map(({ meta }) => `${meta.importExport.tableName}: mapValues(await this.${meta.data.dataServiceName}.getAll()),`)
         .join('\n');
     const isEmptyChecks = mm.map(({ meta }) => `(await this.${meta.data.dataServiceName}.count()) === 0`).join(' &&');
+    // Building blocks for bulk mutations
+    imports.addImports({
+        [meta.types.importPath]: [meta.types.dto.create, meta.types.dto.update],
+        [meta.data.repository.typeFilePath]: [meta.data.repository.typeName],
+        [meta.data.types.filePath]: [meta.data.types.bulkMutation],
+        [meta.actions.importPath]: [meta.actions.actionExecution.interface],
+    });
+    const creates = [];
+    const updates = [];
+    const upserts = [];
+    const deletes = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        creates.push(`await this.create({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.create, repo: this.${modelMeta.data.dataServiceName}, execution })`);
+        updates.push(`await this.update({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.update, repo: this.${modelMeta.data.dataServiceName}, execution })`);
+        upserts.push(`await this.upsert({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.upsert, repo: this.${modelMeta.data.dataServiceName}, execution })`);
+        deletes.push(`await this.delete({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.delete, repo: this.${modelMeta.data.dataServiceName}, execution })`);
+    }
     return /* ts */ `
-import { Injectable } from '@nestjs/common'
+import { Injectable, Logger } from '@nestjs/common'
 
-import { mapValues } from '@pxl/common'
+import { format, mapValues, pluralize } from '@pxl/common'
 
 ${imports.generate()}
 
+// If true, the bulk mutation will be executed one by one, instead of all at once (which is the default).
+// Also, each item will be logged to the console.
+// This should help to quickly identify the item that causes an error in a bulk mutation.
+const DEBUG = false
+
 @Injectable()
-export class ${meta.data.dataServiceClassName} {
+export class ${meta.data.dataService.class} {
+  private readonly logger = new Logger(${meta.data.dataService.class}.name)
+
   constructor(${constructor}) {}
 
   public async prepareExcelExport() {
@@ -49,6 +74,174 @@ export class ${meta.data.dataServiceClassName} {
       ${isEmptyChecks}
     )
   }
+  public async ${meta.data.dataService.executeBulkMutations}(
+    { steps, execution }: 
+    { steps: ${meta.data.types.bulkMutation}[]; execution: ${meta.actions.actionExecution.interface} }
+  ) {
+    let index = 0
+    for (const step of steps) {
+      this.logger.log(\`Uploading data step \${++index}/\${steps.length}\`)
+      await this.${meta.data.dataService.executeBulkMutation}({ data: step, execution })
+    }
+  }
+
+  public async ${meta.data.dataService.executeBulkMutation}(
+    { data, execution }: 
+    { data: ${meta.data.types.bulkMutation}, execution: ${meta.actions.actionExecution.interface}}
+  ) {
+    // 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.
+    // Attention: Depending on the dependencies in seed data, you may also have to take care of relations,
+    // e.g. by removing any foreign key first - and then update these after all data is created.
+    // Alternatively, you can also do this in multiple steps
+    ${creates.join('\n')}
+
+    ${updates.join('\n')}
+
+    ${upserts.join('\n')}
+
+    ${deletes.join('\n')}
+  }
+
+  private async create<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: ${meta.types.dto.create}<T, ID>[] | undefined
+    repo: ${meta.data.repository.typeName}<T, ID>
+    execution: ${meta.actions.actionExecution.interface}
+  }): Promise<void> {
+    if (!data) {
+      return
+    }
+    if (!DEBUG) {
+      await repo.createMany?.({ items: data, execution })
+    } else {
+      let i = 0
+      for (const item of data) {
+        i++
+        this.logger.log(\`Creating \${name} \${i} - \${_getItemDescription(item)}\`)
+        try {
+          await repo.create?.({ item, execution })
+        } catch (error) {
+          this.logger.error(\`Error creating \${name} \${i} - \${_getItemDescription(item)}\`, error)
+          throw error
+        }
+      }
+    }
+    this.logger.log(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
+  }
+  
+  private async update<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: ${meta.types.dto.update}<T, ID>[] | undefined
+    repo: ${meta.data.repository.typeName}<T, ID>
+    execution: ${meta.actions.actionExecution.interface}
+  }): Promise<void> {
+    if (!data) {
+      return
+    }
+    if (!DEBUG) {
+      await repo.updateMany?.({ items: data, execution })
+    } else {
+      let i = 0
+      for (const item of data) {
+        i++
+        this.logger.log(\`Updating \${name} \${i} - \${_getItemDescription(item)}\`)
+        try {
+          await repo.update?.({ item, execution })
+        } catch (error) {
+          this.logger.error(\`Error updating \${name} \${i} - \${_getItemDescription(item)}\`, error)
+          throw error
+        }
+      }
+    }
+    this.logger.log(\`✅ Updated \${format(data.length)} \${pluralize(name)}\`)
+  }
+
+  private async upsert<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: (${meta.types.dto.create}<T, ID> | ${meta.types.dto.update}<T, ID>)[] | undefined
+    repo: ${meta.data.repository.typeName}<T, ID>
+    execution: ${meta.actions.actionExecution.interface}
+  }): Promise<void> {
+    if (!data) {
+      return
+    }
+    if (!DEBUG) {
+      await repo.upsertMany?.({ items: data, execution })
+    } else {
+      let i = 0
+      for (const item of data) {
+        i++
+        this.logger.log(\`Upserting \${name} \${i} - \${_getItemDescription(item)}\`)
+        try {
+          await repo.upsert?.({ item, execution })
+        } catch (error) {
+          this.logger.error(\`Error upserting \${name} \${i} - \${_getItemDescription(item)}\`, error)
+          throw error
+        }
+      }
+    }
+    this.logger.log(\`✅ Upserted \${format(data.length)} \${pluralize(name)}\`)
+  }
+
+  private async delete<T extends { id: ID }, ID extends number | string | boolean>({
+    name,
+    data,
+    repo,
+    execution,
+  }: {
+    name: string
+    data: ID[] | undefined
+    repo: ${meta.data.repository.typeName}<T, ID>
+    execution: ${meta.actions.actionExecution.interface}
+  }): Promise<void> {
+    if (!data) {
+      return
+    }
+    if (!DEBUG) {
+      await repo.deleteMany?.({ ids: data, execution })
+    } else {
+      let i = 0
+      for (const id of data) {
+        i++
+        this.logger.log(\`Deleting \${name} \${i} - id: \${id.toString()}\`)
+        try {
+          await repo.delete?.({ id, execution })
+        } catch (error) {
+          this.logger.error(\`Error deleting \${name} \${i} - id: \${id.toString()}\`, error)
+          throw error
+        }
+      }
+    }
+    this.logger.log(\`✅ Deleted \${format(data.length)} \${pluralize(name)}\`)
+  }
+}
+
+function _getItemDescription<T extends Partial<{ id: ID }>, ID extends number | string | boolean>(item: T): string {
+  const id = \`id: \${item.id !== undefined ? item.id.toString() : 'not provided'}\`
+
+  // If the item has a name, we can assume it is a string and add it to the description
+  if ('name' in item) {
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    return \`\${id}, name: \${item.name}\`
+  }
+  return id
 }
 `;
 }

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

@@ -7,8 +7,9 @@ const meta_1 = require("../../lib/meta");
  * Generates the action dispatcher service.
  */
 function generateActionsDispatcherService({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.seed.serviceFilePath).addImports({
+    const imports = imports_1.ImportsGenerator.from(meta.actions.dispatcherService.filePath).addImports({
         [meta.seed.importPath]: [meta.seed.serviceClassName],
+        [meta.importExport.importPath]: [meta.importExport.importService.name],
         [meta.businessLogic.update.importPath]: [meta.businessLogic.update.serviceClassName],
         [meta.types.importPath]: meta.config.userType,
     });
@@ -30,11 +31,15 @@ import { Action, ResultOfAction } from './actions.types'
 
 
 @Injectable()
-export class DispatcherService {
-  // as the SeedModule gets instantiated after the ActionsModule, we use this hack to avoid a circular dependency:
-  // we set the seedService to a dummy value and then overwrite it in the ${meta.seed.serviceClassName} constructor.
+export class ${meta.actions.dispatcherService.class} {
+  
+  // As SeedModule and ImportExportModule get instantiated after the ActionsModule, we use this hack to avoid a circular dependency:
+  // we set the seedService and the importService to value and then overwrite it in the services' constructors.
   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-  public seedService: ${meta.seed.serviceClassName} = {} as unknown as any
+  public seedService: SeedService = {} as unknown as any
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+  public ${meta.importExport.importService.sharedName}: ImportService = {} as unknown as any
+
   constructor(
     private readonly updateService: ${meta.businessLogic.update.serviceClassName}, 
     private readonly dbService: DbService,
@@ -72,6 +77,10 @@ export class DispatcherService {
         .join('\n')}
       case 'seed':
         return this.seedService.dispatch({ action, execution })
+      
+      case 'import':
+        return this.importService.dispatch({ action, execution })
+      
       default:
         throw new ExhaustiveSwitchCheck(action)
     }

package/dist/generators/indices/importexport-convert-import-functions.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates the Exporter class for the Import-Export module
+ */
+export declare function generateImportExportConvertImportFunctions({ models, meta, }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;