@postxl/generator 0.74.1 → 1.0.1

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

@@ -1,50 +0,0 @@
-"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/convert-functions.generator.d.ts

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

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

@@ -1,509 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 Convert function for the Import module
- */
-function generateConvertImportFunctions({ models, meta }) {
-    const { dto } = meta.types;
-    const { importedDataToBulkMutations, deltaToBulkMutations } = meta.import.converterFunctions;
-    const { types } = meta.import;
-    const { delta } = types;
-    const imports = imports_1.ImportsGenerator.from(meta.import.converterFunctions.location.path);
-    imports.addImports({
-        [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),
-        ],
-        [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(dto.genericModel), (0, types_1.toAnnotatedTypeName)(dto.idType)],
-        [types.location.path]: [(0, types_1.toAnnotatedTypeName)(types.delta), (0, types_1.toAnnotatedTypeName)(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 '@postxl/runtime'
-${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.import.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)
-}
-`;
-}
-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, }) {
-    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_2.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_2.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.addTypeImport({
-            from: schemaMeta.types.importPath,
-            items: [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.addTypeImport({
-            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.import.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.import.types.delta_Model;
-    imports.addTypeImport({
-        from: modelMeta.types.importPath,
-        items: [modelMeta.types.typeName, modelMeta.types.brandedIdType],
-    });
-    imports.addTypeImport({
-        from: schemaMeta.import.types.location.path,
-        items: [type, create.type, update.type],
-    });
-    imports.addImport({
-        from: schemaMeta.import.types.location.path,
-        items: [create.typeGuard, update.typeGuard],
-    });
-    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.addTypeImport({
-            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.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`);
-    }
-    const { linkFromObject, linkFromCreateDTO, linkFromDelta } = generateFieldAssignmentBlocks({
-        fieldsGrouped,
-        modelMeta,
-    });
-    return {
-        importConvertBlock: /* ts */ `
-      ${modelMeta.seed.constantName}: {
-        update: input.${modelMeta.import.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;
-}

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

@@ -1,9 +0,0 @@
-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

@@ -1,40 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-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;