@postxl/generator 0.38.2 → 0.40.0

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

@@ -0,0 +1,528 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportExportConvertImportFunctions = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/types");
+/**
+ * Generates the Exporter class for the Import-Export module
+ */
+function generateImportExportConvertImportFunctions({ models, meta, }) {
+    const { dto } = meta.types;
+    const { importedDataToBulkMutations, deltaToBulkMutations } = meta.importExport.converterFunctions;
+    const { types } = meta.importExport;
+    const { delta } = types;
+    const imports = imports_1.ImportsGenerator.from(meta.importExport.converterFunctions.filePath);
+    imports.addImports({
+        [meta.importExport.decoder.fullDecoderFilePath]: [meta.importExport.decoder.decodedPXLModelDataTypeName],
+        [meta.data.importPath]: [
+            meta.data.dataMockDataType,
+            meta.data.types.bulkMutation,
+            meta.data.types.bulkMutationForModel,
+        ],
+        [meta.types.importPath]: [dto.genericModel, dto.idType],
+        [types.filePath]: [types.delta, types.delta_Model.type],
+    });
+    const importConverterBlocks = [];
+    const deltaConverterBlocks = [];
+    let state = initializeModelsState(models);
+    let nextStep = determineNextStep(state);
+    // logState({ state, nextStep, lastStep: 'init' })
+    let iteration = 0;
+    while (nextStep !== 'completed') {
+        iteration++;
+        const { importConvertBlock, deltaConvertBlock, state: stateUpdated, } = generateBlocks({ state, nextStep, imports, iteration, schemaMeta: meta });
+        importConverterBlocks.push(importConvertBlock);
+        deltaConverterBlocks.push(deltaConvertBlock);
+        state = updateModelState(stateUpdated);
+        nextStep = determineNextStep(state);
+        // logState({ state, nextStep, lastStep: 'updateModelState' })
+    }
+    return /* ts */ `
+import { ExhaustiveSwitchCheck } from '@pxl/common'
+${imports.generate()}
+
+/**
+ * Converts ${types.delta} to ${meta.data.types.bulkMutation} steps, taking into account the order of dependencies.
+ * **Important**: It assumes that data has been pre-checked and converted to \`${delta}\`.
+ */
+export function ${deltaToBulkMutations}(
+  input: ${types.delta}
+  ): ${meta.data.types.bulkMutation}[] {
+  return [${deltaConverterBlocks.join(',\n')}]
+}
+
+/**
+ * Converts any models to ${meta.data.types.bulkMutation} steps, taking into account the order of dependencies.
+ * **Important**: It does not check if the items exist, ie. it is meant mainly for seeding.
+ *                For sophisticated imports that handle deltas, use \`${deltaToBulkMutations}\` instead!
+ */
+export function ${importedDataToBulkMutations}(
+  input: ${meta.importExport.decoder.decodedPXLModelDataTypeName}
+  ): ${meta.data.types.bulkMutation}[] {
+  return [${importConverterBlocks.join(',\n')}]
+}
+
+/**
+ * Removes empty arrays from a ${meta.data.types.bulkMutation} object.
+ */
+function _removeBlank${meta.data.types.bulkMutation}<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}>(
+  bulk: ${meta.data.types.bulkMutationForModel}<Model, ID>,
+): ${meta.data.types.bulkMutationForModel}<Model, ID> {
+  const result: ${meta.data.types.bulkMutationForModel}<Model, ID> = {}
+  if (bulk.create && bulk.create.length > 0) { result.create = bulk.create }
+  if (bulk.update && bulk.update.length > 0) { result.update = bulk.update }
+  if (bulk.upsert && bulk.upsert.length > 0) { result.upsert = bulk.upsert }
+  if (bulk.delete && bulk.delete.length > 0) { result.delete = bulk.delete }
+
+  return result
+}
+
+/**
+ * Converts a list of Deltas for a model to a ${meta.data.types.bulkMutation} object.
+ */
+function deltaModelTo${meta.data.types.bulkMutation}<
+  Model extends ${dto.genericModel}<ID>, 
+  ID extends ${dto.idType},
+  ModelErrors
+>(
+  items?: ${types.delta_Model.type}<Model, ID, ModelErrors>[],
+): ${meta.data.types.bulkMutationForModel}<Model, ID> {
+  const result: Required<${meta.data.types.bulkMutationForModel}<Model, ID>> = {
+    create: [],
+    update: [],
+    upsert: [],
+    delete: [],
+  }
+
+  for (const item of items ?? []) {
+    switch (item.type) {
+      case 'create':
+        result.create.push(item.createDTO)
+        break
+      case 'update':
+        result.update.push(item.updateDTO)
+        break
+      case 'delete':
+        result.delete.push(item.input.id)
+        break
+      case 'unchanged':
+        break
+      case 'errors':
+        throw new Error('Cannot convert delta to bulk mutation as it contains errors')
+      default:
+        throw new ExhaustiveSwitchCheck(item)
+    }
+  }
+
+  return _removeBlank${meta.data.types.bulkMutation}(result)
+}
+
+${generateMockDataToBulkFunction({ models, meta })}
+`;
+}
+exports.generateImportExportConvertImportFunctions = generateImportExportConvertImportFunctions;
+// 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, }) {
+    console.log(`
+Iteration: ${iteration++}
+LastStep: ${lastStep}
+Completed: ${[...state.completed.values()].map((model) => model.name).join(', ')}
+CreatedToBeLinked: ${[...state.createdToBeLinked.values()].map((x) => x.model.name).join(', ')}
+CanBeCreatedFullyLinked: ${[...state.canBeCreatedFullyLinked.values()].map((x) => x.model.name).join(', ')}
+CanBeCreatedPartiallyLinked: ${[...state.canBeCreatedPartiallyLinked.values()].map((x) => x.model.name).join(', ')}
+Blocked: ${[...state.blocked.values()].map((x) => x.model.name).join(', ')}
+NextStep: ${nextStep}`);
+}
+/**
+ * Groups the fields of a model into fields that can be created, fields that can be created as null, and fields that block the creation of the model.
+ */
+function groupModelFields({ state, model }) {
+    const result = {
+        model,
+        create: new Set(),
+        nullableFieldsForLaterLinking: new Set(),
+        requiredFieldsBlockingLinking: new Set(),
+        ignoreFields: new Set(),
+    };
+    for (const field of model.fields) {
+        // We ignore createdAt and updatedAt fields as they are set automatically.
+        if (field.attributes.ignore || field.attributes.isCreatedAt || field.attributes.isUpdatedAt) {
+            result.ignoreFields.add(field);
+            continue;
+        }
+        // Non-relations can always be created without extra checks.
+        if (field.kind !== 'relation') {
+            result.create.add(field);
+            continue;
+        }
+        // Related model is already created so we can create the field.
+        if (state.completed.has(field.relationToModel.name) || state.createdToBeLinked.has(field.relationToModel.name)) {
+            result.create.add(field);
+            continue;
+        }
+        // In nullable relation we can set the field to null and link it later.
+        if (!field.isRequired) {
+            result.nullableFieldsForLaterLinking.add(field);
+            continue;
+        }
+        // All other options are exhausted meaning this is a required relation and the related model hasn't been created yet.
+        // We cannot create the field yet so we add it to backlog.
+        result.requiredFieldsBlockingLinking.add(field);
+    }
+    return result;
+}
+/**
+ * Determines the state (created partially linked, or can be created fully linked) of a model based on its fields
+ */
+function determineModelNextStep(fieldsGrouped) {
+    // If we have blocking fields, we cannot create the model yet
+    if (fieldsGrouped.requiredFieldsBlockingLinking.size > 0) {
+        return 'blocked';
+    }
+    // If we have no blocking fields, we can create the model but need to link some fields later
+    if (fieldsGrouped.nullableFieldsForLaterLinking.size > 0) {
+        return 'canBeCreatedPartiallyLinked';
+    }
+    // If no field is blocking and all nullable fields can be linked, we can create the model and link all fields
+    return 'canBeCreatedFullyLinked';
+}
+function assignModelToState({ state, modelNextStep, fieldsGrouped, }) {
+    switch (modelNextStep) {
+        case 'blocked':
+            state.blocked.set(fieldsGrouped.model.name, fieldsGrouped);
+            break;
+        case 'canBeCreatedPartiallyLinked':
+            state.canBeCreatedPartiallyLinked.set(fieldsGrouped.model.name, fieldsGrouped);
+            break;
+        case 'canBeCreatedFullyLinked':
+            state.canBeCreatedFullyLinked.set(fieldsGrouped.model.name, fieldsGrouped);
+            break;
+        default:
+            throw new types_1.ExhaustiveSwitchCheck(modelNextStep);
+    }
+}
+function initializeModelsState(models) {
+    const state = {
+        completed: new Map(),
+        createdToBeLinked: new Map(),
+        canBeCreatedFullyLinked: new Map(),
+        canBeCreatedPartiallyLinked: new Map(),
+        blocked: new Map(),
+    };
+    for (const model of models) {
+        const fieldsGrouped = groupModelFields({ state, model });
+        const modelNextStep = determineModelNextStep(fieldsGrouped);
+        assignModelToState({ state, modelNextStep, fieldsGrouped });
+    }
+    return state;
+}
+/**
+ * Checks if any of the blocked or partially linked models can be created now.
+ */
+function updateModelState(oldState) {
+    const newState = copyModelState(oldState);
+    newState.blocked = new Map();
+    newState.canBeCreatedPartiallyLinked = new Map();
+    // We iterate over all blocked models and check if they can be created now
+    for (const [, fieldsGrouped] of oldState.blocked) {
+        const fieldsGroupedUpdated = groupModelFields({ state: oldState, model: fieldsGrouped.model });
+        const modelNextStep = determineModelNextStep(fieldsGroupedUpdated);
+        assignModelToState({ state: newState, modelNextStep, fieldsGrouped: fieldsGroupedUpdated });
+    }
+    // We iterate over all partially linked models and check if they can be created fully linked now
+    for (const [, fieldsGrouped] of oldState.canBeCreatedPartiallyLinked) {
+        const fieldsGroupedUpdated = groupModelFields({ state: oldState, model: fieldsGrouped.model });
+        const modelNextStep = determineModelNextStep(fieldsGroupedUpdated);
+        assignModelToState({ state: newState, modelNextStep, fieldsGrouped: fieldsGroupedUpdated });
+    }
+    return newState;
+}
+function determineNextStep(modelsState) {
+    // We prioritize models that can be created fully linked, so we do not need unnecessary linking steps later
+    if (modelsState.canBeCreatedFullyLinked.size > 0) {
+        return 'createFullyLinked';
+    }
+    // If no model can be created fully linked, we check if we can create models partially linked
+    if (modelsState.canBeCreatedPartiallyLinked.size > 0) {
+        return 'createPartiallyLinked';
+    }
+    // Lastly, we link all models that require linking
+    if (modelsState.createdToBeLinked.size > 0) {
+        return 'link';
+    }
+    // If we now still have blocked models, we have a circular dependency
+    if (modelsState.blocked.size > 0) {
+        throw new Error(`Cannot create the following models because they have a circular dependency: ${Array.from(modelsState.blocked.values())
+            .map((model) => model.model.name)
+            .join(', ')}`);
+    }
+    // If we have no blocked models, we are done
+    return 'completed';
+}
+function generateBlocks({ state, nextStep, imports, iteration, schemaMeta, }) {
+    switch (nextStep) {
+        case 'createFullyLinked':
+            return generateBulkMutationBlockCreateFullyLinked({ state, imports, iteration, schemaMeta });
+        case 'createPartiallyLinked':
+            return generateBulkMutationBlockCreatePartiallyLinked({ state, imports, iteration, schemaMeta });
+        case 'link':
+            return generateBulkMutationBlockLink({ state, imports, iteration, schemaMeta });
+        default:
+            throw new types_1.ExhaustiveSwitchCheck(nextStep);
+    }
+}
+function copyModelState(state) {
+    return {
+        completed: new Map(state.completed),
+        createdToBeLinked: new Map(state.createdToBeLinked),
+        canBeCreatedFullyLinked: new Map(state.canBeCreatedFullyLinked),
+        canBeCreatedPartiallyLinked: new Map(state.canBeCreatedPartiallyLinked),
+        blocked: new Map(state.blocked),
+    };
+}
+function generateBulkMutationBlockCreateFullyLinked({ state, iteration, imports, schemaMeta, }) {
+    const newState = copyModelState(state);
+    newState.canBeCreatedFullyLinked = new Map();
+    const models = state.canBeCreatedFullyLinked;
+    const importConvertBlocks = [];
+    const deltaConvertBlocks = [];
+    const modelNames = [];
+    for (const [, fieldsGrouped] of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model: fieldsGrouped.model });
+        imports.addImports({
+            [schemaMeta.types.importPath]: [modelMeta.types.dto.create],
+        });
+        const { block: importConvertBlock } = generateModelCreateBlock({ fieldsGrouped, modelMeta });
+        importConvertBlocks.push(importConvertBlock);
+        deltaConvertBlocks.push(`${modelMeta.seed.constantName}: deltaModelTo${schemaMeta.data.types.bulkMutation}(input.${modelMeta.seed.constantName})`);
+        newState.completed.set(fieldsGrouped.model.name, fieldsGrouped.model);
+        modelNames.push(modelMeta.userFriendlyNamePlural);
+    }
+    const importConvertBlock = `
+  // Step ${iteration}: Create fully linked models: ${modelNames.join(', ')}
+  {
+    ${importConvertBlocks.join(',\n')}
+  }`;
+    const deltaConvertBlock = `
+  // Step ${iteration}: Create/update entire entries for: ${modelNames.join(', ')}
+  {
+    ${deltaConvertBlocks.join(',\n')}
+  }`;
+    return { importConvertBlock, deltaConvertBlock, state: newState };
+}
+function generateBulkMutationBlockCreatePartiallyLinked({ state, imports, iteration, schemaMeta, }) {
+    const newState = copyModelState(state);
+    newState.canBeCreatedPartiallyLinked = new Map();
+    const models = state.canBeCreatedPartiallyLinked;
+    const importConvertBlocks = [];
+    const deltaConvertBlocks = [];
+    const modelNames = [];
+    for (const [, fieldsGrouped] of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model: fieldsGrouped.model });
+        imports.addImport({
+            from: modelMeta.types.importPath,
+            items: [modelMeta.types.dto.create],
+        });
+        const { block: importConvertBlock, fieldsToBeLinkedLater } = generateModelCreateBlock({ fieldsGrouped, modelMeta });
+        importConvertBlocks.push(importConvertBlock);
+        const deltaConvertBlock = generateDeltaBlock({ fieldsGrouped, modelMeta, schemaMeta, imports });
+        deltaConvertBlocks.push(deltaConvertBlock);
+        newState.createdToBeLinked.set(fieldsGrouped.model.name, fieldsGrouped);
+        modelNames.push(`${modelMeta.userFriendlyNamePlural} (without ${fieldsToBeLinkedLater.join(', ')})`);
+    }
+    const importConvertBlock = `
+  // Step ${iteration}: Create partially linked models: 
+  // * ${modelNames.join('\n  // * ')}
+  {
+    ${importConvertBlocks.join(',\n')}
+  }`;
+    const deltaConvertBlock = `
+  // Step ${iteration}: Create partially linked models:
+  // * ${modelNames.join('\n  // * ')}
+  {
+    ${deltaConvertBlocks.join(',\n')}
+  }`;
+    return { importConvertBlock, deltaConvertBlock, state: newState };
+}
+function generateModelCreateBlock({ fieldsGrouped, modelMeta, }) {
+    const { createFromObject: createAssignments, fieldsToBeLinkedLater } = generateFieldAssignmentBlocks({
+        fieldsGrouped,
+        modelMeta,
+    });
+    return {
+        block: /* ts */ `
+    ${modelMeta.seed.constantName}: {
+      create: input.${modelMeta.importExport.decoder.decodedModelArrayName}?.map(
+        (item: ${modelMeta.types.dto.create}) => ({
+          ${createAssignments.join(',\n')}
+        })) 
+        ?? []
+      }`,
+        fieldsToBeLinkedLater,
+    };
+}
+function generateDeltaBlock({ fieldsGrouped, modelMeta, schemaMeta, imports, }) {
+    const { createFromDelta: createAssignments, updateFromDelta: updateAssignments } = generateFieldAssignmentBlocks({
+        fieldsGrouped,
+        modelMeta,
+    });
+    const genericsDefinition = `${modelMeta.types.typeName}, ${modelMeta.types.brandedIdType}`;
+    const { type, create, update } = schemaMeta.importExport.types.delta_Model;
+    imports.addImports({
+        [modelMeta.types.importPath]: [modelMeta.types.typeName, modelMeta.types.brandedIdType],
+        [schemaMeta.importExport.types.filePath]: [
+            type,
+            create.type,
+            create.typeGuard,
+            update.type,
+            update.typeGuard,
+            // modelMeta.importExport.delta_Model_Errors,
+        ],
+    });
+    return /* ts */ `
+  ${modelMeta.seed.constantName}: {
+    create:
+      input.${modelMeta.seed.constantName}
+        ?.filter(${create.typeGuard})
+        .map((item: ${create.type}<${genericsDefinition}>) => ({
+          ${createAssignments.join(',\n')}
+        })) ?? [],
+    update:
+      input.${modelMeta.seed.constantName}
+        ?.filter(${update.typeGuard})
+        .map((item: ${update.type}<${genericsDefinition}>) => ({
+          id: item.input.id,
+          ${updateAssignments.join(',\n')},
+        })) ?? [],
+    }`;
+}
+function generateBulkMutationBlockLink({ state, imports, iteration, schemaMeta, }) {
+    const newState = copyModelState(state);
+    newState.createdToBeLinked = new Map();
+    const models = state.createdToBeLinked;
+    const importConvertBlocks = [];
+    const deltaConvertBlocks = [];
+    const modelNames = [];
+    for (const [, fieldsGrouped] of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model: fieldsGrouped.model });
+        imports.addImport({
+            from: modelMeta.types.importPath,
+            items: [modelMeta.types.dto.update],
+        });
+        const { importConvertBlock, deltaConvertBlock } = generateModelLinkBlocks({ fieldsGrouped, modelMeta, schemaMeta });
+        importConvertBlocks.push(importConvertBlock);
+        deltaConvertBlocks.push(deltaConvertBlock);
+        newState.completed.set(fieldsGrouped.model.name, fieldsGrouped.model);
+        modelNames.push(modelMeta.userFriendlyNamePlural);
+    }
+    const importConvertBlock = `
+  // Step ${iteration}: Link models: ${modelNames.join(', ')}
+  {
+    ${importConvertBlocks.join(',\n')}
+  }`;
+    const deltaConvertBlock = `
+  // Step ${iteration}: Link models: ${modelNames.join(', ')}
+  {
+    ${deltaConvertBlocks.join(',\n')}
+  }`;
+    return { importConvertBlock, deltaConvertBlock, state: newState };
+}
+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;
+    if (nullableFieldsForLaterLinking.size === 0) {
+        throw new Error(`Cannot link fields for ${model.name} as it does not have any nullable fields`);
+    }
+    const { linkFromObject, linkFromCreateDTO, linkFromDelta } = generateFieldAssignmentBlocks({
+        fieldsGrouped,
+        modelMeta,
+    });
+    return {
+        importConvertBlock: /* ts */ `
+      ${modelMeta.seed.constantName}: {
+        update: input.${modelMeta.importExport.decoder.decodedModelArrayName}?.map(
+          (item: ${modelMeta.types.dto.update}) => ({
+            id: item.id,
+            ${linkFromObject.join(',\n')}
+          }))
+          ?? []
+      }`,
+        deltaConvertBlock: /* ts */ `
+    ${modelMeta.seed.constantName}: {
+        update: [
+          ...input.${modelMeta.seed.constantName}
+            ?.filter(${create.typeGuard})
+            .map((item: ${create.type}<${genericsDefinition}>) => ({
+              id: item.input.id,
+              ${linkFromCreateDTO.join(',\n')}
+            })) ?? [],
+      
+          ...input.${modelMeta.seed.constantName}
+            ?.filter(${update.typeGuard})
+            .map((item: ${update.type}<${genericsDefinition}>) => ({
+              id: item.input.id,
+              ${linkFromDelta.join(',\n')},
+            })) ?? [],
+          ]
+      }`,
+    };
+}
+function generateFieldAssignmentBlocks({ fieldsGrouped, }) {
+    const { model, create, nullableFieldsForLaterLinking, requiredFieldsBlockingLinking } = fieldsGrouped;
+    if (requiredFieldsBlockingLinking.size > 0) {
+        const _fields = Array.from(requiredFieldsBlockingLinking.values())
+            .map((field) => field.name)
+            .join(', ');
+        throw new Error(`Cannot create model ${model.name} because some required fields don't exist yet: ${_fields}`);
+    }
+    const result = {
+        fieldsToBeLinkedLater: [],
+        createFromObject: [],
+        createFromDelta: [],
+        updateFromDelta: [],
+        linkFromObject: [],
+        linkFromCreateDTO: [],
+        linkFromDelta: [],
+    };
+    for (const field of create) {
+        result.createFromObject.push(`${field.name}: item.${field.name}`);
+        result.createFromDelta.push(`${field.name}: item.input.${field.name}`);
+        if (field.kind !== 'id') {
+            result.updateFromDelta.push(`${field.name}: '${field.name}' in item.delta && item.delta['${field.name}'] ? item.delta['${field.name}'].new : undefined`);
+        }
+    }
+    for (const field of nullableFieldsForLaterLinking) {
+        result.createFromObject.push(`${field.name}: null`);
+        result.createFromDelta.push(`${field.name}: null`);
+        if (field.kind !== 'id') {
+            result.updateFromDelta.push(`${field.name}: '${field.name}' in item.delta  ? null : undefined`);
+        }
+        result.fieldsToBeLinkedLater.push(field.name);
+        result.linkFromObject.push(`${field.name}: item.${field.name}`);
+        result.linkFromCreateDTO.push(`${field.name}: item.input.${field.name}`);
+        result.linkFromDelta.push(`${field.name}: '${field.name}' in item.delta && item.delta['${field.name}'] ? item.delta['${field.name}'].new : undefined`);
+    }
+    return result;
+}
+function generateMockDataToBulkFunction({ models, meta }) {
+    const mockConverters = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        mockConverters.push(`${modelMeta.seed.constantName}: { create: data.${modelMeta.seed.constantName} }`);
+    }
+    return /* ts */ `
+/**
+ * Converts MockData from the DataMocker to ${meta.data.types.bulkMutation}, so it can be
+ * imported during the E2E seed process.
+ */
+export function ${meta.importExport.converterFunctions.mockDataToBulkMutations}(
+  data: ${meta.data.dataMockDataType}
+): ${meta.data.types.bulkMutation} {
+  return {
+    ${mockConverters.join(',\n')}
+  }
+}`;
+}

package/dist/generators/indices/importexport-exporter-class.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 generateImportExportExporterClass({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/generators/indices/importexport-exporter-class.generator.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportExportExporterClass = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates the Exporter class for the Import-Export module
+ */
+function generateImportExportExporterClass({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.importExport.exporterClass.filePath);
+    imports.addImports({
+        [meta.businessLogic.view.importPath]: [meta.businessLogic.view.serviceClassName],
+        [meta.importExport.decoder.fullDecoderFilePath]: [
+            meta.importExport.decoder.fullEncoderFunctionName,
+            meta.importExport.decoder.encodedExcelDataTypeName,
+        ],
+    });
+    const typeExports = [];
+    const typeExportsDataEntries = [];
+    const privateMaps = [];
+    const exportDataProperties = [];
+    const addFunctions = [];
+    const addAllCalls = [];
+    for (const model of models) {
+        const modelMeta = (0, meta_1.getModelMetadata)({ model });
+        imports.addImport({
+            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}[]`);
+        privateMaps.push(`private ${modelMeta.internalPluralName} = new Map<${modelMeta.types.brandedIdType}, ${modelMeta.types.typeName}>()`);
+        exportDataProperties.push(`${modelMeta.importExport.exportDataFullPropertyName}: mapValues(this.${modelMeta.internalPluralName})`);
+        const linkedItems = [];
+        for (const field of model.fields) {
+            if (field.kind !== 'relation') {
+                continue;
+            }
+            const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
+            if (field.isRequired) {
+                linkedItems.push(`await this.${linkedModelMeta.importExport.exportAddFunctionName}(item.${field.name})`);
+            }
+            else {
+                linkedItems.push(`
+          if (item.${field.name}) { 
+            await this.${linkedModelMeta.importExport.exportAddFunctionName}(item.${field.name}) 
+          }`);
+            }
+        }
+        addFunctions.push(`
+        /**
+         * Adds a ${modelMeta.userFriendlyName} and all related (and nested) dependencies to the export.
+         */
+        public async ${modelMeta.importExport.exportAddFunctionName}(id: ${model.brandedIdType}) {
+          if (this.${modelMeta.internalPluralName}.has(id)) {
+            return
+          }
+          const item = await this.viewService.${modelMeta.businessLogic.view.serviceVariableName}.get(id)
+          if (!item) {
+            this.logger.error(\`Cannot find ${modelMeta.userFriendlyName} \${id}\`)
+            return
+          }
+          this.${modelMeta.internalPluralName}.set(id, item)
+      
+          ${linkedItems.join('\n')}
+        }
+      `);
+        addAllCalls.push(`this.${modelMeta.internalPluralName} = await this.viewService.${modelMeta.businessLogic.view.serviceVariableName}.getAll()`);
+    }
+    return /* ts */ `
+import { Logger } from '@nestjs/common'
+
+import { mapValues } from '@pxl/common'
+${imports.generate()}
+
+/**
+ * Exporter helps to export data items and all their (nested) dependencies to Excel format.
+ * 
+ * Usage:
+ *  - Create an instance of the Exporter
+ *  - Call the \`add{ModelName}(itemId)\` methods to add the items you want to export.
+ *      This will automatically add all dependencies of the item.
+ *  - 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} {
+  private logger = new Logger(Exporter.name)
+
+  ${privateMaps.join('\n  ')}
+
+  constructor(private readonly viewService: ViewService) {}
+
+  /**
+   * Exports all data that was added by prior calls to \`.add{Model}\` functions.
+   */
+  public exportData(): ${meta.importExport.decoder.encodedExcelDataTypeName} {
+    return ${meta.importExport.decoder.fullEncoderFunctionName}({
+      ${exportDataProperties.join(',\n      ')}
+    })
+  }
+
+  /**
+   * Exports all data.
+   */
+  public async exportAll(): Promise<${meta.importExport.decoder.encodedExcelDataTypeName}> {
+    ${addAllCalls.join('\n')}
+
+    return this.exportData()
+  }
+
+  ${addFunctions.join('\n\n')}
+}
+
+`;
+}
+exports.generateImportExportExporterClass = generateImportExportExporterClass;

package/dist/generators/indices/importexport-import-service.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 generateImportExportImportService({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;