wapi-client 0.7.2 → 0.8.1

package/dist/lib/query-builder.browser.cjs

@@ -0,0 +1,528 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/query-builder.ts
+var query_builder_exports = {};
+__export(query_builder_exports, {
+  AggregateQueryBuilder: () => AggregateQueryBuilder,
+  QueryBuilder: () => QueryBuilder,
+  QueryBuilderInterface: () => QueryBuilderInterface,
+  ReverseQueryBuilder: () => ReverseQueryBuilder,
+  UpdateQueryBuilder: () => UpdateQueryBuilder
+});
+module.exports = __toCommonJS(query_builder_exports);
+var import_tx_consts = require('../txs/tx-consts.enums.cjs');
+var import_errors = require('./errors.cjs');
+var QueryBuilderInner = class _QueryBuilderInner {
+  constructor(modifiers) {
+    this.filter = [];
+    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);
+    this.optionsObject = {};
+    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 import_errors.InputError({
+      message: "Invalid Aggregator"
+    });
+  }
+  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
+    });
+    this.aggregatorObject = {
+      aggregators: []
+    };
+    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 (import_tx_consts.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, modifiers, optionsModifiers });
+    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, modifiers, optionsModifiers });
+    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;
+  }
+};