velocious 1.0.431 → 1.0.433

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

@@ -1,201 +1,176 @@
 // @ts-check
-
-import BelongsToPreloader from "./preloader/belongs-to.js"
-import HasManyPreloader from "./preloader/has-many.js"
-import HasOnePreloader from "./preloader/has-one.js"
-import PreloaderSelection from "./preloader/selection.js"
-import restArgsError from "../../utils/rest-args-error.js"
-
+import BelongsToPreloader from "./preloader/belongs-to.js";
+import HasManyPreloader from "./preloader/has-many.js";
+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.
  */
 function normalizeNestedPreload(preload) {
-  if (!preload || typeof preload == "boolean") return null
-
-  if (typeof preload == "string") {
-    return {[preload]: true}
-  }
-
-  if (Array.isArray(preload)) {
-    /**
-     * Result.
-      @type {import("../query/index.js").NestedPreloadRecord} */
-    const result = {}
-
-    for (const entry of preload) {
-      if (typeof entry == "string") {
-        result[entry] = true
-        continue
-      }
-
-      if (entry && typeof entry == "object") {
-        const normalizedEntry = normalizeNestedPreload(entry)
-
-        if (normalizedEntry) {
-          for (const [key, value] of Object.entries(normalizedEntry)) {
-            result[key] = value
-          }
+    if (!preload || typeof preload == "boolean")
+        return null;
+    if (typeof preload == "string") {
+        return { [preload]: true };
+    }
+    if (Array.isArray(preload)) {
+        /**
+         * Result.
+          @type {import("../query/index.js").NestedPreloadRecord} */
+        const result = {};
+        for (const entry of preload) {
+            if (typeof entry == "string") {
+                result[entry] = true;
+                continue;
+            }
+            if (entry && typeof entry == "object") {
+                const normalizedEntry = normalizeNestedPreload(entry);
+                if (normalizedEntry) {
+                    for (const [key, value] of Object.entries(normalizedEntry)) {
+                        result[key] = value;
+                    }
+                }
+                continue;
+            }
+            throw new Error(`Invalid preload entry type: ${typeof entry}`);
         }
-        continue
-      }
-
-      throw new Error(`Invalid preload entry type: ${typeof entry}`)
+        return result;
     }
-
-    return result
-  }
-
-  if (preload && typeof preload == "object") {
-    /**
-     * Result.
-      @type {import("../query/index.js").NestedPreloadRecord} */
-    const result = {}
-
-    for (const [key, value] of Object.entries(preload)) {
-      if (value === true || value === false) {
-        result[key] = value
-        continue
-      }
-
-      const normalizedValue = normalizeNestedPreload(value)
-
-      if (normalizedValue) {
-        result[key] = normalizedValue
-      } else {
-        throw new Error(`Invalid preload value for ${key}: ${typeof value}`)
-      }
+    if (preload && typeof preload == "object") {
+        /**
+         * Result.
+          @type {import("../query/index.js").NestedPreloadRecord} */
+        const result = {};
+        for (const [key, value] of Object.entries(preload)) {
+            if (value === true || value === false) {
+                result[key] = value;
+                continue;
+            }
+            const normalizedValue = normalizeNestedPreload(value);
+            if (normalizedValue) {
+                result[key] = normalizedValue;
+            }
+            else {
+                throw new Error(`Invalid preload value for ${key}: ${typeof value}`);
+            }
+        }
+        return result;
     }
-
-    return result
-  }
-
-  throw new Error(`Invalid preload type: ${typeof preload}`)
+    throw new Error(`Invalid preload type: ${typeof preload}`);
 }
-
 export default class VelociousDatabaseQueryPreloader {
-  /**
-   * Preloads relationship(s) onto one or more already-loaded model instances.
-   * Accepts either a query built via `Model.preload(...).select(...)` (its
-   * preload graph and selects are used) or a raw preload spec
-   * (string / array / nested object).
-   * @param {Array<import("../record/index.js").default>} models - Model instances to preload onto.
-   * @param {import("./model-class-query.js").default | import("./index.js").NestedPreloadRecord | string | Array<string | import("./index.js").NestedPreloadRecord>} queryOrSpec - Preload source.
-   * @param {{force?: boolean}} [options] - Options.
-   * @returns {Promise<void>} - Resolves when preloading completes.
-   */
-  static async preload(models, queryOrSpec, {force = false} = {}) {
-    if (models.length == 0) return
-
-    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
-      ? /**
-         * Narrows the runtime value to the documented type.
-          @type {import("./model-class-query.js").default} */ (queryOrSpec)
-      : modelClass.preload(/**
+    /**
+     * Preloads relationship(s) onto one or more already-loaded model instances.
+     * Accepts either a query built via `Model.preload(...).select(...)` (its
+     * preload graph and selects are used) or a raw preload spec
+     * (string / array / nested object).
+     * @param {Array<import("../record/index.js").default>} models - Model instances to preload onto.
+     * @param {import("./model-class-query.js").default | import("./index.js").NestedPreloadRecord | string | Array<string | import("./index.js").NestedPreloadRecord>} queryOrSpec - Preload source.
+     * @param {{force?: boolean}} [options] - Options.
+     * @returns {Promise<void>} - Resolves when preloading completes.
+     */
+    static async preload(models, queryOrSpec, { force = false } = {}) {
+        if (models.length == 0)
+            return;
+        const modelClass = /**
                             * Narrows the runtime value to the documented type.
-                             @type {?} */ (queryOrSpec))
-
-    const preloader = new VelociousDatabaseQueryPreloader({
-      modelClass,
-      models,
-      preload: query._preload,
-      selection: new PreloaderSelection({
-        preloadSelects: query._preloadSelects,
-        preloadSelectsExtra: query._preloadSelectsExtra,
-        force
-      })
-    })
-
-    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.
-   * @param {import("../query/index.js").NestedPreloadRecord} args.preload - Preload.
-   * @param {Record<string, string[]>} [args.preloadSelects] - Narrowing selects keyed by target model name.
-   * @param {Record<string, string[]>} [args.preloadSelectsExtra] - Extra selects keyed by target model name.
-   * @param {PreloaderSelection} [args.selection] - Pre-built selection (takes precedence over the select maps when given).
-   */
-  constructor({modelClass, models, preload, preloadSelects = {}, preloadSelectsExtra = {}, selection, ...restArgs}) {
-    restArgsError(restArgs)
-
-    this.modelClass = modelClass
-    this.models = models
-    this.preload = preload
-    this.selection = selection || new PreloaderSelection({preloadSelects, preloadSelectsExtra})
-  }
-
-  async run() {
-    for (const preloadRelationshipName in this.preload) {
-      const relationship = this.modelClass.getRelationshipByName(preloadRelationshipName)
-      let preloadResult
-
-      if (relationship.getType() == "belongsTo") {
-        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 = /**
-                                     * 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 = /**
-                                    * 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()
-      } else {
-        throw new Error(`Unknown relationship type: ${relationship.getType()}`)
-      }
-
-      const targetModels = Array.isArray(preloadResult) ? preloadResult : (preloadResult?.targetModels || [])
-      const targetModelsByClassName = Array.isArray(preloadResult) ? undefined : preloadResult?.targetModelsByClassName
-
-      // Handle any further preloads in the tree
-      const newPreload = this.preload[preloadRelationshipName]
-      const normalizedPreload = normalizeNestedPreload(newPreload)
-
-      if (normalizedPreload && targetModels.length > 0) {
-        if (relationship.getPolymorphic() && targetModelsByClassName) {
-          const configuration = relationship.getConfiguration()
-
-          for (const className in targetModelsByClassName) {
-            const models = targetModelsByClassName[className]
-
-            if (models.length == 0) continue
-
-            const targetModelClass = configuration.getModelClass(className)
-            const preloader = new VelociousDatabaseQueryPreloader({modelClass: targetModelClass, models, preload: normalizedPreload, selection: this.selection})
-
-            await preloader.run()
-          }
-        } else {
-          const targetModelClass = relationship.getTargetModelClass()
-
-          if (!targetModelClass) throw new Error("No target model class could be gotten from relationship")
-
-          const preloader = new VelociousDatabaseQueryPreloader({modelClass: targetModelClass, models: targetModels, preload: normalizedPreload, selection: this.selection})
-
-          await preloader.run()
+                             @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
+            ? /**
+               * 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,
+            preload: query._preload,
+            selection: new PreloaderSelection({
+                preloadSelects: query._preloadSelects,
+                preloadSelectsExtra: query._preloadSelectsExtra,
+                force
+            })
+        });
+        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.
+     * @param {import("../query/index.js").NestedPreloadRecord} args.preload - Preload.
+     * @param {Record<string, string[]>} [args.preloadSelects] - Narrowing selects keyed by target model name.
+     * @param {Record<string, string[]>} [args.preloadSelectsExtra] - Extra selects keyed by target model name.
+     * @param {PreloaderSelection} [args.selection] - Pre-built selection (takes precedence over the select maps when given).
+     */
+    constructor({ modelClass, models, preload, preloadSelects = {}, preloadSelectsExtra = {}, selection, ...restArgs }) {
+        restArgsError(restArgs);
+        this.modelClass = modelClass;
+        this.models = models;
+        this.preload = preload;
+        this.selection = selection || new PreloaderSelection({ preloadSelects, preloadSelectsExtra });
+    }
+    async run() {
+        for (const preloadRelationshipName in this.preload) {
+            const relationship = this.modelClass.getRelationshipByName(preloadRelationshipName);
+            let preloadResult;
+            if (relationship.getType() == "belongsTo") {
+                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 = /**
+                                             * 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 = /**
+                                            * 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();
+            }
+            else {
+                throw new Error(`Unknown relationship type: ${relationship.getType()}`);
+            }
+            const targetModels = Array.isArray(preloadResult) ? preloadResult : (preloadResult?.targetModels || []);
+            const targetModelsByClassName = Array.isArray(preloadResult) ? undefined : preloadResult?.targetModelsByClassName;
+            // Handle any further preloads in the tree
+            const newPreload = this.preload[preloadRelationshipName];
+            const normalizedPreload = normalizeNestedPreload(newPreload);
+            if (normalizedPreload && targetModels.length > 0) {
+                if (relationship.getPolymorphic() && targetModelsByClassName) {
+                    const configuration = relationship.getConfiguration();
+                    for (const className in targetModelsByClassName) {
+                        const models = targetModelsByClassName[className];
+                        if (models.length == 0)
+                            continue;
+                        const targetModelClass = configuration.getModelClass(className);
+                        const preloader = new VelociousDatabaseQueryPreloader({ modelClass: targetModelClass, models, preload: normalizedPreload, selection: this.selection });
+                        await preloader.run();
+                    }
+                }
+                else {
+                    const targetModelClass = relationship.getTargetModelClass();
+                    if (!targetModelClass)
+                        throw new Error("No target model class could be gotten from relationship");
+                    const preloader = new VelociousDatabaseQueryPreloader({ modelClass: targetModelClass, models: targetModels, preload: normalizedPreload, selection: this.selection });
+                    await preloader.run();
+                }
+            }
         }
-      }
     }
-  }
 }
+//# 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"]}