@postxl/generator 0.54.0 → 0.56.0

package/dist/generator.js

@@ -221,7 +221,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         generated.write(`/${meta.importExport.decoder.fullDecoderFilePath}.ts`, (0, importexport_decoder_generator_1.generateImportExportDecoder)({ models, meta }));
         generated.write(`/${meta.importExport.converterFunctions.filePath}.ts`, (0, importexport_convert_import_functions_generator_1.generateImportExportConvertImportFunctions)({ models, meta }));
         // Actions
-        generated.write(`/${meta.actions.dispatcherService.filePath}.ts`, (0, dispatcher_service_generator_1.generateActionsDispatcherService)({ models, meta }));
+        generated.write(`/${meta.actions.dispatcher.filePath}.ts`, (0, dispatcher_service_generator_1.generateActionsDispatcherService)({ models, meta }));
         // Business Logic
         generated.write(`/${meta.businessLogic.view.indexFilePath}.ts`, (0, businesslogic_view_index_generator_1.generateBusinessLogicViewIndex)({ models, meta }));
         generated.write(`/${meta.businessLogic.view.moduleFilePath}.ts`, (0, businesslogic_view_module_generator_1.generateBusinessLogicViewModule)({ models, meta }));

package/dist/generators/indices/businesslogic-actiontypes.generator.js

@@ -3,27 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateBusinessLogicActionTypes = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/schema/types");
+const file_1 = require("../../lib/utils/file");
 /**
  * Generates the action types for the BusinessLogicModule.
  */
 function generateBusinessLogicActionTypes({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.actionTypesFilePath);
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.actionTypesFilePath).addImport({
+        from: meta.actions.importPath,
+        items: [(0, types_1.toTypeName)('ActionDefPayload'), (0, types_1.toTypeName)('ActionDefResult')],
+    });
+    const updateServiceImports = [];
     const modelNameTypeElements = [];
     const actionsTypeElements = [];
     const actionResultTypeElements = [];
     for (const model of models) {
         const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        imports.addImport({
-            items: [modelMeta.businessLogic.update.actionName, modelMeta.businessLogic.update.actionResultName],
-            from: modelMeta.businessLogic.update.serviceFilePath,
+        const className = modelMeta.businessLogic.update.serviceClassName;
+        const scope = modelMeta.businessLogic.update.actionModelDiscriminantName;
+        modelNameTypeElements.push(`'${scope}'`);
+        const relativeImportPath = (0, file_1.getRelativePath)({
+            from: meta.businessLogic.update.actionTypesFilePath,
+            to: modelMeta.businessLogic.update.serviceFilePath,
         });
-        modelNameTypeElements.push(`'${modelMeta.businessLogic.update.actionModelDiscriminantName}'`);
-        actionsTypeElements.push(modelMeta.businessLogic.update.actionName);
-        actionResultTypeElements.push(`${modelMeta.businessLogic.update.actionModelDiscriminantName}: ${modelMeta.businessLogic.update.actionResultName}`);
+        updateServiceImports.push(`import type * as ${className} from '${relativeImportPath}'`);
+        actionsTypeElements.push(`ActionDefPayload<${className}.Scope, ${className}.Actions>`);
+        actionResultTypeElements.push(`${scope}: ActionDefResult<${className}.Actions>`);
     }
     return /* ts */ `
 ${imports.generate()}
 
+${updateServiceImports.join('\n')}
+
 /**
 * Used by any of the default actions (create, update, delete) to identify the model.
 */

package/dist/generators/indices/businesslogic-update-index.generator.js

@@ -13,7 +13,9 @@ function generateBusinessLogicUpdateIndex({ models, meta }) {
     exports.exportEverythingFromPath(meta.businessLogic.update.actionTypesFilePath);
     for (const model of models) {
         const meta = (0, meta_1.getModelMetadata)({ model });
-        exports.exportEverythingFromPath(meta.businessLogic.update.serviceFilePath);
+        exports.exportSelectionFromPath(meta.businessLogic.update.serviceFilePath, [
+            meta.businessLogic.update.serviceClassName,
+        ]);
     }
     return exports.generate();
 }

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

@@ -8,7 +8,7 @@ const types_1 = require("../../lib/schema/types");
  * Generates the action dispatcher service.
  */
 function generateActionsDispatcherService({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.actions.dispatcherService.filePath).addImports({
+    const imports = imports_1.ImportsGenerator.from(meta.actions.dispatcher.filePath).addImports({
         [meta.seed.importPath]: [meta.seed.serviceClassName],
         [meta.importExport.importPath]: [meta.importExport.importService.name],
         [meta.businessLogic.update.importPath]: [meta.businessLogic.update.serviceClassName],
@@ -32,7 +32,7 @@ import { Action, ResultOfAction } from './actions.types'
 
 
 @Injectable()
-export class ${meta.actions.dispatcherService.class} {
+export class ${meta.actions.dispatcher.class} {
   
   // As SeedModule and ImportExportModule get instantiated after the ActionsModule, we use this hack to avoid a circular dependency:
   // we set the seedService and the importService to value and then overwrite it in the services' constructors.

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

@@ -9,6 +9,7 @@ const types_1 = require("../../lib/schema/types");
  */
 function generateImportExportExporterClass({ models, meta }) {
     const imports = imports_1.ImportsGenerator.from(meta.importExport.exporterClass.filePath);
+    const modelsMap = new Map(models.map((model) => [model.name, model]));
     imports.addImports({
         [meta.businessLogic.view.importPath]: [meta.businessLogic.view.serviceClassName],
         [meta.importExport.decoder.fullDecoderFilePath]: [
@@ -39,20 +40,50 @@ function generateImportExportExporterClass({ models, meta }) {
             }
             const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
             if (field.isRequired) {
-                linkedItems.push(`await this.${linkedModelMeta.importExport.exportAddFunctionName}(item.${field.name})`);
+                linkedItems.push(`await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})`);
             }
             else {
                 linkedItems.push(`
           if (item.${field.name}) { 
-            await this.${linkedModelMeta.importExport.exportAddFunctionName}(item.${field.name}) 
+            await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})
           }`);
             }
         }
+        const childItemCalls = [];
+        for (const relatedModelCore of model.relatedModels) {
+            const relatedModel = modelsMap.get(relatedModelCore.name);
+            // This should not happen as the related models are always present
+            if (!relatedModel) {
+                continue;
+            }
+            for (const field of relatedModel.fields) {
+                if (field.kind !== 'relation') {
+                    continue;
+                }
+                if (field.relationToModel.name !== model.name) {
+                    continue;
+                }
+                const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: relatedModel });
+                const linkedFieldMeta = (0, meta_1.getFieldMetadata)({ field: field });
+                childItemCalls.push(`
+          // Add all ${linkedModelMeta.userFriendlyNamePlural} that are related to the ${modelMeta.userFriendlyName} via ${field.name}
+          for (const ${field.name} of await this.viewService.${linkedModelMeta.businessLogic.view.serviceVariableName}.data.${linkedFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {
+            await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: ${field.name}, includeChildren})
+          }`);
+            }
+        }
+        const childItems = childItemCalls.length > 0
+            ? `
+          if (includeChildren) {
+            ${childItemCalls.join('\n')}
+          }`
+            : '';
+        const signature = `{id, includeChildren = true}: {id: ${model.brandedIdType}, includeChildren?: boolean}`;
         addFunctions.push(`
         /**
          * Adds a ${modelMeta.userFriendlyName} and all related (and nested) dependencies to the export.
          */
-        public async ${modelMeta.importExport.exportAddFunctionName}(id: ${model.brandedIdType}) {
+        public async ${modelMeta.importExport.exportAddFunctionName}(${signature}) {
           if (this.${modelMeta.internalPluralName}.has(id)) {
             return
           }
@@ -64,11 +95,17 @@ function generateImportExportExporterClass({ models, meta }) {
           this.${modelMeta.internalPluralName}.set(id, item)
       
           ${linkedItems.join('\n')}
+
+          ${childItems}
         }
       `);
         addAllCalls.push(`this.${modelMeta.internalPluralName} = await this.viewService.${modelMeta.businessLogic.view.serviceVariableName}.getAll()`);
     }
     return /* ts */ `
+// For consistency, we include \`{ includeChildren = true }\` in the signature of every add function.
+// If the model does not have any related models, the \`includeChildren\` parameter is ignored.
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
 import { Logger } from '@nestjs/common'
 
 import { mapValues } from '@backend/common'
@@ -79,7 +116,7 @@ ${imports.generate()}
  * 
  * Usage:
  *  - Create an instance of the Exporter
- *  - Call the \`add{ModelName}(itemId)\` methods to add the items you want to export.
+ *  - Call the \`add{ModelName}({id})\` 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. 

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

@@ -22,7 +22,7 @@ function generateImportExportImportService({ models, meta }) {
             (0, types_1.toAnnotatedTypeName)(dto.idType),
             (0, types_1.toAnnotatedTypeName)(dto.update),
         ],
-        [meta.actions.importPath]: [meta.actions.actionExecution.interface, meta.actions.dispatcherService.class],
+        [meta.actions.importPath]: [meta.actions.actionExecution.interface, meta.actions.dispatcher.class],
         [types.filePath]: [
             (0, types_1.toAnnotatedTypeName)(delta_Fields),
             (0, types_1.toAnnotatedTypeName)(delta_Model.type),
@@ -61,7 +61,7 @@ type Delta_Result<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType
 export class ${meta.importExport.importService.name} {
   constructor(
     private readonly data: ${meta.data.dataService.class},
-    private readonly dispatcher: ${meta.actions.dispatcherService.class},
+    private readonly dispatcher: ${meta.actions.dispatcher.class},
   ) {
     // We have a circular dependency between DispatcherService and ${meta.importExport.importService.name}. 
     // In order to avoid trouble, instead of using Nest's forwardRef(), we inject the dispatcher service here

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSeedMigration = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
+const types_1 = require("../../lib/schema/types");
 /**
  * Generates the initial migration based on the generated seed data.
  */
@@ -14,21 +15,22 @@ function generateSeedMigration({ models, meta }) {
         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')],
         });
         modelTypes.push(`${modelMeta.seed.constantName}`);
     }
     return /* ts */ `
-import { createActionSeedData } from '${meta.seed.importPath}'
 ${imports.generate()}
 
-export const MIGRATION_001_BASEDATA = createActionSeedData({
+export const MIGRATION_001_BASEDATA: Action_Seed_Data = {
+  scope: 'seed',
+  type: 'data',
   name: 'Base data',
   order: 1,
-  data: ${meta.importExport.converterFunctions.importedDataToBulkMutations}({
-      ${modelTypes.join(',\n')}
-    },
-  ),
-})
+  payload: ${meta.importExport.converterFunctions.importedDataToBulkMutations}({
+    ${modelTypes.join(',\n')}
+  }),
+}
 `;
 }
 exports.generateSeedMigration = generateSeedMigration;

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

@@ -16,7 +16,6 @@ function generateTestDataService({ models, meta: schemaMeta, }) {
             (0, types_1.toAnnotatedTypeName)(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 }) }));
@@ -57,12 +56,19 @@ export class TestDataService {
     this.logger.log('✍ Setting test data')
 
     const mockData = ${schemaMeta.importExport.converterFunctions.mockDataToBulkMutations}(data)
-    const action = createActionSeedData({ name: 'E2E', order: 0, data: [] })
+
     const actionExecution = await this.actionExecutionFactory.create({
-      action,
+      action: {
+        scope: 'seed',
+        type: 'data',
+        name: 'E2E', 
+        order: 0, 
+        payload: []
+      },
       dbService: this.db,
       user: this.dataService.users.rootUser,
     })
+
     try {
       ${reInitCalls.join('\n')}