wapi-client 0.12.3 → 0.12.5-beta.1

package/dist/lib/query-builder.js

@@ -1,523 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/lib/query-builder.ts
-import { InputError } from "./errors";
-import { ITxPeriodSimpleEnum } from "../txs/consts";
-var QueryBuilderInner = class _QueryBuilderInner {
-  constructor(modifiers) {
-    __publicField(this, "filter", []);
-    __publicField(this, "modifierFn");
-    this.modifierFn = modifiers;
-  }
-  add(item) {
-    this.filter.push(item);
-    return this;
-  }
-  addWhere(fn, field, operator, value) {
-    if (typeof field === "object") {
-      const innerValue = {};
-      for (const [key, value2] of Object.entries(field)) {
-        innerValue[key] = this.modifierFn ? this.modifierFn(
-          key,
-          value2
-        ) : value2;
-      }
-      return this.add({
-        function: fn,
-        value: innerValue
-      });
-    }
-    if (typeof field === "function") {
-      const innerQueryBuilder = new _QueryBuilderInner(this.modifierFn);
-      field.call(innerQueryBuilder, innerQueryBuilder);
-      return this.add({
-        function: fn,
-        inner: innerQueryBuilder.toJSON().filter
-      });
-    }
-    if (value !== void 0) {
-      return this.add({
-        function: fn,
-        field,
-        operator,
-        value
-      });
-    }
-    if (typeof operator === "object") {
-      return this.add({
-        function: fn,
-        value: {
-          [field]: operator
-        }
-      });
-    }
-    if (operator !== void 0) {
-      const innerValue = this.modifierFn ? this.modifierFn(
-        field,
-        operator
-      ) : operator;
-      return this.add({
-        function: fn,
-        field,
-        value: innerValue
-      });
-    }
-    throw TypeError("Invalid input");
-  }
-  where(field, operator, value) {
-    return this.addWhere("where", field, operator, value);
-  }
-  orWhere(field, operator, value) {
-    return this.addWhere("orWhere", field, operator, value);
-  }
-  whereIn(field, value) {
-    return this.add({
-      function: "whereIn",
-      field,
-      value
-    });
-  }
-  orWhereIn(field, value) {
-    return this.add({
-      function: "orWhereIn",
-      field,
-      value
-    });
-  }
-  whereNull(field) {
-    return this.add({
-      function: "whereNull",
-      field
-    });
-  }
-  orWhereNull(field) {
-    return this.add({
-      function: "orWhereNull",
-      field
-    });
-  }
-  whereNotNull(field) {
-    return this.add({
-      function: "whereNotNull",
-      field
-    });
-  }
-  orWhereNotNull(field) {
-    return this.add({
-      function: "orWhereNotNull",
-      field
-    });
-  }
-  whereMetadata(field, operator, value) {
-    if (value === void 0) {
-      return this.add({
-        function: "whereMetadata",
-        field,
-        operator: "=",
-        value: operator
-      });
-    }
-    return this.add({
-      function: "whereMetadata",
-      field,
-      operator,
-      value
-    });
-  }
-  orWhereMetadata(field, operator, value) {
-    if (value === void 0) {
-      return this.add({
-        function: "orWhereMetadata",
-        field,
-        operator: "=",
-        value: operator
-      });
-    }
-    return this.add({
-      function: "orWhereMetadata",
-      field,
-      operator,
-      value
-    });
-  }
-  whereMetadataIn(field, value) {
-    return this.add({
-      function: "whereMetadataIn",
-      field,
-      value
-    });
-  }
-  orWhereMetadataIn(field, value) {
-    return this.add({
-      function: "orWhereMetadataIn",
-      field,
-      value
-    });
-  }
-  whereMetadataNull(field) {
-    return this.add({
-      function: "whereMetadataNull",
-      field
-    });
-  }
-  orWhereMetadataNull(field) {
-    return this.add({
-      function: "orWhereMetadataNull",
-      field
-    });
-  }
-  whereMetadataNotNull(field) {
-    return this.add({
-      function: "whereMetadataNotNull",
-      field
-    });
-  }
-  orWhereMetadataNotNull(field) {
-    return this.add({
-      function: "orWhereMetadataNotNull",
-      field
-    });
-  }
-  toJSON() {
-    return {
-      filter: JSON.parse(JSON.stringify(this.filter))
-    };
-  }
-};
-function queryBuilderOrderByToTxOrderBy(input) {
-  return input.map((item) => {
-    if (typeof item === "string") {
-      if (item.includes(" ")) {
-        throw new TypeError("invalid order option: " + item);
-      }
-      return {
-        field: item,
-        direction: "asc"
-      };
-    }
-    return {
-      field: item.column,
-      direction: item.order,
-      nulls: item.nulls
-    };
-  });
-}
-var QueryBuilderInterface = class extends QueryBuilderInner {
-  constructor({
-    start,
-    modifiers,
-    optionsModifiers
-  }) {
-    super(modifiers);
-    __publicField(this, "execFn");
-    __publicField(this, "optionsObject", {});
-    __publicField(this, "optionsModifiers");
-    this.execFn = start;
-    this.optionsModifiers = optionsModifiers;
-  }
-  start() {
-    return this.execFn(this.toJSON());
-  }
-  toJSON() {
-    return __spreadProps(__spreadValues({}, super.toJSON()), {
-      options: __spreadValues({}, this.optionsObject)
-    });
-  }
-  options(optionsInput) {
-    if (this.optionsModifiers === void 0) {
-      this.optionsObject = __spreadValues(__spreadValues({}, this.optionsObject), optionsInput);
-      return this;
-    }
-    this.optionsObject = __spreadValues({}, this.optionsObject);
-    for (const [key, value] of Object.entries(optionsInput)) {
-      this.optionsObject[key] = this.optionsModifiers(key, value);
-    }
-    return this;
-  }
-  then(onfulfilled, onrejected) {
-    return this.start().then(onfulfilled, onrejected);
-  }
-  catch(onerror) {
-    return this.start().catch(onerror);
-  }
-  stream() {
-    return this.start().stream();
-  }
-};
-var QueryBuilder = class extends QueryBuilderInterface {
-  constructor({
-    start,
-    modifiers,
-    optionsModifiers
-  }) {
-    super({
-      start: (query) => start(query),
-      modifiers,
-      optionsModifiers
-    });
-  }
-  limit(nr) {
-    this.optionsObject.limit = nr;
-    return this;
-  }
-  offset(nr) {
-    this.optionsObject.offset = nr;
-    return this;
-  }
-  orderBy(input, direction, nullsDirection) {
-    if (!Array.isArray(input) && typeof input !== "string") {
-      throw new TypeError("invalid input");
-    }
-    if (Array.isArray(input)) {
-      this.optionsObject.order = queryBuilderOrderByToTxOrderBy(input);
-      return this;
-    }
-    if (!input.includes(" ")) {
-      this.optionsObject.order = queryBuilderOrderByToTxOrderBy([
-        {
-          column: input,
-          order: direction || "asc",
-          nulls: nullsDirection
-        }
-      ]);
-      return this;
-    }
-    const [column, order, nulls, nullsDir] = input.split(" ");
-    if (order !== "asc" && order !== "desc") {
-      throw new TypeError("invalid order");
-    }
-    const innerInput = {
-      column,
-      order
-    };
-    if (nulls === "nulls") {
-      if (!["first", "last"].includes(nullsDir)) {
-        throw new TypeError("invalid nulls order");
-      }
-      innerInput.nulls = nullsDir;
-    }
-    this.optionsObject.order = queryBuilderOrderByToTxOrderBy([input]);
-    return this;
-  }
-  select(...fields) {
-    this.optionsObject.select = fields;
-    return this;
-  }
-  deselect(...fields) {
-    this.optionsObject.deselect = fields;
-    return this;
-  }
-};
-function aggregatorInputToAggregator(fn, input) {
-  if (!input) {
-    return {
-      function: fn,
-      alias: fn
-    };
-  }
-  if (!input.includes(" ")) {
-    return {
-      function: fn,
-      field: input,
-      alias: fn
-    };
-  }
-  if (!input.includes(" as ")) {
-    throw new InputError("UNCLEAR_AGGREGATOR", {
-      input
-    });
-  }
-  const [field, alias] = input.split(" as ");
-  return {
-    function: fn,
-    field,
-    alias: alias || field
-  };
-}
-var AggregateQueryBuilder = class extends QueryBuilderInterface {
-  constructor({
-    start,
-    modifiers,
-    optionsModifiers
-  }) {
-    super({
-      start: (query) => start(query),
-      modifiers,
-      optionsModifiers
-    });
-    __publicField(this, "aggregatorObject", {
-      aggregators: []
-    });
-    __publicField(this, "timezoneString", "");
-  }
-  toJSON() {
-    return __spreadProps(__spreadValues({}, super.toJSON()), {
-      aggregators: JSON.parse(
-        JSON.stringify(this.aggregatorObject.aggregators)
-      ),
-      groups: JSON.parse(JSON.stringify(this.aggregatorObject.groups || []))
-    });
-  }
-  timezone(input) {
-    this.timezoneString = input;
-    if (this.aggregatorObject.groups && Array.isArray(this.aggregatorObject.groups)) {
-      this.aggregatorObject.groups.forEach((group) => {
-        if (group.type === "period") {
-          group.field = {
-            period: group.field,
-            timezone: input
-          };
-        }
-      });
-    }
-    return this;
-  }
-  groupBy(input, ...rest) {
-    const group = {};
-    if (typeof input !== "string") {
-      throw new TypeError("expected string as input, got" + typeof input);
-    }
-    const [field, alias] = input.split(" as ");
-    if (ITxPeriodSimpleEnum.hasOwnProperty(field)) {
-      group.type = "period";
-      group.alias = alias || field;
-      if (this.timezoneString) {
-        group.field = {
-          period: field,
-          timezone: this.timezoneString
-        };
-      } else {
-        group.field = field;
-      }
-    } else if (field.startsWith("metadata.")) {
-      const [, realField] = field.split(".");
-      group.type = "metadata_field";
-      group.field = realField;
-      group.alias = alias || realField;
-    } else {
-      group.type = "field";
-      group.field = field;
-      group.alias = alias || field;
-    }
-    if (!this.aggregatorObject.groups) {
-      this.aggregatorObject.groups = [group];
-    } else {
-      this.aggregatorObject.groups.push(group);
-    }
-    if (rest.length) {
-      rest.forEach((item) => this.groupBy(item));
-    }
-    return this;
-  }
-  count(input) {
-    this.aggregatorObject.aggregators.push(
-      aggregatorInputToAggregator("count", input)
-    );
-    return this;
-  }
-  distinct(input) {
-    this.aggregatorObject.aggregators.push(
-      aggregatorInputToAggregator("countDistinct", input)
-    );
-    return this;
-  }
-  avg(input) {
-    this.aggregatorObject.aggregators.push(
-      aggregatorInputToAggregator("average", input)
-    );
-    return this;
-  }
-  min(input) {
-    this.aggregatorObject.aggregators.push(
-      aggregatorInputToAggregator("min", input)
-    );
-    return this;
-  }
-  max(input) {
-    this.aggregatorObject.aggregators.push(
-      aggregatorInputToAggregator("max", input)
-    );
-    return this;
-  }
-  sum(input) {
-    this.aggregatorObject.aggregators.push(
-      aggregatorInputToAggregator("sum", input)
-    );
-    return this;
-  }
-};
-var UpdateQueryBuilder = class extends QueryBuilderInterface {
-  constructor({
-    start,
-    modifiers,
-    optionsModifiers
-  }) {
-    super({
-      start: (query) => start(query),
-      modifiers,
-      optionsModifiers
-    });
-    __publicField(this, "updateObject", {});
-  }
-  toJSON() {
-    return __spreadProps(__spreadValues({}, super.toJSON()), {
-      update: JSON.parse(JSON.stringify(this.updateObject))
-    });
-  }
-  update(updateData) {
-    this.updateObject = Object.assign(this.updateObject, updateData);
-    return this;
-  }
-};
-var ReverseQueryBuilder = class extends QueryBuilderInterface {
-  constructor({
-    start,
-    modifiers,
-    optionsModifiers
-  }) {
-    super({
-      start: (query) => start(query),
-      modifiers,
-      optionsModifiers
-    });
-    __publicField(this, "reverseModifications", {});
-  }
-  toJSON() {
-    return __spreadProps(__spreadValues({}, super.toJSON()), {
-      reverse: JSON.parse(JSON.stringify(this.reverseModifications))
-    });
-  }
-  reverse(modifications) {
-    this.reverseModifications = Object.assign(
-      this.reverseModifications,
-      modifications
-    );
-    return this;
-  }
-};
-export {
-  AggregateQueryBuilder,
-  QueryBuilder,
-  QueryBuilderInterface,
-  ReverseQueryBuilder,
-  UpdateQueryBuilder
-};