velocious 1.0.301 → 1.0.303

package/README.md

@@ -649,6 +649,29 @@ await project.loadTasks()
 const tasks = project.tasks().loaded()
 ```
 
+## Through relationships
+
+Use the `through` option on `hasMany` to define a relationship that traverses an intermediate (join) table:
+
+```js
+Invoice.hasMany("invoiceGroupLinks")
+Invoice.hasMany("invoiceGroups", {through: "invoiceGroupLinks", className: "InvoiceGroup"})
+```
+
+Through relationships work with both instance-level loading and batch preloading:
+
+```js
+// Instance-level loading
+const invoice = await Invoice.find(1)
+const groups = await invoice.invoiceGroups().toArray()
+
+// Batch preloading
+const invoices = await Invoice.preload({invoiceGroups: true}).toArray()
+const groups = invoices[0].invoiceGroupsLoaded()
+```
+
+The intermediate relationship (e.g. `invoiceGroupLinks`) must be defined as a separate `hasMany` on the same model. The `foreignKey` option on the through relationship specifies the column on the target table that points to the intermediate table (defaults to the conventional foreign key).
+
 ## Relationship scopes
 
 You can pass a scope callback to `hasMany`, `hasOne`, or `belongsTo` to add custom filters. The callback receives the query and is also bound as `this`:

package/build/src/database/query/preloader/has-many.d.ts

@@ -10,6 +10,19 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
     });
     models: import("../../record/index.js").default[];
     relationship: import("../../record/relationships/has-many.js").default;
+    /** @returns {Promise<import("../../record/index.js").default[]>} - Loaded target models. */
     run(): Promise<import("../../record/index.js").default[]>;
+    /**
+     * Preload through a join table (e.g. hasMany("invoiceGroups", {through: "invoiceGroupLinks"})).
+     *
+     * @returns {Promise<import("../../record/index.js").default[]>} - Loaded target models.
+     */
+    _runThrough(): Promise<import("../../record/index.js").default[]>;
+    /**
+     * Preload direct has-many relationships.
+     *
+     * @returns {Promise<import("../../record/index.js").default[]>} - Loaded target models.
+     */
+    _runDirect(): Promise<import("../../record/index.js").default[]>;
 }
 //# sourceMappingURL=has-many.d.ts.map

package/build/src/database/query/preloader/has-many.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../../../../src/database/query/preloader/has-many.js"],"names":[],"mappings":"AAIA;IACE;;;;OAIG;IACH,mDAHG;QAAwD,MAAM,EAAtD,OAAO,uBAAuB,EAAE,OAAO,EAAE;QACsB,YAAY,EAA3E,OAAO,wCAAwC,EAAE,OAAO;KAClE,EAMA;IAFC,kDAAoB;IACpB,uEAAgC;IAGlC,0DA0EC;CACF"}
+{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../../../../src/database/query/preloader/has-many.js"],"names":[],"mappings":"AAIA;IACE;;;;OAIG;IACH,mDAHG;QAAwD,MAAM,EAAtD,OAAO,uBAAuB,EAAE,OAAO,EAAE;QACsB,YAAY,EAA3E,OAAO,wCAAwC,EAAE,OAAO;KAClE,EAMA;IAFC,kDAAoB;IACpB,uEAAgC;IAGlC,4FAA4F;IAC5F,OADc,OAAO,CAAC,OAAO,uBAAuB,EAAE,OAAO,EAAE,CAAC,CAO/D;IAED;;;;OAIG;IACH,eAFa,OAAO,CAAC,OAAO,uBAAuB,EAAE,OAAO,EAAE,CAAC,CAwH9D;IAED;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,uBAAuB,EAAE,OAAO,EAAE,CAAC,CA0E9D;CACF"}

package/build/src/database/query/preloader/has-many.js

@@ -11,7 +11,115 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
         this.models = models;
         this.relationship = relationship;
     }
+    /** @returns {Promise<import("../../record/index.js").default[]>} - Loaded target models. */
     async run() {
+        if (this.relationship.through) {
+            return await this._runThrough();
+        }
+        return await this._runDirect();
+    }
+    /**
+     * Preload through a join table (e.g. hasMany("invoiceGroups", {through: "invoiceGroupLinks"})).
+     *
+     * @returns {Promise<import("../../record/index.js").default[]>} - Loaded target models.
+     */
+    async _runThrough() {
+        const primaryKey = this.relationship.getPrimaryKey();
+        if (!primaryKey) {
+            throw new Error(`${this.relationship.getModelClass().name}#${this.relationship.getRelationshipName()} doesn't have a primary key`);
+        }
+        const throughRelationshipName = /** @type {string} */ (this.relationship.through);
+        const parentModelClass = this.relationship.getModelClass();
+        const throughRelationship = parentModelClass.getRelationshipByName(throughRelationshipName);
+        const throughModelClass = throughRelationship.getTargetModelClass();
+        if (!throughModelClass)
+            throw new Error(`Through relationship ${throughRelationshipName} has no target model class`);
+        const targetModelClass = this.relationship.getTargetModelClass();
+        if (!targetModelClass)
+            throw new Error("No target model class could be gotten from relationship");
+        const throughForeignKey = throughRelationship.getForeignKey();
+        /** @type {Array<number | string>} */
+        const modelsPrimaryKeyValues = [];
+        /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
+        const modelsByPrimaryKeyValue = {};
+        /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
+        const preloadCollections = {};
+        for (const model of this.models) {
+            const primaryKeyValue = /** @type {string | number} */ (model.readColumn(primaryKey));
+            preloadCollections[primaryKeyValue] = [];
+            if (!modelsPrimaryKeyValues.includes(primaryKeyValue))
+                modelsPrimaryKeyValues.push(primaryKeyValue);
+            if (!(primaryKeyValue in modelsByPrimaryKeyValue))
+                modelsByPrimaryKeyValue[primaryKeyValue] = [];
+            modelsByPrimaryKeyValue[primaryKeyValue].push(model);
+        }
+        // Step 1: Query the through table to build parent→target ID mapping
+        const throughModels = await throughModelClass
+            .where({ [throughForeignKey]: modelsPrimaryKeyValues })
+            .toArray();
+        /** @type {Record<string | number, Array<string | number>>} */
+        const parentToTargetIds = {};
+        /** @type {Set<string | number>} */
+        const allTargetIds = new Set();
+        const targetForeignKey = this.relationship.getForeignKey();
+        for (const throughModel of throughModels) {
+            const parentId = /** @type {string | number} */ (throughModel.readColumn(throughForeignKey));
+            const throughId = /** @type {string | number} */ (throughModel.readColumn(throughModelClass.primaryKey()));
+            if (!(parentId in parentToTargetIds))
+                parentToTargetIds[parentId] = [];
+            parentToTargetIds[parentId].push(throughId);
+            allTargetIds.add(throughId);
+        }
+        // Step 2: Load target models by the foreign key that points to the through table
+        /** @type {import("../../record/index.js").default[]} */
+        let targetModels = [];
+        if (allTargetIds.size > 0) {
+            let query = targetModelClass.where({ [targetForeignKey]: [...allTargetIds] });
+            query = this.relationship.applyScope(query);
+            targetModels = await query.toArray();
+        }
+        // Step 3: Index target models by their foreign key (maps to through model ID)
+        /** @type {Record<string | number, Array<import("../../record/index.js").default>>} */
+        const targetModelsByForeignKey = {};
+        for (const targetModel of targetModels) {
+            const fkValue = /** @type {string | number} */ (targetModel.readColumn(targetForeignKey));
+            if (!(fkValue in targetModelsByForeignKey))
+                targetModelsByForeignKey[fkValue] = [];
+            targetModelsByForeignKey[fkValue].push(targetModel);
+        }
+        // Step 4: Map targets to parents via the through mapping
+        for (const parentId in parentToTargetIds) {
+            const throughIds = parentToTargetIds[parentId];
+            for (const throughId of throughIds) {
+                const matchingTargets = targetModelsByForeignKey[throughId] || [];
+                for (const targetModel of matchingTargets) {
+                    if (parentId in preloadCollections) {
+                        preloadCollections[parentId].push(targetModel);
+                    }
+                }
+            }
+        }
+        for (const modelValue in preloadCollections) {
+            const preloadedCollection = preloadCollections[modelValue];
+            for (const model of modelsByPrimaryKeyValue[modelValue]) {
+                const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName());
+                if (preloadedCollection.length == 0) {
+                    modelRelationship.setLoaded([]);
+                }
+                else {
+                    modelRelationship.addToLoaded(preloadedCollection);
+                }
+                modelRelationship.setPreloaded(true);
+            }
+        }
+        return targetModels;
+    }
+    /**
+     * Preload direct has-many relationships.
+     *
+     * @returns {Promise<import("../../record/index.js").default[]>} - Loaded target models.
+     */
+    async _runDirect() {
         /** @type {Array<number | string>} */
         const modelsPrimaryKeyValues = [];
         /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
@@ -42,7 +150,6 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
         const targetModelClass = this.relationship.getTargetModelClass();
         if (!targetModelClass)
             throw new Error("No target model class could be gotten from relationship");
-        // Load target models to be preloaded on the given models
         let query = targetModelClass.where(whereArgs);
         query = this.relationship.applyScope(query);
         const targetModels = await query.toArray();
@@ -50,7 +157,6 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
             const foreignKeyValue = /** @type {string | number} */ (targetModel.readColumn(foreignKey));
             preloadCollections[foreignKeyValue].push(targetModel);
         }
-        // Set the target preloaded models on the given models
         for (const modelValue in preloadCollections) {
             const preloadedCollection = preloadCollections[modelValue];
             for (const model of modelsByPrimaryKeyValue[modelValue]) {
@@ -67,4 +173,4 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
         return targetModels;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"has-many.js","sourceRoot":"","sources":["../../../../../src/database/query/preloader/has-many.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport restArgsError from \"../../../utils/rest-args-error.js\"\n\nexport default class VelociousDatabaseQueryPreloaderHasMany {\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../../record/index.js\").default[]} args.models - Model instances.\n   * @param {import(\"../../record/relationships/has-many.js\").default} args.relationship - Relationship.\n   */\n  constructor({models, relationship, ...restArgs}) {\n    restArgsError(restArgs)\n\n    this.models = models\n    this.relationship = relationship\n  }\n\n  /** @returns {Promise<import(\"../../record/index.js\").default[]>} - Loaded target models. */\n  async run() {\n    if (this.relationship.through) {\n      return await this._runThrough()\n    }\n\n    return await this._runDirect()\n  }\n\n  /**\n   * Preload through a join table (e.g. hasMany(\"invoiceGroups\", {through: \"invoiceGroupLinks\"})).\n   *\n   * @returns {Promise<import(\"../../record/index.js\").default[]>} - Loaded target models.\n   */\n  async _runThrough() {\n    const primaryKey = this.relationship.getPrimaryKey()\n\n    if (!primaryKey) {\n      throw new Error(`${this.relationship.getModelClass().name}#${this.relationship.getRelationshipName()} doesn't have a primary key`)\n    }\n\n    const throughRelationshipName = /** @type {string} */ (this.relationship.through)\n    const parentModelClass = this.relationship.getModelClass()\n    const throughRelationship = parentModelClass.getRelationshipByName(throughRelationshipName)\n    const throughModelClass = throughRelationship.getTargetModelClass()\n\n    if (!throughModelClass) throw new Error(`Through relationship ${throughRelationshipName} has no target model class`)\n\n    const targetModelClass = this.relationship.getTargetModelClass()\n\n    if (!targetModelClass) throw new Error(\"No target model class could be gotten from relationship\")\n\n    const throughForeignKey = throughRelationship.getForeignKey()\n\n    /** @type {Array<number | string>} */\n    const modelsPrimaryKeyValues = []\n\n    /** @type {Record<number | string, Array<import(\"../../record/index.js\").default>>} */\n    const modelsByPrimaryKeyValue = {}\n\n    /** @type {Record<number | string, Array<import(\"../../record/index.js\").default>>} */\n    const preloadCollections = {}\n\n    for (const model of this.models) {\n      const primaryKeyValue = /** @type {string | number} */ (model.readColumn(primaryKey))\n\n      preloadCollections[primaryKeyValue] = []\n\n      if (!modelsPrimaryKeyValues.includes(primaryKeyValue)) modelsPrimaryKeyValues.push(primaryKeyValue)\n      if (!(primaryKeyValue in modelsByPrimaryKeyValue)) modelsByPrimaryKeyValue[primaryKeyValue] = []\n\n      modelsByPrimaryKeyValue[primaryKeyValue].push(model)\n    }\n\n    // Step 1: Query the through table to build parent→target ID mapping\n    const throughModels = await throughModelClass\n      .where({[throughForeignKey]: modelsPrimaryKeyValues})\n      .toArray()\n\n    /** @type {Record<string | number, Array<string | number>>} */\n    const parentToTargetIds = {}\n\n    /** @type {Set<string | number>} */\n    const allTargetIds = new Set()\n\n    const targetForeignKey = this.relationship.getForeignKey()\n\n    for (const throughModel of throughModels) {\n      const parentId = /** @type {string | number} */ (throughModel.readColumn(throughForeignKey))\n      const throughId = /** @type {string | number} */ (throughModel.readColumn(throughModelClass.primaryKey()))\n\n      if (!(parentId in parentToTargetIds)) parentToTargetIds[parentId] = []\n\n      parentToTargetIds[parentId].push(throughId)\n      allTargetIds.add(throughId)\n    }\n\n    // Step 2: Load target models by the foreign key that points to the through table\n    /** @type {import(\"../../record/index.js\").default[]} */\n    let targetModels = []\n\n    if (allTargetIds.size > 0) {\n      let query = targetModelClass.where({[targetForeignKey]: [...allTargetIds]})\n\n      query = this.relationship.applyScope(query)\n      targetModels = await query.toArray()\n    }\n\n    // Step 3: Index target models by their foreign key (maps to through model ID)\n    /** @type {Record<string | number, Array<import(\"../../record/index.js\").default>>} */\n    const targetModelsByForeignKey = {}\n\n    for (const targetModel of targetModels) {\n      const fkValue = /** @type {string | number} */ (targetModel.readColumn(targetForeignKey))\n\n      if (!(fkValue in targetModelsByForeignKey)) targetModelsByForeignKey[fkValue] = []\n\n      targetModelsByForeignKey[fkValue].push(targetModel)\n    }\n\n    // Step 4: Map targets to parents via the through mapping\n    for (const parentId in parentToTargetIds) {\n      const throughIds = parentToTargetIds[parentId]\n\n      for (const throughId of throughIds) {\n        const matchingTargets = targetModelsByForeignKey[throughId] || []\n\n        for (const targetModel of matchingTargets) {\n          if (parentId in preloadCollections) {\n            preloadCollections[parentId].push(targetModel)\n          }\n        }\n      }\n    }\n\n    for (const modelValue in preloadCollections) {\n      const preloadedCollection = preloadCollections[modelValue]\n\n      for (const model of modelsByPrimaryKeyValue[modelValue]) {\n        const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())\n\n        if (preloadedCollection.length == 0) {\n          modelRelationship.setLoaded([])\n        } else {\n          modelRelationship.addToLoaded(preloadedCollection)\n        }\n\n        modelRelationship.setPreloaded(true)\n      }\n    }\n\n    return targetModels\n  }\n\n  /**\n   * Preload direct has-many relationships.\n   *\n   * @returns {Promise<import(\"../../record/index.js\").default[]>} - Loaded target models.\n   */\n  async _runDirect() {\n    /** @type {Array<number | string>} */\n    const modelsPrimaryKeyValues = []\n\n    /** @type {Record<number | string, Array<import(\"../../record/index.js\").default>>} */\n    const modelsByPrimaryKeyValue = {}\n\n    const foreignKey = this.relationship.getForeignKey()\n    const primaryKey = this.relationship.getPrimaryKey()\n\n    /** @type {Record<number | string, Array<import(\"../../record/index.js\").default>>} */\n    const preloadCollections = {}\n\n    if (!primaryKey) {\n      throw new Error(`${this.relationship.getModelClass().name}#${this.relationship.getRelationshipName()} doesn't have a primary key`)\n    }\n\n    for (const model of this.models) {\n      const primaryKeyValue = /** @type {string | number} */ (model.readColumn(primaryKey))\n\n      preloadCollections[primaryKeyValue] = []\n\n      if (!modelsPrimaryKeyValues.includes(primaryKeyValue)) modelsPrimaryKeyValues.push(primaryKeyValue)\n      if (!(primaryKeyValue in modelsByPrimaryKeyValue)) modelsByPrimaryKeyValue[primaryKeyValue] = []\n\n      modelsByPrimaryKeyValue[primaryKeyValue].push(model)\n    }\n\n    /** @type {Record<string, string | number | Array<string | number>>} */\n    const whereArgs = {}\n\n    whereArgs[foreignKey] = modelsPrimaryKeyValues\n\n    if (this.relationship.getPolymorphic()) {\n      const typeColumn = this.relationship.getPolymorphicTypeColumn()\n\n      whereArgs[typeColumn] = this.relationship.getModelClass().getModelName()\n    }\n\n    const targetModelClass = this.relationship.getTargetModelClass()\n\n    if (!targetModelClass) throw new Error(\"No target model class could be gotten from relationship\")\n\n    let query = targetModelClass.where(whereArgs)\n\n    query = this.relationship.applyScope(query)\n\n    const targetModels = await query.toArray()\n\n    for (const targetModel of targetModels) {\n      const foreignKeyValue = /** @type {string | number} */ (targetModel.readColumn(foreignKey))\n\n      preloadCollections[foreignKeyValue].push(targetModel)\n    }\n\n    for (const modelValue in preloadCollections) {\n      const preloadedCollection = preloadCollections[modelValue]\n\n      for (const model of modelsByPrimaryKeyValue[modelValue]) {\n        const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())\n\n        if (preloadedCollection.length == 0) {\n          modelRelationship.setLoaded([])\n        } else {\n          modelRelationship.addToLoaded(preloadedCollection)\n        }\n\n        modelRelationship.setPreloaded(true)\n      }\n    }\n\n    return targetModels\n  }\n}\n"]}