@postxl/generator 0.56.1 → 0.56.3

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

@@ -3,7 +3,6 @@ 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.
@@ -11,7 +10,7 @@ const file_1 = require("../../lib/utils/file");
 function generateBusinessLogicActionTypes({ models, meta }) {
     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')],
+        items: [meta.actions.definition.payload, meta.actions.definition.resultDict],
     });
     const updateServiceImports = [];
     const modelNameTypeElements = [];
@@ -27,8 +26,8 @@ function generateBusinessLogicActionTypes({ models, meta }) {
             to: modelMeta.businessLogic.update.serviceFilePath,
         });
         updateServiceImports.push(`import type * as ${className} from '${relativeImportPath}'`);
-        actionsTypeElements.push(`ActionDefPayload<${className}.Scope, ${className}.Actions>`);
-        actionResultTypeElements.push(`${scope}: ActionDefResult<${className}.Actions>`);
+        actionsTypeElements.push(`${meta.actions.definition.payload}<${className}.Scope, ${className}.Actions>`);
+        actionResultTypeElements.push(`${scope}: ${meta.actions.definition.resultDict}<${className}.Actions>`);
     }
     return /* ts */ `
 ${imports.generate()}

package/dist/generators/indices/datamock-module.generator.js

@@ -36,7 +36,7 @@ function generateDataMockModule({ models, meta }) {
         [meta.data.dataModuleFilePath]: [Types.toVariableName('DataModule')],
         [meta.data.dataService.filePath]: [meta.data.dataService.class],
         // we need to import the file directly instead via the normal index file as this would cause a circular dependency else
-        [meta.actions.importPath]: [meta.actions.actionExecution.mock],
+        [meta.actions.importPath]: [meta.actions.execution.mock],
     });
     for (const { model, meta } of mm) {
         imports.addTypeImport({ items: [model.typeName], from: meta.types.importPath });

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

@@ -29,7 +29,7 @@ function generateDataService({ models, meta }) {
         [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(meta.types.dto.create), (0, types_1.toAnnotatedTypeName)(meta.types.dto.update)],
         [meta.data.repository.typeFilePath]: [(0, types_1.toAnnotatedTypeName)(meta.data.repository.typeName)],
         [meta.data.types.filePath]: [(0, types_1.toAnnotatedTypeName)(meta.data.types.bulkMutation)],
-        [meta.actions.importPath]: [meta.actions.actionExecution.interface],
+        [meta.actions.importPath]: [meta.actions.execution.interface],
     });
     const creates = [];
     const updates = [];
@@ -77,7 +77,7 @@ export class ${meta.data.dataService.class} {
   }
   public async ${meta.data.dataService.executeBulkMutations}(
     { steps, execution }: 
-    { steps: ${meta.data.types.bulkMutation}[]; execution: ${meta.actions.actionExecution.interface} }
+    { steps: ${meta.data.types.bulkMutation}[]; execution: ${meta.actions.execution.interface} }
   ) {
     let index = 0
     for (const step of steps) {
@@ -88,7 +88,7 @@ export class ${meta.data.dataService.class} {
 
   public async ${meta.data.dataService.executeBulkMutation}(
     { data, execution }: 
-    { data: ${meta.data.types.bulkMutation}, execution: ${meta.actions.actionExecution.interface}}
+    { data: ${meta.data.types.bulkMutation}, execution: ${meta.actions.execution.interface}}
   ) {
     // NOTE: the order of these calls is important, because of foreign key constraints
     // The current order is based on the order of the models in the schema
@@ -114,7 +114,7 @@ export class ${meta.data.dataService.class} {
     name: string
     data: ${meta.types.dto.create}<T, ID>[] | undefined
     repo: ${meta.data.repository.typeName}<T, ID>
-    execution: ${meta.actions.actionExecution.interface}
+    execution: ${meta.actions.execution.interface}
   }): Promise<void> {
     if (!data) {
       return
@@ -146,7 +146,7 @@ export class ${meta.data.dataService.class} {
     name: string
     data: ${meta.types.dto.update}<T, ID>[] | undefined
     repo: ${meta.data.repository.typeName}<T, ID>
-    execution: ${meta.actions.actionExecution.interface}
+    execution: ${meta.actions.execution.interface}
   }): Promise<void> {
     if (!data) {
       return
@@ -178,7 +178,7 @@ export class ${meta.data.dataService.class} {
     name: string
     data: (${meta.types.dto.create}<T, ID> | ${meta.types.dto.update}<T, ID>)[] | undefined
     repo: ${meta.data.repository.typeName}<T, ID>
-    execution: ${meta.actions.actionExecution.interface}
+    execution: ${meta.actions.execution.interface}
   }): Promise<void> {
     if (!data) {
       return
@@ -210,7 +210,7 @@ export class ${meta.data.dataService.class} {
     name: string
     data: ID[] | undefined
     repo: ${meta.data.repository.typeName}<T, ID>
-    execution: ${meta.actions.actionExecution.interface}
+    execution: ${meta.actions.execution.interface}
   }): Promise<void> {
     if (!data) {
       return

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.dispatcher.class],
+        [meta.actions.importPath]: [meta.actions.execution.interface, meta.actions.dispatcher.class],
         [types.filePath]: [
             (0, types_1.toAnnotatedTypeName)(delta_Fields),
             (0, types_1.toAnnotatedTypeName)(delta_Model.type),
@@ -78,7 +78,7 @@ export class ${meta.importExport.importService.name} {
     execution 
   }: { 
     action: Action_Import; 
-    execution: ${meta.actions.actionExecution.interface} 
+    execution: ${meta.actions.execution.interface} 
   }) {
     switch (action.type) {
       case 'detect-delta':
@@ -110,7 +110,7 @@ export class ${meta.importExport.importService.name} {
     execution 
   }: { 
     delta: Delta; 
-    execution: ${meta.actions.actionExecution.interface}
+    execution: ${meta.actions.execution.interface}
   }) {
     const bulkMutations = ${converterFunctions.deltaToBulkMutations}(delta)
     return this.data.${meta.data.dataService.executeBulkMutations}({ steps: bulkMutations, execution })
@@ -121,7 +121,7 @@ export class ${meta.importExport.importService.name} {
     execution 
   }: { 
     data: ${meta.importExport.decoder.decodedPXLModelDataTypeName}; 
-    execution: ${meta.actions.actionExecution.interface}
+    execution: ${meta.actions.execution.interface}
   }) {
     const { bulkMutations } = await this.detectDelta(data)
     return this.data.${meta.data.dataService.executeBulkMutations}({ steps: bulkMutations, execution })

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

@@ -23,14 +23,14 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         ],
         [meta.businessLogic.view.serviceFilePath]: [meta.businessLogic.view.serviceClassName],
         [schemaMeta.actions.importPath]: [
-            schemaMeta.actions.actionExecution.interface,
+            schemaMeta.actions.execution.interface,
             schemaMeta.actions.dispatcher.interface,
-            schemaMeta.actions.dispatcher.actionMethod,
+            schemaMeta.actions.definition.payload,
+            schemaMeta.actions.definition.result,
         ],
         [schemaMeta.businessLogic.update.serviceFilePath]: schemaMeta.businessLogic.update.serviceClassName,
         [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
     });
-    const { dispatcher } = schemaMeta.actions;
     for (const relation of (0, fields_1.getRelationFields)(model)) {
         // NOTE: We add branded id type and type name imports only for foreign models.
         if (relation.relationToModel.typeName === model.typeName) {
@@ -39,7 +39,7 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         const refMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
         imports.addImport({
             items: [refMeta.types.toBrandedIdTypeFnName],
-            from: refMeta.types.filePath,
+            from: refMeta.types.importPath,
         });
     }
     /**
@@ -54,9 +54,16 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly viewService: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
     const { zodCreateObject, zodUpdateObject, zodUpsertObject } = meta.businessLogic.update;
+    const { dispatcher, definition } = schemaMeta.actions;
+    /**
+     * A return value of the dispatcher.
+     *
+     * NOTE: We need to cast to the return value every time so that the function correctly determines the return type.
+     */
+    const dispatcherReturnValue = `Promise<${definition.result}<Actions, A>>`;
     return /* ts */ `
     import { Inject, Injectable, forwardRef } from '@nestjs/common'
-    import { ExhaustiveSwitchCheck, UnionOmit } from '@backend/common'
+    import { ExhaustiveSwitchCheck } from '@backend/common'
     import { z } from 'zod'
 
     ${imports.generate()}
@@ -154,37 +161,37 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
       /**
        * Dispatches an action to the appropriate method of the repository.
        */
-      public async dispatch<A extends ${dispatcher.actionMethod}<Scope, Actions>>({
+      public async dispatch<A extends ${definition.payload}<Scope, Actions>>({
         action,
         execution,
       }: {
-        action: UnionOmit<A, 'result'>
-        execution: ${schemaMeta.actions.actionExecution.interface}
-      }): Promise<A['result']> {
+        action: A
+        execution: ${schemaMeta.actions.execution.interface}
+      }): ${dispatcherReturnValue} {
         switch (action.type) {
           case 'create':
-            return this.data.create({ item: action.payload, execution })
+            return this.data.create({ item: action.payload, execution }) as ${dispatcherReturnValue}
 
           case 'createMany':
-            return this.data.createMany({ items: action.payload, execution })
+            return this.data.createMany({ items: action.payload, execution }) as ${dispatcherReturnValue}
 
           case 'update':
-            return this.data.update({ item: action.payload, execution })
+            return this.data.update({ item: action.payload, execution }) as ${dispatcherReturnValue}
 
           case 'updateMany':
-            return this.data.updateMany({ items: action.payload, execution })
+            return this.data.updateMany({ items: action.payload, execution }) as ${dispatcherReturnValue}
 
           case 'upsert':
-            return this.data.upsert({ item: action.payload, execution })
+            return this.data.upsert({ item: action.payload, execution }) as ${dispatcherReturnValue}
 
           case 'upsertMany':
-            return this.data.upsertMany({ items: action.payload, execution })
+            return this.data.upsertMany({ items: action.payload, execution }) as ${dispatcherReturnValue}
 
           case 'delete':
-            return this.data.delete({ id: action.payload, execution })
+            return this.data.delete({ id: action.payload, execution }) as ${dispatcherReturnValue}
 
           case 'deleteMany':
-            return this.data.deleteMany({ ids: action.payload, execution })
+            return this.data.deleteMany({ ids: action.payload, execution }) as ${dispatcherReturnValue}
           
           default: 
             throw new ExhaustiveSwitchCheck(action)

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

@@ -59,8 +59,8 @@ function generateModelBusinessLogicView({ model, meta }) {
             variableDefinition: `const ${relationVariableName} = ${relationVariableDefinition}`,
         });
         if (relation.relationToModel.typeName !== model.typeName) {
-            imports.addImport({ from: refMeta.types.filePath, items: [refMeta.types.toBrandedIdTypeFnName] });
-            imports.addTypeImport({ from: refMeta.types.filePath, items: [refModel.brandedIdType, refMeta.types.typeName] });
+            imports.addImport({ from: refMeta.types.importPath, items: [refMeta.types.toBrandedIdTypeFnName] });
+            imports.addTypeImport({ from: refMeta.types.importPath, items: [refModel.brandedIdType, refMeta.types.typeName] });
         }
     }
     const hasLinkedItems = variables.size > 0;
@@ -68,7 +68,7 @@ function generateModelBusinessLogicView({ model, meta }) {
         // NOTE: If we need to generate the linked item type, we need to import the enum types.
         for (const enumField of (0, fields_1.getEnumFields)(model)) {
             const enumMeta = (0, meta_1.getEnumMetadata)(enumField);
-            imports.addTypeImport({ from: enumMeta.types.filePath, items: [enumField.typeName] });
+            imports.addTypeImport({ from: enumMeta.types.importPath, items: [enumField.typeName] });
         }
     }
     const linkedItemsGetterFn = `

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

@@ -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.actionExecution.interface],
+        [schemaMeta.actions.importPath]: [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.
@@ -990,42 +990,42 @@ function getRepositoryMethodsTypeSignatures({ model, meta }) {
     return {
         create: {
             jsDoc: [`Creates a new ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.actionExecution.interface}}`],
+            parameters: [`{item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.execution.interface}}`],
             returnType: `Promise<${model.typeName}>`,
         },
         createMany: {
             jsDoc: [`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.actionExecution.interface}}`],
+            parameters: [`{items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.execution.interface}}`],
             returnType: `Promise<${model.typeName}[]>`,
         },
         update: {
             jsDoc: [`Updates a ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.actionExecution.interface}}`],
+            parameters: [`{item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.execution.interface}}`],
             returnType: `Promise<${model.typeName}>`,
         },
         updateMany: {
             jsDoc: [`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.actionExecution.interface}}`],
+            parameters: [`{items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.execution.interface}}`],
             returnType: `Promise<${model.typeName}[]>`,
         },
         upsert: {
             jsDoc: [`Creates or updates a ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.actionExecution.interface}}`],
+            parameters: [`{item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.execution.interface}}`],
             returnType: `Promise<${model.typeName}>`,
         },
         upsertMany: {
             jsDoc: [`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.actionExecution.interface}}`],
+            parameters: [`{items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.execution.interface}}`],
             returnType: `Promise<${model.typeName}[]>`,
         },
         delete: {
             jsDoc: [`Deletes a ${meta.userFriendlyName} and returns its id.`],
-            parameters: [`{id: ${model.brandedIdType}, execution: ${schemaMeta.actions.actionExecution.interface}}`],
+            parameters: [`{id: ${model.brandedIdType}, execution: ${schemaMeta.actions.execution.interface}}`],
             returnType: `Promise<${model.brandedIdType}>`,
         },
         deleteMany: {
             jsDoc: [`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`],
-            parameters: [`{ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.actionExecution.interface}}`],
+            parameters: [`{ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.execution.interface}}`],
             returnType: `Promise<${model.brandedIdType}[]>`,
         },
     };

package/dist/lib/meta.d.ts

@@ -93,7 +93,7 @@ export type SchemaMetaData = {
          * Path that may be used to import from the action module.
          */
         importPath: Types.BackendModulePath;
-        actionExecution: {
+        execution: {
             /**
              * The name of the interface that handles the action execution.
              */
@@ -120,10 +120,24 @@ export type SchemaMetaData = {
              * The name of the interface that indicates a service can dispatch actions.
              */
             interface: Types.ClassName;
+        };
+        definition: {
+            /**
+             * The schema type to define action definitions.
+             */
+            schema: Types.TypeName;
+            /**
+             * The generated payload of the defined actions.
+             */
+            payload: Types.TypeName;
+            /**
+             * The generated result of the defined actions.
+             */
+            result: Types.TypeName;
             /**
-             * The name of a util type that is used to create a dictionary of action payloads and results from the action descriptions.
+             * The transformer type that converts action definitions into results dictionary.
              */
-            actionMethod: Types.TypeName;
+            resultDict: Types.TypeName;
         };
     };
     /**

package/dist/lib/meta.js

@@ -81,7 +81,7 @@ function getSchemaMetadata({ config }) {
         actions: {
             moduleName: Types.toClassName(`ActionModule`),
             importPath: Types.toBackendModulePath(`@backend/actions`),
-            actionExecution: {
+            execution: {
                 interface: Types.toClassName(`IActionExecution`),
                 class: Types.toClassName(`ActionExecution`),
                 mock: Types.toClassName(`MockActionExecution`),
@@ -90,7 +90,12 @@ function getSchemaMetadata({ config }) {
                 filePath: Types.toPath(`${config.paths.actionsPath}dispatcher.service`),
                 class: Types.toClassName(`DispatcherService`),
                 interface: Types.toClassName(`IDispatcher`),
-                actionMethod: Types.toTypeName(`ActionMethod`),
+            },
+            definition: {
+                schema: Types.toTypeName('ActionDef'),
+                payload: Types.toTypeName('ActionDefPayload'),
+                result: Types.toTypeName('ActionDefResult'),
+                resultDict: Types.toTypeName('ActionDefResultDict'),
             },
         },
         businessLogic: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.56.1",
+  "version": "0.56.3",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {