laravel-query-builder-js 1.0.1

package/dist/index.cjs

@@ -0,0 +1,676 @@
+'use strict';
+
+var lodash = require('lodash');
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/map-obj/index.js
+var require_map_obj = __commonJS({
+  "node_modules/map-obj/index.js"(exports, module) {
+    var isObject = (value) => typeof value === "object" && value !== null;
+    var mapObjectSkip = /* @__PURE__ */ Symbol("skip");
+    var isObjectCustom = (value) => isObject(value) && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+    var mapObject = (object, mapper, options, isSeen = /* @__PURE__ */ new WeakMap()) => {
+      options = {
+        deep: false,
+        target: {},
+        ...options
+      };
+      if (isSeen.has(object)) {
+        return isSeen.get(object);
+      }
+      isSeen.set(object, options.target);
+      const { target } = options;
+      delete options.target;
+      const mapArray = (array) => array.map((element) => isObjectCustom(element) ? mapObject(element, mapper, options, isSeen) : element);
+      if (Array.isArray(object)) {
+        return mapArray(object);
+      }
+      for (const [key, value] of Object.entries(object)) {
+        const mapResult = mapper(key, value, object);
+        if (mapResult === mapObjectSkip) {
+          continue;
+        }
+        let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
+        if (newKey === "__proto__") {
+          continue;
+        }
+        if (options.deep && shouldRecurse && isObjectCustom(newValue)) {
+          newValue = Array.isArray(newValue) ? mapArray(newValue) : mapObject(newValue, mapper, options, isSeen);
+        }
+        target[newKey] = newValue;
+      }
+      return target;
+    };
+    module.exports = (object, mapper, options) => {
+      if (!isObject(object)) {
+        throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
+      }
+      return mapObject(object, mapper, options);
+    };
+    module.exports.mapObjectSkip = mapObjectSkip;
+  }
+});
+
+// node_modules/tslib/tslib.es6.mjs
+var __assign;
+var init_tslib_es6 = __esm({
+  "node_modules/tslib/tslib.es6.mjs"() {
+    __assign = function() {
+      __assign = Object.assign || function __assign2(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+  }
+});
+
+// node_modules/lower-case/dist.es2015/index.js
+function lowerCase(str) {
+  return str.toLowerCase();
+}
+var init_dist = __esm({
+  "node_modules/lower-case/dist.es2015/index.js"() {
+  }
+});
+
+// node_modules/no-case/dist.es2015/index.js
+function noCase(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
+  var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
+  var start = 0;
+  var end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split("\0").map(transform).join(delimiter);
+}
+function replace(input, re, value) {
+  if (re instanceof RegExp)
+    return input.replace(re, value);
+  return re.reduce(function(input2, re2) {
+    return input2.replace(re2, value);
+  }, input);
+}
+var DEFAULT_SPLIT_REGEXP, DEFAULT_STRIP_REGEXP;
+var init_dist2 = __esm({
+  "node_modules/no-case/dist.es2015/index.js"() {
+    init_dist();
+    DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+    DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+  }
+});
+
+// node_modules/dot-case/dist.es2015/index.js
+function dotCase(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return noCase(input, __assign({ delimiter: "." }, options));
+}
+var init_dist3 = __esm({
+  "node_modules/dot-case/dist.es2015/index.js"() {
+    init_tslib_es6();
+    init_dist2();
+  }
+});
+
+// node_modules/snake-case/dist.es2015/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  snakeCase: () => snakeCase2
+});
+function snakeCase2(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return dotCase(input, __assign({ delimiter: "_" }, options));
+}
+var init_dist4 = __esm({
+  "node_modules/snake-case/dist.es2015/index.js"() {
+    init_tslib_es6();
+    init_dist3();
+  }
+});
+
+// node_modules/snakecase-keys/index.js
+var require_snakecase_keys = __commonJS({
+  "node_modules/snakecase-keys/index.js"(exports, module) {
+    var map3 = require_map_obj();
+    var { snakeCase: snakeCase3 } = (init_dist4(), __toCommonJS(dist_exports));
+    var PlainObjectConstructor = {}.constructor;
+    module.exports = function(obj, options) {
+      if (Array.isArray(obj)) {
+        if (obj.some((item) => item.constructor !== PlainObjectConstructor)) {
+          throw new Error("obj must be array of plain objects");
+        }
+      } else {
+        if (obj.constructor !== PlainObjectConstructor) {
+          throw new Error("obj must be an plain object");
+        }
+      }
+      options = Object.assign({ deep: true, exclude: [], parsingOptions: {} }, options);
+      const convertCase = options.snakeCase || ((key) => snakeCase3(key, options.parsingOptions));
+      return map3(obj, function(key, val) {
+        return [
+          matches(options.exclude, key) ? key : convertCase(key),
+          val,
+          mapperOptions(key, val, options)
+        ];
+      }, options);
+    };
+    function matches(patterns, value) {
+      return patterns.some(function(pattern) {
+        return typeof pattern === "string" ? pattern === value : pattern.test(value);
+      });
+    }
+    function mapperOptions(key, val, options) {
+      return options.shouldRecurse ? { shouldRecurse: options.shouldRecurse(key, val) } : void 0;
+    }
+  }
+});
+var BaseQueryBuilder = class _BaseQueryBuilder {
+  constructor(name = "") {
+    this.query = {
+      name: "",
+      select: [],
+      filter: {},
+      sort: {},
+      include: [],
+      page: null,
+      limit: null
+    };
+    this.query.name = name;
+  }
+  select(fields) {
+    if (typeof fields === "string") {
+      return this.select(lodash.split(fields, ","));
+    }
+    this.query.select = fields.map((str) => lodash.snakeCase(str));
+    return this;
+  }
+  resetSelect() {
+    this.query.select = [];
+    return this;
+  }
+  addSelect(fields) {
+    if (typeof fields === "string") {
+      this.addSelect(lodash.split(fields, ","));
+    }
+    if (Array.isArray(fields)) {
+      this.query.select.push(...fields);
+    }
+    return this;
+  }
+  clearClauses(condition, field, op) {
+    let index = -1;
+    if (typeof field === "string") {
+      index = lodash.get(this.query, `filter.${condition}`, []).findIndex(
+        (f) => {
+          if (!op) {
+            return lodash.get(f, "field") === field;
+          }
+          return lodash.get(f, "field") === field && lodash.get(f, "op") === op;
+        }
+      );
+    }
+    if (Array.isArray(field)) {
+      index = lodash.get(this.query, `filter.${condition}`, []).findIndex(
+        (item) => Array.isArray(item.field) && item.field.length === field.length && item.field.every((_field, i) => _field == field[i])
+      );
+    }
+    if (index !== -1) {
+      lodash.pullAt(this.query.filter[condition], index);
+      if (lodash.isEmpty(this.query.filter[condition])) delete this.query.filter[condition];
+    }
+    return this;
+  }
+  clearOrWhere(field, op) {
+    if (lodash.isFunction(field) && typeof field === "function") {
+      const nestedBuilder = new _BaseQueryBuilder(this.query.name);
+      field(nestedBuilder);
+      const nestedFilter = nestedBuilder.getQuery().filter;
+      this.removeFunctionBaseWhereClauses(this.query.filter, nestedFilter);
+    } else this.clearClauses("or", field, op);
+    return this;
+  }
+  removeFunctionBaseWhereClauses(baseFilter, nestedFilter) {
+    const areFiltersEqual = (filter1, filter2) => {
+      if (filter1.field !== filter2.field || filter1.op !== filter2.op) {
+        return false;
+      }
+      if (filter1.value && filter2.value) {
+        if (Array.isArray(filter1.value) && Array.isArray(filter2.value)) {
+          if (filter1.value.length !== filter2.value.length) {
+            return false;
+          }
+          for (let i = 0; i < filter1.value.length; i++) {
+            if (!areFiltersEqual(filter1.value[i], filter2.value[i])) {
+              return false;
+            }
+          }
+        } else if (JSON.stringify(filter1.value) !== JSON.stringify(filter2.value)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    const iterateAndRemove = (filters, filterToRemove) => {
+      return filters.filter((filter) => {
+        if (areFiltersEqual(filter, filterToRemove)) {
+          return false;
+        }
+        if (filter.and) {
+          filter.and = iterateAndRemove(filter.and, filterToRemove);
+        }
+        if (filter.or) {
+          filter.or = iterateAndRemove(filter.or, filterToRemove);
+        }
+        return true;
+      });
+    };
+    if (baseFilter.and) {
+      baseFilter.and = iterateAndRemove(baseFilter.and, nestedFilter);
+      if (lodash.isEmpty(baseFilter.and)) delete baseFilter.and;
+    }
+    if (baseFilter.or) {
+      baseFilter.or = iterateAndRemove(baseFilter.or, nestedFilter);
+      if (lodash.isEmpty(baseFilter.or)) delete baseFilter.or;
+    }
+  }
+  clearWhere(field, op) {
+    if (lodash.isFunction(field) && typeof field === "function") {
+      const nestedBuilder = new _BaseQueryBuilder(this.query.name);
+      field(nestedBuilder);
+      const nestedFilter = nestedBuilder.getQuery().filter;
+      this.removeFunctionBaseWhereClauses(this.query.filter, nestedFilter);
+    } else {
+      this.clearClauses("and", field, op);
+    }
+    return this;
+  }
+  addFilter(condition, filter) {
+    const _filter = filter;
+    if (lodash.get(_filter, "field") && lodash.get(_filter, "op")) {
+      this.clearClauses(condition, _filter.field, _filter.op);
+    }
+    if (!lodash.has(this.query.filter, condition)) {
+      lodash.set(this.query.filter, condition, []);
+    }
+    this.query.filter[condition].push(filter);
+    return this;
+  }
+  filter(filter) {
+    this.query.filter = filter;
+    return this;
+  }
+  resetFilter() {
+    this.query.filter = {};
+    return this;
+  }
+  whereNotNull(field) {
+    return this.where(field, "not_null");
+  }
+  whereNull(field) {
+    return this.where(field, "null");
+  }
+  where(field, op, value) {
+    if (lodash.isFunction(value) && typeof value === "function" && !lodash.isFunction(field) && typeof field != "function") {
+      const nestedBuilder = new _BaseQueryBuilder(this.query.name);
+      value(nestedBuilder);
+      const nestedFilter = nestedBuilder.getQuery().filter;
+      return this.addFilter("and", { field, op, value: nestedFilter });
+    }
+    if (lodash.isFunction(field) && typeof field === "function") {
+      const nestedBuilder = new _BaseQueryBuilder(this.query.name);
+      field(nestedBuilder);
+      const nestedFilter = nestedBuilder.getQuery().filter;
+      return this.addFilter("and", nestedFilter);
+    }
+    if ((typeof field === "string" || Array.isArray(field)) && op !== void 0 && value !== void 0) {
+      const _value = value;
+      return this.addFilter("and", { field, op, value: _value });
+    }
+    if (typeof field === "string" && op !== void 0 && value === void 0) {
+      return this.addFilter("and", { field, op });
+    }
+    return this;
+  }
+  whereIn(field, value) {
+    return this.where(field, "in", value);
+  }
+  orWhere(field, op, value) {
+    if (lodash.isFunction(value) && typeof value === "function" && !lodash.isFunction(field) && typeof field != "function") {
+      const nestedBuilder = new _BaseQueryBuilder(this.query.name);
+      value(nestedBuilder);
+      const nestedFilter = nestedBuilder.getQuery().filter;
+      return this.addFilter("or", { field, op, value: nestedFilter });
+    }
+    if (lodash.isFunction(field) && typeof field === "function") {
+      const nestedBuilder = new _BaseQueryBuilder(this.query.name);
+      field(nestedBuilder);
+      const nestedFilter = nestedBuilder.getQuery().filter;
+      return this.addFilter("or", nestedFilter);
+    }
+    if ((typeof field === "string" || Array.isArray(field)) && op !== void 0 && value !== void 0) {
+      const _value = value;
+      return this.addFilter("or", { field, op, value: _value });
+    }
+    if (typeof field === "string" && op !== void 0 && value === void 0) {
+      return this.addFilter("or", { field, op });
+    }
+    if (Array.isArray(field)) {
+      field.forEach((singleField) => this.orWhere(singleField, op, value));
+      return this;
+    }
+    return this;
+  }
+  sort(sort) {
+    this.query.sort = sort;
+    return this;
+  }
+  addSort(sort) {
+    this.query.sort = lodash.merge({}, this.query.sort, sort);
+    return this;
+  }
+  resetSort() {
+    this.query.sort = {};
+    return this;
+  }
+  addInclude(include) {
+    if (!Array.isArray(include)) {
+      return this.addInclude([include]);
+    }
+    this.query.include.push(...include);
+    return this;
+  }
+  include(include) {
+    if (!Array.isArray(include)) {
+      return this.include([include]);
+    }
+    this.query.include = include;
+    return this;
+  }
+  resetInclude() {
+    this.query.include = [];
+    return this;
+  }
+  paginate(page = 1, limit = 15) {
+    this.fromPage(page);
+    this.query.limit = limit;
+    return this;
+  }
+  fromPage(page = 1) {
+    this.query.page = page;
+    return this;
+  }
+  resetQuery() {
+    this.resetSelect();
+    this.resetFilter();
+    this.resetSort();
+    this.resetInclude();
+    this.paginate();
+    return this;
+  }
+  addQueryBuilder(queryBuilder) {
+    const otherQuery = queryBuilder.getQuery();
+    this.query.select = [.../* @__PURE__ */ new Set([...this.query.select, ...otherQuery.select])];
+    this.query.filter = lodash.mergeWith(this.query.filter, otherQuery.filter, (objValue, srcValue) => {
+      if (Array.isArray(objValue)) {
+        return objValue.concat(srcValue);
+      }
+    });
+    this.query.sort = { ...this.query.sort, ...otherQuery.sort };
+    this.query.include = [.../* @__PURE__ */ new Set([...this.query.include, ...otherQuery.include])];
+    return this;
+  }
+  getQuery() {
+    return this.query;
+  }
+};
+
+// src/include-query-builder.ts
+var import_snakecase_keys = __toESM(require_snakecase_keys());
+var withRelation = class _withRelation extends BaseQueryBuilder {
+  constructor(name) {
+    super(name);
+    this.query = {
+      name: "",
+      select: [],
+      aggregate: "",
+      filter: {},
+      sort: {},
+      include: []
+    };
+    this.query.name = name;
+  }
+  static create(name) {
+    return new _withRelation(name);
+  }
+  static new(name) {
+    return _withRelation.create(name);
+  }
+  aggregate(value) {
+    this.query.aggregate = value;
+    return this;
+  }
+  new(name) {
+    return _withRelation.create(name);
+  }
+  getQuery() {
+    return this.query;
+  }
+  clone() {
+    const clone = new _withRelation(this.query.name);
+    clone.query = { ...this.query };
+    return clone;
+  }
+  /**
+   * Serialise this relation (and any nested relations) into the plain
+   * object shape the backend expects.
+   */
+  toQueryObject() {
+    const query = {};
+    query.name = this.query.name;
+    if (!lodash.isEmpty(this.query.select)) {
+      query.select = this.query.select;
+    }
+    if (!lodash.isEmpty(this.query.filter)) {
+      query.filter = this.query.filter;
+    }
+    if (!lodash.isEmpty(this.query.sort)) {
+      query.sort = (0, import_snakecase_keys.default)(this.query.sort);
+    }
+    if (!lodash.isEmpty(this.query.aggregate)) {
+      query.aggregate = this.query.aggregate;
+    }
+    if (!lodash.isEmpty(this.query.include)) {
+      query.include = lodash.map(this.query.include, (_include) => {
+        if (_include instanceof _withRelation) {
+          return _include.toQueryObject();
+        }
+        return _include;
+      });
+    }
+    return query;
+  }
+};
+
+// src/query-builder.ts
+var import_snakecase_keys2 = __toESM(require_snakecase_keys());
+var QueryBuilder = class _QueryBuilder extends BaseQueryBuilder {
+  constructor(name) {
+    super(name);
+    this.query = {
+      name: "",
+      select: [],
+      filter: {},
+      sort: {},
+      include: [],
+      page: null,
+      limit: null
+    };
+  }
+  get limit() {
+    return this.query.limit;
+  }
+  set limit(value) {
+    this.query.limit = value;
+  }
+  get page() {
+    return this.query.page;
+  }
+  set page(value) {
+    this.query.page = value;
+  }
+  static create(name) {
+    return new _QueryBuilder(name);
+  }
+  static new(name) {
+    return _QueryBuilder.create(name);
+  }
+  new(name) {
+    return _QueryBuilder.create(name);
+  }
+  static withRelation(name) {
+    return withRelation.create(name);
+  }
+  withRelation(name) {
+    return withRelation.create(name);
+  }
+  getQuery() {
+    return this.query;
+  }
+  clone() {
+    const clone = new _QueryBuilder();
+    clone.query = lodash.cloneDeep(this.query);
+    return clone;
+  }
+  nextPage() {
+    this.query.page = (this.query.page || 1) + 1;
+    return this;
+  }
+  previousPage() {
+    this.query.page = (this.query.page || 2) - 1;
+    return this;
+  }
+  resetPage() {
+    this.query.page = 1;
+    return this;
+  }
+  /**
+   * Serialise into a `Record<string, string>` of query params. Filter,
+   * select, sort and include values are JSON-stringified.
+   */
+  toParams() {
+    const query = {};
+    if (!lodash.isEmpty(this.query.select)) {
+      query.select = JSON.stringify(this.query.select);
+    }
+    if (!lodash.isEmpty(this.query.filter)) {
+      query.filter = JSON.stringify(this.query.filter);
+    }
+    if (!lodash.isEmpty(this.query.sort)) {
+      query.sort = JSON.stringify((0, import_snakecase_keys2.default)(this.query.sort));
+    }
+    if (!lodash.isEmpty(this.query.sort)) {
+      query.aggregate = JSON.stringify(this.query);
+    }
+    if (!lodash.isEmpty(this.query.include)) {
+      const include = lodash.map(this.query.include, (_include) => {
+        if (_include instanceof withRelation) {
+          return _include.toQueryObject();
+        }
+        return _include;
+      });
+      query.include = JSON.stringify(include);
+    }
+    if (this.query.page) {
+      query.page = this.query.page;
+    }
+    if (this.query.limit) {
+      query.limit = this.query.limit;
+    }
+    return query;
+  }
+  /**
+   * Serialise into a URL-encoded query string, e.g.
+   * `filter=...&sort=...&page=1&limit=25`.
+   */
+  toQueryParams() {
+    const queryParams = [];
+    if (!lodash.isEmpty(this.query.select)) {
+      queryParams.push(`select=${encodeURIComponent(JSON.stringify(this.query.select))}`);
+    }
+    if (!lodash.isEmpty(this.query.filter)) {
+      queryParams.push(`filter=${encodeURIComponent(JSON.stringify(this.query.filter))}`);
+    }
+    if (!lodash.isEmpty(this.query.sort)) {
+      queryParams.push(
+        `sort=${encodeURIComponent(JSON.stringify((0, import_snakecase_keys2.default)(this.query.sort)))}`
+      );
+    }
+    if (!lodash.isEmpty(this.query.include)) {
+      const include = lodash.map(this.query.include, (_include) => {
+        if (_include instanceof withRelation) {
+          return _include.toQueryObject();
+        }
+        return _include;
+      });
+      queryParams.push(`include=${encodeURIComponent(JSON.stringify(include))}`);
+    }
+    if (this.query.page) {
+      queryParams.push(`page=${this.query.page}`);
+    }
+    if (this.query.limit) {
+      queryParams.push(`limit=${this.query.limit}`);
+    }
+    return queryParams.join("&");
+  }
+};
+
+exports.BaseQueryBuilder = BaseQueryBuilder;
+exports.QueryBuilder = QueryBuilder;
+exports.withRelation = withRelation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map