@postxl/generator 0.56.2 → 0.56.4

package/dist/generator.js

@@ -60,6 +60,7 @@ const importexport_exporter_class_generator_1 = require("./generators/indices/im
 const importexport_import_service_generator_1 = require("./generators/indices/importexport-import-service.generator");
 const importexport_types_generator_1 = require("./generators/indices/importexport-types.generator");
 const repositories_generator_1 = require("./generators/indices/repositories.generator");
+const routes_index_generator_1 = require("./generators/indices/routes-index.generator");
 const seed_migration_generator_1 = require("./generators/indices/seed-migration.generator");
 const seed_template_generator_1 = require("./generators/indices/seed-template.generator");
 const selectors_generator_1 = require("./generators/indices/selectors.generator");
@@ -234,7 +235,7 @@ function generate({ models, enums, config, prismaClientPath, logger, }) {
         generated.write(`/${meta.seedData.initialMigrationFilePath}.ts`, (0, seed_migration_generator_1.generateSeedMigration)({ models, meta }));
         generated.write(`/${meta.seedData.templateExcelFilePath}`, yield (0, seed_template_generator_1.generateSeedExcelTemplate)({ models }));
         // Routes
-        generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, route_generator_1.generateRoutesIndex)({ models, meta }));
+        generated.write(`/${meta.trpc.routesFilePath}.ts`, (0, routes_index_generator_1.generateRoutesIndex)({ models, meta }));
         // Types
         generated.write(`/${meta.types.indexFilePath}.ts`, (0, types_generator_2.generateTypesIndex)({ models, enums, meta }));
         // -------------------------------------------------------------------------

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/dispatcher-service.generator.js

@@ -54,7 +54,7 @@ export class ${meta.actions.dispatcher.class} {
     const execution = await this.actionExecutionFactory.create({ action, dbService: this.dbService, user })
 
     try {
-      const result = await (this.execute({ action, execution }) as Promise<ResultOfAction<A>>)
+      const result = await this.execute({ action, execution })
 
       await execution.success(result)
 
@@ -65,22 +65,35 @@ export class ${meta.actions.dispatcher.class} {
     }
   }
 
-  private async execute({ action, execution }: { action: Action; execution: IActionExecution }) {
+  private async execute<A extends Action>({
+    action,
+    execution,
+  }: {
+    action: A
+    execution: IActionExecution
+  }): Promise<ResultOfAction<A>> {
     switch (action.scope) {
       ${models
         .map((model) => {
         const modelMeta = (0, meta_1.getModelMetadata)({ model });
         return `
-        case '${modelMeta.businessLogic.scopeName}':
-          return this.updateService.${modelMeta.businessLogic.update.serviceVariableName}.dispatch({ action, execution })
+        case '${modelMeta.businessLogic.scopeName}': {
+          const method = this.updateService.${modelMeta.businessLogic.update.serviceVariableName}[action.type] as (params: {
+            data: A['payload']
+            execution: IActionExecution
+          }) => Promise<ResultOfAction<A>>
+    
+          return method({ data: action.payload, execution })
+        }
         `;
     })
         .join('\n')}
+
       case 'seed':
-        return this.seedService.dispatch({ action, execution })
+        return this.seedService.dispatch({ action, execution }) as Promise<ResultOfAction<A>>
       
       case 'import':
-        return this.importService.dispatch({ action, execution })
+        return this.importService.dispatch({ action, execution }) as Promise<ResultOfAction<A>>
       
       default:
         throw new ExhaustiveSwitchCheck(action)

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

@@ -9,7 +9,6 @@ const types_1 = require("../../lib/schema/types");
  */
 function generateImportExportExporterClass({ models, meta }) {
     const imports = imports_1.ImportsGenerator.from(meta.importExport.exporterClass.filePath);
-    const modelsMap = new Map(models.map((model) => [model.name, model]));
     imports.addImports({
         [meta.businessLogic.view.importPath]: [meta.businessLogic.view.serviceClassName],
         [meta.importExport.decoder.fullDecoderFilePath]: [
@@ -50,27 +49,15 @@ function generateImportExportExporterClass({ models, meta }) {
             }
         }
         const childItemCalls = [];
-        for (const relatedModelCore of model.relatedModels) {
-            const relatedModel = modelsMap.get(relatedModelCore.name);
-            // This should not happen as the related models are always present
-            if (!relatedModel) {
-                continue;
-            }
-            for (const field of relatedModel.fields) {
-                if (field.kind !== 'relation') {
-                    continue;
-                }
-                if (field.relationToModel.name !== model.name) {
-                    continue;
-                }
-                const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: relatedModel });
-                const linkedFieldMeta = (0, meta_1.getFieldMetadata)({ field: field });
-                childItemCalls.push(`
-          // Add all ${linkedModelMeta.userFriendlyNamePlural} that are related to the ${modelMeta.userFriendlyName} via ${field.name}
-          for (const ${field.name} of await this.viewService.${linkedModelMeta.businessLogic.view.serviceVariableName}.data.${linkedFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {
-            await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: ${field.name}, includeChildren})
-          }`);
-            }
+        for (const { referencingField, referencingModel } of model.references) {
+            const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: referencingModel });
+            const linkedFieldMeta = (0, meta_1.getFieldMetadata)({ field: referencingField });
+            childItemCalls.push(`
+        // Add all ${linkedModelMeta.userFriendlyNamePlural} that are related to the ${modelMeta.userFriendlyName} via ${referencingField.name}
+        for (const ${referencingField.name} of await this.viewService.${linkedModelMeta.businessLogic.view.serviceVariableName}.data.${linkedFieldMeta.getByForeignKeyIdsMethodFnName}(id)) {
+          await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: ${referencingField.name}, includeChildren})
+        }
+        `);
         }
         const childItems = childItemCalls.length > 0
             ? `

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/indices/routes-index.generator.d.ts

@@ -0,0 +1,9 @@
+import { SchemaMetaData } from '../../lib/meta';
+import { Model } from '../../lib/schema/schema';
+/**
+ * Generates the index file for all the routes.
+ */
+export declare function generateRoutesIndex({ models, meta }: {
+    models: Model[];
+    meta: SchemaMetaData;
+}): string;

package/dist/generators/indices/routes-index.generator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRoutesIndex = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+/**
+ * Generates the index file for all the routes.
+ */
+function generateRoutesIndex({ models, meta }) {
+    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
+    const imports = imports_1.ImportsGenerator.from(meta.trpc.routesFilePath);
+    for (const { meta } of mm) {
+        imports.addImport({ items: [meta.trpc.routerName], from: meta.trpc.routerFilePath });
+    }
+    return /* ts */ `
+      ${imports.generate()}
+  
+      /**
+       * Object with all generated routes.
+       */
+      export const routes = {
+        ${mm.map(({ meta }) => `${meta.trpc.routerName}`).join(',\n')}
+      }
+    `;
+}
+exports.generateRoutesIndex = generateRoutesIndex;

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

@@ -13,25 +13,48 @@ const jsdoc_1 = require("../../lib/utils/jsdoc");
  */
 function generateModelBusinessLogicUpdate({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
+    /**
+     * Shorthand variable for relevant metadata.
+     */
+    const m = {
+        /**
+         * The name of the interface that handles the action execution.
+         */
+        iExecution: schemaMeta.actions.execution.interface,
+        /**
+         * The name of the type that represents a fully typed, flat object, e.g. `Aggregation`
+         */
+        typeName: meta.types.typeName,
+        /**
+         * Type of the ID field that is specific to this model, e.g. `AggregationId`
+         */
+        brandedId: model.brandedIdType,
+        /**
+         * Internal type name for create payload, e.g. `CreateAggregation`
+         */
+        createType: `Create${meta.internalSingularNameCapitalized}`,
+        /**
+         * Internal type name for update payload, e.g. `UpdateAggregation`
+         */
+        updateType: `Update${meta.internalSingularNameCapitalized}`,
+        /**
+         * Internal type name for upsert payload, e.g. `UpsertAggregation`
+         */
+        upsertType: `Upsert${meta.internalSingularNameCapitalized}`,
+    };
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.update.serviceFilePath);
     imports.addImports({
         [meta.data.importPath]: meta.data.repository.className,
         [meta.types.importPath]: [
-            (0, types_1.toAnnotatedTypeName)(model.brandedIdType),
-            (0, types_1.toAnnotatedTypeName)(meta.types.typeName),
+            (0, types_1.toAnnotatedTypeName)(m.brandedId),
+            (0, types_1.toAnnotatedTypeName)(m.typeName),
             meta.types.toBrandedIdTypeFnName,
         ],
         [meta.businessLogic.view.serviceFilePath]: [meta.businessLogic.view.serviceClassName],
-        [schemaMeta.actions.importPath]: [
-            schemaMeta.actions.actionExecution.interface,
-            schemaMeta.actions.dispatcher.result,
-            schemaMeta.actions.dispatcher.interface,
-            schemaMeta.actions.dispatcher.actionMethod,
-        ],
+        [schemaMeta.actions.importPath]: [schemaMeta.actions.execution.interface, schemaMeta.actions.dispatcher.definition],
         [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) {
@@ -40,7 +63,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,
         });
     }
     /**
@@ -50,27 +73,70 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
      */
     const modelRepositoryVariableName = meta.businessLogic.dataRepositoryVariableName;
     const constructorParameters = [
-        `public readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
+        `private readonly ${modelRepositoryVariableName}: ${meta.data.repository.className}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.update.serviceClassName})) private readonly updateService: ${schemaMeta.businessLogic.update.serviceClassName}`,
         `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly viewService: ${schemaMeta.businessLogic.view.serviceClassName}`,
     ];
     const { zodCreateObject, zodUpdateObject, zodUpsertObject } = meta.businessLogic.update;
-    /**
-     * 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<${schemaMeta.actions.dispatcher.result}<Actions, AM>>`;
+    const { view, update } = meta.businessLogic;
+    /* prettier-ignore */
     return /* ts */ `
     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}"
 
-    
+    export type Actions = {
+      ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
+      create: {
+        payload: ${m.createType}
+        result: ${m.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`])}
+      createMany: {
+        payload: ${m.createType}[]
+        result: ${m.typeName}[]
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
+      update: {
+        payload: ${m.updateType}
+        result: ${m.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
+      updateMany: {
+        payload: ${m.updateType}[]
+        result: ${m.typeName}[]
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
+      upsert: {
+        payload: ${m.upsertType}
+        result: ${m.typeName}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
+      upsertMany: {
+        payload: ${m.upsertType}[]
+        result: ${m.typeName}[]
+      }
+      
+      ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} and returns its id.`])}
+      delete: {
+        payload: ${m.brandedId}
+        result: ${m.brandedId}
+      }
+
+      ${(0, jsdoc_1.toJsDocComment)([`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`])}
+      deleteMany: {
+        payload: ${m.brandedId}[]
+        result: ${m.brandedId}[]
+      }
+    }
 
     /**
      * Zod decoder for validating the create input of a ${meta.userFriendlyName}.
@@ -82,6 +148,8 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         .join(',')}
     })
 
+    type ${m.createType} = z.infer<typeof ${zodCreateObject}>
+
     /**
      * Zod decoder for validating the update input of a ${meta.userFriendlyName} .
      */
@@ -92,112 +160,68 @@ function generateModelBusinessLogicUpdate({ model, meta }) {
         .join(',')}
     })
 
+    type ${m.updateType} = z.infer<typeof ${zodUpdateObject}>
+
     /**
      * Zod decoder for validating the upsert input of a ${meta.userFriendlyName} .
      */
     export const ${zodUpsertObject} = z.union([${zodUpdateObject}, ${zodCreateObject}])
+    
+    type ${m.upsertType} = z.infer<typeof ${zodUpsertObject}>
+
+    export type ${update.serviceInterfaceName} = ${schemaMeta.actions.dispatcher.definition}<Actions>
+
+    @Injectable()
+    export class ${update.serviceClassName} implements ${update.serviceInterfaceName} {
+
+      /**
+       * Instance of the ${meta.userFriendlyName} view service for convenience.
+       */
+      private view: ${view.serviceClassName}
+
+      constructor(${constructorParameters.join(',\n')}) {
+        this.view = this.viewService.${view.serviceVariableName}
+      }
 
-    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}
+      public async create({ data, execution }: { data: ${m.createType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+        return this.data.create({ item: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`])}
-      createMany: {
-        payload: z.infer<typeof ${zodCreateObject}>[]
-        result: ${meta.types.typeName}[]
+      public async createMany({ data, execution }: { data: ${m.createType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
+        return this.data.createMany({ items: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
-      update: {
-        payload: z.infer<typeof ${zodUpdateObject}>
-        result: ${meta.types.typeName}
+      public async update({ data, execution }: { data: ${m.updateType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+        return this.data.update({ item: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
-      updateMany: {
-        payload: z.infer<typeof ${zodUpdateObject}>[]
-        result: ${meta.types.typeName}[]
+      public async updateMany({ data, execution }: { data: ${m.updateType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
+        return this.data.updateMany({ items: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
-      upsert: {
-        payload: z.infer<typeof ${zodUpsertObject}>
-        result: ${meta.types.typeName}
+      public async upsert({ data, execution }: { data: ${m.upsertType}; execution: ${m.iExecution} }): Promise<${m.typeName}> {
+        return this.data.upsert({ item: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
-      upsertMany: {
-        payload: z.infer<typeof ${zodUpsertObject}>[]
-        result: ${meta.types.typeName}[]
+      public async upsertMany({ data, execution }: { data: ${m.upsertType}[]; execution: ${m.iExecution} }): Promise<${m.typeName}[]> {
+        return this.data.upsertMany({ items: data, execution })
       }
-      
+
       ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} and returns its id.`])}
-      delete: {
-        payload: ${model.brandedIdType}
-        result: ${model.brandedIdType}
+      public async delete({ data, execution }: { data: ${m.brandedId}; execution: ${m.iExecution} }): Promise<${m.brandedId}> {
+        return this.data.delete({ id: data, execution })
       }
 
       ${(0, jsdoc_1.toJsDocComment)([`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`])}
-      deleteMany: {
-        payload: ${model.brandedIdType}[]
-        result: ${model.brandedIdType}[]
-      }
-    }
-
-    @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<AM extends ${dispatcher.actionMethod}<Scope, Actions>>({
-        action,
-        execution,
-      }: {
-        action: UnionOmit<AM, 'result'>
-        execution: ${schemaMeta.actions.actionExecution.interface}
-      }): ${dispatcherReturnValue} {
-        switch (action.type) {
-          case 'create':
-            return this.data.create({ item: action.payload, execution }) as ${dispatcherReturnValue}
-
-          case 'createMany':
-            return this.data.createMany({ items: action.payload, execution }) as ${dispatcherReturnValue}
-
-          case 'update':
-            return this.data.update({ item: action.payload, execution }) as ${dispatcherReturnValue}
-
-          case 'updateMany':
-            return this.data.updateMany({ items: action.payload, execution }) as ${dispatcherReturnValue}
-
-          case 'upsert':
-            return this.data.upsert({ item: action.payload, execution }) as ${dispatcherReturnValue}
-
-          case 'upsertMany':
-            return this.data.upsertMany({ items: action.payload, execution }) as ${dispatcherReturnValue}
-
-          case 'delete':
-            return this.data.delete({ id: action.payload, execution }) as ${dispatcherReturnValue}
-
-          case 'deleteMany':
-            return this.data.deleteMany({ ids: action.payload, execution }) as ${dispatcherReturnValue}
-          
-          default: 
-            throw new ExhaustiveSwitchCheck(action)
-          
-        }
-      }
+      public async deleteMany({ data, execution }: { data: ${m.brandedId}[]; execution: ${m.iExecution} }): Promise<${m.brandedId}[]> {
+        return this.data.deleteMany({ ids: data, execution })
+      }  
     }
  `;
 }

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/generators/models/route.generator.d.ts

@@ -1,4 +1,4 @@
-import { ModelMetaData, SchemaMetaData } from '../../lib/meta';
+import { ModelMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
  * Generates TRPC route for a given model.
@@ -7,10 +7,3 @@ export declare function generateRoute({ model, meta }: {
     model: Model;
     meta: ModelMetaData;
 }): string;
-/**
- * Generates the index file for all the routes.
- */
-export declare function generateRoutesIndex({ models, meta }: {
-    models: Model[];
-    meta: SchemaMetaData;
-}): string;

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

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRoutesIndex = exports.generateRoute = void 0;
+exports.generateRoute = void 0;
 const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
 const types_1 = require("../../lib/schema/types");
 /**
  * Generates TRPC route for a given model.
@@ -96,24 +95,3 @@ export const ${meta.trpc.routerName} = router({
 `;
 }
 exports.generateRoute = generateRoute;
-/**
- * Generates the index file for all the routes.
- */
-function generateRoutesIndex({ models, meta }) {
-    const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
-    const imports = imports_1.ImportsGenerator.from(meta.trpc.routesFilePath);
-    for (const { meta } of mm) {
-        imports.addImport({ items: [meta.trpc.routerName], from: meta.trpc.routerFilePath });
-    }
-    return /* ts */ `
-    ${imports.generate()}
-
-    /**
-     * Object with all generated routes.
-     */
-    export const routes = {
-      ${mm.map(({ meta }) => `${meta.trpc.routerName}`).join(',\n')}
-    }
-  `;
-}
-exports.generateRoutesIndex = generateRoutesIndex;

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.
              */
@@ -117,17 +117,27 @@ export type SchemaMetaData = {
              */
             class: Types.ClassName;
             /**
-             * The name of the interface that indicates a service can dispatch actions.
+             * The definition type that may be used to create a dispatcher conforming class.
              */
-            interface: Types.ClassName;
+            definition: Types.TypeName;
+        };
+        definition: {
+            /**
+             * The schema type to define action definitions.
+             */
+            schema: 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 generated payload of the defined actions.
              */
-            actionMethod: Types.TypeName;
+            payload: Types.TypeName;
             /**
-             * The name of the type that represents the result of the action method.
+             * The generated result of the defined actions.
              */
             result: Types.TypeName;
+            /**
+             * The transformer type that converts action definitions into results dictionary.
+             */
+            resultDict: Types.TypeName;
         };
     };
     /**
@@ -909,9 +919,13 @@ export type ModelMetaData = {
          */
         update: {
             /**
-             * The name by which the model's update class is exposed in the updateService/context. (e.g. aggregations)
+             * The name by which the model's update class is exposed in the updateService/context. (e.g. AggregationUpdateService)
              */
             serviceClassName: Types.ClassName;
+            /**
+             * The name of the interface that represents the update service for this model. (e.g. IAggregationUpdateService)
+             */
+            serviceInterfaceName: Types.TypeName;
             /**
              * The name by which the model's service is exposed in the updateService/context. (e.g. aggregations)
              */

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`),
@@ -89,9 +89,13 @@ function getSchemaMetadata({ config }) {
             dispatcher: {
                 filePath: Types.toPath(`${config.paths.actionsPath}dispatcher.service`),
                 class: Types.toClassName(`DispatcherService`),
-                interface: Types.toClassName(`IDispatcher`),
-                actionMethod: Types.toTypeName(`ActionMethod`),
-                result: Types.toTypeName(`ActionMethodResult`),
+                definition: Types.toTypeName('IDispatcherDefinition'),
+            },
+            definition: {
+                schema: Types.toTypeName('ActionDef'),
+                payload: Types.toTypeName('ActionDefPayload'),
+                result: Types.toTypeName('ActionDefResult'),
+                resultDict: Types.toTypeName('ActionDefResultDict'),
             },
         },
         businessLogic: {
@@ -334,6 +338,7 @@ function getModelMetadata({ model }) {
             },
             update: {
                 serviceClassName: Types.toClassName(`${PascalCase}UpdateService`),
+                serviceInterfaceName: Types.toTypeName(`I${PascalCase}UpdateService`),
                 serviceVariableName: Types.toVariableName(`${uncapitalizedPlural}`),
                 serviceFileName: Types.toFileName(`${camelCase}.update.service`),
                 serviceFilePath: Types.toPath(`${config.paths.businessLogicPath}update/${camelCase}.update.service`),

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

@@ -173,7 +173,16 @@ export type ModelFields = {
     /**
      * A list of models that reference this model in their relations.
      */
-    relatedModels: ModelCore[];
+    references: {
+        /**
+         * The name of the field in the referencing model that references this model.
+         */
+        referencingField: FieldRelation;
+        /**
+         * The model that references this model.
+         */
+        referencingModel: ModelCore;
+    }[];
 };
 /**
  * A field of a model.

package/dist/prisma/parse.js

@@ -41,9 +41,27 @@ function parsePrismaSchema({ datamodel: { enums: enumsRaw, models: modelsRaw },
     // NOTE: We preprocess models and enums so that we can populate relationships.
     const models = modelsRaw.map((dmmfModel) => parseModelCore({ dmmfModel, config }));
     const enums = enumsRaw.map((dmmfEnum) => parseEnum({ dmmfEnum, config }));
+    // NOTE: Then we parse the fields of the models.
     const modelsWithFields = modelsRaw
         .map((dmmfModel) => parseModel({ dmmfModel, models, enums, config }))
         .filter(isModelNotIgnored);
+    // NOTE: Lastly we link back-relations to models.
+    for (const mwf of modelsWithFields) {
+        for (const field of mwf.fields) {
+            if (field.kind !== 'relation') {
+                continue;
+            }
+            const referencedModel = modelsWithFields.find((m) => m.sourceName === field.relationToModel.sourceName);
+            if (!referencedModel) {
+                // NOTE: This should never happen because Prisma should validate the validity of the relation.
+                (0, error_1.throwError)(`Model ${highlight(mwf.name)} not found!`);
+            }
+            referencedModel.references.push({
+                referencingModel: mwf,
+                referencingField: field,
+            });
+        }
+    }
     return { models: modelsWithFields, enums };
 }
 exports.parsePrismaSchema = parsePrismaSchema;
@@ -144,10 +162,6 @@ function parseModel({ dmmfModel, enums, models, config, }) {
     //       we need to preprocess relations and then figure out which scalar
     //       fields are actually foreign-keys.
     const referencedModels = {};
-    /**
-     * A map of models that are referenced in any way in the relations.
-     */
-    const relatedModels = {};
     for (const dmmfField of dmmfModel.fields) {
         if (dmmfField.kind !== 'object' || !dmmfField.relationName) {
             continue;
@@ -158,7 +172,6 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         }
         if (!dmmfField.relationFromFields || dmmfField.relationFromFields.length === 0) {
             // NOTE: This field has no foreign-key values in this model so it must be a back-relation.
-            relatedModels[dmmfField.type] = referencedModel;
             continue;
         }
         if (dmmfField.relationFromFields.length > 1) {
@@ -172,11 +185,10 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         referencedModels[dmmfField.relationFromFields[0]] = referencedModel;
     }
     const relationFields = dmmfModel.fields
-        .filter((f) => { var _a; return f.kind === 'object' && ((_a = f.relationToFields) === null || _a === void 0 ? void 0 : _a.length) === 1; })
+        .filter((f) => { var _a, _b; return f.kind === 'object' && ((_a = f.relationToFields) === null || _a === void 0 ? void 0 : _a.length) === 1 && ((_b = f.relationFromFields) === null || _b === void 0 ? void 0 : _b.length) === 1; })
         .reduce((acc, f) => {
-        if (f.relationFromFields && f.relationFromFields[0]) {
-            acc[f.relationFromFields[0]] = f;
-        }
+        // NOTE: It's safe to assume that `relationFromFields` and `relationToFields` are defined because of the filter above.
+        acc[f.relationFromFields[0]] = f;
         return acc;
     }, {});
     const fields = dmmfModel.fields
@@ -246,7 +258,9 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         nameField,
         fields,
         createdAtField,
-        updatedAtField, relatedModels: Object.values(relatedModels) });
+        updatedAtField, 
+        // NOTE: This is only a stub because we link references after all models were parsed above.
+        references: [] });
 }
 /**
  * Checks that there is exactly one id field and that there is at most one default field.

package/package.json

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