velocious 1.0.428 → 1.0.430

package/build/src/database/query/preloader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preloader.d.ts","sourceRoot":"","sources":["../../../../src/database/query/preloader.js"],"names":[],"mappings":"AAuEA;IACE;;;;;;;;;OASG;IACH,uBALW,KAAK,CAAC,OAAO,oBAAoB,EAAE,OAAO,CAAC,eAC3C,OAAO,wBAAwB,EAAE,OAAO,GAAG,OAAO,YAAY,EAAE,mBAAmB,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,OAAO,YAAY,EAAE,mBAAmB,CAAC,cACvJ;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAC,GACf,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;OAQG;IACH,0GAPG;QAA0D,UAAU,EAA5D,cAAc,oBAAoB,EAAE,OAAO;QACE,MAAM,EAAnD,OAAO,oBAAoB,EAAE,OAAO,EAAE;QACgB,OAAO,EAA7D,OAAO,mBAAmB,EAAE,mBAAmB;QACf,cAAc;QACd,mBAAmB;QACzB,SAAS;KAC7C,EAQA;IAJC,wDAA4B;IAC5B,+CAAoB;IACpB,yDAAsB;IACtB,8BAA2F;IAG7F,qBAwDC;CACF;+BAjL8B,0BAA0B"}
+{"version":3,"file":"preloader.d.ts","sourceRoot":"","sources":["../../../../src/database/query/preloader.js"],"names":[],"mappings":"AA4EA;IACE;;;;;;;;;OASG;IACH,uBALW,KAAK,CAAC,OAAO,oBAAoB,EAAE,OAAO,CAAC,eAC3C,OAAO,wBAAwB,EAAE,OAAO,GAAG,OAAO,YAAY,EAAE,mBAAmB,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,OAAO,YAAY,EAAE,mBAAmB,CAAC,cACvJ;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAC,GACf,OAAO,CAAC,IAAI,CAAC,CA+BzB;IAED;;;;;;;;;OASG;IACH,0GAPG;QAA0D,UAAU,EAA5D,cAAc,oBAAoB,EAAE,OAAO;QACE,MAAM,EAAnD,OAAO,oBAAoB,EAAE,OAAO,EAAE;QACgB,OAAO,EAA7D,OAAO,mBAAmB,EAAE,mBAAmB;QACf,cAAc;QACd,mBAAmB;QACzB,SAAS;KAC7C,EAQA;IAJC,wDAA4B;IAC5B,+CAAoB;IACpB,yDAAsB;IACtB,8BAA2F;IAG7F,qBA8DC;CACF;+BAnM8B,0BAA0B"}

package/build/src/database/query/preloader.js

@@ -5,6 +5,7 @@ import HasOnePreloader from "./preloader/has-one.js";
 import PreloaderSelection from "./preloader/selection.js";
 import restArgsError from "../../utils/rest-args-error.js";
 /**
+ * Runs normalize nested preload.
  * @param {import("../query/index.js").NestedPreloadRecord | string | string[] | boolean} preload - Preload data in shorthand or nested form.
  * @returns {import("../query/index.js").NestedPreloadRecord | null} - Normalized nested preload record.
  */
@@ -15,7 +16,9 @@ function normalizeNestedPreload(preload) {
         return { [preload]: true };
     }
     if (Array.isArray(preload)) {
-        /** @type {import("../query/index.js").NestedPreloadRecord} */
+        /**
+         * Result.
+          @type {import("../query/index.js").NestedPreloadRecord} */
         const result = {};
         for (const entry of preload) {
             if (typeof entry == "string") {
@@ -36,7 +39,9 @@ function normalizeNestedPreload(preload) {
         return result;
     }
     if (preload && typeof preload == "object") {
-        /** @type {import("../query/index.js").NestedPreloadRecord} */
+        /**
+         * Result.
+          @type {import("../query/index.js").NestedPreloadRecord} */
         const result = {};
         for (const [key, value] of Object.entries(preload)) {
             if (value === true || value === false) {
@@ -69,13 +74,20 @@ export default class VelociousDatabaseQueryPreloader {
     static async preload(models, queryOrSpec, { force = false } = {}) {
         if (models.length == 0)
             return;
-        const modelClass = /** @type {typeof import("../record/index.js").default} */ (models[0].constructor);
+        const modelClass = /**
+                            * Narrows the runtime value to the documented type.
+                             @type {typeof import("../record/index.js").default} */ (models[0].constructor);
         const isQuery = Boolean(queryOrSpec) && typeof queryOrSpec == "object" && "_preload" in queryOrSpec;
         // Reuse the query builder's preload/select normalization for raw specs
         // instead of duplicating it here.
         const query = isQuery
-            ? /** @type {import("./model-class-query.js").default} */ (queryOrSpec)
-            : modelClass.preload(/** @type {any} */ (queryOrSpec));
+            ? /**
+               * Narrows the runtime value to the documented type.
+                @type {import("./model-class-query.js").default} */
+                (queryOrSpec)
+            : modelClass.preload(/**
+                                  * Narrows the runtime value to the documented type.
+                                   @type {?} */ (queryOrSpec));
         const preloader = new VelociousDatabaseQueryPreloader({
             modelClass,
             models,
@@ -89,6 +101,7 @@ export default class VelociousDatabaseQueryPreloader {
         await preloader.run();
     }
     /**
+     * Runs constructor.
      * @param {object} args - Options object.
      * @param {typeof import("../record/index.js").default} args.modelClass - Model class.
      * @param {import("../record/index.js").default[]} args.models - Model instances.
@@ -109,17 +122,23 @@ export default class VelociousDatabaseQueryPreloader {
             const relationship = this.modelClass.getRelationshipByName(preloadRelationshipName);
             let preloadResult;
             if (relationship.getType() == "belongsTo") {
-                const belongsToRelationship = /** @type {import("../record/relationships/belongs-to.js").default} */ (relationship);
+                const belongsToRelationship = /**
+                                               * Narrows the runtime value to the documented type.
+                                                @type {import("../record/relationships/belongs-to.js").default} */ (relationship);
                 const hasManyPreloader = new BelongsToPreloader({ models: this.models, relationship: belongsToRelationship, selection: this.selection });
                 preloadResult = await hasManyPreloader.run();
             }
             else if (relationship.getType() == "hasMany") {
-                const hasManyRelationship = /** @type {import("../record/relationships/has-many.js").default} */ (relationship);
+                const hasManyRelationship = /**
+                                             * Narrows the runtime value to the documented type.
+                                              @type {import("../record/relationships/has-many.js").default} */ (relationship);
                 const hasManyPreloader = new HasManyPreloader({ models: this.models, relationship: hasManyRelationship, selection: this.selection });
                 preloadResult = await hasManyPreloader.run();
             }
             else if (relationship.getType() == "hasOne") {
-                const hasOneRelationship = /** @type {import("../record/relationships/has-one.js").default} */ (relationship);
+                const hasOneRelationship = /**
+                                            * Narrows the runtime value to the documented type.
+                                             @type {import("../record/relationships/has-one.js").default} */ (relationship);
                 const hasOnePreloader = new HasOnePreloader({ models: this.models, relationship: hasOneRelationship, selection: this.selection });
                 preloadResult = await hasOnePreloader.run();
             }
@@ -154,4 +173,4 @@ export default class VelociousDatabaseQueryPreloader {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preloader.js","sourceRoot":"","sources":["../../../../src/database/query/preloader.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BelongsToPreloader from \"./preloader/belongs-to.js\"\nimport HasManyPreloader from \"./preloader/has-many.js\"\nimport HasOnePreloader from \"./preloader/has-one.js\"\nimport PreloaderSelection from \"./preloader/selection.js\"\nimport restArgsError from \"../../utils/rest-args-error.js\"\n\n/**\n * @param {import(\"../query/index.js\").NestedPreloadRecord | string | string[] | boolean} preload - Preload data in shorthand or nested form.\n * @returns {import(\"../query/index.js\").NestedPreloadRecord | null} - Normalized nested preload record.\n */\nfunction normalizeNestedPreload(preload) {\n  if (!preload || typeof preload == \"boolean\") return null\n\n  if (typeof preload == \"string\") {\n    return {[preload]: true}\n  }\n\n  if (Array.isArray(preload)) {\n    /** @type {import(\"../query/index.js\").NestedPreloadRecord} */\n    const result = {}\n\n    for (const entry of preload) {\n      if (typeof entry == \"string\") {\n        result[entry] = true\n        continue\n      }\n\n      if (entry && typeof entry == \"object\") {\n        const normalizedEntry = normalizeNestedPreload(entry)\n\n        if (normalizedEntry) {\n          for (const [key, value] of Object.entries(normalizedEntry)) {\n            result[key] = value\n          }\n        }\n        continue\n      }\n\n      throw new Error(`Invalid preload entry type: ${typeof entry}`)\n    }\n\n    return result\n  }\n\n  if (preload && typeof preload == \"object\") {\n    /** @type {import(\"../query/index.js\").NestedPreloadRecord} */\n    const result = {}\n\n    for (const [key, value] of Object.entries(preload)) {\n      if (value === true || value === false) {\n        result[key] = value\n        continue\n      }\n\n      const normalizedValue = normalizeNestedPreload(value)\n\n      if (normalizedValue) {\n        result[key] = normalizedValue\n      } else {\n        throw new Error(`Invalid preload value for ${key}: ${typeof value}`)\n      }\n    }\n\n    return result\n  }\n\n  throw new Error(`Invalid preload type: ${typeof preload}`)\n}\n\nexport default class VelociousDatabaseQueryPreloader {\n  /**\n   * Preloads relationship(s) onto one or more already-loaded model instances.\n   * Accepts either a query built via `Model.preload(...).select(...)` (its\n   * preload graph and selects are used) or a raw preload spec\n   * (string / array / nested object).\n   * @param {Array<import(\"../record/index.js\").default>} models - Model instances to preload onto.\n   * @param {import(\"./model-class-query.js\").default | import(\"./index.js\").NestedPreloadRecord | string | Array<string | import(\"./index.js\").NestedPreloadRecord>} queryOrSpec - Preload source.\n   * @param {{force?: boolean}} [options] - Options.\n   * @returns {Promise<void>} - Resolves when preloading completes.\n   */\n  static async preload(models, queryOrSpec, {force = false} = {}) {\n    if (models.length == 0) return\n\n    const modelClass = /** @type {typeof import(\"../record/index.js\").default} */ (models[0].constructor)\n    const isQuery = Boolean(queryOrSpec) && typeof queryOrSpec == \"object\" && \"_preload\" in queryOrSpec\n    // Reuse the query builder's preload/select normalization for raw specs\n    // instead of duplicating it here.\n    const query = isQuery\n      ? /** @type {import(\"./model-class-query.js\").default} */ (queryOrSpec)\n      : modelClass.preload(/** @type {any} */ (queryOrSpec))\n\n    const preloader = new VelociousDatabaseQueryPreloader({\n      modelClass,\n      models,\n      preload: query._preload,\n      selection: new PreloaderSelection({\n        preloadSelects: query._preloadSelects,\n        preloadSelectsExtra: query._preloadSelectsExtra,\n        force\n      })\n    })\n\n    await preloader.run()\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {typeof import(\"../record/index.js\").default} args.modelClass - Model class.\n   * @param {import(\"../record/index.js\").default[]} args.models - Model instances.\n   * @param {import(\"../query/index.js\").NestedPreloadRecord} args.preload - Preload.\n   * @param {Record<string, string[]>} [args.preloadSelects] - Narrowing selects keyed by target model name.\n   * @param {Record<string, string[]>} [args.preloadSelectsExtra] - Extra selects keyed by target model name.\n   * @param {PreloaderSelection} [args.selection] - Pre-built selection (takes precedence over the select maps when given).\n   */\n  constructor({modelClass, models, preload, preloadSelects = {}, preloadSelectsExtra = {}, selection, ...restArgs}) {\n    restArgsError(restArgs)\n\n    this.modelClass = modelClass\n    this.models = models\n    this.preload = preload\n    this.selection = selection || new PreloaderSelection({preloadSelects, preloadSelectsExtra})\n  }\n\n  async run() {\n    for (const preloadRelationshipName in this.preload) {\n      const relationship = this.modelClass.getRelationshipByName(preloadRelationshipName)\n      let preloadResult\n\n      if (relationship.getType() == \"belongsTo\") {\n        const belongsToRelationship = /** @type {import(\"../record/relationships/belongs-to.js\").default} */ (relationship)\n        const hasManyPreloader = new BelongsToPreloader({models: this.models, relationship: belongsToRelationship, selection: this.selection})\n\n        preloadResult = await hasManyPreloader.run()\n      } else if (relationship.getType() == \"hasMany\") {\n        const hasManyRelationship = /** @type {import(\"../record/relationships/has-many.js\").default} */ (relationship)\n        const hasManyPreloader = new HasManyPreloader({models: this.models, relationship: hasManyRelationship, selection: this.selection})\n\n        preloadResult = await hasManyPreloader.run()\n      } else if (relationship.getType() == \"hasOne\") {\n        const hasOneRelationship = /** @type {import(\"../record/relationships/has-one.js\").default} */ (relationship)\n        const hasOnePreloader = new HasOnePreloader({models: this.models, relationship: hasOneRelationship, selection: this.selection})\n\n        preloadResult = await hasOnePreloader.run()\n      } else {\n        throw new Error(`Unknown relationship type: ${relationship.getType()}`)\n      }\n\n      const targetModels = Array.isArray(preloadResult) ? preloadResult : (preloadResult?.targetModels || [])\n      const targetModelsByClassName = Array.isArray(preloadResult) ? undefined : preloadResult?.targetModelsByClassName\n\n      // Handle any further preloads in the tree\n      const newPreload = this.preload[preloadRelationshipName]\n      const normalizedPreload = normalizeNestedPreload(newPreload)\n\n      if (normalizedPreload && targetModels.length > 0) {\n        if (relationship.getPolymorphic() && targetModelsByClassName) {\n          const configuration = relationship.getConfiguration()\n\n          for (const className in targetModelsByClassName) {\n            const models = targetModelsByClassName[className]\n\n            if (models.length == 0) continue\n\n            const targetModelClass = configuration.getModelClass(className)\n            const preloader = new VelociousDatabaseQueryPreloader({modelClass: targetModelClass, models, preload: normalizedPreload, selection: this.selection})\n\n            await preloader.run()\n          }\n        } else {\n          const targetModelClass = relationship.getTargetModelClass()\n\n          if (!targetModelClass) throw new Error(\"No target model class could be gotten from relationship\")\n\n          const preloader = new VelociousDatabaseQueryPreloader({modelClass: targetModelClass, models: targetModels, preload: normalizedPreload, selection: this.selection})\n\n          await preloader.run()\n        }\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preloader.js","sourceRoot":"","sources":["../../../../src/database/query/preloader.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BelongsToPreloader from \"./preloader/belongs-to.js\"\nimport HasManyPreloader from \"./preloader/has-many.js\"\nimport HasOnePreloader from \"./preloader/has-one.js\"\nimport PreloaderSelection from \"./preloader/selection.js\"\nimport restArgsError from \"../../utils/rest-args-error.js\"\n\n/**\n * Runs normalize nested preload.\n * @param {import(\"../query/index.js\").NestedPreloadRecord | string | string[] | boolean} preload - Preload data in shorthand or nested form.\n * @returns {import(\"../query/index.js\").NestedPreloadRecord | null} - Normalized nested preload record.\n */\nfunction normalizeNestedPreload(preload) {\n  if (!preload || typeof preload == \"boolean\") return null\n\n  if (typeof preload == \"string\") {\n    return {[preload]: true}\n  }\n\n  if (Array.isArray(preload)) {\n    /**\n     * Result.\n      @type {import(\"../query/index.js\").NestedPreloadRecord} */\n    const result = {}\n\n    for (const entry of preload) {\n      if (typeof entry == \"string\") {\n        result[entry] = true\n        continue\n      }\n\n      if (entry && typeof entry == \"object\") {\n        const normalizedEntry = normalizeNestedPreload(entry)\n\n        if (normalizedEntry) {\n          for (const [key, value] of Object.entries(normalizedEntry)) {\n            result[key] = value\n          }\n        }\n        continue\n      }\n\n      throw new Error(`Invalid preload entry type: ${typeof entry}`)\n    }\n\n    return result\n  }\n\n  if (preload && typeof preload == \"object\") {\n    /**\n     * Result.\n      @type {import(\"../query/index.js\").NestedPreloadRecord} */\n    const result = {}\n\n    for (const [key, value] of Object.entries(preload)) {\n      if (value === true || value === false) {\n        result[key] = value\n        continue\n      }\n\n      const normalizedValue = normalizeNestedPreload(value)\n\n      if (normalizedValue) {\n        result[key] = normalizedValue\n      } else {\n        throw new Error(`Invalid preload value for ${key}: ${typeof value}`)\n      }\n    }\n\n    return result\n  }\n\n  throw new Error(`Invalid preload type: ${typeof preload}`)\n}\n\nexport default class VelociousDatabaseQueryPreloader {\n  /**\n   * Preloads relationship(s) onto one or more already-loaded model instances.\n   * Accepts either a query built via `Model.preload(...).select(...)` (its\n   * preload graph and selects are used) or a raw preload spec\n   * (string / array / nested object).\n   * @param {Array<import(\"../record/index.js\").default>} models - Model instances to preload onto.\n   * @param {import(\"./model-class-query.js\").default | import(\"./index.js\").NestedPreloadRecord | string | Array<string | import(\"./index.js\").NestedPreloadRecord>} queryOrSpec - Preload source.\n   * @param {{force?: boolean}} [options] - Options.\n   * @returns {Promise<void>} - Resolves when preloading completes.\n   */\n  static async preload(models, queryOrSpec, {force = false} = {}) {\n    if (models.length == 0) return\n\n    const modelClass = /**\n                        * Narrows the runtime value to the documented type.\n                         @type {typeof import(\"../record/index.js\").default} */ (models[0].constructor)\n    const isQuery = Boolean(queryOrSpec) && typeof queryOrSpec == \"object\" && \"_preload\" in queryOrSpec\n    // Reuse the query builder's preload/select normalization for raw specs\n    // instead of duplicating it here.\n    const query = isQuery\n      ? /**\n         * Narrows the runtime value to the documented type.\n          @type {import(\"./model-class-query.js\").default} */ (queryOrSpec)\n      : modelClass.preload(/**\n                            * Narrows the runtime value to the documented type.\n                             @type {?} */ (queryOrSpec))\n\n    const preloader = new VelociousDatabaseQueryPreloader({\n      modelClass,\n      models,\n      preload: query._preload,\n      selection: new PreloaderSelection({\n        preloadSelects: query._preloadSelects,\n        preloadSelectsExtra: query._preloadSelectsExtra,\n        force\n      })\n    })\n\n    await preloader.run()\n  }\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {typeof import(\"../record/index.js\").default} args.modelClass - Model class.\n   * @param {import(\"../record/index.js\").default[]} args.models - Model instances.\n   * @param {import(\"../query/index.js\").NestedPreloadRecord} args.preload - Preload.\n   * @param {Record<string, string[]>} [args.preloadSelects] - Narrowing selects keyed by target model name.\n   * @param {Record<string, string[]>} [args.preloadSelectsExtra] - Extra selects keyed by target model name.\n   * @param {PreloaderSelection} [args.selection] - Pre-built selection (takes precedence over the select maps when given).\n   */\n  constructor({modelClass, models, preload, preloadSelects = {}, preloadSelectsExtra = {}, selection, ...restArgs}) {\n    restArgsError(restArgs)\n\n    this.modelClass = modelClass\n    this.models = models\n    this.preload = preload\n    this.selection = selection || new PreloaderSelection({preloadSelects, preloadSelectsExtra})\n  }\n\n  async run() {\n    for (const preloadRelationshipName in this.preload) {\n      const relationship = this.modelClass.getRelationshipByName(preloadRelationshipName)\n      let preloadResult\n\n      if (relationship.getType() == \"belongsTo\") {\n        const belongsToRelationship = /**\n                                       * Narrows the runtime value to the documented type.\n                                        @type {import(\"../record/relationships/belongs-to.js\").default} */ (relationship)\n        const hasManyPreloader = new BelongsToPreloader({models: this.models, relationship: belongsToRelationship, selection: this.selection})\n\n        preloadResult = await hasManyPreloader.run()\n      } else if (relationship.getType() == \"hasMany\") {\n        const hasManyRelationship = /**\n                                     * Narrows the runtime value to the documented type.\n                                      @type {import(\"../record/relationships/has-many.js\").default} */ (relationship)\n        const hasManyPreloader = new HasManyPreloader({models: this.models, relationship: hasManyRelationship, selection: this.selection})\n\n        preloadResult = await hasManyPreloader.run()\n      } else if (relationship.getType() == \"hasOne\") {\n        const hasOneRelationship = /**\n                                    * Narrows the runtime value to the documented type.\n                                     @type {import(\"../record/relationships/has-one.js\").default} */ (relationship)\n        const hasOnePreloader = new HasOnePreloader({models: this.models, relationship: hasOneRelationship, selection: this.selection})\n\n        preloadResult = await hasOnePreloader.run()\n      } else {\n        throw new Error(`Unknown relationship type: ${relationship.getType()}`)\n      }\n\n      const targetModels = Array.isArray(preloadResult) ? preloadResult : (preloadResult?.targetModels || [])\n      const targetModelsByClassName = Array.isArray(preloadResult) ? undefined : preloadResult?.targetModelsByClassName\n\n      // Handle any further preloads in the tree\n      const newPreload = this.preload[preloadRelationshipName]\n      const normalizedPreload = normalizeNestedPreload(newPreload)\n\n      if (normalizedPreload && targetModels.length > 0) {\n        if (relationship.getPolymorphic() && targetModelsByClassName) {\n          const configuration = relationship.getConfiguration()\n\n          for (const className in targetModelsByClassName) {\n            const models = targetModelsByClassName[className]\n\n            if (models.length == 0) continue\n\n            const targetModelClass = configuration.getModelClass(className)\n            const preloader = new VelociousDatabaseQueryPreloader({modelClass: targetModelClass, models, preload: normalizedPreload, selection: this.selection})\n\n            await preloader.run()\n          }\n        } else {\n          const targetModelClass = relationship.getTargetModelClass()\n\n          if (!targetModelClass) throw new Error(\"No target model class could be gotten from relationship\")\n\n          const preloader = new VelociousDatabaseQueryPreloader({modelClass: targetModelClass, models: targetModels, preload: normalizedPreload, selection: this.selection})\n\n          await preloader.run()\n        }\n      }\n    }\n  }\n}\n"]}

package/build/src/database/query/query-data.d.ts

@@ -1,13 +1,16 @@
 /**
- * @typedef {Object} QueryDataEntry
+ * QueryDataEntry type.
+ * @typedef {object} QueryDataEntry
  * @property {string[]} chain - Relationship chain from the root model to the model that declares the fn. Empty for a root-level entry.
  * @property {string} fnName - Identifier under which the fn is registered on the declaring model.
  */
 /**
- * @typedef {string | Array<string | Record<string, any>> | {[key: string]: true | false | string | string[] | Record<string, any>}} QueryDataSpec
+ * Defines this typedef.
+ * @typedef {string | Array<string | Record<string, ?>> | {[key: string]: true | false | string | string[] | Record<string, ?>}} QueryDataSpec
  */
 /**
- * @typedef {Object} QueryDataCallbackArgs
+ * QueryDataCallbackArgs type.
+ * @typedef {object} QueryDataCallbackArgs
  * @property {string} attributeName - Name under which the fn was registered. Convenient when a fn is reused across aliases.
  * @property {import("../drivers/base.js").default} driver - Active database driver, for quoting helpers and type-specific SQL.
  * @property {typeof import("../record/index.js").default} modelClass - Model class the fn is registered on (the chain's target).
@@ -16,6 +19,7 @@
  * @property {string} tableName - Unquoted table reference (alias or table name) for the chain's target, ready to paste into SQL.
  */
 /**
+ * QueryDataFn type.
  * @typedef {(args: QueryDataCallbackArgs) => void | import("./model-class-query.js").default} QueryDataFn
  */
 /**
@@ -33,7 +37,6 @@
  *   {projects: {tasks: ["transportSecondsSum", {timelogs: ["timeSecondsSum"]}]}}
  *     → [{chain: ["projects","tasks"], fnName: "transportSecondsSum"},
  *        {chain: ["projects","tasks","timelogs"], fnName: "timeSecondsSum"}]
- *
  * @param {QueryDataSpec} spec - User-supplied spec.
  * @param {string[]} [chain] - Current chain (internal recursion).
  * @returns {QueryDataEntry[]} - Flat list of entries.
@@ -53,7 +56,6 @@ export function normalizeQueryDataSpec(spec: QueryDataSpec, chain?: string[]): Q
  *
  * Mirrors the shape of `runWithCount`: one query per entry, a separate
  * storage map on the record, never touches `_attributes`.
- *
  * @param {object} args - Options.
  * @param {typeof import("../record/index.js").default} args.rootModelClass - Root model class.
  * @param {import("../record/index.js").default[]} args.rootModels - Loaded root records.
@@ -65,6 +67,9 @@ export function runQueryData({ rootModelClass, rootModels, entries }: {
     rootModels: import("../record/index.js").default[];
     entries: QueryDataEntry[];
 }): Promise<void>;
+/**
+ * QueryDataEntry type.
+ */
 export type QueryDataEntry = {
     /**
      * - Relationship chain from the root model to the model that declares the fn. Empty for a root-level entry.
@@ -75,9 +80,15 @@ export type QueryDataEntry = {
      */
     fnName: string;
 };
-export type QueryDataSpec = string | Array<string | Record<string, any>> | {
-    [key: string]: true | false | string | string[] | Record<string, any>;
+/**
+ * Defines this typedef.
+ */
+export type QueryDataSpec = string | Array<string | Record<string, unknown>> | {
+    [key: string]: true | false | string | string[] | Record<string, unknown>;
 };
+/**
+ * QueryDataCallbackArgs type.
+ */
 export type QueryDataCallbackArgs = {
     /**
      * - Name under which the fn was registered. Convenient when a fn is reused across aliases.
@@ -104,5 +115,8 @@ export type QueryDataCallbackArgs = {
      */
     tableName: string;
 };
+/**
+ * QueryDataFn type.
+ */
 export type QueryDataFn = (args: QueryDataCallbackArgs) => void | import("./model-class-query.js").default;
 //# sourceMappingURL=query-data.d.ts.map

package/build/src/database/query/query-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-data.d.ts","sourceRoot":"","sources":["../../../../src/database/query/query-data.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,6CAJW,aAAa,UACb,MAAM,EAAE,GACN,cAAc,EAAE,CA0D5B;AAwDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sEALG;IAA0D,cAAc,EAAhE,cAAc,oBAAoB,EAAE,OAAO;IACE,UAAU,EAAvD,OAAO,oBAAoB,EAAE,OAAO,EAAE;IACf,OAAO,EAA9B,cAAc,EAAE;CACxB,GAAU,OAAO,CAAC,IAAI,CAAC,CAWzB;;;;;WAxLa,MAAM,EAAE;;;;YACR,MAAM;;4BAIP,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAC;;;;;mBAKrH,MAAM;;;;YACN,OAAO,oBAAoB,EAAE,OAAO;;;;gBACpC,cAAc,oBAAoB,EAAE,OAAO;;;;eAC3C,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;;;;WACtB,OAAO,wBAAwB,EAAE,OAAO;;;;eACxC,MAAM;;0BAIP,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAAG,OAAO,wBAAwB,EAAE,OAAO"}
+{"version":3,"file":"query-data.d.ts","sourceRoot":"","sources":["../../../../src/database/query/query-data.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AAEH;;;GAGG;AAEH;;;;;;;;;GASG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,6CAJW,aAAa,UACb,MAAM,EAAE,GACN,cAAc,EAAE,CAkE5B;AAwDD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,sEALG;IAA0D,cAAc,EAAhE,cAAc,oBAAoB,EAAE,OAAO;IACE,UAAU,EAAvD,OAAO,oBAAoB,EAAE,OAAO,EAAE;IACf,OAAO,EAA9B,cAAc,EAAE;CACxB,GAAU,OAAO,CAAC,IAAI,CAAC,CAazB;;;;;;;;WAnMa,MAAM,EAAE;;;;YACR,MAAM;;;;;4BAKP,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAA;CAAC;;;;;;;;mBAMjH,MAAM;;;;YACN,OAAO,oBAAoB,EAAE,OAAO;;;;gBACpC,cAAc,oBAAoB,EAAE,OAAO;;;;eAC3C,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;;;;WACtB,OAAO,wBAAwB,EAAE,OAAO;;;;eACxC,MAAM;;;;;0BAKP,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAAG,OAAO,wBAAwB,EAAE,OAAO"}

package/build/src/database/query/query-data.js

@@ -1,15 +1,18 @@
 // @ts-check
 import { isPlainObject } from "is-plain-object";
 /**
- * @typedef {Object} QueryDataEntry
+ * QueryDataEntry type.
+ * @typedef {object} QueryDataEntry
  * @property {string[]} chain - Relationship chain from the root model to the model that declares the fn. Empty for a root-level entry.
  * @property {string} fnName - Identifier under which the fn is registered on the declaring model.
  */
 /**
- * @typedef {string | Array<string | Record<string, any>> | {[key: string]: true | false | string | string[] | Record<string, any>}} QueryDataSpec
+ * Defines this typedef.
+ * @typedef {string | Array<string | Record<string, ?>> | {[key: string]: true | false | string | string[] | Record<string, ?>}} QueryDataSpec
  */
 /**
- * @typedef {Object} QueryDataCallbackArgs
+ * QueryDataCallbackArgs type.
+ * @typedef {object} QueryDataCallbackArgs
  * @property {string} attributeName - Name under which the fn was registered. Convenient when a fn is reused across aliases.
  * @property {import("../drivers/base.js").default} driver - Active database driver, for quoting helpers and type-specific SQL.
  * @property {typeof import("../record/index.js").default} modelClass - Model class the fn is registered on (the chain's target).
@@ -18,6 +21,7 @@ import { isPlainObject } from "is-plain-object";
  * @property {string} tableName - Unquoted table reference (alias or table name) for the chain's target, ready to paste into SQL.
  */
 /**
+ * QueryDataFn type.
  * @typedef {(args: QueryDataCallbackArgs) => void | import("./model-class-query.js").default} QueryDataFn
  */
 /**
@@ -35,7 +39,6 @@ import { isPlainObject } from "is-plain-object";
  *   {projects: {tasks: ["transportSecondsSum", {timelogs: ["timeSecondsSum"]}]}}
  *     → [{chain: ["projects","tasks"], fnName: "transportSecondsSum"},
  *        {chain: ["projects","tasks","timelogs"], fnName: "timeSecondsSum"}]
- *
  * @param {QueryDataSpec} spec - User-supplied spec.
  * @param {string[]} [chain] - Current chain (internal recursion).
  * @returns {QueryDataEntry[]} - Flat list of entries.
@@ -47,7 +50,9 @@ export function normalizeQueryDataSpec(spec, chain = []) {
         return [{ chain: [...chain], fnName: spec }];
     }
     if (Array.isArray(spec)) {
-        /** @type {QueryDataEntry[]} */
+        /**
+         * Entries.
+          @type {QueryDataEntry[]} */
         const entries = [];
         for (const item of spec) {
             if (typeof item === "string") {
@@ -55,7 +60,9 @@ export function normalizeQueryDataSpec(spec, chain = []) {
                 continue;
             }
             if (isPlainObject(item)) {
-                for (const nested of normalizeQueryDataSpec(/** @type {any} */ (item), chain)) {
+                for (const nested of normalizeQueryDataSpec(/**
+                                                             * Narrows the runtime value to the documented type.
+                                                              @type {?} */ (item), chain)) {
                     entries.push(nested);
                 }
                 continue;
@@ -65,7 +72,9 @@ export function normalizeQueryDataSpec(spec, chain = []) {
         return entries;
     }
     if (isPlainObject(spec)) {
-        /** @type {QueryDataEntry[]} */
+        /**
+         * Entries.
+          @type {QueryDataEntry[]} */
         const entries = [];
         for (const [key, value] of Object.entries(spec)) {
             if (value === true) {
@@ -75,7 +84,9 @@ export function normalizeQueryDataSpec(spec, chain = []) {
             if (value === false)
                 continue;
             if (typeof value === "string" || Array.isArray(value) || isPlainObject(value)) {
-                for (const nested of normalizeQueryDataSpec(/** @type {any} */ (value), [...chain, key])) {
+                for (const nested of normalizeQueryDataSpec(/**
+                                                             * Narrows the runtime value to the documented type.
+                                                              @type {?} */ (value), [...chain, key])) {
                     entries.push(nested);
                 }
                 continue;
@@ -91,14 +102,15 @@ export function normalizeQueryDataSpec(spec, chain = []) {
  * `["projects", "tasks"]` → `{projects: {tasks: true}}`. Used internally so
  * the runner can reuse the existing `joins` path-registration machinery
  * (JoinTracker, alias generation, scope application).
- *
  * @param {string[]} chain - Relationship chain.
- * @returns {true | Record<string, any>} - Nested join descriptor, or `true` when the chain is empty.
+ * @returns {true | Record<string, ?>} - Nested join descriptor, or `true` when the chain is empty.
  */
 function buildNestedJoinDescriptor(chain) {
     if (chain.length === 0)
         return true;
-    /** @type {Record<string, any>} */
+    /**
+     * Obj.
+      @type {Record<string, ?>} */
     const obj = {};
     let cursor = obj;
     for (let i = 0; i < chain.length; i += 1) {
@@ -114,7 +126,6 @@ function buildNestedJoinDescriptor(chain) {
  * Walk a relationship chain from the root model and return the model
  * class at its tail. Throws with a clear message when any segment is
  * unknown.
- *
  * @param {typeof import("../record/index.js").default} rootModelClass - Root model class.
  * @param {string[]} chain - Relationship chain.
  * @returns {typeof import("../record/index.js").default} - Target model class.
@@ -145,7 +156,6 @@ function resolveTargetModelClass(rootModelClass, chain) {
  *
  * Mirrors the shape of `runWithCount`: one query per entry, a separate
  * storage map on the record, never touches `_attributes`.
- *
  * @param {object} args - Options.
  * @param {typeof import("../record/index.js").default} args.rootModelClass - Root model class.
  * @param {import("../record/index.js").default[]} args.rootModels - Loaded root records.
@@ -156,12 +166,15 @@ export async function runQueryData({ rootModelClass, rootModels, entries }) {
     if (rootModels.length === 0 || entries.length === 0)
         return;
     const primaryKey = rootModelClass.primaryKey();
-    const rootIds = rootModels.map((model) => /** @type {string | number} */ (model.readColumn(primaryKey)));
+    const rootIds = rootModels.map((model) => /**
+                                               * Narrows the runtime value to the documented type.
+                                                @type {string | number} */ (model.readColumn(primaryKey)));
     for (const entry of entries) {
         await runEntry({ entry, primaryKey, rootIds, rootModelClass, rootModels });
     }
 }
 /**
+ * Runs run entry.
  * @param {object} args - Options.
  * @param {QueryDataEntry} args.entry - Entry being evaluated.
  * @param {string} args.primaryKey - Root model primary key column.
@@ -189,7 +202,9 @@ async function runEntry({ entry, primaryKey, rootIds, rootModelClass, rootModels
     const driver = query.driver;
     const rootTable = rootModelClass.tableName();
     const rootPkSql = `${driver.quoteTable(rootTable)}.${driver.quoteColumn(primaryKey)}`;
-    /** @type {Record<string, unknown>} */
+    /**
+     * Root where.
+      @type {Record<string, ?>} */
     const rootWhere = {};
     rootWhere[primaryKey] = rootIds;
     query.where(rootWhere);
@@ -214,7 +229,9 @@ async function runEntry({ entry, primaryKey, rootIds, rootModelClass, rootModels
         query,
         tableName: targetTableRef
     });
-    const rows = /** @type {Array<Record<string, unknown>>} */ (await query._executeQuery());
+    const rows = /**
+                  * Narrows the runtime value to the documented type.
+                   @type {Array<Record<string, ?>>} */ (await query._executeQuery());
     const byParent = new Map();
     for (const row of rows) {
         const parentId = row.parent_id;
@@ -223,7 +240,9 @@ async function runEntry({ entry, primaryKey, rootIds, rootModelClass, rootModels
         byParent.set(parentId, row);
     }
     for (const model of rootModels) {
-        const modelId = /** @type {string | number} */ (model.readColumn(primaryKey));
+        const modelId = /**
+                         * Narrows the runtime value to the documented type.
+                          @type {string | number} */ (model.readColumn(primaryKey));
         // Driver-type tolerance: MySQL can return PKs as strings even when
         // the column is numeric. Fall back to a string lookup so results
         // still land on the right model.
@@ -239,4 +258,4 @@ async function runEntry({ entry, primaryKey, rootIds, rootModelClass, rootModels
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-data.js","sourceRoot":"","sources":["../../../../src/database/query/query-data.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isPlainObject} from \"is-plain-object\"\n\n/**\n * @typedef {Object} QueryDataEntry\n * @property {string[]} chain - Relationship chain from the root model to the model that declares the fn. Empty for a root-level entry.\n * @property {string} fnName - Identifier under which the fn is registered on the declaring model.\n */\n\n/**\n * @typedef {string | Array<string | Record<string, any>> | {[key: string]: true | false | string | string[] | Record<string, any>}} QueryDataSpec\n */\n\n/**\n * @typedef {Object} QueryDataCallbackArgs\n * @property {string} attributeName - Name under which the fn was registered. Convenient when a fn is reused across aliases.\n * @property {import(\"../drivers/base.js\").default} driver - Active database driver, for quoting helpers and type-specific SQL.\n * @property {typeof import(\"../record/index.js\").default} modelClass - Model class the fn is registered on (the chain's target).\n * @property {Array<string | number>} parentIds - Primary-key values of the loaded root records.\n * @property {import(\"./model-class-query.js\").default} query - Grouped query already joined down the chain, filtered by `parentIds`, with `parent_id` pre-selected.\n * @property {string} tableName - Unquoted table reference (alias or table name) for the chain's target, ready to paste into SQL.\n */\n\n/**\n * @typedef {(args: QueryDataCallbackArgs) => void | import(\"./model-class-query.js\").default} QueryDataFn\n */\n\n/**\n * Normalize a user-supplied queryData spec into a flat list of entries\n * the runner can consume. The spec mirrors the shape of `preload`, with\n * the important distinction that **leaf strings are fn names**, not\n * further relationship segments. Nested keys are relationship names\n * along the join chain from the root model to the declaring model.\n *\n * Accepted shapes (all yield the same flat entries):\n *   \"foo\"                                      → [{chain: [], fnName: \"foo\"}]\n *   [\"foo\", \"bar\"]                             → [{chain: [], fnName: \"foo\"}, {chain: [], fnName: \"bar\"}]\n *   {foo: true}                                → [{chain: [], fnName: \"foo\"}]\n *   {projects: [\"tasksCount\"]}                 → [{chain: [\"projects\"], fnName: \"tasksCount\"}]\n *   {projects: {tasks: [\"transportSecondsSum\", {timelogs: [\"timeSecondsSum\"]}]}}\n *     → [{chain: [\"projects\",\"tasks\"], fnName: \"transportSecondsSum\"},\n *        {chain: [\"projects\",\"tasks\",\"timelogs\"], fnName: \"timeSecondsSum\"}]\n *\n * @param {QueryDataSpec} spec - User-supplied spec.\n * @param {string[]} [chain] - Current chain (internal recursion).\n * @returns {QueryDataEntry[]} - Flat list of entries.\n */\nexport function normalizeQueryDataSpec(spec, chain = []) {\n  if (spec == null) return []\n\n  if (typeof spec === \"string\") {\n    return [{chain: [...chain], fnName: spec}]\n  }\n\n  if (Array.isArray(spec)) {\n    /** @type {QueryDataEntry[]} */\n    const entries = []\n\n    for (const item of spec) {\n      if (typeof item === \"string\") {\n        entries.push({chain: [...chain], fnName: item})\n        continue\n      }\n\n      if (isPlainObject(item)) {\n        for (const nested of normalizeQueryDataSpec(/** @type {any} */ (item), chain)) {\n          entries.push(nested)\n        }\n        continue\n      }\n\n      throw new Error(`Invalid queryData array entry: ${typeof item}`)\n    }\n\n    return entries\n  }\n\n  if (isPlainObject(spec)) {\n    /** @type {QueryDataEntry[]} */\n    const entries = []\n\n    for (const [key, value] of Object.entries(spec)) {\n      if (value === true) {\n        entries.push({chain: [...chain], fnName: key})\n        continue\n      }\n\n      if (value === false) continue\n\n      if (typeof value === \"string\" || Array.isArray(value) || isPlainObject(value)) {\n        for (const nested of normalizeQueryDataSpec(/** @type {any} */ (value), [...chain, key])) {\n          entries.push(nested)\n        }\n        continue\n      }\n\n      throw new Error(`Invalid queryData value for \"${key}\": ${typeof value}`)\n    }\n\n    return entries\n  }\n\n  throw new Error(`Invalid queryData spec: ${typeof spec}`)\n}\n\n/**\n * Build the nested `joins(...)` descriptor for a chain of relationship names.\n * `[\"projects\", \"tasks\"]` → `{projects: {tasks: true}}`. Used internally so\n * the runner can reuse the existing `joins` path-registration machinery\n * (JoinTracker, alias generation, scope application).\n *\n * @param {string[]} chain - Relationship chain.\n * @returns {true | Record<string, any>} - Nested join descriptor, or `true` when the chain is empty.\n */\nfunction buildNestedJoinDescriptor(chain) {\n  if (chain.length === 0) return true\n\n  /** @type {Record<string, any>} */\n  const obj = {}\n  let cursor = obj\n\n  for (let i = 0; i < chain.length; i += 1) {\n    const seg = chain[i]\n    const isLast = i === chain.length - 1\n\n    cursor[seg] = isLast ? true : {}\n\n    if (!isLast) cursor = cursor[seg]\n  }\n\n  return obj\n}\n\n/**\n * Walk a relationship chain from the root model and return the model\n * class at its tail. Throws with a clear message when any segment is\n * unknown.\n *\n * @param {typeof import(\"../record/index.js\").default} rootModelClass - Root model class.\n * @param {string[]} chain - Relationship chain.\n * @returns {typeof import(\"../record/index.js\").default} - Target model class.\n */\nfunction resolveTargetModelClass(rootModelClass, chain) {\n  let modelClass = rootModelClass\n\n  for (const segment of chain) {\n    const relationship = modelClass.getRelationshipByName(segment)\n    const target = relationship.getTargetModelClass()\n\n    if (!target) {\n      throw new Error(`queryData: could not resolve target model for ${modelClass.name}#${segment}`)\n    }\n\n    modelClass = target\n  }\n\n  return modelClass\n}\n\n/**\n * Run every queryData entry against the loaded root records, attaching\n * the resulting values as queryData entries on each root record.\n *\n * One grouped query per entry: the runner builds a fresh query over the\n * root model, joins down the chain, groups by the root table's primary\n * key, and invokes the registered fn to add its own SELECT (and any\n * additional joins/where). Results are mapped back to root models by\n * primary key and attached via `_setQueryData(name, value)` for every\n * selected alias (except the reserved `parent_id`). Rows missing from\n * the result keep `null` — matches the feature's documented default.\n *\n * Mirrors the shape of `runWithCount`: one query per entry, a separate\n * storage map on the record, never touches `_attributes`.\n *\n * @param {object} args - Options.\n * @param {typeof import(\"../record/index.js\").default} args.rootModelClass - Root model class.\n * @param {import(\"../record/index.js\").default[]} args.rootModels - Loaded root records.\n * @param {QueryDataEntry[]} args.entries - Normalized queryData entries.\n * @returns {Promise<void>}\n */\nexport async function runQueryData({rootModelClass, rootModels, entries}) {\n  if (rootModels.length === 0 || entries.length === 0) return\n\n  const primaryKey = rootModelClass.primaryKey()\n  const rootIds = rootModels.map((model) => /** @type {string | number} */ (model.readColumn(primaryKey)))\n\n  for (const entry of entries) {\n    await runEntry({entry, primaryKey, rootIds, rootModelClass, rootModels})\n  }\n}\n\n/**\n * @param {object} args - Options.\n * @param {QueryDataEntry} args.entry - Entry being evaluated.\n * @param {string} args.primaryKey - Root model primary key column.\n * @param {Array<string | number>} args.rootIds - Root primary-key values.\n * @param {typeof import(\"../record/index.js\").default} args.rootModelClass - Root model class.\n * @param {import(\"../record/index.js\").default[]} args.rootModels - Loaded root records.\n * @returns {Promise<void>}\n */\nasync function runEntry({entry, primaryKey, rootIds, rootModelClass, rootModels}) {\n  const targetModelClass = resolveTargetModelClass(rootModelClass, entry.chain)\n  const fn = targetModelClass.getQueryDataByName(entry.fnName)\n\n  if (!fn) {\n    throw new Error(`queryData: ${targetModelClass.name} has no entry registered as ${JSON.stringify(entry.fnName)}. ` +\n      `Declare it with ${targetModelClass.name}.queryData(${JSON.stringify(entry.fnName)}, ({query, tableName}) => query.select(...))`)\n  }\n\n  const query = rootModelClass._newQuery()\n\n  // Empty out any defaults the query factory added — queryData runs\n  // a bare aggregate, not a full model load.\n  query._selects = []\n  query._preload = {}\n\n  // Force the root WHERE to qualify by table name so it survives the\n  // joins the fn may add later (otherwise a child table sharing the\n  // root PK column name, e.g. `id`, makes the clause ambiguous).\n  query._forceQualifyBaseTable = true\n\n  const driver = query.driver\n  const rootTable = rootModelClass.tableName()\n  const rootPkSql = `${driver.quoteTable(rootTable)}.${driver.quoteColumn(primaryKey)}`\n\n  /** @type {Record<string, unknown>} */\n  const rootWhere = {}\n  rootWhere[primaryKey] = rootIds\n  query.where(rootWhere)\n\n  const joinDescriptor = buildNestedJoinDescriptor(entry.chain)\n\n  if (joinDescriptor !== true) {\n    query.joins(joinDescriptor)\n  }\n\n  query.group(rootPkSql)\n  query.select(`${rootPkSql} AS parent_id`)\n\n  const targetTableRef = entry.chain.length === 0\n    ? rootTable\n    : query.getTableReferenceForJoin(...entry.chain)\n\n  // NB: we intentionally leave `_joinBasePath` at [] so the outer chain\n  // joins continue to resolve from the root model at render time. The\n  // fn gets `tableName` for self-reference; additional joins from\n  // nested levels should use full paths from the root.\n  fn({\n    attributeName: entry.fnName,\n    driver,\n    modelClass: targetModelClass,\n    parentIds: rootIds,\n    query,\n    tableName: targetTableRef\n  })\n\n  const rows = /** @type {Array<Record<string, unknown>>} */ (await query._executeQuery())\n  const byParent = new Map()\n\n  for (const row of rows) {\n    const parentId = row.parent_id\n\n    if (parentId == null) continue\n\n    byParent.set(parentId, row)\n  }\n\n  for (const model of rootModels) {\n    const modelId = /** @type {string | number} */ (model.readColumn(primaryKey))\n    // Driver-type tolerance: MySQL can return PKs as strings even when\n    // the column is numeric. Fall back to a string lookup so results\n    // still land on the right model.\n    const row = byParent.has(modelId)\n      ? byParent.get(modelId)\n      : byParent.get(String(modelId))\n\n    if (!row) continue\n\n    for (const [columnName, value] of Object.entries(row)) {\n      if (columnName === \"parent_id\") continue\n\n      model._setQueryData(columnName, value)\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-data.js","sourceRoot":"","sources":["../../../../src/database/query/query-data.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isPlainObject} from \"is-plain-object\"\n\n/**\n * QueryDataEntry type.\n * @typedef {object} QueryDataEntry\n * @property {string[]} chain - Relationship chain from the root model to the model that declares the fn. Empty for a root-level entry.\n * @property {string} fnName - Identifier under which the fn is registered on the declaring model.\n */\n\n/**\n * Defines this typedef.\n * @typedef {string | Array<string | Record<string, ?>> | {[key: string]: true | false | string | string[] | Record<string, ?>}} QueryDataSpec\n */\n\n/**\n * QueryDataCallbackArgs type.\n * @typedef {object} QueryDataCallbackArgs\n * @property {string} attributeName - Name under which the fn was registered. Convenient when a fn is reused across aliases.\n * @property {import(\"../drivers/base.js\").default} driver - Active database driver, for quoting helpers and type-specific SQL.\n * @property {typeof import(\"../record/index.js\").default} modelClass - Model class the fn is registered on (the chain's target).\n * @property {Array<string | number>} parentIds - Primary-key values of the loaded root records.\n * @property {import(\"./model-class-query.js\").default} query - Grouped query already joined down the chain, filtered by `parentIds`, with `parent_id` pre-selected.\n * @property {string} tableName - Unquoted table reference (alias or table name) for the chain's target, ready to paste into SQL.\n */\n\n/**\n * QueryDataFn type.\n * @typedef {(args: QueryDataCallbackArgs) => void | import(\"./model-class-query.js\").default} QueryDataFn\n */\n\n/**\n * Normalize a user-supplied queryData spec into a flat list of entries\n * the runner can consume. The spec mirrors the shape of `preload`, with\n * the important distinction that **leaf strings are fn names**, not\n * further relationship segments. Nested keys are relationship names\n * along the join chain from the root model to the declaring model.\n *\n * Accepted shapes (all yield the same flat entries):\n *   \"foo\"                                      → [{chain: [], fnName: \"foo\"}]\n *   [\"foo\", \"bar\"]                             → [{chain: [], fnName: \"foo\"}, {chain: [], fnName: \"bar\"}]\n *   {foo: true}                                → [{chain: [], fnName: \"foo\"}]\n *   {projects: [\"tasksCount\"]}                 → [{chain: [\"projects\"], fnName: \"tasksCount\"}]\n *   {projects: {tasks: [\"transportSecondsSum\", {timelogs: [\"timeSecondsSum\"]}]}}\n *     → [{chain: [\"projects\",\"tasks\"], fnName: \"transportSecondsSum\"},\n *        {chain: [\"projects\",\"tasks\",\"timelogs\"], fnName: \"timeSecondsSum\"}]\n * @param {QueryDataSpec} spec - User-supplied spec.\n * @param {string[]} [chain] - Current chain (internal recursion).\n * @returns {QueryDataEntry[]} - Flat list of entries.\n */\nexport function normalizeQueryDataSpec(spec, chain = []) {\n  if (spec == null) return []\n\n  if (typeof spec === \"string\") {\n    return [{chain: [...chain], fnName: spec}]\n  }\n\n  if (Array.isArray(spec)) {\n    /**\n     * Entries.\n      @type {QueryDataEntry[]} */\n    const entries = []\n\n    for (const item of spec) {\n      if (typeof item === \"string\") {\n        entries.push({chain: [...chain], fnName: item})\n        continue\n      }\n\n      if (isPlainObject(item)) {\n        for (const nested of normalizeQueryDataSpec(/**\n                                                     * Narrows the runtime value to the documented type.\n                                                      @type {?} */ (item), chain)) {\n          entries.push(nested)\n        }\n        continue\n      }\n\n      throw new Error(`Invalid queryData array entry: ${typeof item}`)\n    }\n\n    return entries\n  }\n\n  if (isPlainObject(spec)) {\n    /**\n     * Entries.\n      @type {QueryDataEntry[]} */\n    const entries = []\n\n    for (const [key, value] of Object.entries(spec)) {\n      if (value === true) {\n        entries.push({chain: [...chain], fnName: key})\n        continue\n      }\n\n      if (value === false) continue\n\n      if (typeof value === \"string\" || Array.isArray(value) || isPlainObject(value)) {\n        for (const nested of normalizeQueryDataSpec(/**\n                                                     * Narrows the runtime value to the documented type.\n                                                      @type {?} */ (value), [...chain, key])) {\n          entries.push(nested)\n        }\n        continue\n      }\n\n      throw new Error(`Invalid queryData value for \"${key}\": ${typeof value}`)\n    }\n\n    return entries\n  }\n\n  throw new Error(`Invalid queryData spec: ${typeof spec}`)\n}\n\n/**\n * Build the nested `joins(...)` descriptor for a chain of relationship names.\n * `[\"projects\", \"tasks\"]` → `{projects: {tasks: true}}`. Used internally so\n * the runner can reuse the existing `joins` path-registration machinery\n * (JoinTracker, alias generation, scope application).\n * @param {string[]} chain - Relationship chain.\n * @returns {true | Record<string, ?>} - Nested join descriptor, or `true` when the chain is empty.\n */\nfunction buildNestedJoinDescriptor(chain) {\n  if (chain.length === 0) return true\n\n  /**\n   * Obj.\n    @type {Record<string, ?>} */\n  const obj = {}\n  let cursor = obj\n\n  for (let i = 0; i < chain.length; i += 1) {\n    const seg = chain[i]\n    const isLast = i === chain.length - 1\n\n    cursor[seg] = isLast ? true : {}\n\n    if (!isLast) cursor = cursor[seg]\n  }\n\n  return obj\n}\n\n/**\n * Walk a relationship chain from the root model and return the model\n * class at its tail. Throws with a clear message when any segment is\n * unknown.\n * @param {typeof import(\"../record/index.js\").default} rootModelClass - Root model class.\n * @param {string[]} chain - Relationship chain.\n * @returns {typeof import(\"../record/index.js\").default} - Target model class.\n */\nfunction resolveTargetModelClass(rootModelClass, chain) {\n  let modelClass = rootModelClass\n\n  for (const segment of chain) {\n    const relationship = modelClass.getRelationshipByName(segment)\n    const target = relationship.getTargetModelClass()\n\n    if (!target) {\n      throw new Error(`queryData: could not resolve target model for ${modelClass.name}#${segment}`)\n    }\n\n    modelClass = target\n  }\n\n  return modelClass\n}\n\n/**\n * Run every queryData entry against the loaded root records, attaching\n * the resulting values as queryData entries on each root record.\n *\n * One grouped query per entry: the runner builds a fresh query over the\n * root model, joins down the chain, groups by the root table's primary\n * key, and invokes the registered fn to add its own SELECT (and any\n * additional joins/where). Results are mapped back to root models by\n * primary key and attached via `_setQueryData(name, value)` for every\n * selected alias (except the reserved `parent_id`). Rows missing from\n * the result keep `null` — matches the feature's documented default.\n *\n * Mirrors the shape of `runWithCount`: one query per entry, a separate\n * storage map on the record, never touches `_attributes`.\n * @param {object} args - Options.\n * @param {typeof import(\"../record/index.js\").default} args.rootModelClass - Root model class.\n * @param {import(\"../record/index.js\").default[]} args.rootModels - Loaded root records.\n * @param {QueryDataEntry[]} args.entries - Normalized queryData entries.\n * @returns {Promise<void>}\n */\nexport async function runQueryData({rootModelClass, rootModels, entries}) {\n  if (rootModels.length === 0 || entries.length === 0) return\n\n  const primaryKey = rootModelClass.primaryKey()\n  const rootIds = rootModels.map((model) => /**\n                                             * Narrows the runtime value to the documented type.\n                                              @type {string | number} */ (model.readColumn(primaryKey)))\n\n  for (const entry of entries) {\n    await runEntry({entry, primaryKey, rootIds, rootModelClass, rootModels})\n  }\n}\n\n/**\n * Runs run entry.\n * @param {object} args - Options.\n * @param {QueryDataEntry} args.entry - Entry being evaluated.\n * @param {string} args.primaryKey - Root model primary key column.\n * @param {Array<string | number>} args.rootIds - Root primary-key values.\n * @param {typeof import(\"../record/index.js\").default} args.rootModelClass - Root model class.\n * @param {import(\"../record/index.js\").default[]} args.rootModels - Loaded root records.\n * @returns {Promise<void>}\n */\nasync function runEntry({entry, primaryKey, rootIds, rootModelClass, rootModels}) {\n  const targetModelClass = resolveTargetModelClass(rootModelClass, entry.chain)\n  const fn = targetModelClass.getQueryDataByName(entry.fnName)\n\n  if (!fn) {\n    throw new Error(`queryData: ${targetModelClass.name} has no entry registered as ${JSON.stringify(entry.fnName)}. ` +\n      `Declare it with ${targetModelClass.name}.queryData(${JSON.stringify(entry.fnName)}, ({query, tableName}) => query.select(...))`)\n  }\n\n  const query = rootModelClass._newQuery()\n\n  // Empty out any defaults the query factory added — queryData runs\n  // a bare aggregate, not a full model load.\n  query._selects = []\n  query._preload = {}\n\n  // Force the root WHERE to qualify by table name so it survives the\n  // joins the fn may add later (otherwise a child table sharing the\n  // root PK column name, e.g. `id`, makes the clause ambiguous).\n  query._forceQualifyBaseTable = true\n\n  const driver = query.driver\n  const rootTable = rootModelClass.tableName()\n  const rootPkSql = `${driver.quoteTable(rootTable)}.${driver.quoteColumn(primaryKey)}`\n\n  /**\n   * Root where.\n    @type {Record<string, ?>} */\n  const rootWhere = {}\n  rootWhere[primaryKey] = rootIds\n  query.where(rootWhere)\n\n  const joinDescriptor = buildNestedJoinDescriptor(entry.chain)\n\n  if (joinDescriptor !== true) {\n    query.joins(joinDescriptor)\n  }\n\n  query.group(rootPkSql)\n  query.select(`${rootPkSql} AS parent_id`)\n\n  const targetTableRef = entry.chain.length === 0\n    ? rootTable\n    : query.getTableReferenceForJoin(...entry.chain)\n\n  // NB: we intentionally leave `_joinBasePath` at [] so the outer chain\n  // joins continue to resolve from the root model at render time. The\n  // fn gets `tableName` for self-reference; additional joins from\n  // nested levels should use full paths from the root.\n  fn({\n    attributeName: entry.fnName,\n    driver,\n    modelClass: targetModelClass,\n    parentIds: rootIds,\n    query,\n    tableName: targetTableRef\n  })\n\n  const rows = /**\n                * Narrows the runtime value to the documented type.\n                 @type {Array<Record<string, ?>>} */ (await query._executeQuery())\n  const byParent = new Map()\n\n  for (const row of rows) {\n    const parentId = row.parent_id\n\n    if (parentId == null) continue\n\n    byParent.set(parentId, row)\n  }\n\n  for (const model of rootModels) {\n    const modelId = /**\n                     * Narrows the runtime value to the documented type.\n                      @type {string | number} */ (model.readColumn(primaryKey))\n    // Driver-type tolerance: MySQL can return PKs as strings even when\n    // the column is numeric. Fall back to a string lookup so results\n    // still land on the right model.\n    const row = byParent.has(modelId)\n      ? byParent.get(modelId)\n      : byParent.get(String(modelId))\n\n    if (!row) continue\n\n    for (const [columnName, value] of Object.entries(row)) {\n      if (columnName === \"parent_id\") continue\n\n      model._setQueryData(columnName, value)\n    }\n  }\n}\n"]}

package/build/src/database/query/select-base.d.ts

@@ -1,14 +1,17 @@
 export default class VelociousDatabaseQuerySelectBase {
     /**
+     * Runs get options.
      * @returns {import("../query-parser/options.js").default} - The options options.
      */
     getOptions(): import("../query-parser/options.js").default;
     /**
+     * Runs set query.
      * @param {import("./index.js").default} query - Query instance.
      */
     setQuery(query: import("./index.js").default): void;
     query: import("./index.js").default | undefined;
     /**
+     * Runs to sql.
      * @abstract
      * @returns {string} - SQL string.
      */

package/build/src/database/query/select-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/select-base.js"],"names":[],"mappings":"AAEA;IACE;;OAEG;IACH,cAFa,OAAO,4BAA4B,EAAE,OAAO,CAMxD;IAED;;OAEG;IACH,gBAFW,OAAO,YAAY,EAAE,OAAO,QAItC;IADC,gDAAkB;IAGpB;;;OAGG;IACH,SAFa,MAAM,CAIlB;CACF"}
+{"version":3,"file":"select-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/select-base.js"],"names":[],"mappings":"AAEA;IACE;;;OAGG;IACH,cAFa,OAAO,4BAA4B,EAAE,OAAO,CAMxD;IAED;;;OAGG;IACH,gBAFW,OAAO,YAAY,EAAE,OAAO,QAItC;IADC,gDAAkB;IAGpB;;;;OAIG;IACH,SAFa,MAAM,CAIlB;CACF"}

package/build/src/database/query/select-base.js

@@ -1,6 +1,7 @@
 // @ts-check
 export default class VelociousDatabaseQuerySelectBase {
     /**
+     * Runs get options.
      * @returns {import("../query-parser/options.js").default} - The options options.
      */
     getOptions() {
@@ -9,12 +10,14 @@ export default class VelociousDatabaseQuerySelectBase {
         return this.query.driver.options();
     }
     /**
+     * Runs set query.
      * @param {import("./index.js").default} query - Query instance.
      */
     setQuery(query) {
         this.query = query;
     }
     /**
+     * Runs to sql.
      * @abstract
      * @returns {string} - SQL string.
      */
@@ -22,4 +25,4 @@ export default class VelociousDatabaseQuerySelectBase {
         throw new Error("'toSql' wasn't implemented");
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YWJhc2UvcXVlcnkvc2VsZWN0LWJhc2UuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE1BQU0sQ0FBQyxPQUFPLE9BQU8sZ0NBQWdDO0lBQ25EOztPQUVHO0lBQ0gsVUFBVTtRQUNSLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSztZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQTtRQUUzRCxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFBO0lBQ3BDLENBQUM7SUFFRDs7T0FFRztJQUNILFFBQVEsQ0FBQyxLQUFLO1FBQ1osSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUE7SUFDcEIsQ0FBQztJQUVEOzs7T0FHRztJQUNILEtBQUs7UUFDSCxNQUFNLElBQUksS0FBSyxDQUFDLDRCQUE0QixDQUFDLENBQUE7SUFDL0MsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIFZlbG9jaW91c0RhdGFiYXNlUXVlcnlTZWxlY3RCYXNlIHtcbiAgLyoqXG4gICAqIEByZXR1cm5zIHtpbXBvcnQoXCIuLi9xdWVyeS1wYXJzZXIvb3B0aW9ucy5qc1wiKS5kZWZhdWx0fSAtIFRoZSBvcHRpb25zIG9wdGlvbnMuXG4gICAqL1xuICBnZXRPcHRpb25zKCkge1xuICAgIGlmICghdGhpcy5xdWVyeSkgdGhyb3cgbmV3IEVycm9yKFwiJ3F1ZXJ5JyBoYXNuJ3QgYmVlbiBzZXRcIilcblxuICAgIHJldHVybiB0aGlzLnF1ZXJ5LmRyaXZlci5vcHRpb25zKClcbiAgfVxuXG4gIC8qKlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4vaW5kZXguanNcIikuZGVmYXVsdH0gcXVlcnkgLSBRdWVyeSBpbnN0YW5jZS5cbiAgICovXG4gIHNldFF1ZXJ5KHF1ZXJ5KSB7XG4gICAgdGhpcy5xdWVyeSA9IHF1ZXJ5XG4gIH1cblxuICAvKipcbiAgICogQGFic3RyYWN0XG4gICAqIEByZXR1cm5zIHtzdHJpbmd9IC0gU1FMIHN0cmluZy5cbiAgICovXG4gIHRvU3FsKCkge1xuICAgIHRocm93IG5ldyBFcnJvcihcIid0b1NxbCcgd2Fzbid0IGltcGxlbWVudGVkXCIpXG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YWJhc2UvcXVlcnkvc2VsZWN0LWJhc2UuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE1BQU0sQ0FBQyxPQUFPLE9BQU8sZ0NBQWdDO0lBQ25EOzs7T0FHRztJQUNILFVBQVU7UUFDUixJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUs7WUFBRSxNQUFNLElBQUksS0FBSyxDQUFDLHlCQUF5QixDQUFDLENBQUE7UUFFM0QsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsQ0FBQTtJQUNwQyxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsUUFBUSxDQUFDLEtBQUs7UUFDWixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQTtJQUNwQixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILEtBQUs7UUFDSCxNQUFNLElBQUksS0FBSyxDQUFDLDRCQUE0QixDQUFDLENBQUE7SUFDL0MsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIFZlbG9jaW91c0RhdGFiYXNlUXVlcnlTZWxlY3RCYXNlIHtcbiAgLyoqXG4gICAqIFJ1bnMgZ2V0IG9wdGlvbnMuXG4gICAqIEByZXR1cm5zIHtpbXBvcnQoXCIuLi9xdWVyeS1wYXJzZXIvb3B0aW9ucy5qc1wiKS5kZWZhdWx0fSAtIFRoZSBvcHRpb25zIG9wdGlvbnMuXG4gICAqL1xuICBnZXRPcHRpb25zKCkge1xuICAgIGlmICghdGhpcy5xdWVyeSkgdGhyb3cgbmV3IEVycm9yKFwiJ3F1ZXJ5JyBoYXNuJ3QgYmVlbiBzZXRcIilcblxuICAgIHJldHVybiB0aGlzLnF1ZXJ5LmRyaXZlci5vcHRpb25zKClcbiAgfVxuXG4gIC8qKlxuICAgKiBSdW5zIHNldCBxdWVyeS5cbiAgICogQHBhcmFtIHtpbXBvcnQoXCIuL2luZGV4LmpzXCIpLmRlZmF1bHR9IHF1ZXJ5IC0gUXVlcnkgaW5zdGFuY2UuXG4gICAqL1xuICBzZXRRdWVyeShxdWVyeSkge1xuICAgIHRoaXMucXVlcnkgPSBxdWVyeVxuICB9XG5cbiAgLyoqXG4gICAqIFJ1bnMgdG8gc3FsLlxuICAgKiBAYWJzdHJhY3RcbiAgICogQHJldHVybnMge3N0cmluZ30gLSBTUUwgc3RyaW5nLlxuICAgKi9cbiAgdG9TcWwoKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFwiJ3RvU3FsJyB3YXNuJ3QgaW1wbGVtZW50ZWRcIilcbiAgfVxufVxuIl19

package/build/src/database/query/select-plain.d.ts

@@ -1,5 +1,6 @@
 export default class VelociousDatabaseQuerySelectPlain extends SelectBase {
     /**
+     * Runs constructor.
      * @param {string} plain - Plain.
      */
     constructor(plain: string);

package/build/src/database/query/select-plain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select-plain.d.ts","sourceRoot":"","sources":["../../../../src/database/query/select-plain.js"],"names":[],"mappings":"AAIA;IACE;;OAEG;IACH,mBAFW,MAAM,EAKhB;IADC,cAAkB;CAMrB;uBAdsB,kBAAkB"}
+{"version":3,"file":"select-plain.d.ts","sourceRoot":"","sources":["../../../../src/database/query/select-plain.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,mBAFW,MAAM,EAKhB;IADC,cAAkB;CAMrB;uBAfsB,kBAAkB"}