velocious 1.0.430 → 1.0.431

package/build/src/database/record/instance-relationships/base.js

@@ -1,7 +1,9 @@
 // @ts-check
-import BelongsToPreloader from "../../query/preloader/belongs-to.js";
-import HasManyPreloader from "../../query/preloader/has-many.js";
-import HasOnePreloader from "../../query/preloader/has-one.js";
+
+import BelongsToPreloader from "../../query/preloader/belongs-to.js"
+import HasManyPreloader from "../../query/preloader/has-many.js"
+import HasOnePreloader from "../../query/preloader/has-one.js"
+
 /**
  * InstanceRelationshipsBaseArgs type.
  * @template {typeof import("../index.js").default} [MC=typeof import("../index.js").default]
@@ -10,246 +12,278 @@ import HasOnePreloader from "../../query/preloader/has-one.js";
  * @property {InstanceType<MC>} model - Parent model instance.
  * @property {import("../relationships/base.js").default} relationship - Relationship metadata definition.
  */
+
 /**
  * A generic query over some model type.
  * @template {typeof import("../index.js").default} [MC=typeof import("../index.js").default]
  * @template {typeof import("../index.js").default} [TMC=typeof import("../index.js").default]
  */
 export default class VelociousDatabaseRecordBaseInstanceRelationship {
-    /**
-     * Auto save.
-      @type {boolean | undefined} */
-    _autoSave = undefined;
-    /**
-     * Preloaded.
-      @type {boolean | undefined} */
-    _preloaded = undefined;
-    /**
-     * Loaded.
-      @type {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} */
-    _loaded = undefined;
-    /**
-     * Runs constructor.
-     * @param {InstanceRelationshipsBaseArgs<MC, TMC>} args - Options object.
-     */
-    constructor({ model, relationship }) {
-        this._dirty = false;
-        this.model = model;
-        this.relationship = relationship;
-    }
-    /**
-     * Runs add to loaded.
-     * @abstract
-     * @param {InstanceType<TMC>[] | InstanceType<TMC>} models - Model instances.
-     * @returns {void} - No return value.
-     */
-    addToLoaded(models) {
-        throw new Error("addToLoaded not implemented");
-    }
-    /**
-     * Runs build.
-     * @abstract
-     * @param {Record<string, ?>} attributes - Attributes.
-     * @returns {InstanceType<TMC>} - The build.
-     */
-    build(attributes) {
-        throw new Error("'build' not implemented");
-    }
-    /**
-     * Runs get auto save.
-     * @returns {boolean | undefined} Whether the relationship should be auto-saved before saving the parent model
-     */
-    getAutoSave() { return this._autoSave; }
-    /**
-     * Runs set auto save.
-     * @param {boolean} newAutoSaveValue Whether the relationship should be auto-saved before saving the parent model
-     * @returns {void} - No return value.
-     */
-    setAutoSave(newAutoSaveValue) { this._autoSave = newAutoSaveValue; }
-    /**
-     * Runs set dirty.
-     * @param {boolean} newValue Whether the relationship is dirty (has been modified)
-     * @returns {void} - No return value.
-     */
-    setDirty(newValue) { this._dirty = newValue; }
-    /**
-     * Runs get dirty.
-     * @returns {boolean} Whether the relationship is dirty (has been modified)
-     */
-    getDirty() { return this._dirty; }
-    /**
-     * Runs load.
-     * @abstract
-     * @returns {Promise<InstanceType<TMC> | Array<InstanceType<TMC>> | undefined>} - Resolves with loaded relationship value.
-     */
-    load() {
-        throw new Error("'load' not implemented");
-    }
-    /**
-     * Loads the relationship if not already loaded. When the parent record was
-     * loaded as part of a batch (cohort) and autoload is enabled, siblings in
-     * the cohort that share this relationship and have not preloaded it yet
-     * are batched into a single query via the existing preloader path.
-     * @returns {Promise<InstanceType<TMC> | Array<InstanceType<TMC>> | undefined>} - Resolves with loaded relationship value.
-     */
-    async autoloadOrLoad() {
-        if (this._loaded !== undefined)
-            return this._loaded;
-        const batched = await this._tryCohortPreload();
-        if (!batched)
-            await this.load();
-        return this._loaded;
+  /**
+   * Auto save.
+    @type {boolean | undefined} */
+  _autoSave = undefined
+  /**
+   * Preloaded.
+    @type {boolean | undefined} */
+  _preloaded = undefined
+  /**
+   * Loaded.
+    @type {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} */
+  _loaded = undefined
+
+  /**
+   * Runs constructor.
+   * @param {InstanceRelationshipsBaseArgs<MC, TMC>} args - Options object.
+   */
+  constructor({model, relationship}) {
+    this._dirty = false
+    this.model = model
+    this.relationship = relationship
+  }
+
+  /**
+   * Runs add to loaded.
+   * @abstract
+   * @param {InstanceType<TMC>[] | InstanceType<TMC>} models - Model instances.
+   * @returns {void} - No return value.
+   */
+  addToLoaded(models) { // eslint-disable-line no-unused-vars
+    throw new Error("addToLoaded not implemented")
+  }
+
+  /**
+   * Runs build.
+   * @abstract
+   * @param {Record<string, ?>} attributes - Attributes.
+   * @returns {InstanceType<TMC>} - The build.
+   */
+  build(attributes) { // eslint-disable-line no-unused-vars
+    throw new Error("'build' not implemented")
+  }
+
+  /**
+   * Runs get auto save.
+   * @returns {boolean | undefined} Whether the relationship should be auto-saved before saving the parent model
+   */
+  getAutoSave() { return this._autoSave }
+
+  /**
+   * Runs set auto save.
+   * @param {boolean} newAutoSaveValue Whether the relationship should be auto-saved before saving the parent model
+   * @returns {void} - No return value.
+   */
+  setAutoSave(newAutoSaveValue) { this._autoSave = newAutoSaveValue }
+
+  /**
+   * Runs set dirty.
+   * @param {boolean} newValue Whether the relationship is dirty (has been modified)
+   * @returns {void} - No return value.
+   */
+  setDirty(newValue) { this._dirty = newValue }
+
+  /**
+   * Runs get dirty.
+   * @returns {boolean} Whether the relationship is dirty (has been modified)
+   */
+  getDirty() { return this._dirty }
+
+  /**
+   * Runs load.
+   * @abstract
+   * @returns {Promise<InstanceType<TMC> | Array<InstanceType<TMC>> | undefined>} - Resolves with loaded relationship value.
+   */
+  load() {
+    throw new Error("'load' not implemented")
+  }
+
+  /**
+   * Loads the relationship if not already loaded. When the parent record was
+   * loaded as part of a batch (cohort) and autoload is enabled, siblings in
+   * the cohort that share this relationship and have not preloaded it yet
+   * are batched into a single query via the existing preloader path.
+   * @returns {Promise<InstanceType<TMC> | Array<InstanceType<TMC>> | undefined>} - Resolves with loaded relationship value.
+   */
+  async autoloadOrLoad() {
+    if (this._loaded !== undefined) return this._loaded
+
+    const batched = await this._tryCohortPreload()
+
+    if (!batched) await this.load()
+
+    return this._loaded
+  }
+
+  /**
+   * Attempts to batch-load this relationship across cohort siblings via the
+   * existing preloader path. Returns true when a batch ran (self is always
+   * included because callers reset their own `_preloaded` state before
+   * calling), false when autoload is off, there is no cohort, or no batch
+   * candidates remain. Siblings that have already preloaded this relationship
+   * are skipped so their cached value is preserved.
+   * @returns {Promise<boolean>} - Whether a cohort batch preload ran.
+   */
+  async _tryCohortPreload() {
+    const relationshipDef = this.getRelationship()
+    const configuration = relationshipDef.getConfiguration()
+    const cohort = /**
+                    * Narrows the runtime value to the documented type.
+                     @type {Array<import("../index.js").default> | undefined} */ (/**
+                                                                                   * Narrows the runtime value to the documented type.
+                                                                                    @type {?} */ (this.model)._loadCohort)
+
+    if (!configuration.getAutoload() || !relationshipDef.getAutoload() || !cohort || cohort.length <= 1) {
+      return false
     }
+
+    const relationshipName = relationshipDef.getRelationshipName()
+    const OwnerModelClass = /**
+                             * Narrows the runtime value to the documented type.
+                              @type {?} */ (this.model).constructor
     /**
-     * Attempts to batch-load this relationship across cohort siblings via the
-     * existing preloader path. Returns true when a batch ran (self is always
-     * included because callers reset their own `_preloaded` state before
-     * calling), false when autoload is off, there is no cohort, or no batch
-     * candidates remain. Siblings that have already preloaded this relationship
-     * are skipped so their cached value is preserved.
-     * @returns {Promise<boolean>} - Whether a cohort batch preload ran.
-     */
-    async _tryCohortPreload() {
-        const relationshipDef = this.getRelationship();
-        const configuration = relationshipDef.getConfiguration();
-        const cohort = /**
-                        * Narrows the runtime value to the documented type.
-                         @type {Array<import("../index.js").default> | undefined} */ ( /**
-                                                                      * Narrows the runtime value to the documented type.
-                                                                       @type {?} */(this.model)._loadCohort);
-        if (!configuration.getAutoload() || !relationshipDef.getAutoload() || !cohort || cohort.length <= 1) {
-            return false;
-        }
-        const relationshipName = relationshipDef.getRelationshipName();
-        const OwnerModelClass = /**
-                                 * Narrows the runtime value to the documented type.
-                                  @type {?} */ (this.model).constructor;
-        /**
-         * Batch.
-          @type {Array<import("../index.js").default>} */
-        const batch = [];
-        // Exact same class, persisted, no existing in-memory relationship state.
-        // Skip siblings where `_loaded` is already set — they may have been
-        // preloaded (preserve cache) OR locally manipulated via `build...` /
-        // `set...` (preserve unsaved edits). Either way the preloader would
-        // overwrite that state.
-        for (const sibling of cohort) {
-            if (sibling.constructor !== OwnerModelClass)
-                continue;
-            if (!sibling.isPersisted())
-                continue;
-            const siblingInstanceRelationship = sibling.getRelationshipByName(relationshipName);
-            if (siblingInstanceRelationship.getLoadedOrUndefined() !== undefined)
-                continue;
-            batch.push(sibling);
-        }
-        if (batch.length === 0)
-            return false;
-        const type = relationshipDef.getType();
-        if (type == "belongsTo") {
-            const belongsToRelationship = /**
-                                           * Narrows the runtime value to the documented type.
-                                            @type {import("../relationships/belongs-to.js").default} */ (relationshipDef);
-            const preloader = new BelongsToPreloader({ models: batch, relationship: belongsToRelationship });
-            await preloader.run();
-        }
-        else if (type == "hasMany") {
-            const hasManyRelationship = /**
-                                         * Narrows the runtime value to the documented type.
-                                          @type {import("../relationships/has-many.js").default} */ (relationshipDef);
-            const preloader = new HasManyPreloader({ models: batch, relationship: hasManyRelationship });
-            await preloader.run();
-        }
-        else if (type == "hasOne") {
-            const hasOneRelationship = /**
-                                        * Narrows the runtime value to the documented type.
-                                         @type {import("../relationships/has-one.js").default} */ (relationshipDef);
-            const preloader = new HasOnePreloader({ models: batch, relationship: hasOneRelationship });
-            await preloader.run();
-        }
-        else {
-            throw new Error(`Unknown relationship type: ${type}`);
-        }
-        return true;
+     * Batch.
+      @type {Array<import("../index.js").default>} */
+    const batch = []
+
+    // Exact same class, persisted, no existing in-memory relationship state.
+    // Skip siblings where `_loaded` is already set — they may have been
+    // preloaded (preserve cache) OR locally manipulated via `build...` /
+    // `set...` (preserve unsaved edits). Either way the preloader would
+    // overwrite that state.
+    for (const sibling of cohort) {
+      if (sibling.constructor !== OwnerModelClass) continue
+      if (!sibling.isPersisted()) continue
+
+      const siblingInstanceRelationship = sibling.getRelationshipByName(relationshipName)
+
+      if (siblingInstanceRelationship.getLoadedOrUndefined() !== undefined) continue
+
+      batch.push(sibling)
     }
-    /**
-     * Runs is loaded.
-     * @returns {boolean} Whether the relationship has been preloaded
-     */
-    isLoaded() { return Boolean(this._loaded); }
-    /**
-     * Runs loaded.
-     * @returns {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} The loaded model or models (depending on relationship type)
-     */
-    loaded() {
-        if (!this._preloaded && this.model.isPersisted()) {
-            throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`);
-        }
-        return this._loaded;
-    }
-    /**
-     * Runs set loaded.
-     * @param {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} model - Related model(s) to mark as loaded.
-     */
-    setLoaded(model) { this._loaded = model; }
-    /**
-     * Runs get loaded or undefined.
-     * @returns {InstanceType<TMC> | InstanceType<TMC>[] | undefined} - The loaded or undefined.
-     */
-    getLoadedOrUndefined() { return this._loaded; }
-    /**
-     * Runs get preloaded.
-     * @returns {boolean} The loaded model or models (depending on relationship type)
-     */
-    getPreloaded() { return this._preloaded || false; }
-    /**
-     * Runs set preloaded.
-     * @param {boolean} isPreloaded - Whether the relationship is preloaded.
-     */
-    setPreloaded(isPreloaded) { this._preloaded = isPreloaded; }
-    /**
-     * Runs get foreign key.
-     * @returns {string} The foreign key for this relationship
-     */
-    getForeignKey() { return this.getRelationship().getForeignKey(); }
-    /**
-     * Runs get model.
-     * @returns {InstanceType<MC>} - The model.
-     */
-    getModel() { return this.model; }
-    /**
-     * Runs get primary key.
-     * @returns {string} The primary key for this relationship's model
-     */
-    getPrimaryKey() { return this.getRelationship().getPrimaryKey(); }
-    /**
-     * Runs get relationship.
-     * @returns {import("../relationships/base.js").default} The relationship object that this instance relationship is based on
-     */
-    getRelationship() { return this.relationship; }
-    /**
-     * Runs apply scope.
-     * @template T
-     * @param {T} query - Query instance.
-     * @returns {T} - Scoped query.
-     */
-    applyScope(query) {
-        return this.getRelationship().applyScope(query);
-    }
-    /**
-     * Runs get target model class.
-     * @returns {TMC | undefined} The model class that this instance relationship
-     */
-    getTargetModelClass() {
-        const TargetModelClass = /**
+
+    if (batch.length === 0) return false
+
+    const type = relationshipDef.getType()
+
+    if (type == "belongsTo") {
+      const belongsToRelationship = /**
+                                     * Narrows the runtime value to the documented type.
+                                      @type {import("../relationships/belongs-to.js").default} */ (relationshipDef)
+      const preloader = new BelongsToPreloader({models: batch, relationship: belongsToRelationship})
+
+      await preloader.run()
+    } else if (type == "hasMany") {
+      const hasManyRelationship = /**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {import("../relationships/has-many.js").default} */ (relationshipDef)
+      const preloader = new HasManyPreloader({models: batch, relationship: hasManyRelationship})
+
+      await preloader.run()
+    } else if (type == "hasOne") {
+      const hasOneRelationship = /**
                                   * Narrows the runtime value to the documented type.
-                                   @type {TMC} */ (this.getRelationship().getTargetModelClass());
-        return TargetModelClass;
+                                   @type {import("../relationships/has-one.js").default} */ (relationshipDef)
+      const preloader = new HasOnePreloader({models: batch, relationship: hasOneRelationship})
+
+      await preloader.run()
+    } else {
+      throw new Error(`Unknown relationship type: ${type}`)
     }
-    /**
-     * Runs get type.
-     * @returns {string} The type of relationship (e.g. "has_many", "belongs_to", etc.)
-     */
-    getType() { return this.getRelationship().getType(); }
+
+    return true
+  }
+
+  /**
+   * Runs is loaded.
+   * @returns {boolean} Whether the relationship has been preloaded
+   */
+  isLoaded() { return Boolean(this._loaded) }
+
+  /**
+   * Runs loaded.
+   * @returns {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} The loaded model or models (depending on relationship type)
+   */
+  loaded() {
+    if (!this._preloaded && this.model.isPersisted()) {
+      throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
+    }
+
+    return this._loaded
+  }
+
+  /**
+   * Runs set loaded.
+   * @param {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} model - Related model(s) to mark as loaded.
+   */
+  setLoaded(model) { this._loaded = model }
+
+  /**
+   * Runs get loaded or undefined.
+   * @returns {InstanceType<TMC> | InstanceType<TMC>[] | undefined} - The loaded or undefined.
+   */
+  getLoadedOrUndefined() { return this._loaded }
+
+  /**
+   * Runs get preloaded.
+   * @returns {boolean} The loaded model or models (depending on relationship type)
+   */
+  getPreloaded() { return this._preloaded || false }
+
+  /**
+   * Runs set preloaded.
+   * @param {boolean} isPreloaded - Whether the relationship is preloaded.
+   */
+  setPreloaded(isPreloaded) { this._preloaded = isPreloaded }
+
+  /**
+   * Runs get foreign key.
+   * @returns {string} The foreign key for this relationship
+   */
+  getForeignKey() { return this.getRelationship().getForeignKey() }
+
+  /**
+   * Runs get model.
+   * @returns {InstanceType<MC>} - The model.
+   */
+  getModel() { return this.model }
+
+  /**
+   * Runs get primary key.
+   * @returns {string} The primary key for this relationship's model
+   */
+  getPrimaryKey() { return this.getRelationship().getPrimaryKey() }
+
+  /**
+   * Runs get relationship.
+   * @returns {import("../relationships/base.js").default} The relationship object that this instance relationship is based on
+   */
+  getRelationship() { return this.relationship }
+
+  /**
+   * Runs apply scope.
+   * @template T
+   * @param {T} query - Query instance.
+   * @returns {T} - Scoped query.
+   */
+  applyScope(query) {
+    return this.getRelationship().applyScope(query)
+  }
+
+  /**
+   * Runs get target model class.
+   * @returns {TMC | undefined} The model class that this instance relationship
+   */
+  getTargetModelClass() {
+    const TargetModelClass = /**
+                              * Narrows the runtime value to the documented type.
+                               @type {TMC} */ (this.getRelationship().getTargetModelClass())
+
+    return TargetModelClass
+  }
+
+  /**
+   * Runs get type.
+   * @returns {string} The type of relationship (e.g. "has_many", "belongs_to", etc.)
+   */
+  getType() { return this.getRelationship().getType() }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/database/record/instance-relationships/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BelongsToPreloader from \"../../query/preloader/belongs-to.js\"\nimport HasManyPreloader from \"../../query/preloader/has-many.js\"\nimport HasOnePreloader from \"../../query/preloader/has-one.js\"\n\n/**\n * InstanceRelationshipsBaseArgs type.\n * @template {typeof import(\"../index.js\").default} [MC=typeof import(\"../index.js\").default]\n * @template {typeof import(\"../index.js\").default} [TMC=typeof import(\"../index.js\").default]\n * @typedef {object} InstanceRelationshipsBaseArgs\n * @property {InstanceType<MC>} model - Parent model instance.\n * @property {import(\"../relationships/base.js\").default} relationship - Relationship metadata definition.\n */\n\n/**\n * A generic query over some model type.\n * @template {typeof import(\"../index.js\").default} [MC=typeof import(\"../index.js\").default]\n * @template {typeof import(\"../index.js\").default} [TMC=typeof import(\"../index.js\").default]\n */\nexport default class VelociousDatabaseRecordBaseInstanceRelationship {\n  /**\n   * Auto save.\n    @type {boolean | undefined} */\n  _autoSave = undefined\n  /**\n   * Preloaded.\n    @type {boolean | undefined} */\n  _preloaded = undefined\n  /**\n   * Loaded.\n    @type {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} */\n  _loaded = undefined\n\n  /**\n   * Runs constructor.\n   * @param {InstanceRelationshipsBaseArgs<MC, TMC>} args - Options object.\n   */\n  constructor({model, relationship}) {\n    this._dirty = false\n    this.model = model\n    this.relationship = relationship\n  }\n\n  /**\n   * Runs add to loaded.\n   * @abstract\n   * @param {InstanceType<TMC>[] | InstanceType<TMC>} models - Model instances.\n   * @returns {void} - No return value.\n   */\n  addToLoaded(models) { // eslint-disable-line no-unused-vars\n    throw new Error(\"addToLoaded not implemented\")\n  }\n\n  /**\n   * Runs build.\n   * @abstract\n   * @param {Record<string, ?>} attributes - Attributes.\n   * @returns {InstanceType<TMC>} - The build.\n   */\n  build(attributes) { // eslint-disable-line no-unused-vars\n    throw new Error(\"'build' not implemented\")\n  }\n\n  /**\n   * Runs get auto save.\n   * @returns {boolean | undefined} Whether the relationship should be auto-saved before saving the parent model\n   */\n  getAutoSave() { return this._autoSave }\n\n  /**\n   * Runs set auto save.\n   * @param {boolean} newAutoSaveValue Whether the relationship should be auto-saved before saving the parent model\n   * @returns {void} - No return value.\n   */\n  setAutoSave(newAutoSaveValue) { this._autoSave = newAutoSaveValue }\n\n  /**\n   * Runs set dirty.\n   * @param {boolean} newValue Whether the relationship is dirty (has been modified)\n   * @returns {void} - No return value.\n   */\n  setDirty(newValue) { this._dirty = newValue }\n\n  /**\n   * Runs get dirty.\n   * @returns {boolean} Whether the relationship is dirty (has been modified)\n   */\n  getDirty() { return this._dirty }\n\n  /**\n   * Runs load.\n   * @abstract\n   * @returns {Promise<InstanceType<TMC> | Array<InstanceType<TMC>> | undefined>} - Resolves with loaded relationship value.\n   */\n  load() {\n    throw new Error(\"'load' not implemented\")\n  }\n\n  /**\n   * Loads the relationship if not already loaded. When the parent record was\n   * loaded as part of a batch (cohort) and autoload is enabled, siblings in\n   * the cohort that share this relationship and have not preloaded it yet\n   * are batched into a single query via the existing preloader path.\n   * @returns {Promise<InstanceType<TMC> | Array<InstanceType<TMC>> | undefined>} - Resolves with loaded relationship value.\n   */\n  async autoloadOrLoad() {\n    if (this._loaded !== undefined) return this._loaded\n\n    const batched = await this._tryCohortPreload()\n\n    if (!batched) await this.load()\n\n    return this._loaded\n  }\n\n  /**\n   * Attempts to batch-load this relationship across cohort siblings via the\n   * existing preloader path. Returns true when a batch ran (self is always\n   * included because callers reset their own `_preloaded` state before\n   * calling), false when autoload is off, there is no cohort, or no batch\n   * candidates remain. Siblings that have already preloaded this relationship\n   * are skipped so their cached value is preserved.\n   * @returns {Promise<boolean>} - Whether a cohort batch preload ran.\n   */\n  async _tryCohortPreload() {\n    const relationshipDef = this.getRelationship()\n    const configuration = relationshipDef.getConfiguration()\n    const cohort = /**\n                    * Narrows the runtime value to the documented type.\n                     @type {Array<import(\"../index.js\").default> | undefined} */ (/**\n                                                                                   * Narrows the runtime value to the documented type.\n                                                                                    @type {?} */ (this.model)._loadCohort)\n\n    if (!configuration.getAutoload() || !relationshipDef.getAutoload() || !cohort || cohort.length <= 1) {\n      return false\n    }\n\n    const relationshipName = relationshipDef.getRelationshipName()\n    const OwnerModelClass = /**\n                             * Narrows the runtime value to the documented type.\n                              @type {?} */ (this.model).constructor\n    /**\n     * Batch.\n      @type {Array<import(\"../index.js\").default>} */\n    const batch = []\n\n    // Exact same class, persisted, no existing in-memory relationship state.\n    // Skip siblings where `_loaded` is already set — they may have been\n    // preloaded (preserve cache) OR locally manipulated via `build...` /\n    // `set...` (preserve unsaved edits). Either way the preloader would\n    // overwrite that state.\n    for (const sibling of cohort) {\n      if (sibling.constructor !== OwnerModelClass) continue\n      if (!sibling.isPersisted()) continue\n\n      const siblingInstanceRelationship = sibling.getRelationshipByName(relationshipName)\n\n      if (siblingInstanceRelationship.getLoadedOrUndefined() !== undefined) continue\n\n      batch.push(sibling)\n    }\n\n    if (batch.length === 0) return false\n\n    const type = relationshipDef.getType()\n\n    if (type == \"belongsTo\") {\n      const belongsToRelationship = /**\n                                     * Narrows the runtime value to the documented type.\n                                      @type {import(\"../relationships/belongs-to.js\").default} */ (relationshipDef)\n      const preloader = new BelongsToPreloader({models: batch, relationship: belongsToRelationship})\n\n      await preloader.run()\n    } else if (type == \"hasMany\") {\n      const hasManyRelationship = /**\n                                   * Narrows the runtime value to the documented type.\n                                    @type {import(\"../relationships/has-many.js\").default} */ (relationshipDef)\n      const preloader = new HasManyPreloader({models: batch, relationship: hasManyRelationship})\n\n      await preloader.run()\n    } else if (type == \"hasOne\") {\n      const hasOneRelationship = /**\n                                  * Narrows the runtime value to the documented type.\n                                   @type {import(\"../relationships/has-one.js\").default} */ (relationshipDef)\n      const preloader = new HasOnePreloader({models: batch, relationship: hasOneRelationship})\n\n      await preloader.run()\n    } else {\n      throw new Error(`Unknown relationship type: ${type}`)\n    }\n\n    return true\n  }\n\n  /**\n   * Runs is loaded.\n   * @returns {boolean} Whether the relationship has been preloaded\n   */\n  isLoaded() { return Boolean(this._loaded) }\n\n  /**\n   * Runs loaded.\n   * @returns {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} The loaded model or models (depending on relationship type)\n   */\n  loaded() {\n    if (!this._preloaded && this.model.isPersisted()) {\n      throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)\n    }\n\n    return this._loaded\n  }\n\n  /**\n   * Runs set loaded.\n   * @param {InstanceType<TMC> | Array<InstanceType<TMC>> | undefined} model - Related model(s) to mark as loaded.\n   */\n  setLoaded(model) { this._loaded = model }\n\n  /**\n   * Runs get loaded or undefined.\n   * @returns {InstanceType<TMC> | InstanceType<TMC>[] | undefined} - The loaded or undefined.\n   */\n  getLoadedOrUndefined() { return this._loaded }\n\n  /**\n   * Runs get preloaded.\n   * @returns {boolean} The loaded model or models (depending on relationship type)\n   */\n  getPreloaded() { return this._preloaded || false }\n\n  /**\n   * Runs set preloaded.\n   * @param {boolean} isPreloaded - Whether the relationship is preloaded.\n   */\n  setPreloaded(isPreloaded) { this._preloaded = isPreloaded }\n\n  /**\n   * Runs get foreign key.\n   * @returns {string} The foreign key for this relationship\n   */\n  getForeignKey() { return this.getRelationship().getForeignKey() }\n\n  /**\n   * Runs get model.\n   * @returns {InstanceType<MC>} - The model.\n   */\n  getModel() { return this.model }\n\n  /**\n   * Runs get primary key.\n   * @returns {string} The primary key for this relationship's model\n   */\n  getPrimaryKey() { return this.getRelationship().getPrimaryKey() }\n\n  /**\n   * Runs get relationship.\n   * @returns {import(\"../relationships/base.js\").default} The relationship object that this instance relationship is based on\n   */\n  getRelationship() { return this.relationship }\n\n  /**\n   * Runs apply scope.\n   * @template T\n   * @param {T} query - Query instance.\n   * @returns {T} - Scoped query.\n   */\n  applyScope(query) {\n    return this.getRelationship().applyScope(query)\n  }\n\n  /**\n   * Runs get target model class.\n   * @returns {TMC | undefined} The model class that this instance relationship\n   */\n  getTargetModelClass() {\n    const TargetModelClass = /**\n                              * Narrows the runtime value to the documented type.\n                               @type {TMC} */ (this.getRelationship().getTargetModelClass())\n\n    return TargetModelClass\n  }\n\n  /**\n   * Runs get type.\n   * @returns {string} The type of relationship (e.g. \"has_many\", \"belongs_to\", etc.)\n   */\n  getType() { return this.getRelationship().getType() }\n}\n"]}