@postxl/generator 0.54.0 → 0.55.0

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

@@ -9,6 +9,7 @@ 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]: [
@@ -39,20 +40,50 @@ function generateImportExportExporterClass({ models, meta }) {
             }
             const linkedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
             if (field.isRequired) {
-                linkedItems.push(`await this.${linkedModelMeta.importExport.exportAddFunctionName}(item.${field.name})`);
+                linkedItems.push(`await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})`);
             }
             else {
                 linkedItems.push(`
           if (item.${field.name}) { 
-            await this.${linkedModelMeta.importExport.exportAddFunctionName}(item.${field.name}) 
+            await this.${linkedModelMeta.importExport.exportAddFunctionName}({id: item.${field.name}, includeChildren: false})
           }`);
             }
         }
+        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})
+          }`);
+            }
+        }
+        const childItems = childItemCalls.length > 0
+            ? `
+          if (includeChildren) {
+            ${childItemCalls.join('\n')}
+          }`
+            : '';
+        const signature = `{id, includeChildren = true}: {id: ${model.brandedIdType}, includeChildren?: boolean}`;
         addFunctions.push(`
         /**
          * Adds a ${modelMeta.userFriendlyName} and all related (and nested) dependencies to the export.
          */
-        public async ${modelMeta.importExport.exportAddFunctionName}(id: ${model.brandedIdType}) {
+        public async ${modelMeta.importExport.exportAddFunctionName}(${signature}) {
           if (this.${modelMeta.internalPluralName}.has(id)) {
             return
           }
@@ -64,11 +95,17 @@ function generateImportExportExporterClass({ models, meta }) {
           this.${modelMeta.internalPluralName}.set(id, item)
       
           ${linkedItems.join('\n')}
+
+          ${childItems}
         }
       `);
         addAllCalls.push(`this.${modelMeta.internalPluralName} = await this.viewService.${modelMeta.businessLogic.view.serviceVariableName}.getAll()`);
     }
     return /* ts */ `
+// For consistency, we include \`{ includeChildren = true }\` in the signature of every add function.
+// If the model does not have any related models, the \`includeChildren\` parameter is ignored.
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
 import { Logger } from '@nestjs/common'
 
 import { mapValues } from '@backend/common'
@@ -79,7 +116,7 @@ ${imports.generate()}
  * 
  * Usage:
  *  - Create an instance of the Exporter
- *  - Call the \`add{ModelName}(itemId)\` methods to add the items you want to export.
+ *  - Call the \`add{ModelName}({id})\` methods to add the items you want to export.
  *      This will automatically add all dependencies of the item.
  *  - Call the \`exportData()\` method to get the encoded Excel data.
  *  - Alternatively, you can call 'exportAll()' to dump all data. 

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

@@ -44,18 +44,17 @@ 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}`,
         });
     }
     const hasLinkedItems = variables.size > 0;

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

@@ -11,12 +11,17 @@ const jsdoc_1 = require("../../lib/utils/jsdoc");
  * Generates types for a given model.
  */
 function generateModelTypes({ model, meta }) {
-    var _a, _b;
+    var _a;
     const idField = model.idField;
     const imports = imports_1.ImportsGenerator.from(meta.types.filePath);
+    /**
+     * Tells whether model references other models.
+     */
     let hasLinkedItems = false;
     for (const relation of (0, fields_1.getRelationFields)(model)) {
+        hasLinkedItems = true;
         if (relation.relationToModel.typeName === model.typeName) {
+            // NOTE: All type definitions are already present in this file for this model.
             continue;
         }
         const refModel = relation.relationToModel;
@@ -29,7 +34,6 @@ function generateModelTypes({ model, meta }) {
             items: [refModel.brandedIdType, refMeta.types.typeName],
             from: refMeta.types.filePath,
         });
-        hasLinkedItems = true;
     }
     for (const f of (0, fields_1.getEnumFields)(model)) {
         const refEnumMeta = (0, meta_1.getEnumMetadata)({ enumerator: f.enumerator });
@@ -44,30 +48,34 @@ function generateModelTypes({ model, meta }) {
         from: schemaMeta.types.dto.path,
     });
     const decoderNames = meta.types.zodDecoderFnNames;
+    const linkedTypeDefinition = `
+    export type ${meta.types.linkedTypeName} = { 
+      ${model.fields
+        .map((f) => `
+            ${getFieldComment(f)}
+            ${getLinkedFieldType(f)}${f.isRequired ? '' : ' | null'}
+          `)
+        .join('\n')}
+    }
+  `;
     return /* ts */ `
 import { z } from 'zod'
 
 ${imports.generate()}
 
-${(0, jsdoc_1.toJsDocComment)((_b = (_a = model.description) === null || _a === void 0 ? void 0 : _a.split('\n')) !== null && _b !== void 0 ? _b : [])}
+${(0, jsdoc_1.toJsDocComment)((_a = model.description) === null || _a === void 0 ? void 0 : _a.split('\n'))}
 export type ${meta.types.typeName} = { 
   ${model.fields
-        .map((f) => `
-      ${getFieldComment(f)}
-      ${f.name}: ${getFieldType(f)}${f.isRequired ? '' : ' | null'}`)
+        .map((f) => {
+        return `
+        ${getFieldComment(f)}
+        ${f.name}: ${getFieldType(f)}${f.isRequired ? '' : ' | null'}
+      `;
+    })
         .join('\n')}
 }
 
-${!hasLinkedItems
-        ? ``
-        : `
-export type ${meta.types.linkedTypeName} = { 
-  ${model.fields
-            .map((f) => `
-${getFieldComment(f)}
-${getLinkedFieldType(f)}${f.isRequired ? '' : ' | null'}`)
-            .join('\n')}
-}`}
+${hasLinkedItems ? linkedTypeDefinition : ``}
 
 /**
  * Branded Id type that should be used to identify an instance of a ${meta.userFriendlyName}.
@@ -187,7 +195,7 @@ function getLinkedFieldType(f) {
         case 'enum':
             return `${f.name}: ${f.typeName}`;
         case 'relation':
-            return `${f.relatedModelBacklinkFieldName}: ${f.relationToModel.typeName}`;
+            return `${f.relationFieldName}: ${f.relationToModel.typeName}`;
         case 'id':
             return `${f.name}: ${f.model.brandedIdType}`;
         case 'scalar':

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

@@ -170,6 +170,10 @@ export type ModelFields = {
      * All fields of the model
      */
     fields: Field[];
+    /**
+     * A list of models that reference this model in their relations.
+     */
+    relatedModels: ModelCore[];
 };
 /**
  * A field of a model.
@@ -313,12 +317,12 @@ export type FieldRelation = Prettify<Omit<FieldCore, 'name'> & {
      */
     name: Types.FieldName;
     /**
-     * Name of the field in the related model that references this model (e.g. `aggregation`).
+     * Name of the relation field in the model.
      *
      * NOTE: This does not reference the database column name, but the field name
      *  in the model (e.g. not `aggregationId`, but `aggregation`).
      */
-    relatedModelBacklinkFieldName: Types.FieldName;
+    relationFieldName: Types.FieldName;
     /**
      * Name of the unbranded TypeScript type of the field, e.g. string
      *
@@ -329,7 +333,7 @@ export type FieldRelation = Prettify<Omit<FieldCore, 'name'> & {
      */
     unbrandedTypeName: Types.TypeName;
     /**
-     * The referenced model
+     * The referenced model.
      */
     relationToModel: ModelCore;
 }>;
@@ -343,12 +347,12 @@ export declare const isFieldRelation: (field: Field) => field is Prettify<Omit<F
      */
     name: Types.FieldName;
     /**
-     * Name of the field in the related model that references this model (e.g. `aggregation`).
+     * Name of the relation field in the model.
      *
      * NOTE: This does not reference the database column name, but the field name
      *  in the model (e.g. not `aggregationId`, but `aggregation`).
      */
-    relatedModelBacklinkFieldName: Types.FieldName;
+    relationFieldName: Types.FieldName;
     /**
      * Name of the unbranded TypeScript type of the field, e.g. string
      *
@@ -359,7 +363,7 @@ export declare const isFieldRelation: (field: Field) => field is Prettify<Omit<F
      */
     unbrandedTypeName: Types.TypeName;
     /**
-     * The referenced model
+     * The referenced model.
      */
     relationToModel: ModelCore;
 }>;

package/dist/prisma/parse.js

@@ -136,34 +136,43 @@ function parseModel({ dmmfModel, enums, models, config, }) {
     if (core.attributes.ignore) {
         return undefined;
     }
-    // NOTE: We assume that each relation may only reference one field. Because of this,
-    // we can "relate" a given relation to a scalar field used in the relation.
-    //   Since Prisma doesn't mark those fields as relations, we need to preprocess
-    // relations and then figure out which scalar fields are used in relations.
-    const relations = {};
+    // NOTE: We assume that each relation may only reference one field.
+    //       Because of this, we can "relate" a given relation to a scalar field
+    //       used as a foreign key.
+    //
+    //       Since Prisma doesn't mark foreign-key fields as relations,
+    //       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 ||
-            !dmmfField.relationFromFields ||
-            !dmmfField.relationToFields) {
+        if (dmmfField.kind !== 'object' || !dmmfField.relationName) {
             continue;
         }
-        if (dmmfField.relationFromFields.length > 1) {
-            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.relationName}`)} has more than one "from" field`);
-        }
         const referencedModel = models.find((m) => m.sourceName === dmmfField.type);
         if (!referencedModel) {
             (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.name}`)} references unknown model ${highlight(dmmfField.type)}.`);
         }
+        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) {
+            (0, error_1.throwError)(`Field ${highlight(`${dmmfModel.name}.${dmmfField.relationName}`)} has more than one "from" field`);
+        }
         if (dmmfField.relationOnDelete && dmmfField.relationOnDelete !== 'NoAction') {
             (0, error_1.throwError)(`Investigate model ${highlight(dmmfModel.name)}: "onDelete" attribute for relationship ${highlight(dmmfField.relationName)} must be "NoAction": any deletes must be handled in the application layer, e.g. to update repository and search caches!`);
         }
         // NOTE: At this point, we only have the `ModelCore`. After all models are parsed, we need to updated
         //       the relations with the full `Model`. This is done in the `linkModels` function.
-        relations[dmmfField.relationFromFields[0]] = referencedModel;
+        referencedModels[dmmfField.relationFromFields[0]] = referencedModel;
     }
     const relationFields = dmmfModel.fields
-        .filter((f) => f.kind === 'object' && f.relationToFields && f.relationToFields.length === 1)
+        .filter((f) => { var _a; return f.kind === 'object' && ((_a = f.relationToFields) === null || _a === void 0 ? void 0 : _a.length) === 1; })
         .reduce((acc, f) => {
         if (f.relationFromFields && f.relationFromFields[0]) {
             acc[f.relationFromFields[0]] = f;
@@ -171,9 +180,14 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         return acc;
     }, {});
     const fields = dmmfModel.fields
-        .filter((dmmfField) => 
-    // if field is a "backlink", i.e. the receiver of a relation, we ignore it
-    dmmfField.kind !== 'object')
+        .filter((dmmfField) => {
+        // NOTE: This is a relation field that we'll handle when we process its foreign-key. If it's a back relation
+        //       then it won't have a foreign-key and we simply ignore it.
+        if (dmmfField.kind === 'object') {
+            return false;
+        }
+        return true;
+    })
         .map((dmmfField) => {
         const attributes = (0, attributes_1.getFieldAttributes)(dmmfField);
         const fieldName = highlight(`${dmmfModel.name}.${dmmfField.name}`);
@@ -187,17 +201,19 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             schemaType: dmmfField.type,
         };
         // NOTE: We mark scalar fields which are used in relations as relation fields by Purple Schema standards.
-        if (dmmfField.name in relations) {
-            const refModel = relations[dmmfField.name];
+        if (dmmfField.name in referencedModels) {
+            const refModel = referencedModels[dmmfField.name];
             const refField = relationFields[dmmfField.name];
             if (!refField) {
                 (0, error_1.throwError)(`${fieldName}: Relation field ${highlight(dmmfField.name)} not found.`);
             }
-            return Object.assign(Object.assign({ kind: 'relation' }, shared), { relatedModelBacklinkFieldName: Types.toFieldName(refField.name), typeName: Types.toTypeName(dmmfField.type), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
+            const _field = Object.assign(Object.assign({ kind: 'relation' }, shared), { relationFieldName: Types.toFieldName(refField.name), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
+            return _field;
         }
         if (dmmfField.isId) {
             const isGeneratedField = isAutoIncrementField(dmmfField) || isUUIDField(dmmfField);
-            return Object.assign(Object.assign({ kind: 'id' }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isGeneratedField, unbrandedTypeName: getTsTypeForId(dmmfField), model: core });
+            const _field = Object.assign(Object.assign({ kind: 'id' }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isGeneratedField, unbrandedTypeName: getTsTypeForId(dmmfField), model: core });
+            return _field;
         }
         if (dmmfField.kind === 'scalar') {
             let validation = undefined;
@@ -210,14 +226,16 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             if (dmmfField.type === 'Float') {
                 validation = { type: 'float' };
             }
-            return Object.assign(Object.assign({ kind: 'scalar', validation }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isAutoIncrementField(dmmfField), tsTypeName: getTsTypeForScalar(dmmfField) });
+            const _field = Object.assign(Object.assign({ kind: 'scalar', validation }, shared), { isUnique: isUniqueField(dmmfField), isGenerated: isAutoIncrementField(dmmfField), tsTypeName: getTsTypeForScalar(dmmfField) });
+            return _field;
         }
         if (dmmfField.kind === 'enum') {
             const fieldEnumDef = enums.find((e) => e.sourceName === dmmfField.type);
             if (!fieldEnumDef) {
                 (0, error_1.throwError)(`${fieldName}: Field references unknown enum ${highlight(dmmfField.type)}.`);
             }
-            return Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
+            const _field = Object.assign(Object.assign({ kind: 'enum' }, shared), { typeName: getTsTypeForEnum(dmmfField), enumerator: fieldEnumDef });
+            return _field;
         }
         (0, error_1.throwError)(`${fieldName} is not scalar, enum nor relation.`);
     })
@@ -228,7 +246,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         nameField,
         fields,
         createdAtField,
-        updatedAtField });
+        updatedAtField, relatedModels: Object.values(relatedModels) });
 }
 /**
  * Checks that there is exactly one id field and that there is at most one default field.
@@ -290,7 +308,13 @@ function validateFields({ fields, model: { name } }) {
     if (!idField) {
         (0, error_1.throwError)(`Model ${highlight(name)} does not have an id field`);
     }
-    return { idField, defaultField, nameField: (_a = labelField !== null && labelField !== void 0 ? labelField : nameField) !== null && _a !== void 0 ? _a : idField, createdAtField, updatedAtField };
+    return {
+        idField,
+        defaultField,
+        nameField: (_a = labelField !== null && labelField !== void 0 ? labelField : nameField) !== null && _a !== void 0 ? _a : idField,
+        createdAtField,
+        updatedAtField,
+    };
 }
 function isAutoIncrementField(fieldDmmf) {
     if (fieldDmmf.default === undefined) {

package/package.json

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