@postxl/generator 0.60.7 → 0.61.0

package/dist/generators/indices/importexport-import-service.generator.js

@@ -9,27 +9,29 @@ const string_1 = require("../../lib/utils/string");
  * Generates the Exporter class for the Import-Export module
  */
 function generateImportExportImportService({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.importExport.importService.filePath);
+    const imports = imports_1.ImportsGenerator.from(meta.importExport.importService.location.path);
     const { types, decoder, converterFunctions } = meta.importExport;
     const { delta_Fields, delta, delta_Model } = types;
     const { create, errors, unchanged, update } = delta_Model;
     const { nonUnique, invalidReference, invalidType, isRequiredDependency, missingField } = errors;
     const { dto } = meta.types;
     imports.addImports({
-        [meta.data.importPath]: [meta.data.dataService.class, (0, types_1.toAnnotatedTypeName)(meta.data.types.bulkMutation)],
+        [meta.data.dataService.location.import]: [meta.data.dataService.class],
+        [meta.data.types.location.import]: [(0, types_1.toAnnotatedTypeName)(meta.data.types.bulkMutation)],
         [meta.types.importPath]: [
             (0, types_1.toAnnotatedTypeName)(dto.genericModel),
             (0, types_1.toAnnotatedTypeName)(dto.idType),
             (0, types_1.toAnnotatedTypeName)(dto.update),
         ],
-        [meta.actions.importPath]: [meta.actions.execution.interface, meta.actions.dispatcher.class],
-        [types.filePath]: [
+        [meta.actions.execution.interfaceLocation.import]: [meta.actions.execution.interface],
+        [meta.actions.dispatcher.classLocation.import]: [meta.actions.dispatcher.class],
+        [types.location.path]: [
             (0, types_1.toAnnotatedTypeName)(delta_Fields),
             (0, types_1.toAnnotatedTypeName)(delta_Model.type),
             (0, types_1.toAnnotatedTypeName)(delta),
         ],
-        [decoder.fullDecoderFilePath]: [(0, types_1.toAnnotatedTypeName)(decoder.decodedPXLModelDataTypeName)],
-        [converterFunctions.filePath]: [converterFunctions.deltaToBulkMutations],
+        [decoder.location.path]: [(0, types_1.toAnnotatedTypeName)(decoder.decodedPXLModelDataTypeName)],
+        [converterFunctions.location.path]: [converterFunctions.deltaToBulkMutations],
     });
     const resultAssignments = [];
     const detectDeltaFunctions = [];
@@ -448,7 +450,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
     const { types } = schemaMeta.importExport;
     const { delta_Model } = types;
     imports.addTypeImport({
-        from: types.filePath,
+        from: types.location.path,
         items: [modelMeta.importExport.delta_Model_Errors],
     });
     const returnType = `${delta_Model.type}<${model.typeName}, ${modelMeta.types.brandedIdType}, ${modelMeta.importExport.delta_Model_Errors}>[]`;
@@ -470,7 +472,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
         if (field.kind === 'scalar') {
             if (field.isUnique) {
                 imports.addTypeImport({
-                    from: schemaMeta.importExport.types.filePath,
+                    from: schemaMeta.importExport.types.location.path,
                     items: [delta_Model.errors.nonUnique.type],
                 });
                 const getByName = `getBy${(0, string_1.toPascalCase)(fieldName)}`;
@@ -482,7 +484,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
             }
             if (field.validation && field.validation.type === 'int') {
                 imports.addTypeImport({
-                    from: schemaMeta.importExport.types.filePath,
+                    from: schemaMeta.importExport.types.location.path,
                     items: [delta_Model.errors.invalidType.type],
                 });
                 sharedValidations.push(`this.validateInt({item, fieldName: '${fieldName}'})`);
@@ -491,7 +493,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
         else if (field.kind === 'relation') {
             const relatedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
             imports.addTypeImport({
-                from: schemaMeta.importExport.types.filePath,
+                from: schemaMeta.importExport.types.location.path,
                 items: [delta_Model.errors.invalidReference.type],
             });
             sharedValidations.push(`this.validateReferenceField({
@@ -514,7 +516,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
                 continue;
             }
             imports.addTypeImport({
-                from: schemaMeta.importExport.types.filePath,
+                from: schemaMeta.importExport.types.location.path,
                 items: [delta_Model.errors.isRequiredDependency.type],
             });
             const relatedModelMeta = (0, meta_1.getModelMetadata)({ model: relatedModel });
@@ -532,7 +534,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
     }
     if (requiredFields.length > 0) {
         imports.addTypeImport({
-            from: schemaMeta.importExport.types.filePath,
+            from: schemaMeta.importExport.types.location.path,
             items: [delta_Model.errors.missingField.type],
         });
     }

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

@@ -8,7 +8,7 @@ const meta_1 = require("../../lib/meta");
  */
 function generateImportExportTypes({ models, meta }) {
     const { types } = meta.importExport;
-    const imports = imports_1.ImportsGenerator.from(types.filePath);
+    const imports = imports_1.ImportsGenerator.from(types.location.path);
     const dto = meta.types.dto;
     imports
         .addTypeImport({
@@ -16,7 +16,7 @@ function generateImportExportTypes({ models, meta }) {
         items: [dto.create, dto.update, dto.genericModel, dto.idType],
     })
         .addTypeImport({
-        from: meta.data.importPath,
+        from: meta.data.types.location.import,
         items: [meta.data.types.bulkMutation],
     });
     const deltaTypes = [];

package/dist/generators/indices/repositories.generator.d.ts

@@ -1,12 +1,5 @@
 import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
-/**
- * Generates an index file that exports all repository stubs.
- */
-export declare function generateRepositoriesIndex({ models, meta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;
 /**
  * Generates a an array that contains all the repositories.
  */

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

@@ -1,22 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRepositoriesArray = exports.generateRepositoriesIndex = void 0;
-const exports_1 = require("../../lib/exports");
+exports.generateRepositoriesArray = void 0;
 const imports_1 = require("../../lib/imports");
 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.repository.indexFilePath);
-    for (const model of models) {
-        const meta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(meta.data.repository.filePath);
-    }
-    exports.exportEverythingFromPath(meta.data.repository.constFilePath);
-    return exports.generate();
-}
-exports.generateRepositoriesIndex = generateRepositoriesIndex;
 /**
  * Generates a an array that contains all the repositories.
  */
@@ -26,7 +12,7 @@ function generateRepositoriesArray({ models, meta }) {
     for (const { meta } of mm) {
         imports.addImport({
             items: [meta.data.repository.className],
-            from: meta.data.repository.filePath,
+            from: meta.data.repository.location.path,
         });
     }
     return /* ts */ `  

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

@@ -8,14 +8,16 @@ const types_1 = require("../../lib/schema/types");
  * Generates the initial migration based on the generated seed data.
  */
 function generateSeedMigration({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.seedData.initialMigrationFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.seedData.initialMigrationLocation.path);
     const modelTypes = [];
     for (const model of models) {
         const modelMeta = (0, meta_1.getModelMetadata)({ model });
         imports.addImports({
-            [modelMeta.seed.filePath]: [modelMeta.seed.constantName],
-            [meta.importExport.importPath]: [meta.importExport.converterFunctions.importedDataToBulkMutations],
-            [meta.seed.importPath]: [(0, types_1.toTypeName)('Action_Seed_Data')],
+            [modelMeta.seed.location.path]: [modelMeta.seed.constantName],
+            [meta.importExport.converterFunctions.location.import]: [
+                meta.importExport.converterFunctions.importedDataToBulkMutations,
+            ],
+            [meta.seed.actionsLocation.import]: [(0, types_1.toTypeName)('Action_Seed_Data')],
         });
         modelTypes.push(`${modelMeta.seed.constantName}`);
     }

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

@@ -10,18 +10,19 @@ const types_1 = require("../../lib/schema/types");
 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.dataService.class,
-            (0, types_1.toAnnotatedTypeName)(schemaMeta.data.dataMockDataType),
+        [schemaMeta.actions.execution.classLocation.import]: [(0, types_1.toClassName)('ActionExecutionFactory')],
+        [schemaMeta.data.dataService.location.import]: [schemaMeta.data.dataService.class],
+        [schemaMeta.backendModules.db.databaseService.location.import]: [schemaMeta.backendModules.db.databaseService.name],
+        [schemaMeta.data.mockModule.location.import]: [(0, types_1.toAnnotatedTypeName)(schemaMeta.data.dataMockDataType)],
+        [schemaMeta.importExport.converterFunctions.location.import]: [
+            schemaMeta.importExport.converterFunctions.mockDataToBulkMutations,
         ],
-        [schemaMeta.importExport.importPath]: [schemaMeta.importExport.converterFunctions.mockDataToBulkMutations],
     });
     const reInitCalls = [];
     const modelMetas = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
     for (const { model, meta } of modelMetas) {
         if (model.defaultField) {
-            imports.addImport({ items: [meta.data.stubGenerationFnName], from: meta.data.importPath });
+            imports.addImport({ items: [meta.data.stubGenerationFnName], from: meta.data.stubLocation.import });
             const stubDefault = `${meta.data.stubGenerationFnName}({ ${model.defaultField.name}: true })`;
             reInitCalls.push(`await this.dataService.${meta.data.dataServiceName}.reInit({ items: mockData.${meta.seed.constantName}?.create ?? [${stubDefault}], execution: actionExecution })`);
         }
@@ -32,7 +33,6 @@ function generateTestDataService({ models, meta: schemaMeta, }) {
     return /* ts */ `
 import { Injectable, Logger } from '@nestjs/common'
 
-import { DatabaseService } from '@backend/db'
 ${imports.generate()}
 
 @Injectable()

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

@@ -42,35 +42,36 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         typeName: meta.types.typeName,
         brandedId: model.brandedIdType,
         decoders: {
-            name: meta.businessLogic.update.decoders.name,
+            name: meta.update.decoders.name,
             createType: `Create${meta.internalSingularNameCapitalized}`,
             updateType: `Update${meta.internalSingularNameCapitalized}`,
             upsertType: `Upsert${meta.internalSingularNameCapitalized}`,
             cloneType: `Clone${meta.internalSingularNameCapitalized}`,
         },
         cloneContext: {
-            type: schemaMeta.businessLogic.update.cloneContextType,
-            createMethod: schemaMeta.businessLogic.update.cloneContextCreateMethod,
-            map: meta.businessLogic.update.cloneContextMap,
+            type: schemaMeta.update.cloneContextType,
+            createMethod: schemaMeta.update.cloneContextCreateMethod,
+            map: meta.update.cloneContextMap,
         },
     };
-    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.serviceFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.update.serviceClassLocation.path);
     imports.addImports({
-        [meta.data.importPath]: meta.data.repository.className,
+        [meta.data.repository.location.import]: meta.data.repository.className,
         [meta.types.importPath]: [
             Types.toAnnotatedTypeName(m.brandedId),
             Types.toAnnotatedTypeName(m.typeName),
             meta.types.toBrandedIdTypeFnName,
             Types.toFunctionName(`omitId`),
         ],
-        [meta.businessLogic.view.serviceFilePath]: [meta.businessLogic.view.serviceClassName],
-        [schemaMeta.actions.importPath]: [schemaMeta.actions.execution.interface, schemaMeta.actions.dispatcher.definition],
-        [schemaMeta.businessLogic.update.serviceFilePath]: schemaMeta.businessLogic.update.serviceClassName,
-        [schemaMeta.businessLogic.update.cloneContextFilePath]: [
-            schemaMeta.businessLogic.update.cloneContextType,
-            schemaMeta.businessLogic.update.cloneContextCreateMethod,
+        [meta.view.serviceLocation.import]: [meta.view.serviceClassName],
+        [schemaMeta.actions.execution.interfaceLocation.import]: [schemaMeta.actions.execution.interface],
+        [schemaMeta.actions.dispatcher.definitionLocation.import]: [schemaMeta.actions.dispatcher.definition],
+        [schemaMeta.update.serviceLocation.path]: schemaMeta.update.serviceClassName,
+        [schemaMeta.update.cloneContextFilePath]: [
+            schemaMeta.update.cloneContextType,
+            schemaMeta.update.cloneContextCreateMethod,
         ],
-        [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
+        [schemaMeta.view.serviceLocation.import]: schemaMeta.view.serviceClassName,
     });
     for (const relation of (0, fields_1.getRelationFields)(model)) {
         // NOTE: We add branded id type and type name imports only for foreign models.
@@ -91,14 +92,14 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
      * (e.g. when we generate business logic service for Aggregation, the AggregationRepository
      * would be referenced using `this.data` variable).
      */
-    const modelRepositoryVariableName = meta.businessLogic.dataRepositoryVariableName;
+    const modelRepositoryVariableName = meta.view.dataRepositoryVariableName;
     const constructorParameters = [
         `private readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
-        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.update.serviceClassName})) private readonly updateService: ${schemaMeta.businessLogic.update.serviceClassName}`,
-        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly viewService: ${schemaMeta.businessLogic.view.serviceClassName}`,
+        `@Inject(forwardRef(() => ${schemaMeta.update.serviceClassName})) private readonly updateService: ${schemaMeta.update.serviceClassName}`,
+        `@Inject(forwardRef(() => ${schemaMeta.view.serviceClassName})) private readonly viewService: ${schemaMeta.view.serviceClassName}`,
     ];
-    const decoders = meta.businessLogic.update.decoders;
-    const { view, update } = meta.businessLogic;
+    const decoders = meta.update.decoders;
+    const { view, update } = meta;
     /* prettier-ignore */
     return /* ts */ `
     import { Inject, Injectable, forwardRef } from '@nestjs/common'
@@ -281,8 +282,8 @@ function generateDeleteFunction({ model, meta, m }) {
         backReferenceNames.push(`${refModelMeta.userFriendlyNamePlural}.${referencingField.name}`);
         backReferenceDelete.push(`
       // ${referencingModel.name}.${referencingField.name}
-      const ${ids} = await this.viewService.${refModelMeta.businessLogic.view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(data)
-      await this.updateService.${refModelMeta.businessLogic.update.serviceVariableName}.deleteMany({ data: ${ids}, execution })
+      const ${ids} = await this.viewService.${refModelMeta.view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(data)
+      await this.updateService.${refModelMeta.update.serviceVariableName}.deleteMany({ data: ${ids}, execution })
     `);
     }
     return `
@@ -310,11 +311,11 @@ function generateDeleteManyMethod({ model, meta, m }) {
         idAssignments.push(`
       {
         // ${referencingModel.name}.${referencingField.name}
-        const _ids = await this.viewService.${refModelMeta.businessLogic.view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(id)
+        const _ids = await this.viewService.${refModelMeta.view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(id)
         ${idArray}.push(..._ids)
       }
       `);
-        deleteCalls.push(`await this.updateService.${refModelMeta.businessLogic.update.serviceVariableName}.deleteMany({ data: ${idArray}, execution })`);
+        deleteCalls.push(`await this.updateService.${refModelMeta.update.serviceVariableName}.deleteMany({ data: ${idArray}, execution })`);
     }
     let relatedEntities = '';
     if (model.references.length > 0) {
@@ -356,7 +357,7 @@ function generateCloneMethod({ model, meta, m }) {
         const refModelMeta = (0, meta_1.getModelMetadata)({ model: referencingModel });
         const refFieldMeta = (0, meta_1.getFieldMetadata)({ field: referencingField });
         backReferenceNames.push(`${refModelMeta.userFriendlyNamePlural}.${referencingField.name}`);
-        const { view, update } = refModelMeta.businessLogic;
+        const { view, update } = refModelMeta;
         backReferenceCloning.push(`
       // ${referencingModel.name}.${referencingField.name}
       for (const childId of await this.viewService.${view.serviceVariableName}.data.${refFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {

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

@@ -14,19 +14,18 @@ const jsdoc_1 = require("../../lib/utils/jsdoc");
  */
 function generateModelBusinessLogicView({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.view.serviceFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.view.serviceLocation.path);
     imports.addImports({
-        [meta.data.importPath]: meta.data.repository.className,
+        [meta.data.repository.location.import]: meta.data.repository.className,
         [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(model.brandedIdType), (0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
-        [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
-        [meta.data.importPath]: [meta.data.repository.className],
+        [schemaMeta.view.serviceLocation.path]: schemaMeta.view.serviceClassName,
     });
     /**
      * The name of the variable that holds the repository instance for the current model
      * (e.g. when we generate business logic service for Aggregation, the AggregationRepository
      * would be referenced using `this.data` variable).
      */
-    const modelRepositoryVariableName = meta.businessLogic.dataRepositoryVariableName;
+    const modelRepositoryVariableName = meta.view.dataRepositoryVariableName;
     /**
      * The name of the variable that holds the central business logic service instance.
      * Instead of injecting a repository instance for each model, we inject this single instance
@@ -35,7 +34,7 @@ function generateModelBusinessLogicView({ model, meta }) {
     const viewServiceClassName = 'viewService';
     const constructorParameters = [
         `public readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
-        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
+        `@Inject(forwardRef(() => ${schemaMeta.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.view.serviceClassName}`,
     ];
     /**
      * Variable names and their definitions indexed by the name of the relation they represent.
@@ -44,7 +43,7 @@ function generateModelBusinessLogicView({ model, meta }) {
     for (const relation of (0, fields_1.getRelationFields)(model)) {
         const refModel = relation.relationToModel;
         const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
-        const variableGetter = `await this.${viewServiceClassName}.${refMeta.businessLogic.view.serviceVariableName}.get(itemRaw.${relation.name})`;
+        const variableGetter = `await this.${viewServiceClassName}.${refMeta.view.serviceVariableName}.get(itemRaw.${relation.name})`;
         const variablePresenceCheck = `
       if (!${relation.relationFieldName}) {
         throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
@@ -122,7 +121,7 @@ ${imports.generate()}
 ${hasLinkedItems ? linkedTypeDefinition : ''}
 
 @Injectable()
-export class ${meta.businessLogic.view.serviceClassName} {
+export class ${meta.view.serviceClassName} {
   constructor(${constructorParameters.join(',\n')}) {}
 
   /**
@@ -154,7 +153,7 @@ export class ${meta.businessLogic.view.serviceClassName} {
     sort?: { field: keyof ${model.typeName}; ascending: boolean }
     cursor?: { startRow: number; endRow: number }
   }) {
-    const items = await this.data.getAllAsArray()
+    const items = await this.${modelRepositoryVariableName}.getAllAsArray()
     const filtered = !filter
       ? items
       : items.filter((item) => filterFn(item, filter.field, filter.operator, filter.value))

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

@@ -15,10 +15,3 @@ 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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportExportDecoderIndex = exports.generateImportExportDecoder = exports.generateModelImportExportDecoder = void 0;
-const exports_1 = require("../../lib/exports");
+exports.generateImportExportDecoder = exports.generateModelImportExportDecoder = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const types_1 = require("../../lib/schema/types");
@@ -192,7 +191,7 @@ dbTypeName, nullable, imports, schemaMeta, }) {
  */
 function generateImportExportDecoder({ models, meta }) {
     const { decodedPXLModelDataTypeName, encodedExcelDataTypeName, fullDecoderName, fullEncoderFunctionName } = meta.importExport.decoder;
-    const imports = imports_1.ImportsGenerator.from(meta.importExport.decoder.fullDecoderFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.importExport.decoder.location.path);
     imports.addImports({
         [meta.backendModules.common.importPath]: (0, types_1.toFunctionName)('uncapitalizeKeys'),
     });
@@ -244,16 +243,3 @@ export const ${fullEncoderFunctionName} = (data: ${decodedPXLModelDataTypeName})
 `;
 }
 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;

package/dist/generators/models/repository.generator.js

@@ -15,7 +15,7 @@ const string_1 = require("../../lib/utils/string");
 function generateRepository({ model, meta }) {
     const { idField } = model;
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    const imports = imports_1.ImportsGenerator.from(meta.data.repository.filePath).addImports({
+    const imports = imports_1.ImportsGenerator.from(meta.data.repository.location.path).addImports({
         [schemaMeta.data.repository.typeFilePath]: (0, types_1.toAnnotatedTypeName)(schemaMeta.data.repository.typeName),
         [meta.types.importPath]: [
             (0, types_1.toAnnotatedTypeName)(model.typeName),
@@ -25,7 +25,7 @@ function generateRepository({ model, meta }) {
             (0, types_1.toAnnotatedTypeName)(meta.types.dto.update),
             (0, types_1.toAnnotatedTypeName)(meta.types.dto.upsert),
         ],
-        [schemaMeta.actions.importPath]: [schemaMeta.actions.execution.interface],
+        [schemaMeta.actions.execution.interfaceLocation.import]: [schemaMeta.actions.execution.interface],
     });
     // NOTE: We first generate different parts of the code responsible for a particular task
     //   and then we combine them into the final code block.
@@ -218,7 +218,7 @@ exports.generateRepository = generateRepository;
  */
 function generateMockRepository({ model: modelSource, meta: metaSource, }) {
     // We re-use the repository block, but we change the meta data to use the mock repository name and the model to be in memory only
-    const meta = Object.assign(Object.assign({}, metaSource), { data: Object.assign(Object.assign({}, metaSource.data), { repository: Object.assign(Object.assign({}, metaSource.data.repository), { className: metaSource.data.mockRepository.className, filePath: metaSource.data.mockRepository.filePath }) }) });
+    const meta = Object.assign(Object.assign({}, metaSource), { data: Object.assign(Object.assign({}, metaSource.data), { repository: Object.assign(Object.assign({}, metaSource.data.repository), { className: metaSource.data.mockRepository.className, location: metaSource.data.mockRepository.location }) }) });
     const model = Object.assign(Object.assign({}, modelSource), { attributes: Object.assign(Object.assign({}, modelSource.attributes), { inMemoryOnly: true }) });
     return generateRepository({ model, meta });
 }
@@ -465,10 +465,8 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, schemaMeta, import
     const { idField } = model;
     imports.addImports({
         [meta.types.importPath]: [meta.types.zodDecoderFnNames.fromDatabase],
-        [schemaMeta.backendModules.db.importPath]: [
-            schemaMeta.backendModules.db.databaseService.name,
-            (0, types_1.toAnnotatedTypeName)((0, types_1.toTypeName)(`${model.sourceName} as DbType`)),
-        ],
+        [schemaMeta.backendModules.db.databaseService.location.import]: [schemaMeta.backendModules.db.databaseService.name],
+        [schemaMeta.backendModules.db.typesImportPath]: [(0, types_1.toAnnotatedTypeName)((0, types_1.toTypeName)(`${model.sourceName} as DbType`))],
         [schemaMeta.backendModules.common.importPath]: [
             schemaMeta.backendModules.common.functions.format,
             schemaMeta.backendModules.common.functions.pluralize,

package/dist/generators/models/route.generator.js

@@ -8,18 +8,18 @@ const types_1 = require("../../lib/schema/types");
  */
 function generateRoute({ model, meta }) {
     const { idField, defaultField } = model;
-    const { scopeName, dataRepositoryVariableName } = meta.businessLogic;
+    const { scopeName, dataRepositoryVariableName } = meta.update;
     const defaultValueMethod = `
     getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.${dataRepositoryVariableName}.defaultValue),
   `;
-    const decoders = meta.businessLogic.update.decoders;
+    const decoders = meta.update.decoders;
     const imports = imports_1.ImportsGenerator.from(meta.trpc.routerFilePath).addImports({
         [meta.types.importPath]: [
             (0, types_1.toAnnotatedTypeName)(model.typeName),
             meta.types.toBrandedIdTypeFnName,
             meta.types.zodDecoderFnNames.id,
         ],
-        [meta.businessLogic.update.importPath]: [decoders.name],
+        [meta.update.serviceClassLocation.import]: [decoders.name],
     });
     return /* ts */ `
 import { z } from 'zod'

package/dist/generators/models/seed.generator.js

@@ -21,7 +21,7 @@ function generateSeedModel({ model, itemCount, meta, models, }) {
     for (const model of models) {
         modelMap.set(model.name, model);
     }
-    const imports = imports_1.ImportsGenerator.from(meta.seed.filePath).addImport({
+    const imports = imports_1.ImportsGenerator.from(meta.seed.location.path).addImport({
         items: [(0, types_1.toAnnotatedTypeName)(model.typeName), meta.types.toBrandedIdTypeFnName],
         from: meta.types.importPath,
     });
@@ -268,7 +268,7 @@ function generateSeeds({ models, config, }) {
     for (const { meta } of models) {
         imports.addImport({
             items: [meta.seed.constantName],
-            from: meta.seed.filePath,
+            from: meta.seed.location.path,
         });
     }
     const seeds = models.map(({ meta }) => `${meta.seed.constantName}`).join(',\n');

package/dist/generators/models/stub.generator.js

@@ -10,7 +10,7 @@ const types_1 = require("../../lib/types");
  */
 function generateStub({ model, meta }) {
     const { fields, idField } = model;
-    const imports = imports_1.ImportsGenerator.from(meta.data.stubFilePath)
+    const imports = imports_1.ImportsGenerator.from(meta.data.stubLocation.path)
         .addImport({
         items: [meta.types.toBrandedIdTypeFnName],
         from: meta.types.importPath,