@postxl/generator 0.70.2 → 0.71.0

package/dist/generator.js

@@ -45,31 +45,34 @@ const module_generator_1 = require("./generators/indices/data/module.generator")
 const service_generator_1 = require("./generators/indices/data/service.generator");
 const types_generator_2 = require("./generators/indices/data/types.generator");
 const dispatcher_service_generator_1 = require("./generators/indices/dispatcher-service.generator");
-const importexport_convert_import_functions_generator_1 = require("./generators/indices/import-export/importexport-convert-import-functions.generator");
-const importexport_exporter_class_generator_1 = require("./generators/indices/import-export/importexport-exporter-class.generator");
-const importexport_import_service_generator_1 = require("./generators/indices/import-export/importexport-import-service.generator");
-const importexport_types_generator_1 = require("./generators/indices/import-export/importexport-types.generator");
+const class_generator_1 = require("./generators/indices/export/class.generator");
+const encoder_generator_1 = require("./generators/indices/export/encoder.generator");
+const convert_functions_generator_1 = require("./generators/indices/import/convert-functions.generator");
+const decoder_generator_1 = require("./generators/indices/import/decoder.generator");
+const service_generator_2 = require("./generators/indices/import/service.generator");
+const types_generator_3 = require("./generators/indices/import/types.generator");
 const repositories_generator_1 = require("./generators/indices/repositories.generator");
 const routes_generator_1 = require("./generators/indices/routes.generator");
 const seed_migration_generator_1 = require("./generators/indices/seed-migration.generator");
 const seed_template_generator_1 = require("./generators/indices/seed-template.generator");
 const testids_generator_1 = require("./generators/indices/testids.generator");
-const types_generator_3 = require("./generators/indices/types.generator");
+const types_generator_4 = require("./generators/indices/types.generator");
 const actiontypes_generator_1 = require("./generators/indices/update/actiontypes.generator");
 const module_generator_2 = require("./generators/indices/update/module.generator");
-const service_generator_2 = require("./generators/indices/update/service.generator");
+const service_generator_3 = require("./generators/indices/update/service.generator");
 const module_generator_3 = require("./generators/indices/view/module.generator");
-const service_generator_3 = require("./generators/indices/view/service.generator");
+const service_generator_4 = require("./generators/indices/view/service.generator");
 const admin_page_generator_1 = require("./generators/models/admin.page.generator");
-const importexport_decoder_generator_1 = require("./generators/models/importexport-decoder.generator");
+const encoder_generator_2 = require("./generators/models/export/encoder.generator");
+const decoder_generator_2 = require("./generators/models/import/decoder.generator");
 const react_1 = require("./generators/models/react");
 const repository_generator_1 = require("./generators/models/repository.generator");
 const route_generator_1 = require("./generators/models/route.generator");
 const seed_generator_1 = require("./generators/models/seed.generator");
 const stub_generator_1 = require("./generators/models/stub.generator");
-const types_generator_4 = require("./generators/models/types.generator");
-const service_generator_4 = require("./generators/models/update/service.generator");
-const service_generator_5 = require("./generators/models/view/service.generator");
+const types_generator_5 = require("./generators/models/types.generator");
+const service_generator_5 = require("./generators/models/update/service.generator");
+const service_generator_6 = require("./generators/models/view/service.generator");
 const meta_1 = require("./lib/meta");
 const types_1 = require("./lib/schema/types");
 const client_path_1 = require("./prisma/client-path");
@@ -82,7 +85,8 @@ const CONFIG_SCHEMA = zod_1.z
     pathToDbLib: zod_1.z.string().optional(),
     pathToPlaywright: zod_1.z.string().optional(),
     pathToE2ELib: zod_1.z.string().optional(),
-    pathToImportExport: zod_1.z.string().optional(),
+    pathToImport: zod_1.z.string().optional(),
+    pathToExport: zod_1.z.string().optional(),
     pathToActions: zod_1.z.string().optional(),
     pathToBusinessViewLogic: zod_1.z.string().optional(),
     pathToBusinessUpdateLogic: zod_1.z.string().optional(),
@@ -109,7 +113,8 @@ const CONFIG_SCHEMA = zod_1.z
             playwrightPath: (0, types_1.toPath)(s.pathToPlaywright || './e2e/'),
             dbLibPath: (0, types_1.toPath)(s.pathToDbLib || './backend/libs/db/src/'),
             e2eLibPath: (0, types_1.toPath)(s.pathToE2ELib || './backend/libs/e2e/src/'),
-            importExportPath: (0, types_1.toPath)(s.pathToImportExport || './backend/libs/import-export/src/'),
+            importPath: (0, types_1.toPath)(s.pathToImport || './backend/libs/import/src/'),
+            exportPath: (0, types_1.toPath)(s.pathToExport || './backend/libs/export/src/'),
             actionsPath: (0, types_1.toPath)(s.pathToActions || './backend/libs/actions/src/'),
             businessViewLogicPath: (0, types_1.toPath)(s.pathToBusinessViewLogic || './backend/libs/view/src/'),
             businessUpdateLogicPath: (0, types_1.toPath)(s.pathToBusinessUpdateLogic || './backend/libs/update/src/'),
@@ -166,17 +171,19 @@ function generate(_a) {
         for (const model of models) {
             const meta = (0, meta_1.getModelMetadata)({ model });
             // Types
-            generated.write(`/${meta.types.filePath}.ts`, (0, types_generator_4.generateModelTypes)({ model, meta }));
+            generated.write(`/${meta.types.filePath}.ts`, (0, types_generator_5.generateModelTypes)({ model, meta }));
             // Seed
             generated.write(`/${meta.seed.location.path}.ts`, (0, seed_generator_1.generateSeedModel)({ model, itemCount: 5, meta, models }));
             // Data
             generated.write(`/${meta.data.stubLocation.path}.ts`, (0, stub_generator_1.generateStub)({ model, meta }));
             generated.write(`/${meta.data.repository.location.path}.ts`, (0, repository_generator_1.generateRepository)({ model, meta }));
-            // Import-Export
-            generated.write(`/${meta.importExport.decoder.filePath}.ts`, (0, importexport_decoder_generator_1.generateModelImportExportDecoder)({ model, meta }));
+            // Import
+            generated.write(`/${meta.import.decoder.location.path}.ts`, (0, decoder_generator_2.generateModelImportDecoder)({ model, meta }));
+            // Export
+            generated.write(`/${meta.export.encoder.location.path}.ts`, (0, encoder_generator_2.generateModelExportEncoder)({ model, meta }));
             // Business Logic
-            generated.write(`/${meta.view.serviceLocation.path}.ts`, (0, service_generator_5.generateModelBusinessLogicView)({ model, meta }));
-            generated.write(`/${meta.update.serviceClassLocation.path}.ts`, (0, service_generator_4.generateModelBusinessLogicUpdate)({ model, meta }));
+            generated.write(`/${meta.view.serviceLocation.path}.ts`, (0, service_generator_6.generateModelBusinessLogicView)({ model, meta }));
+            generated.write(`/${meta.update.serviceClassLocation.path}.ts`, (0, service_generator_5.generateModelBusinessLogicUpdate)({ model, meta }));
             // Routes
             generated.write(`/${meta.trpc.routerFilePath}.ts`, (0, route_generator_1.generateRoute)({ model, meta }));
             // React
@@ -199,20 +206,22 @@ function generate(_a) {
         generated.write(`/${meta.data.repository.constFilePath}.ts`, (0, repositories_generator_1.generateRepositoriesArray)({ models, meta }));
         generated.write(`/${meta.data.types.location.path}.ts`, (0, types_generator_2.generateDataTypes)({ models, meta }));
         generated.write(`/${meta.e2e.testIdsFilePath}.ts`, (0, testids_generator_1.generateTestIds)());
-        // Import-Export
-        generated.write(`/${meta.importExport.types.location.path}.ts`, (0, importexport_types_generator_1.generateImportExportTypes)({ models, meta }));
-        generated.write(`/${meta.importExport.exporterClass.location.path}.ts`, (0, importexport_exporter_class_generator_1.generateImportExportExporterClass)({ models, meta }));
-        generated.write(`/${meta.importExport.importService.location.path}.ts`, (0, importexport_import_service_generator_1.generateImportExportImportService)({ models, meta }));
-        generated.write(`/${meta.importExport.decoder.location.path}.ts`, (0, importexport_decoder_generator_1.generateImportExportDecoder)({ models, meta }));
-        generated.write(`/${meta.importExport.converterFunctions.location.path}.ts`, (0, importexport_convert_import_functions_generator_1.generateImportExportConvertImportFunctions)({ models, meta }));
+        // Import
+        generated.write(`/${meta.import.types.location.path}.ts`, (0, types_generator_3.generateImportTypes)({ models, meta }));
+        generated.write(`/${meta.import.importService.location.path}.ts`, (0, service_generator_2.generateImportService)({ models, meta }));
+        generated.write(`/${meta.import.decoder.location.path}.ts`, (0, decoder_generator_1.generateImportDecoder)({ models, meta }));
+        generated.write(`/${meta.import.converterFunctions.location.path}.ts`, (0, convert_functions_generator_1.generateConvertImportFunctions)({ models, meta }));
+        // Export
+        generated.write(`/${meta.export.encoder.location.path}.ts`, (0, encoder_generator_1.generateExportEncoder)({ models, meta }));
+        generated.write(`/${meta.export.exporterClass.location.path}.ts`, (0, class_generator_1.generateExporterClass)({ models, meta }));
         // Actions
         generated.write(`/${meta.actions.dispatcher.classLocation.path}.ts`, (0, dispatcher_service_generator_1.generateActionsDispatcherService)({ models, meta }));
         // View
         generated.write(`/${meta.view.moduleLocation.path}.ts`, (0, module_generator_3.generateBusinessLogicViewModule)({ models, meta }));
-        generated.write(`/${meta.view.serviceLocation.path}.ts`, (0, service_generator_3.generateBusinessLogicViewService)({ models, meta }));
+        generated.write(`/${meta.view.serviceLocation.path}.ts`, (0, service_generator_4.generateBusinessLogicViewService)({ models, meta }));
         // Update
         generated.write(`/${meta.update.moduleLocation.path}.ts`, (0, module_generator_2.generateBusinessLogicUpdateModule)({ models, meta }));
-        generated.write(`/${meta.update.serviceLocation.path}.ts`, (0, service_generator_2.generateBusinessLogicUpdateService)({ models, meta }));
+        generated.write(`/${meta.update.serviceLocation.path}.ts`, (0, service_generator_3.generateBusinessLogicUpdateService)({ models, meta }));
         generated.write(`/${meta.update.actionTypesFilePath}.ts`, (0, actiontypes_generator_1.generateBusinessLogicActionTypes)({ models, meta }));
         // Seed
         generated.write(`/${meta.seedData.initialMigrationLocation.path}.ts`, (0, seed_migration_generator_1.generateSeedMigration)({ models, meta }));
@@ -220,7 +229,7 @@ function generate(_a) {
         // Routes
         generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, routes_generator_1.generateRoutesIndex)({ models, meta }));
         // Types
-        generated.write(`/${meta.types.indexFilePath}.ts`, (0, types_generator_3.generateTypesIndex)({ models, enums, meta }));
+        generated.write(`/${meta.types.indexFilePath}.ts`, (0, types_generator_4.generateTypesIndex)({ models, enums, meta }));
         // -------------------------------------------------------------------------
         // Add disclaimer and format.
         yield generated.transformUTF8Files((path, content) => `${lock_1.GENERATED_FILE_DISCLAIMER}\n${content}`);

package/dist/generators/indices/data/service.generator.js

@@ -21,7 +21,7 @@ function generateDataService({ models, meta }) {
         .join(',\n');
     const initializer = mm.map(({ meta }) => `await this.${meta.data.dataServiceName}.init()`).join('\n');
     const excelExports = mm
-        .map(({ meta }) => `${meta.importExport.tableName}: Array.from((await this.${meta.data.dataServiceName}.getAll()).values()),`)
+        .map(({ meta }) => `${meta.import.tableName}: Array.from((await this.${meta.data.dataServiceName}.getAll()).values()),`)
         .join('\n');
     const isEmptyChecks = mm.map(({ meta }) => `(await this.${meta.data.dataServiceName}.count()) === 0`).join(' &&');
     // Building blocks for bulk mutations

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

@@ -10,7 +10,7 @@ const types_1 = require("../../lib/schema/types");
 function generateActionsDispatcherService({ models, meta }) {
     const imports = imports_1.ImportsGenerator.from(meta.actions.dispatcher.classLocation.path).addImports({
         [meta.seed.serviceLocation.import]: [meta.seed.serviceClassName],
-        [meta.importExport.importService.location.import]: [meta.importExport.importService.name],
+        [meta.import.importService.location.import]: [meta.import.importService.name],
         [meta.update.serviceLocation.import]: [meta.update.serviceClassName],
         [meta.types.importPath]: (0, types_1.toAnnotatedTypeName)(meta.config.userType),
         [meta.backendModules.db.databaseService.location.import]: [meta.backendModules.db.databaseService.name],
@@ -35,12 +35,12 @@ import { Action, ResultOfAction } from './actions.types'
 @Injectable()
 export class ${meta.actions.dispatcher.class} {
   
-  // As SeedModule and ImportExportModule get instantiated after the ActionsModule, we use this hack to avoid a circular dependency:
+  // As SeedModule and ImportModule 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: 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
+  public ${meta.import.importService.sharedName}: ImportService = {} as unknown as any
 
   constructor(
     private readonly updateService: ${meta.update.serviceClassName}, 

package/dist/generators/indices/{import-export/importexport-import-service.generator.d.ts → export/class.generator.d.ts}

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

package/dist/generators/indices/{import-export/importexport-exporter-class.generator.js → export/class.generator.js}

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportExportExporterClass = void 0;
+exports.generateExporterClass = void 0;
 const imports_1 = require("../../../lib/imports");
 const meta_1 = require("../../../lib/meta");
 const types_1 = require("../../../lib/schema/types");
 /**
- * Generates the Exporter class for the Import-Export module
+ * Generates the Exporter class for the Export module
  */
-function generateImportExportExporterClass({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.importExport.exporterClass.location.path);
+function generateExporterClass({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.export.exporterClass.location.path);
     imports.addImports({
         [meta.view.serviceLocation.import]: [meta.view.serviceClassName],
-        [meta.importExport.decoder.location.path]: [
-            meta.importExport.decoder.fullEncoderFunctionName,
-            (0, types_1.toAnnotatedTypeName)(meta.importExport.decoder.encodedExcelDataTypeName),
+        [meta.export.encoder.location.path]: [
+            meta.export.encoder.fullEncoderFunctionName,
+            (0, types_1.toAnnotatedTypeName)(meta.export.encoder.encodedExcelDataTypeName),
         ],
     });
     const typeExports = [];
@@ -28,10 +28,10 @@ function generateImportExportExporterClass({ models, meta }) {
             from: modelMeta.types.importPath,
             items: [modelMeta.types.brandedIdType, modelMeta.types.typeName],
         });
-        typeExports.push(`export type ${modelMeta.importExport.exportDataTypeName} = CapitalizedKeys<${model.name}>`);
-        typeExportsDataEntries.push(`${modelMeta.importExport.exportDataPropertyName}?: ${modelMeta.importExport.exportDataTypeName}[]`);
+        typeExports.push(`export type ${modelMeta.export.exportDataTypeName} = CapitalizedKeys<${model.name}>`);
+        typeExportsDataEntries.push(`${modelMeta.export.exportDataPropertyName}?: ${modelMeta.export.exportDataTypeName}[]`);
         privateMaps.push(`private ${modelMeta.internalPluralName} = new Map<${modelMeta.types.brandedIdType}, ${modelMeta.types.typeName}>()`);
-        exportDataProperties.push(`${modelMeta.importExport.exportDataFullPropertyName}: Array.from(this.${modelMeta.internalPluralName}.values())`);
+        exportDataProperties.push(`${modelMeta.export.exportDataFullPropertyName}: Array.from(this.${modelMeta.internalPluralName}.values())`);
         const linkedItems = [];
         for (const field of model.fields) {
             if (field.kind !== 'relation') {
@@ -39,12 +39,12 @@ function generateImportExportExporterClass({ models, meta }) {
             }
             const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
             if (field.isRequired) {
-                linkedItems.push(`await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})`);
+                linkedItems.push(`await this.${linkedModelMeta.export.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})`);
             }
             else {
                 linkedItems.push(`
           if (item.${field.name}) { 
-            await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})
+            await this.${linkedModelMeta.export.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})
           }`);
             }
         }
@@ -55,7 +55,7 @@ function generateImportExportExporterClass({ models, meta }) {
             childItemCalls.push(`
         // Add all ${linkedModelMeta.userFriendlyNamePlural} that are related to the ${modelMeta.userFriendlyName} via ${referencingField.name}
         for (const ${referencingField.name} of await this.viewService.${linkedModelMeta.view.serviceVariableName}.data.${linkedFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {
-          await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: ${referencingField.name}, includeChildren})
+          await this.${linkedModelMeta.export.exportAddFunctionName}({id: ${referencingField.name}, includeChildren})
         }
         `);
         }
@@ -70,7 +70,7 @@ function generateImportExportExporterClass({ models, meta }) {
         /**
          * Adds a ${modelMeta.userFriendlyName} and all related (and nested) dependencies to the export.
          */
-        public async ${modelMeta.importExport.exportAddFunctionName}(${signature}) {
+        public async ${modelMeta.export.exportAddFunctionName}(${signature}) {
           if (this.${modelMeta.internalPluralName}.has(id)) {
             return
           }
@@ -107,7 +107,7 @@ ${imports.generate()}
  *  - Call the \`exportData()\` method to get the encoded Excel data.
  *  - Alternatively, you can call 'exportAll()' to dump all data. 
  */
-export class ${meta.importExport.exporterClass.name} {
+export class ${meta.export.exporterClass.name} {
   private logger = new Logger(Exporter.name)
 
   ${privateMaps.join('\n  ')}
@@ -117,8 +117,8 @@ export class ${meta.importExport.exporterClass.name} {
   /**
    * Exports all data that was added by prior calls to \`.add{Model}\` functions.
    */
-  public exportData(): ${meta.importExport.decoder.encodedExcelDataTypeName} {
-    return ${meta.importExport.decoder.fullEncoderFunctionName}({
+  public exportData(): ${meta.export.encoder.encodedExcelDataTypeName} {
+    return ${meta.export.encoder.fullEncoderFunctionName}({
       ${exportDataProperties.join(',\n      ')}
     })
   }
@@ -126,7 +126,7 @@ export class ${meta.importExport.exporterClass.name} {
   /**
    * Exports all data.
    */
-  public async exportAll(): Promise<${meta.importExport.decoder.encodedExcelDataTypeName}> {
+  public async exportAll(): Promise<${meta.export.encoder.encodedExcelDataTypeName}> {
     ${addAllCalls.join('\n')}
 
     return this.exportData()
@@ -137,4 +137,4 @@ export class ${meta.importExport.exporterClass.name} {
 
 `;
 }
-exports.generateImportExportExporterClass = generateImportExportExporterClass;
+exports.generateExporterClass = generateExporterClass;

package/dist/generators/indices/{import-export/importexport-exporter-class.generator.d.ts → export/encoder.generator.d.ts}

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

package/dist/generators/indices/export/encoder.generator.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExportEncoder = void 0;
+const imports_1 = require("../../../lib/imports");
+const meta_1 = require("../../../lib/meta");
+const types_1 = require("../../../lib/schema/types");
+/**
+ * Generates the data encoder, aggregating all the models.
+ */
+function generateExportEncoder({ models, meta }) {
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: meta.config });
+    const { encodedExcelDataTypeName, fullEncoderFunctionName } = meta.export.encoder;
+    const imports = imports_1.ImportsGenerator.from(meta.export.encoder.location.path);
+    const { decodedPXLModelDataTypeName } = schemaMeta.import.decoder;
+    imports.addImports({
+        [schemaMeta.import.decoder.location.import]: [decodedPXLModelDataTypeName],
+    });
+    const modelTypes = [];
+    const exportFields = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            from: modelMeta.export.encoder.location.path,
+            items: [
+                modelMeta.export.encoder.arrayEncoderFunctionName,
+                (0, types_1.toAnnotatedTypeName)(modelMeta.export.encoder.encodedExcelType),
+            ],
+        });
+        modelTypes.push(`${modelMeta.export.tableName}?: ${modelMeta.export.encoder.encodedExcelType}[]`);
+        exportFields.push(`${modelMeta.import.tableName}: 
+      data.${modelMeta.export.exportDataFullPropertyName} !== undefined ?
+        ${modelMeta.export.encoder.arrayEncoderFunctionName}(data.${modelMeta.export.exportDataFullPropertyName}) 
+        : undefined`);
+    }
+    return `
+${imports.generate()}
+
+export type ${encodedExcelDataTypeName} = {
+  ${modelTypes.join(',\n')}
+}
+
+/**
+ * Converts the model data to Excel format
+ */
+export const ${fullEncoderFunctionName} = (data: ${decodedPXLModelDataTypeName}): ${encodedExcelDataTypeName} => ({
+  ${exportFields.join(',\n')}
+})
+`;
+}
+exports.generateExportEncoder = generateExportEncoder;

package/dist/generators/indices/{import-export/importexport-convert-import-functions.generator.d.ts → import/convert-functions.generator.d.ts}

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

package/dist/generators/indices/{import-export/importexport-convert-import-functions.generator.js → import/convert-functions.generator.js}

@@ -1,23 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportExportConvertImportFunctions = void 0;
+exports.generateConvertImportFunctions = void 0;
 const imports_1 = require("../../../lib/imports");
 const meta_1 = require("../../../lib/meta");
 const types_1 = require("../../../lib/schema/types");
 const types_2 = require("../../../lib/types");
 /**
- * Generates the Exporter class for the Import-Export module
+ * Generates the Convert function for the Import module
  */
-function generateImportExportConvertImportFunctions({ models, meta, }) {
+function generateConvertImportFunctions({ models, meta }) {
     const { dto } = meta.types;
-    const { importedDataToBulkMutations, deltaToBulkMutations } = meta.importExport.converterFunctions;
-    const { types } = meta.importExport;
+    const { importedDataToBulkMutations, deltaToBulkMutations } = meta.import.converterFunctions;
+    const { types } = meta.import;
     const { delta } = types;
-    const imports = imports_1.ImportsGenerator.from(meta.importExport.converterFunctions.location.path);
+    const imports = imports_1.ImportsGenerator.from(meta.import.converterFunctions.location.path);
     imports.addImports({
-        [meta.importExport.decoder.location.path]: [
-            (0, types_1.toAnnotatedTypeName)(meta.importExport.decoder.decodedPXLModelDataTypeName),
-        ],
+        [meta.import.decoder.location.path]: [(0, types_1.toAnnotatedTypeName)(meta.import.decoder.decodedPXLModelDataTypeName)],
         [meta.data.types.location.import]: [
             (0, types_1.toAnnotatedTypeName)(meta.data.types.bulkMutation),
             (0, types_1.toAnnotatedTypeName)(meta.data.types.bulkMutationForModel),
@@ -60,7 +58,7 @@ export function ${deltaToBulkMutations}(
  *                For sophisticated imports that handle deltas, use \`${deltaToBulkMutations}\` instead!
  */
 export function ${importedDataToBulkMutations}(
-  input: ${meta.importExport.decoder.decodedPXLModelDataTypeName}
+  input: ${meta.import.decoder.decodedPXLModelDataTypeName}
   ): ${meta.data.types.bulkMutation}[] {
   return [${importConverterBlocks.join(',\n')}]
 }
@@ -121,7 +119,7 @@ function deltaModelTo${meta.data.types.bulkMutation}<
 }
 `;
 }
-exports.generateImportExportConvertImportFunctions = generateImportExportConvertImportFunctions;
+exports.generateConvertImportFunctions = generateConvertImportFunctions;
 // Helpful for debugging the complex logic, so should not be removed
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function logState({ iteration, state, nextStep, lastStep, }) {
@@ -355,7 +353,7 @@ function generateModelCreateBlock({ fieldsGrouped, modelMeta, }) {
     return {
         block: /* ts */ `
     ${modelMeta.seed.constantName}: {
-      create: input.${modelMeta.importExport.decoder.decodedModelArrayName}?.map(
+      create: input.${modelMeta.import.decoder.decodedModelArrayName}?.map(
         (item: ${modelMeta.types.dto.create}) => ({
           ${createAssignments.join(',\n')}
         })) 
@@ -370,17 +368,17 @@ function generateDeltaBlock({ fieldsGrouped, modelMeta, schemaMeta, imports, })
         modelMeta,
     });
     const genericsDefinition = `${modelMeta.types.typeName}, ${modelMeta.types.brandedIdType}`;
-    const { type, create, update } = schemaMeta.importExport.types.delta_Model;
+    const { type, create, update } = schemaMeta.import.types.delta_Model;
     imports.addTypeImport({
         from: modelMeta.types.importPath,
         items: [modelMeta.types.typeName, modelMeta.types.brandedIdType],
     });
     imports.addTypeImport({
-        from: schemaMeta.importExport.types.location.path,
+        from: schemaMeta.import.types.location.path,
         items: [type, create.type, update.type],
     });
     imports.addImport({
-        from: schemaMeta.importExport.types.location.path,
+        from: schemaMeta.import.types.location.path,
         items: [create.typeGuard, update.typeGuard],
     });
     return /* ts */ `
@@ -434,7 +432,7 @@ function generateBulkMutationBlockLink({ state, imports, iteration, schemaMeta,
 function generateModelLinkBlocks({ fieldsGrouped, modelMeta, schemaMeta, }) {
     const { model, nullableFieldsForLaterLinking } = fieldsGrouped;
     const genericsDefinition = `${modelMeta.types.typeName}, ${modelMeta.types.brandedIdType}`;
-    const { create, update } = schemaMeta.importExport.types.delta_Model;
+    const { create, update } = schemaMeta.import.types.delta_Model;
     if (nullableFieldsForLaterLinking.size === 0) {
         throw new Error(`Cannot link fields for ${model.name} as it does not have any nullable fields`);
     }
@@ -445,7 +443,7 @@ function generateModelLinkBlocks({ fieldsGrouped, modelMeta, schemaMeta, }) {
     return {
         importConvertBlock: /* ts */ `
       ${modelMeta.seed.constantName}: {
-        update: input.${modelMeta.importExport.decoder.decodedModelArrayName}?.map(
+        update: input.${modelMeta.import.decoder.decodedModelArrayName}?.map(
           (item: ${modelMeta.types.dto.update}) => ({
             id: item.id,
             ${linkFromObject.join(',\n')}

package/dist/generators/indices/import/decoder.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../../lib/meta';
+import { Model } from '../../../lib/schema/schema';
+/**
+ * Generates the data decoder, aggregating all the models.
+ */
+export declare function generateImportDecoder({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/generators/indices/import/decoder.generator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportDecoder = void 0;
+const imports_1 = require("../../../lib/imports");
+const meta_1 = require("../../../lib/meta");
+/**
+ * Generates the data decoder, aggregating all the models.
+ */
+function generateImportDecoder({ models, meta }) {
+    const { decodedPXLModelDataTypeName, fullDecoderName } = meta.import.decoder;
+    const imports = imports_1.ImportsGenerator.from(meta.import.decoder.location.path);
+    const decoderEntries = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            from: modelMeta.import.decoder.location.path,
+            items: [modelMeta.import.decoder.tableDecoder],
+        });
+        decoderEntries.push(`${modelMeta.import.tableName}: ${modelMeta.import.decoder.tableDecoder}.optional()`);
+    }
+    return `
+import * as z from 'zod'
+
+import { uncapitalizeKeys } from '@postxl/runtime'
+
+${imports.generate()}
+
+/**
+ * Decoder that converts Excel data to model data
+ */
+export const ${fullDecoderName} = z
+  .object({
+    ${decoderEntries.join(',\n')}
+  })
+  .transform(uncapitalizeKeys)
+
+export type ${decodedPXLModelDataTypeName} = z.infer<typeof excelDataDecoder>
+`;
+}
+exports.generateImportDecoder = generateImportDecoder;

package/dist/generators/indices/import/service.generator.d.ts

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