@kaspernj/api-maker 1.0.2053 → 1.0.2055

package/build/collection.js

@@ -1,310 +1,449 @@
 import cloneDeep from "clone-deep";
-import CommandsPool from "./commands-pool";
+import CommandsPool from "./commands-pool.js";
 import { digg } from "diggerize";
 import * as inflection from "inflection";
 import { incorporate } from "incorporator";
-import modelClassRequire from "./model-class-require";
-import Result from "./result";
+import modelClassRequire from "./model-class-require.js";
+import Result from "./result.js";
 import uniqunize from "uniqunize";
+/**
+ * @template {typeof import("./base-model.js").default} MC
+ * @typedef {InstanceType<MC>} ModelOf
+ */
+/**
+ * @template {typeof import("./base-model.js").default} MC
+ * @typedef {object} CollectionArgsType
+ * @property {ModelOf<MC>} [model]
+ * @property {MC} modelClass
+ * @property {string} [reflectionName]
+ */
+/**
+ * @typedef {object} QueryArgsType
+ * @property {Record<string, string[]>} [abilities]
+ * @property {string} [accessibleBy]
+ * @property {number} [count]
+ * @property {string} [distinct]
+ * @property {string[]} [groupBy]
+ * @property {number} [limit]
+ * @property {number} [page]
+ * @property {Record<string, any>} [params]
+ * @property {number} [per]
+ * @property {string[]} [preload]
+ * @property {Record<string, any>} [ransack]
+ * @property {Record<string, any>} [search]
+ * @property {Record<string, string[]>} [select]
+ * @property {Record<string, string[]>} [selectColumns]
+ */
+/**
+ * @template {typeof import("./base-model.js").default} MC
+ */
 export default class ApiMakerCollection {
-  static apiMakerType = "Collection";
-  constructor(args, queryArgs = {}) {
-    this.queryArgs = queryArgs;
-    this.args = args;
-  }
-  abilities(originalAbilities) {
-    const newAbilities = {};
-    for (const originalAbilityName in originalAbilities) {
-      const newModelName = inflection.underscore(originalAbilityName);
-      const newValues = [];
-      const originalValues = originalAbilities[originalAbilityName];
-      for (const originalAbilityName of originalValues) {
-        const newAbilityName = inflection.underscore(originalAbilityName);
-        newValues.push(newAbilityName);
-      }
-      newAbilities[newModelName] = newValues;
-    }
-    return this._merge({
-      abilities: newAbilities
-    });
-  }
-  accessibleBy(abilityName) {
-    return this._merge({
-      accessibleBy: inflection.underscore(abilityName)
-    });
-  }
-  async count() {
-    const response = await this.clone()._merge({
-      count: true
-    })._response();
-    return digg(response, "count");
-  }
-  distinct() {
-    return this._merge({
-      distinct: true
-    });
-  }
-  async each(callback) {
-    const array = await this.toArray();
-    for (const model in array) {
-      callback.call(model);
-    }
-  }
-  except(...keys) {
-    for (const key of keys) {
-      if (key == "page") {
-        delete this.queryArgs[key];
-      } else {
-        throw new Error(`Unhandled key: ${key}`);
-      }
-    }
-    return this;
-  }
-  async first() {
-    const models = await this.toArray();
-    return models[0];
-  }
-  groupBy(...arrayOfTablesAndColumns) {
-    const arrayOfTablesAndColumnsWithLowercaseColumns = arrayOfTablesAndColumns.map(tableAndColumn => {
-      if (Array.isArray(tableAndColumn)) {
-        return [tableAndColumn[0], tableAndColumn[1].toLowerCase()];
-      } else {
-        return tableAndColumn.toLowerCase();
-      }
-    });
-    const currentGroupBy = this.queryArgs.groupBy || [];
-    const newGroupBy = currentGroupBy.concat(arrayOfTablesAndColumnsWithLowercaseColumns);
-    return this._merge({
-      groupBy: newGroupBy
-    });
-  }
-  async ensureLoaded() {
-    if (!this.isLoaded()) {
-      const models = await this.toArray();
-      this.set(models);
-    }
-    return this.loaded();
-  }
-  isLoaded() {
-    const {
-      model,
-      reflectionName
-    } = this.args;
-    if (reflectionName in model.relationshipsCache) {
-      return true;
-    } else if (reflectionName in model.relationships) {
-      return true;
-    }
-    return false;
-  }
-  limit(amount) {
-    return this._merge({
-      limit: amount
-    });
-  }
-  preloaded() {
-    if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {
-      throw new Error(`${this.args.reflectionName} hasnt been loaded yet`);
-    }
-    return this.args.model.relationshipsCache[this.args.reflectionName];
-  }
-  loaded() {
-    const {
-      model,
-      reflectionName
-    } = this.args;
-    if (reflectionName in model.relationships) {
-      return model.relationships[reflectionName];
-    } else if (reflectionName in model.relationshipsCache) {
-      return model.relationshipsCache[reflectionName];
-    } else if (model.isNewRecord()) {
-      const reflectionNameUnderscore = inflection.underscore(reflectionName);
-
-      // Initialize as empty and try again to return the empty result
-      this.set([]);
-      return digg(model.relationships, reflectionNameUnderscore);
-    } else {
-      const relationshipsLoaded = uniqunize(Object.keys(model.relationships).concat(Object.keys(model.relationshipsCache)));
-      throw new Error(`${reflectionName} hasnt been loaded yet on ${model.modelClassData().name}. Loaded was: ${relationshipsLoaded.join(", ")}`);
-    }
-  }
-
-  // Replaces the relationships with the given new collection.
-  set(newCollection) {
-    this.args.model.relationships[this.args.reflectionName] = newCollection;
-  }
-
-  // Pushes another model onto the given collection.
-  push(newModel) {
-    const {
-      model,
-      reflectionName
-    } = this.args;
-    if (!(reflectionName in model.relationships)) {
-      model.relationships[reflectionName] = [];
-    }
-    if (!model.relationships[reflectionName].includes(newModel)) {
-      model.relationships[reflectionName].push(newModel);
-    }
-  }
-
-  // Array shortcuts
-  find = (...args) => this.loaded().find(...args);
-  forEach = (...args) => this.loaded().forEach(...args);
-  map = (...args) => this.loaded().map(...args);
-  preload(preloadValue) {
-    return this._merge({
-      preload: preloadValue
-    });
-  }
-  page(page) {
-    if (!page) page = 1;
-    return this._merge({
-      page
-    });
-  }
-  pageKey(pageKey) {
-    return this._merge({
-      pageKey
-    });
-  }
-  isFiltered() {
-    const {
-      queryArgs
-    } = this;
-    if (queryArgs.accessibleBy || queryArgs.count || queryArgs.limit || queryArgs.page || queryArgs.params || queryArgs.per || queryArgs.ransack || queryArgs.search) {
-      return true;
-    }
-    return false;
-  }
-  params() {
-    let params = {};
-    if (this.queryArgs.params) params = incorporate(params, this.queryArgs.params);
-    if (this.queryArgs.abilities) params.abilities = this.queryArgs.abilities;
-    if (this.queryArgs.accessibleBy) params.accessible_by = inflection.underscore(this.queryArgs.accessibleBy);
-    if (this.queryArgs.count) params.count = this.queryArgs.count;
-    if (this.queryArgs.distinct) params.distinct = this.queryArgs.distinct;
-    if (this.queryArgs.groupBy) params.group_by = this.queryArgs.groupBy;
-    if (this.queryArgs.ransack) params.q = this.queryArgs.ransack;
-    if (this.queryArgs.limit) params.limit = this.queryArgs.limit;
-    if (this.queryArgs.preload) params.preload = this.queryArgs.preload;
-    if (this.queryArgs.page) params.page = this.queryArgs.page;
-    if (this.queryArgs.per) params.per = this.queryArgs.per;
-    if (this.queryArgs.search) params.search = this.queryArgs.search;
-    if (this.queryArgs.select) params.select = this.queryArgs.select;
-    if (this.queryArgs.selectColumns) params.select_columns = this.queryArgs.selectColumns;
-    return params;
-  }
-  per(per) {
-    return this._merge({
-      per
-    });
-  }
-  perKey(perKey) {
-    return this._merge({
-      perKey
-    });
-  }
-  ransack(params) {
-    if (params) this._merge({
-      ransack: params
-    });
-    return this;
-  }
-  async result() {
-    const response = await this._response();
-    const models = digg(response, "collection");
-    this._addQueryToModels(models);
-    const result = new Result({
-      collection: this,
-      models,
-      response
-    });
-    return result;
-  }
-  search(params) {
-    if (params) this._merge({
-      search: params
-    });
-    return this;
-  }
-  searchKey(searchKey) {
-    return this._merge({
-      searchKey
-    });
-  }
-  select(originalSelect) {
-    const newSelect = {};
-    for (const originalModelName in originalSelect) {
-      const newModelName = inflection.underscore(originalModelName);
-      const newValues = [];
-      const originalValues = originalSelect[originalModelName];
-      for (const originalAttributeName of originalValues) {
-        const newAttributeName = inflection.underscore(originalAttributeName);
-        newValues.push(newAttributeName);
-      }
-      newSelect[newModelName] = newValues;
-    }
-    return this._merge({
-      select: newSelect
-    });
-  }
-  selectColumns(originalSelect) {
-    const newSelect = {};
-    for (const originalModelName in originalSelect) {
-      const newModelName = inflection.underscore(inflection.underscore(originalModelName));
-      const newValues = [];
-      const originalValues = originalSelect[originalModelName];
-      for (const originalAttributeName of originalValues) {
-        const newAttributeName = inflection.underscore(originalAttributeName);
-        newValues.push(newAttributeName);
-      }
-      newSelect[newModelName] = newValues;
-    }
-    return this._merge({
-      selectColumns: newSelect
-    });
-  }
-  sort(sortBy) {
-    return this._merge({
-      ransack: {
-        s: sortBy
-      }
-    });
-  }
-  async toArray() {
-    const response = await this._response();
-    const models = digg(response, "collection");
-    this._addQueryToModels(models);
-    return models;
-  }
-  modelClass() {
-    const modelName = digg(this.args.modelClass.modelClassData(), "name");
-    return modelClassRequire(modelName);
-  }
-  clone() {
-    const clonedQueryArgs = cloneDeep(this.queryArgs);
-    return new ApiMakerCollection(this.args, clonedQueryArgs);
-  }
-
-  // This is needed when reloading a version of the model with the same selected attributes and preloads
-  _addQueryToModels(models) {
-    for (const model of models) {
-      model.collection = this;
-    }
-  }
-  _merge(newQueryArgs) {
-    incorporate(this.queryArgs, newQueryArgs);
-    return this;
-  }
-  _response() {
-    const modelClassData = this.args.modelClass.modelClassData();
-    return CommandsPool.addCommand({
-      args: this.params(),
-      command: `${modelClassData.collectionName}-index`,
-      collectionName: modelClassData.collectionName,
-      type: "index"
-    }, {});
-  }
+    static apiMakerType = "Collection";
+    /**
+     * @param {CollectionArgsType<MC>} args
+     * @param {QueryArgsType} queryArgs
+     */
+    constructor(args, queryArgs = {}) {
+        if (!args.modelClass)
+            throw new Error(`No modelClass given in ${Object.keys(args).join(", ")}`);
+        this.queryArgs = queryArgs;
+        this.args = args;
+    }
+    abilities(originalAbilities) {
+        const newAbilities = {};
+        for (const originalAbilityName in originalAbilities) {
+            const newModelName = inflection.underscore(originalAbilityName);
+            const newValues = [];
+            const originalValues = originalAbilities[originalAbilityName];
+            for (const originalAbilityName of originalValues) {
+                const newAbilityName = inflection.underscore(originalAbilityName);
+                newValues.push(newAbilityName);
+            }
+            newAbilities[newModelName] = newValues;
+        }
+        return this._merge({ abilities: newAbilities });
+    }
+    /**
+     * @param {string} abilityName
+     * @returns {this}
+     */
+    accessibleBy(abilityName) {
+        return this._merge({ accessibleBy: inflection.underscore(abilityName) });
+    }
+    /**
+     * @returns {Promise<number>}
+     */
+    async count() {
+        const response = await this.clone()._merge({ count: true })._response();
+        return digg(response, "count");
+    }
+    /**
+     * @returns {this}
+     */
+    distinct() {
+        return this._merge({ distinct: true });
+    }
+    /**
+     * @param {function(import("./base-model.js").default) : void} callback
+     * @returns {Promise<void>}
+     */
+    async each(callback) {
+        const array = await this.toArray();
+        for (const model in array) {
+            callback.call(model);
+        }
+    }
+    /**
+     * @param {...string} keys
+     * @returns {this}
+     */
+    except(...keys) {
+        for (const key of keys) {
+            if (key == "page") {
+                delete this.queryArgs[key];
+            }
+            else {
+                throw new Error(`Unhandled key: ${key}`);
+            }
+        }
+        return this;
+    }
+    /**
+     * @returns {Promise<ModelOf<MC>>}
+     */
+    async first() {
+        const models = await this.toArray();
+        return models[0];
+    }
+    groupBy(...arrayOfTablesAndColumns) {
+        const arrayOfTablesAndColumnsWithLowercaseColumns = arrayOfTablesAndColumns.map((tableAndColumn) => {
+            if (Array.isArray(tableAndColumn)) {
+                return [tableAndColumn[0], tableAndColumn[1].toLowerCase()];
+            }
+            else {
+                return tableAndColumn.toLowerCase();
+            }
+        });
+        const currentGroupBy = this.queryArgs.groupBy || [];
+        const newGroupBy = currentGroupBy.concat(arrayOfTablesAndColumnsWithLowercaseColumns);
+        return this._merge({
+            groupBy: newGroupBy
+        });
+    }
+    async ensureLoaded() {
+        if (!this.isLoaded()) {
+            const models = await this.toArray();
+            this.set(models);
+        }
+        return this.loaded();
+    }
+    /**
+     * @returns {boolean}
+     */
+    isLoaded() {
+        const { model, reflectionName } = this.args;
+        if (reflectionName in model.relationshipsCache) {
+            return true;
+        }
+        else if (reflectionName in model.relationships) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @param {number} amount
+     * @returns {this}
+     */
+    limit(amount) {
+        return this._merge({ limit: amount });
+    }
+    /**
+     * @returns {Array<ModelOf<MC>>}
+     */
+    preloaded() {
+        if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {
+            throw new Error(`${this.args.reflectionName} hasnt been loaded yet`);
+        }
+        return this.args.model.relationshipsCache[this.args.reflectionName];
+    }
+    /**
+     * @returns {ModelOf<MC> | Array<ModelOf<MC>>}
+     */
+    loaded() {
+        const { model, reflectionName } = this.args;
+        if (reflectionName in model.relationships) {
+            return model.relationships[reflectionName];
+        }
+        else if (reflectionName in model.relationshipsCache) {
+            return model.relationshipsCache[reflectionName];
+        }
+        else if (model.isNewRecord()) {
+            const reflectionNameUnderscore = inflection.underscore(reflectionName);
+            // Initialize as empty and try again to return the empty result
+            this.set([]);
+            return digg(model.relationships, reflectionNameUnderscore);
+        }
+        else {
+            const relationshipsLoaded = uniqunize(Object.keys(model.relationships).concat(Object.keys(model.relationshipsCache)));
+            throw new Error(`${reflectionName} hasnt been loaded yet on ${model.modelClassData().name}. Loaded was: ${relationshipsLoaded.join(", ")}`);
+        }
+    }
+    /** @returns {Array<ModelOf<MC>>} */
+    loadedArray() {
+        const loaded = this.loaded();
+        if (Array.isArray(loaded)) {
+            return loaded;
+        }
+        else {
+            throw new Error("'loaded' wasn't an array");
+        }
+    }
+    // Replaces the relationships with the given new collection.
+    set(newCollection) {
+        this.args.model.relationships[this.args.reflectionName] = newCollection;
+    }
+    // Pushes another model onto the given collection.
+    push(newModel) {
+        const { model, reflectionName } = this.args;
+        if (!(reflectionName in model.relationships)) {
+            model.relationships[reflectionName] = [];
+        }
+        if (!model.relationships[reflectionName].includes(newModel)) {
+            model.relationships[reflectionName].push(newModel);
+        }
+    }
+    // Array shortcuts
+    /**
+     * @param {function(import("./base-model.js").default): boolean} callback
+     * @returns {import("./base-model.js").default}
+     */
+    find(callback) { return this.loadedArray().find(callback); }
+    /**
+     * @param {function(import("./base-model.js").default): void} callback
+     * @returns {void}
+     */
+    forEach(callback) { return this.loadedArray().forEach(callback); }
+    /**
+     * @param {function(import("./base-model.js").default): void} callback
+     * @returns {any[]}
+     */
+    map(callback) { return this.loadedArray().map(callback); }
+    /**
+     * @param {string[]} preloadValue
+     * @returns {this}
+     */
+    preload(preloadValue) {
+        return this._merge({ preload: preloadValue });
+    }
+    /**
+     * @param {number} page
+     * @returns {this}
+     */
+    page(page) {
+        if (!page)
+            page = 1;
+        return this._merge({ page });
+    }
+    /**
+     * @param {string} pageKey
+     * @returns {this}
+     */
+    pageKey(pageKey) {
+        return this._merge({ pageKey });
+    }
+    /**
+     * @returns {boolean}
+     */
+    isFiltered() {
+        const { queryArgs } = this;
+        if (queryArgs.accessibleBy ||
+            queryArgs.count ||
+            queryArgs.limit ||
+            queryArgs.page ||
+            queryArgs.params ||
+            queryArgs.per ||
+            queryArgs.ransack ||
+            queryArgs.search) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @returns {Record<string, any>}
+     */
+    params() {
+        let params = {};
+        if (this.queryArgs.params)
+            params = incorporate(params, this.queryArgs.params);
+        if (this.queryArgs.abilities)
+            params.abilities = this.queryArgs.abilities;
+        if (this.queryArgs.accessibleBy)
+            params.accessible_by = inflection.underscore(this.queryArgs.accessibleBy);
+        if (this.queryArgs.count)
+            params.count = this.queryArgs.count;
+        if (this.queryArgs.distinct)
+            params.distinct = this.queryArgs.distinct;
+        if (this.queryArgs.groupBy)
+            params.group_by = this.queryArgs.groupBy;
+        if (this.queryArgs.ransack)
+            params.q = this.queryArgs.ransack;
+        if (this.queryArgs.limit)
+            params.limit = this.queryArgs.limit;
+        if (this.queryArgs.preload)
+            params.preload = this.queryArgs.preload;
+        if (this.queryArgs.page)
+            params.page = this.queryArgs.page;
+        if (this.queryArgs.per)
+            params.per = this.queryArgs.per;
+        if (this.queryArgs.search)
+            params.search = this.queryArgs.search;
+        if (this.queryArgs.select)
+            params.select = this.queryArgs.select;
+        if (this.queryArgs.selectColumns)
+            params.select_columns = this.queryArgs.selectColumns;
+        return params;
+    }
+    /**
+     * @param {number} per
+     * @returns {this}
+     */
+    per(per) {
+        return this._merge({ per });
+    }
+    /**
+     * @param {string} perKey
+     * @returns {this}
+     */
+    perKey(perKey) {
+        return this._merge({ perKey });
+    }
+    /**
+     * @param {Record<string, any>} params
+     * @returns {this}
+     */
+    ransack(params) {
+        if (params)
+            this._merge({ ransack: params });
+        return this;
+    }
+    /**
+     * @returns {Promise<Result>}
+     */
+    async result() {
+        const response = await this._response();
+        const models = digg(response, "collection");
+        this._addQueryToModels(models);
+        const result = new Result({ collection: this, models, response });
+        return result;
+    }
+    /**
+     * @param {Record<string, any>} params
+     * @returns {this}
+     */
+    search(params) {
+        if (params)
+            this._merge({ search: params });
+        return this;
+    }
+    /**
+     * @param {string} searchKey
+     * @returns {this}
+     */
+    searchKey(searchKey) {
+        return this._merge({ searchKey });
+    }
+    /**
+     * @param {Record<string, string[]>} originalSelect
+     * @returns {this}
+     */
+    select(originalSelect) {
+        const newSelect = {};
+        for (const originalModelName in originalSelect) {
+            const newModelName = inflection.underscore(originalModelName);
+            const newValues = [];
+            const originalValues = originalSelect[originalModelName];
+            for (const originalAttributeName of originalValues) {
+                const newAttributeName = inflection.underscore(originalAttributeName);
+                newValues.push(newAttributeName);
+            }
+            newSelect[newModelName] = newValues;
+        }
+        return this._merge({ select: newSelect });
+    }
+    /**
+     * @param {Record<string, string[]>} originalSelect
+     * @returns {this}
+     */
+    selectColumns(originalSelect) {
+        const newSelect = {};
+        for (const originalModelName in originalSelect) {
+            const newModelName = inflection.underscore(inflection.underscore(originalModelName));
+            const newValues = [];
+            const originalValues = originalSelect[originalModelName];
+            for (const originalAttributeName of originalValues) {
+                const newAttributeName = inflection.underscore(originalAttributeName);
+                newValues.push(newAttributeName);
+            }
+            newSelect[newModelName] = newValues;
+        }
+        return this._merge({ selectColumns: newSelect });
+    }
+    /**
+     * @param {string} sortBy
+     * @returns {this}
+     */
+    sort(sortBy) {
+        return this._merge({ ransack: { s: sortBy } });
+    }
+    /**
+     * @returns {Promise<Array<ModelOf<MC>>>}
+     */
+    async toArray() {
+        const response = await this._response();
+        const models = digg(response, "collection");
+        this._addQueryToModels(models);
+        return models;
+    }
+    /**
+     * @returns {MC}
+     */
+    modelClass() {
+        if (!this.args.modelClass) {
+            throw new Error("No model class given in args");
+        }
+        return this.args.modelClass;
+    }
+    /**
+     * @returns {ApiMakerCollection}
+     */
+    clone() {
+        const clonedQueryArgs = cloneDeep(this.queryArgs);
+        return new ApiMakerCollection(this.args, clonedQueryArgs);
+    }
+    // This is needed when reloading a version of the model with the same selected attributes and preloads
+    _addQueryToModels(models) {
+        for (const model of models) {
+            model.collection = this;
+        }
+    }
+    _merge(newQueryArgs) {
+        incorporate(this.queryArgs, newQueryArgs);
+        return this;
+    }
+    _response() {
+        if (!this.args)
+            throw new Error("No args?");
+        if (!this.args.modelClass)
+            throw new Error("No modelClass in args");
+        if (!this.args.modelClass.modelClassData)
+            throw new Error(`No modelClassData on modelClass ${this.args.modelClass?.name} (${typeof this.args.modelClass})`);
+        const modelClassData = this.args.modelClass.modelClassData();
+        return CommandsPool.addCommand({
+            args: this.params(),
+            command: `${modelClassData.collectionName}-index`,
+            collectionName: modelClassData.collectionName,
+            type: "index"
+        }, {});
+    }
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["cloneDeep","CommandsPool","digg","inflection","incorporate","modelClassRequire","Result","uniqunize","ApiMakerCollection","apiMakerType","constructor","args","queryArgs","abilities","originalAbilities","newAbilities","originalAbilityName","newModelName","underscore","newValues","originalValues","newAbilityName","push","_merge","accessibleBy","abilityName","count","response","clone","_response","distinct","each","callback","array","toArray","model","call","except","keys","key","Error","first","models","groupBy","arrayOfTablesAndColumns","arrayOfTablesAndColumnsWithLowercaseColumns","map","tableAndColumn","Array","isArray","toLowerCase","currentGroupBy","newGroupBy","concat","ensureLoaded","isLoaded","set","loaded","reflectionName","relationshipsCache","relationships","limit","amount","preloaded","isNewRecord","reflectionNameUnderscore","relationshipsLoaded","Object","modelClassData","name","join","newCollection","newModel","includes","find","forEach","preload","preloadValue","page","pageKey","isFiltered","params","per","ransack","search","accessible_by","group_by","q","select","selectColumns","select_columns","perKey","result","_addQueryToModels","collection","searchKey","originalSelect","newSelect","originalModelName","originalAttributeName","newAttributeName","sort","sortBy","s","modelClass","modelName","clonedQueryArgs","newQueryArgs","addCommand","command","collectionName","type"],"sources":["../src/collection.js"],"sourcesContent":["import cloneDeep from \"clone-deep\"\nimport CommandsPool from \"./commands-pool\"\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport {incorporate} from \"incorporator\"\nimport modelClassRequire from \"./model-class-require\"\nimport Result from \"./result\"\nimport uniqunize from \"uniqunize\"\n\nexport default class ApiMakerCollection {\n  static apiMakerType = \"Collection\"\n\n  constructor(args, queryArgs = {}) {\n    this.queryArgs = queryArgs\n    this.args = args\n  }\n\n  abilities(originalAbilities) {\n    const newAbilities = {}\n\n    for (const originalAbilityName in originalAbilities) {\n      const newModelName = inflection.underscore(originalAbilityName)\n      const newValues = []\n      const originalValues = originalAbilities[originalAbilityName]\n\n      for (const originalAbilityName of originalValues) {\n        const newAbilityName = inflection.underscore(originalAbilityName)\n        newValues.push(newAbilityName)\n      }\n\n      newAbilities[newModelName] = newValues\n    }\n\n    return this._merge({abilities: newAbilities})\n  }\n\n  accessibleBy(abilityName) {\n    return this._merge({accessibleBy: inflection.underscore(abilityName)})\n  }\n\n  async count() {\n    const response = await this.clone()._merge({count: true})._response()\n\n    return digg(response, \"count\")\n  }\n\n  distinct() {\n    return this._merge({distinct: true})\n  }\n\n  async each(callback) {\n    const array = await this.toArray()\n\n    for (const model in array) {\n      callback.call(model)\n    }\n  }\n\n  except(...keys) {\n    for (const key of keys) {\n      if (key == \"page\") {\n        delete this.queryArgs[key]\n      } else {\n        throw new Error(`Unhandled key: ${key}`)\n      }\n    }\n\n    return this\n  }\n\n  async first() {\n    const models = await this.toArray()\n    return models[0]\n  }\n\n  groupBy(...arrayOfTablesAndColumns) {\n    const arrayOfTablesAndColumnsWithLowercaseColumns = arrayOfTablesAndColumns.map((tableAndColumn) => {\n      if (Array.isArray(tableAndColumn)) {\n        return [tableAndColumn[0], tableAndColumn[1].toLowerCase()]\n      } else {\n        return tableAndColumn.toLowerCase()\n      }\n    })\n    const currentGroupBy = this.queryArgs.groupBy || []\n    const newGroupBy = currentGroupBy.concat(arrayOfTablesAndColumnsWithLowercaseColumns)\n\n    return this._merge({\n      groupBy: newGroupBy\n    })\n  }\n\n  async ensureLoaded() {\n    if (!this.isLoaded()) {\n      const models = await this.toArray()\n\n      this.set(models)\n    }\n\n    return this.loaded()\n  }\n\n  isLoaded() {\n    const {model, reflectionName} = this.args\n\n    if (reflectionName in model.relationshipsCache) {\n      return true\n    } else if (reflectionName in model.relationships) {\n      return true\n    }\n\n    return false\n  }\n\n  limit(amount) {\n    return this._merge({limit: amount})\n  }\n\n  preloaded() {\n    if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {\n      throw new Error(`${this.args.reflectionName} hasnt been loaded yet`)\n    }\n\n    return this.args.model.relationshipsCache[this.args.reflectionName]\n  }\n\n  loaded() {\n    const {model, reflectionName} = this.args\n\n    if (reflectionName in model.relationships) {\n      return model.relationships[reflectionName]\n    } else if (reflectionName in model.relationshipsCache) {\n      return model.relationshipsCache[reflectionName]\n    } else if (model.isNewRecord()) {\n      const reflectionNameUnderscore = inflection.underscore(reflectionName)\n\n      // Initialize as empty and try again to return the empty result\n      this.set([])\n\n      return digg(model.relationships, reflectionNameUnderscore)\n    } else {\n      const relationshipsLoaded = uniqunize(Object.keys(model.relationships).concat(Object.keys(model.relationshipsCache)))\n\n      throw new Error(`${reflectionName} hasnt been loaded yet on ${model.modelClassData().name}. Loaded was: ${relationshipsLoaded.join(\", \")}`)\n    }\n  }\n\n  // Replaces the relationships with the given new collection.\n  set(newCollection) {\n    this.args.model.relationships[this.args.reflectionName] = newCollection\n  }\n\n  // Pushes another model onto the given collection.\n  push(newModel) {\n    const {model, reflectionName} = this.args\n\n    if (!(reflectionName in model.relationships)) {\n      model.relationships[reflectionName] = []\n    }\n\n    if (!model.relationships[reflectionName].includes(newModel)) {\n      model.relationships[reflectionName].push(newModel)\n    }\n  }\n\n  // Array shortcuts\n  find = (...args) => this.loaded().find(...args)\n  forEach = (...args) => this.loaded().forEach(...args)\n  map = (...args) => this.loaded().map(...args)\n\n  preload(preloadValue) {\n    return this._merge({preload: preloadValue})\n  }\n\n  page(page) {\n    if (!page) page = 1\n\n    return this._merge({page})\n  }\n\n  pageKey(pageKey) {\n    return this._merge({pageKey})\n  }\n\n  isFiltered() {\n    const {queryArgs} = this\n\n    if (\n      queryArgs.accessibleBy ||\n      queryArgs.count ||\n      queryArgs.limit ||\n      queryArgs.page ||\n      queryArgs.params ||\n      queryArgs.per ||\n      queryArgs.ransack ||\n      queryArgs.search\n    ) {\n      return true\n    }\n\n    return false\n  }\n\n  params() {\n    let params = {}\n\n    if (this.queryArgs.params) params = incorporate(params, this.queryArgs.params)\n    if (this.queryArgs.abilities) params.abilities = this.queryArgs.abilities\n    if (this.queryArgs.accessibleBy) params.accessible_by = inflection.underscore(this.queryArgs.accessibleBy)\n    if (this.queryArgs.count) params.count = this.queryArgs.count\n    if (this.queryArgs.distinct) params.distinct = this.queryArgs.distinct\n    if (this.queryArgs.groupBy) params.group_by = this.queryArgs.groupBy\n    if (this.queryArgs.ransack) params.q = this.queryArgs.ransack\n    if (this.queryArgs.limit) params.limit = this.queryArgs.limit\n    if (this.queryArgs.preload) params.preload = this.queryArgs.preload\n    if (this.queryArgs.page) params.page = this.queryArgs.page\n    if (this.queryArgs.per) params.per = this.queryArgs.per\n    if (this.queryArgs.search) params.search = this.queryArgs.search\n    if (this.queryArgs.select) params.select = this.queryArgs.select\n    if (this.queryArgs.selectColumns) params.select_columns = this.queryArgs.selectColumns\n\n    return params\n  }\n\n  per(per) {\n    return this._merge({per})\n  }\n\n  perKey(perKey) {\n    return this._merge({perKey})\n  }\n\n  ransack(params) {\n    if (params) this._merge({ransack: params})\n    return this\n  }\n\n  async result() {\n    const response = await this._response()\n    const models = digg(response, \"collection\")\n\n    this._addQueryToModels(models)\n\n    const result = new Result({collection: this, models, response})\n\n    return result\n  }\n\n  search(params) {\n    if (params) this._merge({search: params})\n    return this\n  }\n\n  searchKey(searchKey) {\n    return this._merge({searchKey})\n  }\n\n  select(originalSelect) {\n    const newSelect = {}\n\n    for (const originalModelName in originalSelect) {\n      const newModelName = inflection.underscore(originalModelName)\n      const newValues = []\n      const originalValues = originalSelect[originalModelName]\n\n      for (const originalAttributeName of originalValues) {\n        const newAttributeName = inflection.underscore(originalAttributeName)\n        newValues.push(newAttributeName)\n      }\n\n      newSelect[newModelName] = newValues\n    }\n\n    return this._merge({select: newSelect})\n  }\n\n  selectColumns(originalSelect) {\n    const newSelect = {}\n\n    for (const originalModelName in originalSelect) {\n      const newModelName = inflection.underscore(inflection.underscore(originalModelName))\n      const newValues = []\n      const originalValues = originalSelect[originalModelName]\n\n      for (const originalAttributeName of originalValues) {\n        const newAttributeName = inflection.underscore(originalAttributeName)\n        newValues.push(newAttributeName)\n      }\n\n      newSelect[newModelName] = newValues\n    }\n\n    return this._merge({selectColumns: newSelect})\n  }\n\n  sort(sortBy) {\n    return this._merge({ransack: {s: sortBy}})\n  }\n\n  async toArray() {\n    const response = await this._response()\n    const models = digg(response, \"collection\")\n\n    this._addQueryToModels(models)\n\n    return models\n  }\n\n  modelClass() {\n    const modelName = digg(this.args.modelClass.modelClassData(), \"name\")\n\n    return modelClassRequire(modelName)\n  }\n\n  clone() {\n    const clonedQueryArgs = cloneDeep(this.queryArgs)\n\n    return new ApiMakerCollection(this.args, clonedQueryArgs)\n  }\n\n  // This is needed when reloading a version of the model with the same selected attributes and preloads\n  _addQueryToModels(models) {\n    for (const model of models) {\n      model.collection = this\n    }\n  }\n\n  _merge(newQueryArgs) {\n    incorporate(this.queryArgs, newQueryArgs)\n\n    return this\n  }\n\n  _response() {\n    const modelClassData = this.args.modelClass.modelClassData()\n\n    return CommandsPool.addCommand(\n      {\n        args: this.params(),\n        command: `${modelClassData.collectionName}-index`,\n        collectionName: modelClassData.collectionName,\n        type: \"index\"\n      },\n      {}\n    )\n  }\n}\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=collection.js.map