@postxl/generator 0.39.0 → 0.40.0

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

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportExportTypes = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates types for import export module.
+ */
+function generateImportExportTypes({ models, meta }) {
+    const { types } = meta.importExport;
+    const imports = imports_1.ImportsGenerator.from(types.filePath);
+    const dto = meta.types.dto;
+    imports.addImports({
+        [meta.types.importPath]: [dto.create, dto.update, dto.genericModel, dto.idType],
+        [meta.data.importPath]: [meta.data.types.bulkMutation],
+    });
+    const deltaTypes = [];
+    const errorTypes = [];
+    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,
+        });
+        const missingFields = [];
+        const invalidReferenceFieldErrors = [];
+        const nonUniqueFieldErrors = [];
+        const invalidTypeFieldErrors = [];
+        const isRequiredDependencyErrors = [];
+        // Prepare field specific error types
+        for (const field of model.fields) {
+            if (field.attributes.ignore || field.kind === 'id') {
+                continue;
+            }
+            if (field.isRequired) {
+                missingFields.push(`"${field.name}"`);
+            }
+            if (field.kind === 'relation') {
+                invalidReferenceFieldErrors.push(`
+          ${types.delta_Model.errors.invalidReference.type}<"${field.relationToModel.name}", "${field.name}", ${field.relationToModel.brandedIdType}>
+        `);
+            }
+            if (field.kind === 'scalar' && field.isUnique) {
+                nonUniqueFieldErrors.push(`
+          ${types.delta_Model.errors.nonUnique.type}<"${field.name}", ${field.tsTypeName}>
+        `);
+            }
+            if (field.kind === 'scalar' && field.validation) {
+                invalidTypeFieldErrors.push(`
+          ${types.delta_Model.errors.invalidType.type}<"${field.name}", "${field.schemaType}", ${field.tsTypeName}>
+        `);
+            }
+        }
+        // Prepare isRequiredDependency errors
+        for (const relatedModel of models) {
+            if (relatedModel.name === model.name) {
+                continue;
+            }
+            for (const relatedField of relatedModel.fields) {
+                if (relatedField.kind !== 'relation' ||
+                    relatedField.relationToModel.name !== model.name ||
+                    !relatedField.isRequired) {
+                    continue;
+                }
+                isRequiredDependencyErrors.push(`
+        ${types.delta_Model.errors.isRequiredDependency.type}<
+            '${relatedModel.name}',
+            '${relatedField.name}',
+            ${relatedModel.typeName},
+            ${relatedModel.brandedIdType}
+          >
+        `);
+            }
+        }
+        const missingFieldError = missingFields.length > 0
+            ? `${types.delta_Model.errors.missingField.type}<${missingFields.join(' | ')}> `
+            : undefined;
+        const modelErrorTypes = [
+            missingFieldError,
+            ...invalidReferenceFieldErrors,
+            ...nonUniqueFieldErrors,
+            ...invalidTypeFieldErrors,
+            ...isRequiredDependencyErrors,
+        ].filter((t) => t !== undefined);
+        if (modelErrorTypes.length === 0) {
+            modelErrorTypes.push(`never`);
+        }
+        errorTypes.push(`export type ${modelMeta.importExport.delta_Model_Errors} = ${modelErrorTypes.join('\n| ')}`);
+        deltaTypes.push(`${modelMeta.seed.constantName}?: ${types.delta_Model.type}<
+        ${modelMeta.types.typeName}, 
+        ${modelMeta.types.brandedIdType},
+        ${modelMeta.importExport.delta_Model_Errors}
+      >[]`);
+    }
+    return /* ts */ `
+${imports.generate()}
+
+/**
+ * Generic type that contains all changes between an existing item and an updated item.
+ */
+export type ${types.delta_Fields}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = Partial<{
+  [K in keyof Omit<Model, 'id'>]?: { old: Model[K]; new: Model[K] }
+}>
+
+/**
+ * For a given imported item of a model, this type contains the determined action to take - create, update, delete or unchanged.
+ */
+export type ${types.delta_Model.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}, ModelErrors> =
+  | ${types.delta_Model.unchanged.type}<Model, ID>
+  | ${types.delta_Model.create.type}<Model, ID>
+  | ${types.delta_Model.update.type}<Model, ID>
+  | ${types.delta_Model.delete.type}<Model, ID>
+  | ${types.delta_Model.errors.type}<Model, ID, ModelErrors>
+
+export type ${types.delta_Model.unchanged.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = {
+  type: '${types.delta_Model.unchanged.discriminant}'
+  input: Model
+}
+
+export function ${types.delta_Model.unchanged.typeGuard}<Model extends ${dto.genericModel}<ID>, ID extends IDType>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.unchanged.type}<Model, ID> {
+  return delta.type === 'unchanged'
+}
+
+export type ${types.delta_Model.create.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = {
+  type: '${types.delta_Model.create.discriminant}'
+  input: Model
+  createDTO: ${dto.create}<Model, ID>
+}
+
+export function ${types.delta_Model.create.typeGuard}<Model extends ${dto.genericModel}<ID>, ID extends IDType>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.create.type}<Model, ID> {
+  return delta.type === 'create'
+}
+
+export type ${types.delta_Model.update.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = {
+  type: '${types.delta_Model.update.discriminant}'
+  input: Model
+  updateDTO: ${dto.update}<Model, ID>
+  delta: ${types.delta_Fields}<Model, ID>
+}
+
+export function ${types.delta_Model.update.typeGuard}<Model extends ${dto.genericModel}<ID>, ID extends IDType>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.update.type}<Model, ID> {
+  return delta.type === 'update'
+}
+
+export type ${types.delta_Model.delete.type}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}> = {
+  type: '${types.delta_Model.delete.discriminant}'
+  input: Model
+}
+
+export function ${types.delta_Model.delete.typeGuard}<Model extends ${dto.genericModel}<ID>, ID extends IDType>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.delete.type}<Model, ID> {
+  return delta.type === 'delete'
+}
+
+export type ${types.delta_Model.errors.type}<Model extends GenericModel<ID>, ID extends IDType, ModelErrors> = {
+  type: '${types.delta_Model.errors.discriminant}'
+  input: Model
+  errors: ModelErrors[]
+}
+
+export function ${types.delta_Model.errors.typeGuard}<Model extends GenericModel<ID>, ID extends IDType, ModelErrors>(
+  delta: Delta_Model<Model, ID, unknown>,
+): delta is ${types.delta_Model.errors.type}<Model, ID, ModelErrors> {
+  return delta.type === 'errors'
+}
+
+export type ${types.delta_Model.errors.missingField.type}<FieldName extends string> = {
+  error: '${types.delta_Model.errors.missingField.discriminant}'
+  fieldName: FieldName
+}
+
+export type ${types.delta_Model.errors.invalidReference.type}<
+  RelatedModel extends string, FieldName extends string, Value
+  > = {
+  error: '${types.delta_Model.errors.invalidReference.discriminant}'
+  relatedModel: RelatedModel
+  fieldName: FieldName
+  value: Value
+}
+
+export type ${types.delta_Model.errors.nonUnique.type}<FieldName extends string, Value> = {
+  error: '${types.delta_Model.errors.nonUnique.discriminant}'
+  fieldName: FieldName
+  value: Value
+}
+
+export type ${types.delta_Model.errors.invalidType.type}<FieldName extends string, TypeName extends string, Value> = {
+  error: '${types.delta_Model.errors.invalidType.discriminant}'
+  fieldName: FieldName
+  typeExpected: TypeName
+  value: Value
+}
+
+export type ${types.delta_Model.errors.isRequiredDependency.type}<
+    RelatedModelName extends string,
+    RelatedField extends string,
+    RelatedModel extends GenericModel<ID>,
+   ID extends IDType
+  > = { 
+  error: '${types.delta_Model.errors.isRequiredDependency.discriminant}'
+  relatedModel: RelatedModelName
+  relatedField: RelatedField
+  relatedItems: RelatedModel[]
+}
+
+${errorTypes.join('\n')}
+
+/**
+ * The delta of for all models.
+ */
+export type ${types.delta} = {
+  ${deltaTypes.join('\n')}
+}
+
+export type DataChanges = {
+  /**
+   * The delta of all models.
+   */
+  delta: ${types.delta}
+
+  /**
+   * The bulk mutations derived from the delta.
+   */
+  bulkMutations: ${meta.data.types.bulkMutation}[]
+}`;
+}
+exports.generateImportExportTypes = generateImportExportTypes;

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

@@ -8,12 +8,12 @@ const meta_1 = require("../../lib/meta");
  * Generates an index file that exports all repository stubs.
  */
 function generateRepositoriesIndex({ models, meta }) {
-    const exports = exports_1.ExportsGenerator.from(meta.data.repositoriesIndexFilePath);
+    const exports = exports_1.ExportsGenerator.from(meta.data.repository.indexFilePath);
     for (const model of models) {
         const meta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(meta.data.repoFilePath);
+        exports.exportEverythingFromPath(meta.data.repository.filePath);
     }
-    exports.exportEverythingFromPath(meta.data.repositoriesConstFilePath);
+    exports.exportEverythingFromPath(meta.data.repository.constFilePath);
     return exports.generate();
 }
 exports.generateRepositoriesIndex = generateRepositoriesIndex;
@@ -22,18 +22,18 @@ exports.generateRepositoriesIndex = generateRepositoriesIndex;
  */
 function generateRepositoriesArray({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.data.repositoriesConstFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.data.repository.constFilePath);
     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,
         });
     }
     return /* ts */ `  
     ${imports.generate()}
 
     export const repositories = [${models
-        .map((model) => (0, meta_1.getModelMetadata)({ model }).data.repositoryClassName)
+        .map((model) => (0, meta_1.getModelMetadata)({ model }).data.repository.className)
         .join(', ')}]`;
 }
 exports.generateRepositoriesArray = generateRepositoriesArray;

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

@@ -62,7 +62,7 @@ function initializeWorkbook() {
 function addModel({ model, meta, wb }) {
     const ws = wb.addWorksheet(model.name);
     const table = ws.addTable({
-        name: meta.seed.excel.tableName,
+        name: meta.importExport.tableName,
         ref: 'A1',
         headerRow: true,
         totalsRow: false,

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

@@ -11,8 +11,9 @@ function generateTestDataService({ models, meta: schemaMeta, }) {
     const imports = imports_1.ImportsGenerator.from(schemaMeta.data.testDataServiceFilePath);
     imports.addImports({
         [schemaMeta.actions.importPath]: [(0, types_1.toClassName)('ActionExecutionFactory')],
-        [schemaMeta.data.importPath]: [schemaMeta.data.dataServiceClassName, schemaMeta.data.dataMockDataType],
-        [schemaMeta.seed.importPath]: [(0, types_1.toClassName)('createActionSeedData'), schemaMeta.seed.mockDataToCreateFunction],
+        [schemaMeta.data.importPath]: [schemaMeta.data.dataService.class, schemaMeta.data.dataMockDataType],
+        [schemaMeta.importExport.importPath]: [schemaMeta.importExport.converterFunctions.mockDataToBulkMutations],
+        [schemaMeta.seed.importPath]: [(0, types_1.toClassName)('createActionSeedData')],
     });
     const reInitCalls = [];
     const modelMetas = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
@@ -38,7 +39,7 @@ export class TestDataService {
 
   constructor(
     private db: DbService,
-    private dataService: ${schemaMeta.data.dataServiceClassName},
+    private dataService: ${schemaMeta.data.dataService.class},
     private actionExecutionFactory: ActionExecutionFactory,
   ) {}
 
@@ -48,7 +49,7 @@ export class TestDataService {
     // We need to init the user repository first so the root user is created
     await this.dataService.users.init()
 
-    const mockData = ${schemaMeta.seed.mockDataToCreateFunction}(data)
+    const mockData = ${schemaMeta.importExport.converterFunctions.mockDataToBulkMutations}(data)
     const action = createActionSeedData({ name: 'E2E', order: 0, data: [] })
     const actionExecution = await this.actionExecutionFactory.create({
       action,

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

@@ -13,12 +13,12 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.serviceFilePath);
     imports.addImports({
-        [meta.data.importPath]: meta.data.repositoryClassName,
-        [schemaMeta.actions.importPath]: schemaMeta.actions.actionExecutionInterface,
+        [meta.data.importPath]: meta.data.repository.className,
+        [schemaMeta.actions.importPath]: schemaMeta.actions.actionExecution.interface,
         [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
         [schemaMeta.businessLogic.update.serviceFilePath]: schemaMeta.businessLogic.update.serviceClassName,
         [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
-        [meta.data.importPath]: [meta.data.repositoryClassName],
+        [meta.data.importPath]: [meta.data.repository.className],
     });
     /**
      * The name of the variable that holds the repository instance for the current model
@@ -36,7 +36,7 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     const actionBlocks = generateActionsBuildingBlocks({ model, meta });
     imports.addImport({ from: meta.types.importPath, items: actionBlocks.importTypes });
     const constructorParameters = [
-        `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
+        `public readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.update.serviceClassName})) private readonly ${updateServiceClassName}: ${schemaMeta.businessLogic.update.serviceClassName}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
@@ -145,7 +145,7 @@ function generateActionsBuildingBlocks({ model, meta }) {
         dispatcher: `
       public async dispatch<A extends Action_${meta.businessLogic.update.actionNameModelPart}>({ action, execution }: {
         action: A; 
-        execution: ${schemaMeta.actions.actionExecutionInterface} 
+        execution: ${schemaMeta.actions.actionExecution.interface} 
       }) {
         switch (action.type) {
           ${dispatcher.join('\n')}

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

@@ -13,10 +13,10 @@ function generateModelBusinessLogicView({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.view.serviceFilePath);
     imports.addImports({
-        [meta.data.importPath]: meta.data.repositoryClassName,
+        [meta.data.importPath]: meta.data.repository.className,
         [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
         [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
-        [meta.data.importPath]: [meta.data.repositoryClassName],
+        [meta.data.importPath]: [meta.data.repository.className],
     });
     /**
      * The name of the variable that holds the repository instance for the current model
@@ -31,7 +31,7 @@ function generateModelBusinessLogicView({ model, meta }) {
      */
     const viewServiceClassName = 'viewService';
     const constructorParameters = [
-        `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
+        `public readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
     /**

package/dist/generators/models/importexport-decoder.generator.d.ts

@@ -0,0 +1,23 @@
+import { ModelMetaData, SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Creates a decoder for the Seed Excel template.
+ */
+export declare function generateModelImportExportDecoder({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;
+/**
+ * Generates the data decoder, aggregating all the models.
+ */
+export declare function generateImportExportDecoder({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;
+/**
+ * Generates the index file for all the routes.
+ */
+export declare function generateImportExportDecoderIndex({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/generators/models/importexport-decoder.generator.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportExportDecoderIndex = exports.generateImportExportDecoder = exports.generateModelImportExportDecoder = void 0;
+const exports_1 = require("../../lib/exports");
+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");
+// TODO: Remove hardcoded path that seems to be reused in multiple places!
+const PXL_COMMON = (0, types_1.toPath)('@pxl/common');
+/**
+ * Creates a decoder for the Seed Excel template.
+ */
+function generateModelImportExportDecoder({ model, meta }) {
+    const { filePath: decoderFilePath, itemEncoderFunctionName: rowExportFunctionName, encodedExcelType: excelType, arrayEncoderFunctionName: tableExportFunctionName, tableDecoder: tableImportDecoder, } = meta.importExport.decoder;
+    const imports = imports_1.ImportsGenerator.from(decoderFilePath);
+    imports.addImports({
+        [PXL_COMMON]: [
+            (0, types_1.toFunctionName)('uncapitalizeKeys'),
+            (0, types_1.toFunctionName)('capitalizeKeys'),
+            (0, types_1.toFunctionName)('nullOrBlankDecoder'),
+        ],
+        [meta.types.importPath]: [meta.types.typeName],
+    });
+    const { userFriendlyName: userFriendly, userFriendlyNamePlural: userFriendlyPlural, internalSingularName: singular, internalSingularNameCapitalized: singularCapitalized, } = meta;
+    const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, imports });
+    return `
+import * as z from 'zod'
+${imports.generate()}
+
+/**
+* The decoder for an Excel row containing a ${userFriendly} entry
+*/
+const ${singular}ExcelRowImportDecoderInput = z.object({
+  ${fieldDecoders.join(',\n')}
+})
+
+
+/**
+ * The type for rows in the ${userFriendly} table
+ */
+export type ${excelType} = z.infer<typeof ${singular}ExcelRowImportDecoderInput>
+
+const ${singular}ExcelRowImportDecoder = ${singular}ExcelRowImportDecoderInput.transform(uncapitalizeKeys)
+
+/**
+ * The decoder to identify blank rows in the ${userFriendly} table
+ */
+const blank${singularCapitalized}ExcelRowImportDecoderInput = z
+  .object({
+    ${blankFieldDecoders.join(',\n')}
+  })
+  .transform(() => undefined)
+
+/**
+ * The decoder for an Excel table that contains ${userFriendly} entries
+ */
+export const ${tableImportDecoder} = z
+  .array(${singular}ExcelRowImportDecoder.or(blank${singularCapitalized}ExcelRowImportDecoderInput))
+  .transform((items) => items.filter(Boolean) as ${model.typeName}[])
+
+/**
+ * Converts a ${userFriendly} to an Excel row
+ */
+export const ${rowExportFunctionName} = (item: ${model.typeName}): ${excelType} => capitalizeKeys(item)
+
+/**
+ * Converts a list of ${userFriendlyPlural} to an Excel table
+ */
+export const ${tableExportFunctionName} = (items: ${model.typeName}[]): ${excelType}[] => items.map(${rowExportFunctionName})
+  `;
+}
+exports.generateModelImportExportDecoder = generateModelImportExportDecoder;
+function generateFieldDecoders({ model, meta, imports, }) {
+    const fieldDecoders = [];
+    const blankFieldDecoders = [];
+    for (const field of model.fields) {
+        const fieldMeta = (0, meta_1.getFieldMetadata)({ field });
+        blankFieldDecoders.push(`${fieldMeta.excelColumnName}: nullOrBlankDecoder`);
+        switch (field.kind) {
+            case 'id': {
+                imports.addImport({ items: [meta.types.toBrandedIdTypeFnName], from: meta.types.importPath });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    tsTypeName: field.unbrandedTypeName,
+                    dbTypeName: field.schemaType,
+                    nullable: false,
+                    imports,
+                })}.transform((id: ${field.unbrandedTypeName}) => ${meta.types.toBrandedIdTypeFnName}(id))`);
+                break;
+            }
+            case 'scalar': {
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    tsTypeName: field.tsTypeName,
+                    dbTypeName: field.schemaType,
+                    nullable: !field.isRequired,
+                    imports,
+                })}`);
+                break;
+            }
+            case 'relation': {
+                const refModel = field.relationToModel;
+                const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
+                imports.addImport({ items: [refMeta.types.toBrandedIdTypeFnName], from: refMeta.types.importPath });
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: ${toExcelDecoder({
+                    tsTypeName: field.unbrandedTypeName,
+                    dbTypeName: field.schemaType,
+                    nullable: !field.isRequired,
+                    imports,
+                })}
+          .transform(
+            (id: ${field.unbrandedTypeName}${field.isRequired ? '' : '| null'}) => 
+              ${field.isRequired ? '' : ' id === null ? null : '}${refMeta.types.toBrandedIdTypeFnName}(id)
+          )`);
+                break;
+            }
+            case 'enum': {
+                fieldDecoders.push(`${fieldMeta.excelColumnName}: z.enum([
+            ${field.enumerator.values.map((v) => `'${v}'`).join(', ')}
+          ])${field.isRequired ? '' : '.nullable()'}`);
+                break;
+            }
+            default: {
+                throw new types_2.ExhaustiveSwitchCheck(field);
+            }
+        }
+    }
+    return { fieldDecoders, blankFieldDecoders };
+}
+function toExcelDecoder({ tsTypeName, dbTypeName: typeName, nullable, imports, }) {
+    switch (tsTypeName) {
+        case 'string': {
+            const decoder = (0, types_1.toFunctionName)(nullable ? 'excelStringNullableDecoder' : 'excelStringDecoder');
+            imports.addImport({
+                items: [decoder],
+                from: PXL_COMMON,
+            });
+            return decoder;
+        }
+        case 'boolean':
+            imports.addImport({
+                items: [(0, types_1.toFunctionName)('excelBooleanDecoder')],
+                from: PXL_COMMON,
+            });
+            return 'excelBooleanDecoder';
+        case 'number':
+            switch (typeName) {
+                case 'Int':
+                case 'BigInt':
+                    return `z.number().int()${nullable ? '.nullable()' : ''}`;
+                default:
+                    return `z.number()${nullable ? '.nullable()' : ''}`;
+            }
+        case 'Date': {
+            const decoder = (0, types_1.toFunctionName)(nullable ? 'excelDateNullableDecoder' : 'excelDateDecoder');
+            imports.addImport({
+                items: [decoder],
+                from: PXL_COMMON,
+            });
+            return decoder;
+        }
+        default:
+            throw new Error('Unknown type');
+    }
+}
+/**
+ * Generates the data decoder, aggregating all the models.
+ */
+function generateImportExportDecoder({ models, meta }) {
+    const { decodedPXLModelDataTypeName, encodedExcelDataTypeName, fullDecoderName, fullEncoderFunctionName } = meta.importExport.decoder;
+    const imports = imports_1.ImportsGenerator.from(meta.importExport.decoder.fullDecoderFilePath);
+    imports.addImports({
+        [PXL_COMMON]: (0, types_1.toFunctionName)('uncapitalizeKeys'),
+    });
+    const importTypes = [];
+    const decoderEntries = [];
+    const exportFields = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            from: modelMeta.importExport.decoder.filePath,
+            items: [
+                modelMeta.importExport.decoder.tableDecoder,
+                modelMeta.importExport.decoder.arrayEncoderFunctionName,
+                modelMeta.importExport.decoder.encodedExcelType,
+            ],
+        });
+        importTypes.push(`${modelMeta.importExport.tableName}?: ${modelMeta.importExport.decoder.encodedExcelType}[]`);
+        decoderEntries.push(`${modelMeta.importExport.tableName}: ${modelMeta.importExport.decoder.tableDecoder}.optional()`);
+        exportFields.push(`${modelMeta.importExport.tableName}: 
+      data.${modelMeta.importExport.exportDataFullPropertyName} !== undefined ?
+        ${modelMeta.importExport.decoder.arrayEncoderFunctionName}(data.${modelMeta.importExport.exportDataFullPropertyName}) 
+        : undefined`);
+    }
+    return `
+import * as z from 'zod'
+${imports.generate()}
+
+export type ${encodedExcelDataTypeName} = {
+  ${importTypes.join(',\n')}
+}
+
+/**
+ * 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>
+
+/**
+ * Converts the model data to Excel format
+ */
+export const ${fullEncoderFunctionName} = (data: ${decodedPXLModelDataTypeName}): ${encodedExcelDataTypeName} => ({
+  ${exportFields.join(',\n')}
+})
+`;
+}
+exports.generateImportExportDecoder = generateImportExportDecoder;
+/**
+ * Generates the index file for all the routes.
+ */
+function generateImportExportDecoderIndex({ models, meta }) {
+    const exports = exports_1.ExportsGenerator.from(meta.importExport.decoder.indexFilePath);
+    exports.exportEverythingFromPath(meta.importExport.decoder.fullDecoderFilePath);
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        exports.exportEverythingFromPath(modelMeta.importExport.decoder.filePath);
+    }
+    return exports.generate();
+}
+exports.generateImportExportDecoderIndex = generateImportExportDecoderIndex;