velocious 1.0.429 → 1.0.431

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

@@ -1,176 +1,201 @@
 // @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;
-                    }
-                }
-                continue;
-            }
-            throw new Error(`Invalid preload entry type: ${typeof entry}`);
+  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
+          }
         }
-        return result;
+        continue
+      }
+
+      throw new Error(`Invalid preload entry type: ${typeof entry}`)
     }
-    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
+  }
+
+  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}`)
+      }
     }
-    throw new Error(`Invalid preload type: ${typeof preload}`);
+
+    return result
+  }
+
+  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 = /**
+  /**
+   * 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(/**
                             * 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(/**
-                                  * 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 {?} */ (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"]}