@postxl/generator 0.54.0 → 0.56.0

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.
@@ -44,24 +46,30 @@ function generateModelBusinessLogicView({ model, meta }) {
         const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
         const variableGetter = `await this.${viewServiceClassName}.${refMeta.businessLogic.view.serviceVariableName}.get(itemRaw.${relation.name})`;
         const variablePresenceCheck = `
-      if (!${relation.relatedModelBacklinkFieldName}) {
+      if (!${relation.relationFieldName}) {
         throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
       }
       `;
-        const relationVariableName = relation.relatedModelBacklinkFieldName;
+        const relationVariableName = relation.relationFieldName;
+        const relationVariableDefinition = relation.isRequired
+            ? `${variableGetter};${variablePresenceCheck}`
+            : `itemRaw.${relation.name} !== null ? ${variableGetter} : null`;
         variables.set(relation.name, {
             variableName: relationVariableName,
-            variableDefinition: `
-      const ${relationVariableName} = ${relation.isRequired
-                ? `${variableGetter};${variablePresenceCheck}`
-                : `itemRaw.${relation.name} !== null ? ${variableGetter} : null`} 
-      `,
+            variableDefinition: `const ${relationVariableName} = ${relationVariableDefinition}`,
         });
+        if (relation.relationToModel.typeName !== model.typeName) {
+            imports.addImport({
+                items: [refMeta.types.toBrandedIdTypeFnName],
+                from: refMeta.types.filePath,
+            });
+            imports.addTypeImport({
+                items: [refModel.brandedIdType, refMeta.types.typeName],
+                from: refMeta.types.filePath,
+            });
+        }
     }
     const hasLinkedItems = variables.size > 0;
-    if (hasLinkedItems) {
-        imports.addTypeImport({ from: meta.types.importPath, items: [meta.types.linkedTypeName] });
-    }
     const linkedItemsGetterFn = `
     /**
      * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
@@ -92,6 +100,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 */
@@ -100,6 +118,8 @@ import { FilterOperator } from '@backend/common'
 
 ${imports.generate()}
 
+${hasLinkedItems ? linkedTypeDefinition : ''}
+
 @Injectable()
 export class ${meta.businessLogic.view.serviceClassName} {
   constructor(${constructorParameters.join(',\n')}) {}
@@ -253,3 +273,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})),
 })
 `;
 }