wapi-client 0.12.0-beta.3 → 0.12.5-beta.0

package/dist/lib/query-builder/aggregate-query-builder.js

@@ -0,0 +1,369 @@
+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/aggregate-query-builder.ts
+import { ITxPeriodSimpleEnum } from "../../txs/consts";
+import { ValidationError } from "../errors";
+import { mergeFnOptionsOrderBy } from "../utils";
+import {
+  QueryBuilder
+} from "./query-builder";
+function getITxGroup(field, alias, timezone) {
+  if (field in ITxPeriodSimpleEnum) {
+    return __spreadValues({
+      type: "period",
+      alias: alias != null ? alias : field
+    }, timezone ? { field: { period: field, timezone } } : { field });
+  } else if (field.startsWith("metadata.")) {
+    return {
+      type: "metadata_field",
+      field: field.replace(`metadata.`, ""),
+      alias: alias != null ? alias : field.replace(`metadata.`, "")
+    };
+  } else {
+    return {
+      type: "field",
+      field,
+      alias: alias != null ? alias : field
+    };
+  }
+}
+function getITxAggregator(fn, field, alias) {
+  if (!field) {
+    return {
+      function: fn,
+      alias: fn
+    };
+  }
+  return {
+    function: fn,
+    field,
+    alias: alias != null ? alias : fn
+  };
+}
+var AggregateQueryBuilder = class _AggregateQueryBuilder extends QueryBuilder {
+  constructor({
+    $queries,
+    $options,
+    start,
+    schema,
+    schemaBasic,
+    optionsSchema,
+    aggregators,
+    groups,
+    aggregatableSchema,
+    groupableSchema,
+    timezone
+  }) {
+    super(schemaBasic, schema, $queries);
+    __publicField(this, "$options");
+    __publicField(this, "$optionsSchema");
+    __publicField(this, "$start");
+    __publicField(this, "$aggregators");
+    __publicField(this, "$groups");
+    __publicField(this, "$aggregatableSchema");
+    __publicField(this, "$groupableSchema");
+    __publicField(this, "$timezone");
+    this.$options = $options;
+    this.$optionsSchema = optionsSchema;
+    this.$start = start;
+    this.$aggregators = aggregators;
+    this.$groups = groups;
+    this.$aggregatableSchema = aggregatableSchema;
+    this.$groupableSchema = groupableSchema;
+    this.$timezone = timezone;
+  }
+  add(addQuery) {
+    return new _AggregateQueryBuilder({
+      $queries: [...this.$queries, addQuery],
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      aggregators: this.$aggregators,
+      groups: this.$groups,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema,
+      aggregatableSchema: this.$aggregatableSchema,
+      groupableSchema: this.$groupableSchema,
+      timezone: this.$timezone
+    });
+  }
+  start() {
+    return this.$start(this.toJSON());
+  }
+  getAggregators() {
+    return Object.entries(this.$aggregators).map(([, value]) => value);
+  }
+  getGroups() {
+    return Object.entries(this.$groups).map(([, value]) => value);
+  }
+  toJSON() {
+    return {
+      filter: super.toQuery(),
+      options: this.$options,
+      aggregators: this.getAggregators(),
+      groups: this.getGroups()
+    };
+  }
+  then(onfulfilled, onrejected) {
+    return this.start().then(onfulfilled, onrejected);
+  }
+  catch(onerror) {
+    return this.start().catch(onerror);
+  }
+  finally(fn) {
+    return this.start().finally(fn);
+  }
+  stream() {
+    return this.start().stream();
+  }
+  options(options) {
+    const validatedOptions = this.$optionsSchema.parse(__spreadValues({}, options));
+    const mergedOptions = mergeFnOptionsOrderBy(validatedOptions);
+    return new _AggregateQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadValues(__spreadValues({}, this.$options), mergedOptions),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      aggregators: this.$aggregators,
+      groups: this.$groups,
+      optionsSchema: this.$optionsSchema,
+      aggregatableSchema: this.$aggregatableSchema,
+      groupableSchema: this.$groupableSchema,
+      timezone: this.$timezone
+    });
+  }
+  timezone(timezone) {
+    const tzGroups = Object.fromEntries(
+      Object.entries(this.$groups).map(([alias, group]) => {
+        if (group.type !== "period") {
+          return [alias, group];
+        }
+        return [
+          alias,
+          __spreadProps(__spreadValues({}, group), {
+            field: {
+              period: group.field,
+              timezone
+            }
+          })
+        ];
+      })
+    );
+    return new _AggregateQueryBuilder({
+      $queries: this.$queries,
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      aggregators: this.$aggregators,
+      groups: __spreadValues({}, tzGroups),
+      optionsSchema: this.$optionsSchema,
+      aggregatableSchema: this.$aggregatableSchema,
+      groupableSchema: this.$groupableSchema,
+      timezone
+    });
+  }
+  groupBy(first, ...input) {
+    if (!first) {
+      throw new ValidationError("String input expected");
+    }
+    const extension = Object.fromEntries(
+      [first, ...input].map((entry) => {
+        if (typeof entry !== "string") {
+          throw new ValidationError({ input }, "Expected an array of strings");
+        }
+        const [field, alias] = entry.split(" as ");
+        const group = getITxGroup(field, alias, this.$timezone);
+        return [group.alias, group];
+      })
+    );
+    return new _AggregateQueryBuilder({
+      $queries: this.$queries,
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      aggregators: this.$aggregators,
+      groups: __spreadValues(__spreadValues({}, this.$groups), extension),
+      optionsSchema: this.$optionsSchema,
+      aggregatableSchema: this.$aggregatableSchema,
+      groupableSchema: this.$groupableSchema,
+      timezone: this.$timezone
+    });
+  }
+  addAggregator(fn, first, ...input) {
+    const extension = first === void 0 ? { [fn]: getITxAggregator(fn) } : Object.fromEntries(
+      [first, ...input].map((entry) => {
+        if (typeof entry !== "string") {
+          throw new ValidationError("expected string input");
+        }
+        const [field, alias] = entry.split(" as ");
+        const aggregator = getITxAggregator(fn, field, alias);
+        return [aggregator.alias, aggregator];
+      })
+    );
+    return new _AggregateQueryBuilder({
+      $queries: this.$queries,
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      aggregators: __spreadValues(__spreadValues({}, this.$aggregators), extension),
+      groups: this.$groups,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema,
+      aggregatableSchema: this.$aggregatableSchema,
+      groupableSchema: this.$groupableSchema,
+      timezone: this.$timezone
+    });
+  }
+  count(first, ...input) {
+    return this.addAggregator("count", first, ...input);
+  }
+  distinct(first, ...input) {
+    return this.addAggregator("countDistinct", first, ...input);
+  }
+  avg(first, ...input) {
+    return this.addAggregator("average", first, ...input);
+  }
+  min(first, ...input) {
+    return this.addAggregator("min", first, ...input);
+  }
+  max(first, ...input) {
+    return this.addAggregator("max", first, ...input);
+  }
+  sum(first, ...input) {
+    return this.addAggregator("sum", first, ...input);
+  }
+  where(field, operator, value) {
+    return this.addWhere({
+      fn: "where",
+      field,
+      operator,
+      value
+    });
+  }
+  orWhere(field, operator, value) {
+    return this.addWhere({
+      fn: "orWhere",
+      field,
+      operator,
+      value
+    });
+  }
+  whereIn(field, value) {
+    return this.addIn({
+      fn: "whereIn",
+      field,
+      value
+    });
+  }
+  orWhereIn(field, value) {
+    return this.addIn({
+      fn: "orWhereIn",
+      field,
+      value
+    });
+  }
+  whereNull(field) {
+    return this.addNull({
+      fn: "whereNull",
+      field
+    });
+  }
+  orWhereNull(field) {
+    return this.addNull({
+      fn: "orWhereNull",
+      field
+    });
+  }
+  whereNotNull(field) {
+    return this.addNull({
+      fn: "whereNotNull",
+      field
+    });
+  }
+  orWhereNotNull(field) {
+    return this.addNull({
+      fn: "orWhereNotNull",
+      field
+    });
+  }
+  whereMetadata(field, operator, value) {
+    return this.addMetadata({
+      fn: "whereMetadata",
+      field,
+      operator,
+      value
+    });
+  }
+  orWhereMetadata(field, operator, value) {
+    return this.addMetadata({
+      fn: "orWhereMetadata",
+      field,
+      operator,
+      value
+    });
+  }
+  whereMetadataIn(field, value) {
+    return this.addMetadataIn({
+      fn: "whereMetadataIn",
+      field,
+      value
+    });
+  }
+  orWhereMetadataIn(field, value) {
+    return this.addMetadataIn({
+      fn: "orWhereMetadataIn",
+      field,
+      value
+    });
+  }
+  whereMetadataNull(field) {
+    return this.addMetadataNull({
+      fn: "whereMetadataNull",
+      field
+    });
+  }
+  orWhereMetadataNull(field) {
+    return this.addMetadataNull({
+      fn: "orWhereMetadataNull",
+      field
+    });
+  }
+  whereMetadataNotNull(field) {
+    return this.addMetadataNull({
+      fn: "whereMetadataNotNull",
+      field
+    });
+  }
+  orWhereMetadataNotNull(field) {
+    return this.addMetadataNull({
+      fn: "orWhereMetadataNotNull",
+      field
+    });
+  }
+  // FILTERING FUNCTIONS
+};
+export {
+  AggregateQueryBuilder
+};

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

@@ -0,0 +1,298 @@
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/lib/query-builder/find-query-builder.ts
+var find_query_builder_exports = {};
+__export(find_query_builder_exports, {
+  FindQueryBuilder: () => FindQueryBuilder
+});
+module.exports = __toCommonJS(find_query_builder_exports);
+var import_utils = require('../utils.cjs');
+var import_validation = require('../validation.cjs');
+var import_query_builder = require('./query-builder.cjs');
+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 FindQueryBuilder = class _FindQueryBuilder extends import_query_builder.QueryBuilder {
+  constructor({
+    $queries,
+    $options,
+    start,
+    schema,
+    schemaBasic,
+    optionsSchema
+  }) {
+    super(schemaBasic, schema, $queries);
+    __publicField(this, "$options");
+    __publicField(this, "$optionsSchema");
+    __publicField(this, "$start");
+    this.$options = $options;
+    this.$optionsSchema = optionsSchema;
+    this.$start = start;
+  }
+  add(addQuery) {
+    return new _FindQueryBuilder({
+      $queries: [...this.$queries, addQuery],
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  start() {
+    return this.$start(this.toJSON());
+  }
+  toJSON() {
+    return {
+      filter: super.toQuery(),
+      options: __spreadValues({}, this.$options)
+    };
+  }
+  then(onfulfilled, onrejected) {
+    return this.start().then(onfulfilled, onrejected);
+  }
+  catch(onerror) {
+    return this.start().catch(onerror);
+  }
+  finally(fn) {
+    return this.start().finally(fn);
+  }
+  stream() {
+    return this.start().stream();
+  }
+  select(first, ...select) {
+    var _a, _b;
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadProps(__spreadValues({}, this.$options), {
+        deselect: void 0,
+        select: Array.from(
+          /* @__PURE__ */ new Set([first, ...select, ...(_b = (_a = this.$options) == null ? void 0 : _a.select) != null ? _b : []])
+        )
+      }),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  deselect(first, ...deselect) {
+    var _a, _b;
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadProps(__spreadValues({}, this.$options), {
+        select: void 0,
+        deselect: Array.from(
+          /* @__PURE__ */ new Set([first, ...deselect, ...(_b = (_a = this.$options) == null ? void 0 : _a.deselect) != null ? _b : []])
+        )
+      }),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  de() {
+    return [];
+  }
+  options(options) {
+    const validatedOptions = (0, import_validation.hardValidate)(this.$optionsSchema, options);
+    const mergedOptions = (0, import_utils.mergeFnOptionsOrderBy)(validatedOptions);
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadValues(__spreadValues({}, this.$options), mergedOptions),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  limit(limit) {
+    return this.options({
+      limit
+    });
+  }
+  offset(offset) {
+    return this.options({
+      offset
+    });
+  }
+  orderBy(input, direction, nullsDirection) {
+    if (!Array.isArray(input) && typeof input !== "string") {
+      throw new TypeError("invalid input");
+    }
+    if (Array.isArray(input)) {
+      return this.options({
+        order: queryBuilderOrderByToTxOrderBy(input)
+      });
+    }
+    const internalArr = [input];
+    if (direction) {
+      internalArr.push(direction);
+    }
+    if (nullsDirection) {
+      internalArr.push("nulls", nullsDirection);
+    }
+    return this.options({
+      order_by: internalArr.join(" ")
+    });
+  }
+  where(field, operator, value) {
+    return this.addWhere({
+      fn: "where",
+      field,
+      operator,
+      value
+    });
+  }
+  orWhere(field, operator, value) {
+    return this.addWhere({
+      fn: "orWhere",
+      field,
+      operator,
+      value
+    });
+  }
+  whereIn(field, value) {
+    return this.addIn({
+      fn: "whereIn",
+      field,
+      value
+    });
+  }
+  orWhereIn(field, value) {
+    return this.addIn({
+      fn: "orWhereIn",
+      field,
+      value
+    });
+  }
+  whereNull(field) {
+    return this.addNull({
+      fn: "whereNull",
+      field
+    });
+  }
+  orWhereNull(field) {
+    return this.addNull({
+      fn: "orWhereNull",
+      field
+    });
+  }
+  whereNotNull(field) {
+    return this.addNull({
+      fn: "whereNotNull",
+      field
+    });
+  }
+  orWhereNotNull(field) {
+    return this.addNull({
+      fn: "orWhereNotNull",
+      field
+    });
+  }
+  whereMetadata(field, operator, value) {
+    return this.addMetadata({
+      fn: "whereMetadata",
+      field,
+      operator,
+      value
+    });
+  }
+  orWhereMetadata(field, operator, value) {
+    return this.addMetadata({
+      fn: "orWhereMetadata",
+      field,
+      operator,
+      value
+    });
+  }
+  whereMetadataIn(field, value) {
+    return this.addMetadataIn({
+      fn: "whereMetadataIn",
+      field,
+      value
+    });
+  }
+  orWhereMetadataIn(field, value) {
+    return this.addMetadataIn({
+      fn: "orWhereMetadataIn",
+      field,
+      value
+    });
+  }
+  whereMetadataNull(field) {
+    return this.addMetadataNull({
+      fn: "whereMetadataNull",
+      field
+    });
+  }
+  orWhereMetadataNull(field) {
+    return this.addMetadataNull({
+      fn: "orWhereMetadataNull",
+      field
+    });
+  }
+  whereMetadataNotNull(field) {
+    return this.addMetadataNull({
+      fn: "whereMetadataNotNull",
+      field
+    });
+  }
+  orWhereMetadataNotNull(field) {
+    return this.addMetadataNull({
+      fn: "orWhereMetadataNotNull",
+      field
+    });
+  }
+  // FILTERING FUNCTIONS
+};