@postxl/generator 0.15.6 → 0.15.7

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

@@ -33,72 +33,90 @@ const Types = __importStar(require("../../lib/schema/types"));
  */
 function generateModelBusinessLogic({ model, meta }) {
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.serviceFilePath);
-    const dependencies = new Map();
     imports.addImport({ from: meta.data.importPath, items: [meta.data.repositoryClassName] });
     imports.addImport({ from: meta.types.importPath, items: [model.brandedIdType, meta.types.typeName] });
     /**
-     * Set of repositories (one for each referenced model) to be injected into the constructor.
+     * The name of the variable that holds the repository instance for the current model
+     * (e.g. when we generate business logic service for Aggregation, the AggregationRepository
+     * would be referenced using `this.data` variable).
+     */
+    const modelRepositoryVariableName = Types.toVariableName('data');
+    /**
+     * A map of referenced models indexed by the name of model's repository class.
+     */
+    const dependencies = new Map();
+    /**
+     * Variable names and their definitions indexed by the name of the relation they represent.
      */
-    const dataRepositoryVariableName = Types.toVariableName('data');
-    dependencies.set(meta.data.repositoryClassName, {
-        repositoryClassName: meta.data.repositoryClassName,
-        localRepositoryVariableName: dataRepositoryVariableName,
-    });
-    const linkedForeignBacklinkFields = new Map();
-    // Converts each relationship to a variable that is pulled from the referenced model's repository - and validates
-    // that it exists in case the relationship is required.
-    // Variable definition and name of the variable is stored in a Map for each relationship - and is referenced in
-    // the `getLinkedItem` function.
+    const variables = new Map();
     for (const relation of (0, fields_1.getRelationFields)(model)) {
         const refModel = relation.relationToModel;
         const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
         imports.addImport({ from: refMeta.data.importPath, items: [refMeta.data.repositoryClassName] });
-        /**
-         * Internal variable pointing to an instance of a referenced repository.
-         */
-        const repoReferenceName = relation.relationToModel.typeName !== model.typeName ? refMeta.internalPluralName : dataRepositoryVariableName;
-        dependencies.set(refMeta.data.repositoryClassName, {
-            localRepositoryVariableName: repoReferenceName,
-            repositoryClassName: refMeta.data.repositoryClassName,
-        });
-        const variableDefinition = `
-      const ${relation.relatedModelBacklinkFieldName} = this.${repoReferenceName}.get(itemRaw.${relation.name})
-      ${!relation.isRequired
-            ? ''
-            : `if (!${relation.relatedModelBacklinkFieldName}) {
-              throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
-            }`}      
-      `;
-        linkedForeignBacklinkFields.set(relation.name, {
-            fieldName: relation.relatedModelBacklinkFieldName,
-            variableDefinition,
-        });
+        const variablePresenceCheck = `
+      if (!${relation.relatedModelBacklinkFieldName}) {
+        throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
+      }
+    `;
+        const relationVariableName = relation.relatedModelBacklinkFieldName;
+        if (relation.relationToModel.typeName === model.typeName) {
+            // NOTE: If the referenced model is a self-relation, we want to reuse the instance of the repository
+            //      that is already injected into the constructor meaning that we don't need to set up a dependency and a local variable.
+            variables.set(relation.name, {
+                variableName: relationVariableName,
+                variableDefinition: `
+          const ${relationVariableName} = this.data.get(itemRaw.${relation.name})
+          ${relation.isRequired ? variablePresenceCheck : ``}      
+        `,
+            });
+        }
+        else {
+            const refRepoVariableName = refMeta.internalPluralName;
+            dependencies.set(refMeta.data.repositoryClassName, {
+                localRepositoryVariableName: refRepoVariableName,
+                repositoryClassName: refMeta.data.repositoryClassName,
+            });
+            variables.set(relation.name, {
+                variableName: relationVariableName,
+                variableDefinition: `
+          const ${relationVariableName} = this.${refRepoVariableName}.get(itemRaw.${relation.name})
+          ${relation.isRequired ? variablePresenceCheck : ``}      
+        `,
+            });
+        }
     }
-    const hasLinkedItems = linkedForeignBacklinkFields.size > 0;
+    const hasLinkedItems = variables.size > 0;
     if (hasLinkedItems) {
         imports.addImport({ from: meta.types.importPath, items: [meta.types.linkedTypeName] });
     }
-    const constructorParameters = [...dependencies.values()].map(({ localRepositoryVariableName, repositoryClassName }) => `private readonly ${localRepositoryVariableName}: ${repositoryClassName}`);
+    const constructorParameters = [`public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`];
+    for (const [, { localRepositoryVariableName, repositoryClassName }] of dependencies) {
+        constructorParameters.push(`private readonly ${localRepositoryVariableName}: ${repositoryClassName}`);
+    }
     const linkedItemsGetterFn = `
     /**
      * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
      * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
      */
     public getLinkedItem(id: ${model.brandedIdType}): ${meta.types.linkedTypeName} | null {
-      const itemRaw = this.${dataRepositoryVariableName}.get(id)
-      if (!itemRaw) return null
-      ${[...linkedForeignBacklinkFields.values()].map(({ variableDefinition }) => variableDefinition).join('\n')}
+      const itemRaw = this.${modelRepositoryVariableName}.get(id)
+      if (!itemRaw) {
+        return null
+      }
+
+      ${[...variables.values()].map((r) => r.variableDefinition).join('\n')}
+      
       const item: ${meta.types.linkedTypeName} = {
         ${model.fields
         .map((f) => {
         if (f.kind !== 'relation') {
             return `${f.name}: itemRaw.${f.name}`;
         }
-        const linked = linkedForeignBacklinkFields.get(f.name);
-        if (!linked) {
+        const linkedRel = variables.get(f.name);
+        if (!linkedRel) {
             throw new Error(`Could not find linked item for ${model.typeName}.${f.name}`);
         }
-        return `${linked.fieldName}`;
+        return `${linkedRel.variableName}`;
     })
         .join(',\n')}
       }
@@ -119,7 +137,7 @@ export class ${meta.businessLogic.serviceClassName} {
    * Raw: The ${meta.userFriendlyName} only contains linked Ids, not the linked items themselves.
    */
   public get(id: ${model.brandedIdType}): ${meta.types.typeName} | null {
-    return this.${dataRepositoryVariableName}.get(id)
+    return this.${modelRepositoryVariableName}.get(id)
   }
 
   ${hasLinkedItems ? linkedItemsGetterFn : ''}
@@ -128,14 +146,14 @@ export class ${meta.businessLogic.serviceClassName} {
    * Returns a map of all ${meta.userFriendlyName}s.
    */
   public getAll(): Map<${meta.types.brandedIdType}, ${model.typeName}> {
-    return this.${dataRepositoryVariableName}.getAll()
+    return this.${modelRepositoryVariableName}.getAll()
   }
 
   /**
    * Creates a new ${meta.userFriendlyName}.
    */
   public async create(item: Omit<${model.typeName}, 'id'>): Promise<${model.typeName}> {
-    return this.${dataRepositoryVariableName}.create(item)
+    return this.${modelRepositoryVariableName}.create(item)
   }
 
   /**
@@ -144,7 +162,7 @@ export class ${meta.businessLogic.serviceClassName} {
   public async update(item: Partial<${model.typeName}> & { 
 		id: ${model.brandedIdType}
 	}): Promise<${model.typeName}> {
-    return this.${dataRepositoryVariableName}.update(item)
+    return this.${modelRepositoryVariableName}.update(item)
   }
 
   /**
@@ -154,7 +172,7 @@ export class ${meta.businessLogic.serviceClassName} {
    * If the items is a dependency of another item, the deletion will fail!
    */
   public async delete(id: ${model.brandedIdType}): Promise<void> {
-    return this.${dataRepositoryVariableName}.delete(id)
+    return this.${modelRepositoryVariableName}.delete(id)
   }
 }
 `;

package/package.json

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