@postxl/generator 0.55.0 → 0.56.1

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-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')}
       

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

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateModelBusinessLogicUpdate = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
+const fields_1 = require("../../lib/schema/fields");
 const types_1 = require("../../lib/schema/types");
+const zod_1 = require("../../lib/schema/zod");
 const jsdoc_1 = require("../../lib/utils/jsdoc");
-const repository_generator_1 = require("./repository.generator");
 /**
  * Generates update business logic for a given model.
  * The update logic handles all Create/Update/Delete/Upsert operations. See template's readme for more info.
@@ -15,239 +16,182 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.serviceFilePath);
     imports.addImports({
         [meta.data.importPath]: meta.data.repository.className,
-        [schemaMeta.actions.importPath]: schemaMeta.actions.actionExecution.interface,
-        [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(model.brandedIdType), (0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
+        [meta.types.importPath]: [
+            (0, types_1.toAnnotatedTypeName)(model.brandedIdType),
+            (0, types_1.toAnnotatedTypeName)(meta.types.typeName),
+            meta.types.toBrandedIdTypeFnName,
+        ],
         [meta.businessLogic.view.serviceFilePath]: [meta.businessLogic.view.serviceClassName],
+        [schemaMeta.actions.importPath]: [
+            schemaMeta.actions.actionExecution.interface,
+            schemaMeta.actions.dispatcher.interface,
+            schemaMeta.actions.dispatcher.actionMethod,
+        ],
         [schemaMeta.businessLogic.update.serviceFilePath]: schemaMeta.businessLogic.update.serviceClassName,
         [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
-        [meta.data.importPath]: [meta.data.repository.className],
     });
+    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) {
+            continue;
+        }
+        const refMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
+        imports.addImport({
+            items: [refMeta.types.toBrandedIdTypeFnName],
+            from: refMeta.types.filePath,
+        });
+    }
     /**
      * 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;
-    /**
-     * 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
-     * which then provides access to all models' business logic.
-     */
-    const updateServiceClassName = 'updateService';
-    const viewServiceClassName = 'viewService';
-    const actionBlocks = generateActionsBuildingBlocks({ model, meta });
-    imports.addImport({ from: meta.types.importPath, items: actionBlocks.importTypes });
     const constructorParameters = [
         `public readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
-        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.update.serviceClassName})) private readonly ${updateServiceClassName}: ${schemaMeta.businessLogic.update.serviceClassName}`,
-        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
+        `@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}`,
     ];
-    const methodTypeSignatures = (0, repository_generator_1.getRepositoryMethodsTypeSignatures)({ model, meta });
+    const { zodCreateObject, zodUpdateObject, zodUpsertObject } = meta.businessLogic.update;
     return /* ts */ `
-import { Inject, Injectable, forwardRef } from '@nestjs/common'
-import { ExhaustiveSwitchCheck } from '@backend/common'
-
-${imports.generate()}
-
-${actionBlocks.actionTypeDefinition}
-
-${actionBlocks.resultMap}
-
-${actionBlocks.typeDefinitionWithCreateFunction}
-
-@Injectable()
-export class ${meta.businessLogic.update.serviceClassName} {
-  
-  /**
-   * Instance of the ${meta.userFriendlyName} view service for convenience.
-   */
-  private view: ${meta.businessLogic.view.serviceClassName}
-
-  constructor(${constructorParameters.join(',\n')}) {
-    this.view = this.${viewServiceClassName}.${meta.businessLogic.view.serviceVariableName}
-  }
-
-  ${actionBlocks.dispatcher}
-  
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.create.jsDoc)}
-  public async create(
-    { item, execution }: ${methodTypeSignatures.create.parameters[0]}
-  ): ${methodTypeSignatures.create.returnType} {
-    return this.${modelRepositoryVariableName}.create({ item, execution })
-  }
-
-  
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.createMany.jsDoc)}
-  public async createMany(
-    { items, execution }: ${methodTypeSignatures.createMany.parameters[0]}
-  ): ${methodTypeSignatures.createMany.returnType} {
-    return this.${modelRepositoryVariableName}.createMany({ items, execution })
-  }
-
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.update.jsDoc)}
-  public async update(
-    { item, execution }: ${methodTypeSignatures.update.parameters[0]}
-  ): ${methodTypeSignatures.update.returnType} {
-    return this.${modelRepositoryVariableName}.update({ item, execution })
-  }
-
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.updateMany.jsDoc)}
-  public async updateMany(
-    { items, execution }: ${methodTypeSignatures.updateMany.parameters[0]}
-  ): ${methodTypeSignatures.updateMany.returnType} {
-    return this.${modelRepositoryVariableName}.updateMany({ items, execution })
-  }
-
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsert.jsDoc)}
-  public async upsert(
-    { item, execution }: ${methodTypeSignatures.upsert.parameters[0]}
-  ): ${methodTypeSignatures.upsert.returnType} {
-    return this.${modelRepositoryVariableName}.upsert({ item, execution })
-  }
-
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsertMany.jsDoc)}
-  public async upsertMany(
-    { items, execution }: ${methodTypeSignatures.upsertMany.parameters[0]}
-  ): ${methodTypeSignatures.upsertMany.returnType} {
-    return this.${modelRepositoryVariableName}.upsertMany({ items, execution })
-  }
-  
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.delete.jsDoc)}
-  public async delete(
-    { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
-  ): ${methodTypeSignatures.delete.returnType} {
-    return this.${modelRepositoryVariableName}.delete({ id, execution })
-  }
-
-  ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.deleteMany.jsDoc)}
-  public async deleteMany(
-    { ids, execution }: ${methodTypeSignatures.deleteMany.parameters[0]}
-  ): ${methodTypeSignatures.deleteMany.returnType} {
-    return this.${modelRepositoryVariableName}.deleteMany({ ids, execution })
-  }
-
-}`;
-}
-exports.generateModelBusinessLogicUpdate = generateModelBusinessLogicUpdate;
-function generateActionsBuildingBlocks({ model, meta }) {
-    const actionTypeDefinition = [];
-    const resultMap = [];
-    const typeDefinitionWithCreateFunction = [];
-    const importTypes = [];
-    const dispatcher = [];
-    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    const actionDefinitions = prepareActionDefinitions({ model, meta });
-    for (const [type, config] of Object.entries(actionDefinitions)) {
-        const def = generateAction({ model, meta, type: type, config });
-        actionTypeDefinition.push(def.actionName),
-            resultMap.push(def.resultMap),
-            typeDefinitionWithCreateFunction.push(def.typeDefinition, def.createFunction, ''),
-            importTypes.push(...def.importTypes),
-            dispatcher.push(def.dispatchCaseExpression);
+    import { Inject, Injectable, forwardRef } from '@nestjs/common'
+    import { ExhaustiveSwitchCheck, UnionOmit } from '@backend/common'
+    import { z } from 'zod'
+
+    ${imports.generate()}
+
+    export type Scope = "${meta.actions.actionScopeConstType}"
+
+    
+
+    /**
+     * Zod decoder for validating the create input of a ${meta.userFriendlyName}.
+     */
+    export const ${zodCreateObject} = z.object({
+      ${model.fields
+        .filter((f) => !f.attributes.isReadonly)
+        .map((f) => `${f.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field: f })}`)
+        .join(',')}
+    })
+
+    /**
+     * Zod decoder for validating the update input of a ${meta.userFriendlyName} .
+     */
+    export const ${zodUpdateObject} = z.object({
+      ${model.fields
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
+        .map((f) => `${f.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field: f, allowAnyOptionalField: f.kind !== 'id' })}`)
+        .join(',')}
+    })
+
+    /**
+     * Zod decoder for validating the upsert input of a ${meta.userFriendlyName} .
+     */
+    export const ${zodUpsertObject} = z.union([${zodUpdateObject}, ${zodCreateObject}])
+
+    export type Actions = {
+      ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
+      create: {
+        payload: z.infer<typeof ${zodCreateObject}>
+        result: ${meta.types.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`])}
+      createMany: {
+        payload: z.infer<typeof ${zodCreateObject}>[]
+        result: ${meta.types.typeName}[]
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
+      update: {
+        payload: z.infer<typeof ${zodUpdateObject}>
+        result: ${meta.types.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
+      updateMany: {
+        payload: z.infer<typeof ${zodUpdateObject}>[]
+        result: ${meta.types.typeName}[]
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
+      upsert: {
+        payload: z.infer<typeof ${zodUpsertObject}>
+        result: ${meta.types.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
+      upsertMany: {
+        payload: z.infer<typeof ${zodUpsertObject}>[]
+        result: ${meta.types.typeName}[]
+      }
+      
+      ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} and returns its id.`])}
+      delete: {
+        payload: ${model.brandedIdType}
+        result: ${model.brandedIdType}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`])}
+      deleteMany: {
+        payload: ${model.brandedIdType}[]
+        result: ${model.brandedIdType}[]
+      }
     }
-    return {
-        importTypes,
-        actionTypeDefinition: `export type Action_${meta.businessLogic.update.actionNameModelPart} = ${actionTypeDefinition.join(' | ')}`,
-        resultMap: `export type ActionResult_${meta.businessLogic.update.actionNameModelPart} = { 
-      ${resultMap.join('\n')} 
-    }`,
-        typeDefinitionWithCreateFunction: `${typeDefinitionWithCreateFunction.join('\n')}`,
-        dispatcher: `
-      public async dispatch<A extends Action_${meta.businessLogic.update.actionNameModelPart}>({ action, execution }: {
-        action: A; 
-        execution: ${schemaMeta.actions.actionExecution.interface} 
-      }) {
+
+    @Injectable()
+    export class ${meta.businessLogic.update.serviceClassName} implements ${dispatcher.interface}<Scope, Actions> {
+      /**
+       * Instance of the ${meta.userFriendlyName} view service for convenience.
+       */
+      private view: ${meta.businessLogic.view.serviceClassName}
+
+      constructor(${constructorParameters.join(',\n')}) {
+        this.view = this.viewService.${meta.businessLogic.view.serviceVariableName}
+      }
+
+      /**
+       * Dispatches an action to the appropriate method of the repository.
+       */
+      public async dispatch<A extends ${dispatcher.actionMethod}<Scope, Actions>>({
+        action,
+        execution,
+      }: {
+        action: UnionOmit<A, 'result'>
+        execution: ${schemaMeta.actions.actionExecution.interface}
+      }): Promise<A['result']> {
         switch (action.type) {
-          ${dispatcher.join('\n')}
-          default: {
+          case 'create':
+            return this.data.create({ item: action.payload, execution })
+
+          case 'createMany':
+            return this.data.createMany({ items: action.payload, execution })
+
+          case 'update':
+            return this.data.update({ item: action.payload, execution })
+
+          case 'updateMany':
+            return this.data.updateMany({ items: action.payload, execution })
+
+          case 'upsert':
+            return this.data.upsert({ item: action.payload, execution })
+
+          case 'upsertMany':
+            return this.data.upsertMany({ items: action.payload, execution })
+
+          case 'delete':
+            return this.data.delete({ id: action.payload, execution })
+
+          case 'deleteMany':
+            return this.data.deleteMany({ ids: action.payload, execution })
+          
+          default: 
             throw new ExhaustiveSwitchCheck(action)
-          }
+          
         }
-      }`,
-    };
-}
-function prepareActionDefinitions({ model, meta, }) {
-    return {
-        create: {
-            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Create`,
-            createFunctionName: meta.businessLogic.update.createActionFunctionNameCreate,
-            payload: meta.types.dto.create,
-            resultType: meta.types.typeName,
-            imports: [(0, types_1.toAnnotatedTypeName)(meta.types.dto.create)],
-            dispatcherParameterName: 'item',
-        },
-        createMany: {
-            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_CreateMany`,
-            createFunctionName: meta.businessLogic.update.createActionFunctionNameCreateMany,
-            payload: `${meta.types.dto.create}[]`,
-            resultType: `${meta.types.typeName}[]`,
-            imports: [(0, types_1.toAnnotatedTypeName)(meta.types.dto.create)],
-            dispatcherParameterName: 'items',
-        },
-        update: {
-            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Update`,
-            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpdate,
-            payload: meta.types.dto.update,
-            resultType: meta.types.typeName,
-            imports: [(0, types_1.toAnnotatedTypeName)(meta.types.dto.update)],
-            dispatcherParameterName: 'item',
-        },
-        updateMany: {
-            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_UpdateMany`,
-            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpdateMany,
-            payload: `${meta.types.dto.update}[]`,
-            resultType: `${meta.types.typeName}[]`,
-            imports: [(0, types_1.toAnnotatedTypeName)(meta.types.dto.update)],
-            dispatcherParameterName: 'items',
-        },
-        upsert: {
-            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Upsert`,
-            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpsert,
-            payload: meta.types.dto.upsert,
-            resultType: meta.types.typeName,
-            imports: [(0, types_1.toAnnotatedTypeName)(meta.types.dto.upsert)],
-            dispatcherParameterName: 'item',
-        },
-        upsertMany: {
-            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_UpsertMany`,
-            createFunctionName: meta.businessLogic.update.createActionFunctionNameUpsertMany,
-            payload: `${meta.types.dto.upsert}[]`,
-            resultType: `${meta.types.typeName}[]`,
-            imports: [(0, types_1.toAnnotatedTypeName)(meta.types.dto.upsert)],
-            dispatcherParameterName: 'items',
-        },
-        delete: {
-            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_Delete`,
-            createFunctionName: meta.businessLogic.update.createActionFunctionNameDelete,
-            payload: model.brandedIdType,
-            resultType: model.brandedIdType,
-            imports: [(0, types_1.toAnnotatedTypeName)(model.brandedIdType)],
-            dispatcherParameterName: 'id',
-        },
-        deleteMany: {
-            actionName: `Action_${meta.businessLogic.update.actionNameModelPart}_DeleteMany`,
-            createFunctionName: meta.businessLogic.update.createActionFunctionNameDeleteMany,
-            payload: `${model.brandedIdType}[]`,
-            resultType: `${model.brandedIdType}[]`,
-            imports: [(0, types_1.toAnnotatedTypeName)(model.brandedIdType)],
-            dispatcherParameterName: 'ids',
-        },
-    };
-}
-function generateAction({ meta, type, config: { imports, actionName, payload, createFunctionName, resultType, dispatcherParameterName }, }) {
-    return {
-        actionName,
-        actionType: type,
-        importTypes: imports,
-        resultMap: `${type}: ${resultType}`,
-        typeDefinition: `
-      export type ${actionName} = { scope: '${meta.actions.actionScopeConstType}'; type: '${type}'; payload: ${payload} }`,
-        createFunction: `
-      export function ${createFunctionName}(payload: ${payload}): ${actionName} {
-        return { scope: '${meta.actions.actionScopeConstType}', type: '${type}', payload }
-      }`,
-        dispatchCaseExpression: `
-      case '${type}':
-        return this.${type}({ ${dispatcherParameterName}: action.payload, execution })`,
-    };
+      }
+    }
+ `;
 }
+exports.generateModelBusinessLogicUpdate = generateModelBusinessLogicUpdate;

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

@@ -5,7 +5,9 @@ const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
 const types_1 = require("../../lib/schema/types");
+const types_2 = require("../../lib/types");
 const ast_1 = require("../../lib/utils/ast");
+const jsdoc_1 = require("../../lib/utils/jsdoc");
 /**
  * Generates view business logic for a given model.
  * The view  logic exposes all information and links of a model. See template's readme for more info.
@@ -56,10 +58,18 @@ function generateModelBusinessLogicView({ model, meta }) {
             variableName: relationVariableName,
             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] });
+        }
     }
     const hasLinkedItems = variables.size > 0;
     if (hasLinkedItems) {
-        imports.addTypeImport({ from: meta.types.importPath, items: [meta.types.linkedTypeName] });
+        // 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] });
+        }
     }
     const linkedItemsGetterFn = `
     /**
@@ -91,6 +101,16 @@ function generateModelBusinessLogicView({ model, meta }) {
 
       return item
     }
+  `;
+    const linkedTypeDefinition = `
+    export type ${meta.types.linkedTypeName} = { 
+      ${model.fields
+        .map((f) => `
+            ${(0, jsdoc_1.getFieldComment)(f)}
+            ${getLinkedFieldType(f)}${f.isRequired ? '' : ' | null'}
+          `)
+        .join('\n')}
+    }
   `;
     return /* ts */ `
 /* eslint-disable @typescript-eslint/no-unused-vars */
@@ -99,6 +119,8 @@ import { FilterOperator } from '@backend/common'
 
 ${imports.generate()}
 
+${hasLinkedItems ? linkedTypeDefinition : ''}
+
 @Injectable()
 export class ${meta.businessLogic.view.serviceClassName} {
   constructor(${constructorParameters.join(',\n')}) {}
@@ -252,3 +274,20 @@ function compare(a: ${model.typeName}, b: ${model.typeName}, field: keyof ${mode
 
   `;
 }
+/**
+ * Converts a field to a TypeScript type definition with linked fields.
+ */
+function getLinkedFieldType(f) {
+    switch (f.kind) {
+        case 'enum':
+            return `${f.name}: ${f.typeName}`;
+        case 'relation':
+            return `${f.relationFieldName}: ${f.relationToModel.typeName}`;
+        case 'id':
+            return `${f.name}: ${f.model.brandedIdType}`;
+        case 'scalar':
+            return `${f.name}: ${f.tsTypeName}`;
+        default:
+            throw new types_2.ExhaustiveSwitchCheck(f);
+    }
+}

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

@@ -9,28 +9,18 @@ const types_1 = require("../../lib/schema/types");
  */
 function generateRoute({ model, meta }) {
     const { idField, defaultField } = model;
+    const { scopeName, dataRepositoryVariableName } = meta.businessLogic;
     const defaultValueMethod = `
-    getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.${meta.businessLogic.dataRepositoryVariableName}.defaultValue),
+    getDefault: procedure.query(({ ctx }) => ctx.view.${meta.data.dataServiceName}.${dataRepositoryVariableName}.defaultValue),
   `;
+    const { zodCreateObject, zodUpdateObject, zodUpsertObject } = meta.businessLogic.update;
     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.createObject,
-            meta.types.zodDecoderFnNames.updateObject,
-            meta.types.zodDecoderFnNames.upsertObject,
             meta.types.zodDecoderFnNames.id,
         ],
-        [meta.businessLogic.importPath]: [
-            meta.businessLogic.update.createActionFunctionNameCreate,
-            meta.businessLogic.update.createActionFunctionNameCreateMany,
-            meta.businessLogic.update.createActionFunctionNameUpdate,
-            meta.businessLogic.update.createActionFunctionNameUpdateMany,
-            meta.businessLogic.update.createActionFunctionNameUpsert,
-            meta.businessLogic.update.createActionFunctionNameUpsertMany,
-            meta.businessLogic.update.createActionFunctionNameDelete,
-            meta.businessLogic.update.createActionFunctionNameDeleteMany,
-        ],
+        [meta.businessLogic.update.serviceFilePath]: [zodCreateObject, zodUpdateObject, zodUpsertObject],
     });
     return /* ts */ `
 import { z } from 'zod'
@@ -71,30 +61,37 @@ export const ${meta.trpc.routerName} = router({
       return ctx.view.${meta.data.dataServiceName}.getList(input)
     }),
 
-    create: procedure.input(${meta.types.zodDecoderFnNames.createObject})
-      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameCreate}(input))),
+    create: procedure
+      .input(${zodCreateObject})
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "create", payload: input})),
     
-    createMany: procedure.input(z.array(${meta.types.zodDecoderFnNames.createObject}))
-      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameCreateMany}(input))),
+    createMany: procedure
+      .input(z.array(${zodCreateObject}))
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "createMany", payload: input})),
 
-    update: procedure.input(${meta.types.zodDecoderFnNames.updateObject})
-      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameUpdate}(input))),
+    update: procedure
+      .input(${zodUpdateObject})
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "update", payload: input})),
 
-    updateMany: procedure.input(z.array(${meta.types.zodDecoderFnNames.updateObject}))
-      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameUpdateMany}(input))),
+    updateMany: procedure
+      .input(z.array(${zodUpdateObject}))
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "updateMany", payload: input})),
 
-    upsert: procedure.input(${meta.types.zodDecoderFnNames.upsertObject})
-      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameUpsert}(input))),
+    upsert: procedure
+      .input(${zodUpsertObject})
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "upsert", payload: input})),
 
-    upsertMany: procedure.input(z.array(${meta.types.zodDecoderFnNames.upsertObject}))
-      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameUpsertMany}(input))),
+    upsertMany: procedure
+      .input(z.array(${zodUpsertObject}))
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "upsertMany", payload: input})),
 
-    delete: procedure.input(${meta.types.zodDecoderFnNames.id})
-      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameDelete}(input))),
+    delete: procedure
+      .input(${meta.types.zodDecoderFnNames.id})
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "delete", payload: input})),
     
-    deleteMany: procedure.input(z.array(${meta.types.zodDecoderFnNames.id}))
-      .mutation(({ input, ctx }) => ctx.dispatch(${meta.businessLogic.update.createActionFunctionNameDeleteMany}(input))),
-
+    deleteMany: procedure
+      .input(z.array(${meta.types.zodDecoderFnNames.id}))
+      .mutation(({ input, ctx }) => ctx.dispatch({scope: "${scopeName}", type: "deleteMany", payload: input})),
 })
 `;
 }

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

@@ -14,27 +14,6 @@ function generateModelTypes({ model, meta }) {
     var _a;
     const idField = model.idField;
     const imports = imports_1.ImportsGenerator.from(meta.types.filePath);
-    /**
-     * Tells whether model references other models.
-     */
-    let hasLinkedItems = false;
-    for (const relation of (0, fields_1.getRelationFields)(model)) {
-        hasLinkedItems = true;
-        if (relation.relationToModel.typeName === model.typeName) {
-            // NOTE: All type definitions are already present in this file for this model.
-            continue;
-        }
-        const refModel = relation.relationToModel;
-        const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
-        imports.addImport({
-            items: [refMeta.types.toBrandedIdTypeFnName],
-            from: refMeta.types.filePath,
-        });
-        imports.addTypeImport({
-            items: [refModel.brandedIdType, refMeta.types.typeName],
-            from: refMeta.types.filePath,
-        });
-    }
     for (const f of (0, fields_1.getEnumFields)(model)) {
         const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: f.enumerator });
         imports.addTypeImport({
@@ -48,16 +27,15 @@ function generateModelTypes({ model, meta }) {
         from: schemaMeta.types.dto.path,
     });
     const decoderNames = meta.types.zodDecoderFnNames;
-    const linkedTypeDefinition = `
-    export type ${meta.types.linkedTypeName} = { 
-      ${model.fields
-        .map((f) => `
-            ${getFieldComment(f)}
-            ${getLinkedFieldType(f)}${f.isRequired ? '' : ' | null'}
-          `)
-        .join('\n')}
+    for (const relation of (0, fields_1.getRelationFields)(model)) {
+        if (relation.relationToModel.typeName === model.typeName) {
+            // NOTE: All type definitions are already present in this file for this model.
+            continue;
+        }
+        const refMeta = (0, meta_1.getModelMetadata)({ model: relation.relationToModel });
+        imports.addImport({ from: refMeta.types.filePath, items: [refMeta.types.toBrandedIdTypeFnName] });
+        imports.addTypeImport({ from: refMeta.types.filePath, items: [relation.relationToModel.brandedIdType] });
     }
-  `;
     return /* ts */ `
 import { z } from 'zod'
 
@@ -68,14 +46,14 @@ export type ${meta.types.typeName} = {
   ${model.fields
         .map((f) => {
         return `
-        ${getFieldComment(f)}
+        ${(0, jsdoc_1.getFieldComment)(f)}
         ${f.name}: ${getFieldType(f)}${f.isRequired ? '' : ' | null'}
       `;
     })
         .join('\n')}
 }
 
-${hasLinkedItems ? linkedTypeDefinition : ``}
+
 
 /**
  * Branded Id type that should be used to identify an instance of a ${meta.userFriendlyName}.
@@ -103,31 +81,6 @@ export const ${decoderNames.fromDatabase} = z.object({
   ${model.fields.map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field })}`).join(',')}
 })
 
-/**
- * Zod decoder for validating the create input of a ${meta.userFriendlyName}.
- */
-export const ${decoderNames.createObject} = z.object({
-  ${model.fields
-        .filter((f) => !f.attributes.isReadonly)
-        .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field })}`)
-        .join(',')}
-})
-
-/**
- * Zod decoder for validating the update input of a ${meta.userFriendlyName} .
- */
-export const ${decoderNames.updateObject} = z.object({
-  ${model.fields
-        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
-        .map((field) => `${field.name}: z.${(0, zod_1.getZodDecoderDefinition)({ field, allowAnyOptionalField: field.kind !== 'id' })}`)
-        .join(',')}
-})
-
-/**
- * Zod decoder for validating the upsert input of a ${meta.userFriendlyName} .
- */
-export const ${decoderNames.upsertObject} = z.union([${decoderNames.updateObject}, ${decoderNames.createObject}])
-
 /**
  * Data transfer object for creating a new ${meta.userFriendlyName} instance.
  */
@@ -145,31 +98,6 @@ export type ${meta.types.dto.upsert} = ${schemaMeta.types.dto.upsert}<${meta.typ
 `;
 }
 exports.generateModelTypes = generateModelTypes;
-function getFieldComment(f) {
-    const examples = getFieldExamples(f);
-    let comment = '';
-    if (f.description) {
-        comment = ` * ${f.description.split('\n').join('\n * ')}\n`;
-    }
-    else if (f.kind === 'enum' && f.enumerator.description) {
-        comment = ` * ${f.enumerator.description.split('\n').join('\n * ')}\n`;
-    }
-    if (examples) {
-        comment += ` * ${examples}\n`;
-    }
-    if (comment === '') {
-        return '';
-    }
-    return `
-/**
-${comment}*/`;
-}
-function getFieldExamples(f) {
-    if (!f.attributes.examples) {
-        return undefined;
-    }
-    return `Examples: ${f.attributes.examples.map((e) => `"${e}"`).join(', ')}`;
-}
 /**
  * Converts a field to a TypeScript type definition.
  */
@@ -187,20 +115,3 @@ function getFieldType(f) {
             throw new types_1.ExhaustiveSwitchCheck(f);
     }
 }
-/**
- * Converts a field to a TypeScript type definition with linked fields.
- */
-function getLinkedFieldType(f) {
-    switch (f.kind) {
-        case 'enum':
-            return `${f.name}: ${f.typeName}`;
-        case 'relation':
-            return `${f.relationFieldName}: ${f.relationToModel.typeName}`;
-        case 'id':
-            return `${f.name}: ${f.model.brandedIdType}`;
-        case 'scalar':
-            return `${f.name}: ${f.tsTypeName}`;
-        default:
-            throw new types_1.ExhaustiveSwitchCheck(f);
-    }
-}

package/dist/lib/exports.d.ts

@@ -34,6 +34,10 @@ export declare class ExportsGenerator {
      * NOTE: This should only be used when the generator is a root generator.
      */
     exportEverythingFromFile(file: string): ExportsGenerator;
+    /**
+     * Adds a given file to the collection of files we're exporting a selection from.
+     */
+    exportSelectionFromPath(from: Types.FilePath, elements: Types.ImportableTypes[]): ExportsGenerator;
     /**
      * Returns the TypeScript export statements.
      */

package/dist/lib/exports.js

@@ -8,7 +8,7 @@ const file_1 = require("./utils/file");
 class ExportsGenerator {
     constructor({ path, isRoot }) {
         this._path = path;
-        this._exports = new Set();
+        this._exports = new Map();
         this.isRoot = isRoot !== null && isRoot !== void 0 ? isRoot : false;
     }
     /**
@@ -31,7 +31,7 @@ class ExportsGenerator {
             throw new Error(`Cannot use "exportEverythingFromPath" on a root generator.`);
         }
         const resolvedPath = (0, file_1.getRelativePath)({ from: this._path, to: from });
-        this._exports.add(resolvedPath);
+        this._exports.set(resolvedPath, { kind: 'wildcard' });
         return this;
     }
     /**
@@ -43,18 +43,48 @@ class ExportsGenerator {
         if (!this.isRoot) {
             throw new Error(`Cannot use "exportEverythingFromFile" on a non-root generator.`);
         }
-        this._exports.add(file);
+        this._exports.set(file, { kind: 'wildcard' });
+        return this;
+    }
+    /**
+     * Adds a given file to the collection of files we're exporting a selection from.
+     */
+    exportSelectionFromPath(from, elements) {
+        if (this.isRoot) {
+            throw new Error(`Cannot use "exportSelectionFromPath" on a root generator.`);
+        }
+        const resolvedPath = (0, file_1.getRelativePath)({ from: this._path, to: from });
+        const _existing = this._exports.get(resolvedPath);
+        // NOTE: If we already export everything, we don't need to do anything.
+        if ((_existing === null || _existing === void 0 ? void 0 : _existing.kind) === 'wildcard') {
+            return this;
+        }
+        if ((_existing === null || _existing === void 0 ? void 0 : _existing.kind) === 'selection') {
+            for (const element of elements) {
+                _existing.elements.add(element);
+            }
+            return this;
+        }
+        this._exports.set(resolvedPath, { kind: 'selection', elements: new Set(elements) });
         return this;
     }
     /**
      * Returns the TypeScript export statements.
      */
     generate() {
-        const stetements = [...this._exports.values()]
-            .sort((a, b) => a.localeCompare(b))
-            .map((path) => `export * from '${path}'`)
-            .join('\n');
-        return stetements;
+        const statements = [];
+        const exports = Array.from(this._exports.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+        for (const [_path, _export] of exports) {
+            switch (_export.kind) {
+                case 'wildcard':
+                    statements.push(`export * from '${_path}'`);
+                    break;
+                case 'selection':
+                    statements.push(`export { ${Array.from(_export.elements).join(', ')} } from '${_path}'`);
+                    break;
+            }
+        }
+        return statements.join('\n');
     }
 }
 exports.ExportsGenerator = ExportsGenerator;

package/dist/lib/meta.d.ts

@@ -107,7 +107,7 @@ export type SchemaMetaData = {
              */
             mock: Types.ClassName;
         };
-        dispatcherService: {
+        dispatcher: {
             /**
              * Path to the file containing the dispatcher service class definition.
              */
@@ -116,6 +116,14 @@ export type SchemaMetaData = {
              * The name of the dispatcher service class.
              */
             class: Types.ClassName;
+            /**
+             * The name of the interface that indicates a service can dispatch actions.
+             */
+            interface: Types.ClassName;
+            /**
+             * The name of a util type that is used to create a dictionary of action payloads and results from the action descriptions.
+             */
+            actionMethod: Types.TypeName;
         };
     };
     /**
@@ -917,50 +925,17 @@ export type ModelMetaData = {
              */
             actionModelDiscriminantName: Types.VariableName;
             /**
-             * Name of the model's aggregated action type. (e.g. `Action_Aggregation`)
-             */
-            actionName: Types.VariableName;
-            /**
-             * Name of the model's aggregated action result type. (e.g. `ActionResult_Aggregation`)
-             */
-            actionResultName: Types.VariableName;
-            /**
-             * The model's name that is used to build the different action types.
-             * (e.g. `Aggregation` which will be used to build `Action_Aggregation_Create`)
-             */
-            actionNameModelPart: Types.VariableName;
-            /**
-             * Name of the function that creates a `create` action for the model (e.g. `createActionAggregationCreate`)
-             */
-            createActionFunctionNameCreate: Types.FunctionName;
-            /**
-             * Name of the function that creates a `createMany` action for the model (e.g. `createActionAggregationCreateMany`)
-             */
-            createActionFunctionNameCreateMany: Types.FunctionName;
-            /**
-             * Name of the function that creates a `update` action for the model (e.g. `createActionAggregationUpdate`)
-             */
-            createActionFunctionNameUpdate: Types.FunctionName;
-            /**
-             * Name of the function that creates a `updateMany` action for the model (e.g. `createActionAggregationUpdateMany`)
-             */
-            createActionFunctionNameUpdateMany: Types.FunctionName;
-            /**
-             * Name of the function that creates a `upsert` action for the model (e.g. `createActionAggregationUpsert`)
-             */
-            createActionFunctionNameUpsert: Types.FunctionName;
-            /**
-             * Name of the function that creates a `upsertMany` action for the model (e.g. `createActionAggregationUpsertMany`)
+             * The name of the function that decodes a Create object to a fully typed object, e.g. `aggregationCreateDecoder`.
              */
-            createActionFunctionNameUpsertMany: Types.FunctionName;
+            zodCreateObject: Types.FunctionName;
             /**
-             * Name of the function that creates a `delete` action for the model (e.g. `createActionAggregationDelete`)
+             * The name of the function that decodes an Update object to a fully typed object, e.g. `aggregationUpdateDecoder`.
              */
-            createActionFunctionNameDelete: Types.FunctionName;
+            zodUpdateObject: Types.FunctionName;
             /**
-             * Name of the function that creates a `deleteMany` action for the model (e.g. `createActionAggregationDeleteMany`)
+             * The name of the function that decodes an Upsert object to a fully typed object, e.g. `aggregationUpsertDecoder`.
              */
-            createActionFunctionNameDeleteMany: Types.FunctionName;
+            zodUpsertObject: Types.FunctionName;
         };
         /**
          * Name by which the business logic service exposes the data service.
@@ -1120,18 +1095,6 @@ export type ModelMetaData = {
              * The name of the function that decodes a source (database) object to a fully typed object, e.g. `aggregationDatabaseDecoder`.
              */
             fromDatabase: Types.FunctionName;
-            /**
-             * The name of the function that decodes a Create object to a fully typed object, e.g. `aggregationCreateDecoder`.
-             */
-            createObject: Types.FunctionName;
-            /**
-             * The name of the function that decodes an Update object to a fully typed object, e.g. `aggregationUpdateDecoder`.
-             */
-            updateObject: Types.FunctionName;
-            /**
-             * The name of the function that decodes an Upsert object to a fully typed object, e.g. `aggregationUpsertDecoder`.
-             */
-            upsertObject: Types.FunctionName;
         };
         /**
          * Type definitions for the different Data Transfer Objects (DTOs).

package/dist/lib/meta.js

@@ -86,9 +86,11 @@ function getSchemaMetadata({ config }) {
                 class: Types.toClassName(`ActionExecution`),
                 mock: Types.toClassName(`MockActionExecution`),
             },
-            dispatcherService: {
+            dispatcher: {
                 filePath: Types.toPath(`${config.paths.actionsPath}dispatcher.service`),
                 class: Types.toClassName(`DispatcherService`),
+                interface: Types.toClassName(`IDispatcher`),
+                actionMethod: Types.toTypeName(`ActionMethod`),
             },
         },
         businessLogic: {
@@ -335,17 +337,9 @@ function getModelMetadata({ model }) {
                 serviceFileName: Types.toFileName(`${camelCase}.update.service`),
                 serviceFilePath: Types.toPath(`${config.paths.businessLogicPath}update/${camelCase}.update.service`),
                 actionModelDiscriminantName: Types.toVariableName(`${camelCase}`),
-                actionName: Types.toVariableName(`Action_${PascalCase}`),
-                actionNameModelPart: Types.toVariableName(`${PascalCase}`),
-                actionResultName: Types.toVariableName(`ActionResult_${PascalCase}`),
-                createActionFunctionNameCreate: Types.toFunctionName(`createAction${PascalCase}Create`),
-                createActionFunctionNameCreateMany: Types.toFunctionName(`createAction${PascalCase}CreateMany`),
-                createActionFunctionNameUpdate: Types.toFunctionName(`createAction${PascalCase}Update`),
-                createActionFunctionNameUpdateMany: Types.toFunctionName(`createAction${PascalCase}UpdateMany`),
-                createActionFunctionNameUpsert: Types.toFunctionName(`createAction${PascalCase}Upsert`),
-                createActionFunctionNameUpsertMany: Types.toFunctionName(`createAction${PascalCase}UpsertMany`),
-                createActionFunctionNameDelete: Types.toFunctionName(`createAction${PascalCase}Delete`),
-                createActionFunctionNameDeleteMany: Types.toFunctionName(`createAction${PascalCase}DeleteMany`),
+                zodCreateObject: Types.toFunctionName(`${camelCase}CreateDecoder`),
+                zodUpdateObject: Types.toFunctionName(`${camelCase}UpdateDecoder`),
+                zodUpsertObject: Types.toFunctionName(`${camelCase}UpsertDecoder`),
             },
             dataRepositoryVariableName: Types.toVariableName(`data`),
         },
@@ -409,9 +403,6 @@ function getModelMetadata({ model }) {
             zodDecoderFnNames: {
                 id: Types.toFunctionName(`${camelCase}IdDecoder`),
                 fromDatabase: Types.toFunctionName(`${camelCase}DatabaseDecoder`),
-                createObject: Types.toFunctionName(`${camelCase}CreateDecoder`),
-                updateObject: Types.toFunctionName(`${camelCase}UpdateDecoder`),
-                upsertObject: Types.toFunctionName(`${camelCase}UpsertDecoder`),
             },
             dto: {
                 create: Types.toTypeName(`${PascalCase}CreateDTO`),

package/dist/lib/schema/types.d.ts

@@ -31,7 +31,7 @@ export type DiscriminantName = string & {
 export declare const toDiscriminantName: (t: string) => DiscriminantName;
 /**
  * The name of a model, e.g. "Aggregation".
-*/
+ */
 export type ModelName = string & {
     readonly ___type: 'ModelName';
 };
@@ -67,7 +67,7 @@ export declare const toAnnotatedTypeName: (name: TypeName) => AnnotatedTypeName;
 export declare const isAnnotatedTypeName: (t: string | AnnotatedTypeName) => t is AnnotatedTypeName;
 /**
  * The name of a model field, e.g. "name".
-*/
+ */
 export type FieldName = string & {
     readonly ___type: 'FieldName';
 };
@@ -77,7 +77,7 @@ export type FieldName = string & {
 export declare const toFieldName: (t: string) => FieldName;
 /**
  * The name of an Enum, e.g. "Language".
-*/
+ */
 export type EnumName = string & {
     readonly ___type: 'EnumName';
 };
@@ -87,7 +87,7 @@ export type EnumName = string & {
 export declare const toEnumName: (t: string) => EnumName;
 /**
  * The name of a function (e.g. "toAggregation").
-*/
+ */
 export type FunctionName = string & {
     readonly ___type: 'FunctionName';
 };
@@ -150,7 +150,7 @@ export declare const toPath: (t: string) => FilePath;
 /**
  * Branded string values that can be used as import statement values in the generators
  */
-export type ImportableTypes = FunctionName | ClassName | AnnotatedTypeName | VariableName | EnumName;
+export type ImportableTypes = FunctionName | ClassName | TypeName | AnnotatedTypeName | VariableName | EnumName;
 /**
  * Branded string values that can be used as paths in import statements
  */

package/dist/lib/utils/jsdoc.d.ts

@@ -1,4 +1,9 @@
+import type { Field } from '../schema/schema';
 /**
  * Returns a string of JSDoc comments from an array of lines.
  */
 export declare function toJsDocComment(comments: string[] | undefined): string;
+/**
+ * Returns a JSDoc comment for a field.
+ */
+export declare function getFieldComment(f: Field): string;

package/dist/lib/utils/jsdoc.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toJsDocComment = void 0;
+exports.getFieldComment = exports.toJsDocComment = void 0;
 /**
  * Returns a string of JSDoc comments from an array of lines.
  */
@@ -14,3 +14,24 @@ function toJsDocComment(comments) {
         .join('')} \n   */`;
 }
 exports.toJsDocComment = toJsDocComment;
+/**
+ * Returns a JSDoc comment for a field.
+ */
+function getFieldComment(f) {
+    const lines = [];
+    if (f.description) {
+        lines.push(...f.description.split('\n'));
+    }
+    else if (f.kind === 'enum' && f.enumerator.description) {
+        lines.push(...f.enumerator.description.split('\n'));
+    }
+    const _examples = f.attributes.examples;
+    if (_examples) {
+        lines.push(`Examples: ${_examples.map((e) => `"${e}"`).join(', ')}`);
+    }
+    if (lines.length === 0) {
+        return '';
+    }
+    return toJsDocComment(lines);
+}
+exports.getFieldComment = getFieldComment;

package/package.json

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