@postxl/generator 0.56.3 → 0.56.5

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/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,36 @@ 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>>
+    
+          // NOTE: We need to bind the method to the service instance, as it is a method of the service and not a standalone function.
+          return method.bind(this.updateService.${modelMeta.businessLogic.update.serviceVariableName})({ 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/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,21 +13,45 @@ 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.execution.interface,
-            schemaMeta.actions.dispatcher.interface,
-            schemaMeta.actions.definition.payload,
-            schemaMeta.actions.definition.result,
-        ],
+        [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,
     });
@@ -49,28 +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;
-    const { dispatcher, definition } = schemaMeta.actions;
-    /**
-     * A return value of the dispatcher.
-     *
-     * NOTE: We need to cast to the return value every time so that the function correctly determines the return type.
-     */
-    const dispatcherReturnValue = `Promise<${definition.result}<Actions, A>>`;
+    const { view, update } = meta.businessLogic;
+    /* prettier-ignore */
     return /* ts */ `
     import { Inject, Injectable, forwardRef } from '@nestjs/common'
-    import { ExhaustiveSwitchCheck } 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<A extends ${definition.payload}<Scope, Actions>>({
-        action,
-        execution,
-      }: {
-        action: A
-        execution: ${schemaMeta.actions.execution.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/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

@@ -117,9 +117,9 @@ 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: {
             /**
@@ -919,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

@@ -89,7 +89,7 @@ function getSchemaMetadata({ config }) {
             dispatcher: {
                 filePath: Types.toPath(`${config.paths.actionsPath}dispatcher.service`),
                 class: Types.toClassName(`DispatcherService`),
-                interface: Types.toClassName(`IDispatcher`),
+                definition: Types.toTypeName('IDispatcherDefinition'),
             },
             definition: {
                 schema: Types.toTypeName('ActionDef'),
@@ -338,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.3",
+  "version": "0.56.5",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {