wapi-client 0.17.18 → 0.18.0-beta.2

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

@@ -1,453 +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/aggregate-query-builder.ts
-import { ITxPeriodSimpleEnum } from "../../txs/consts.browser.js";
-import { ValidationError } from "../errors.browser.js";
-import { mergeFnOptionsOrderBy } from "../utils.browser.js";
-import {
-  QueryBuilder
-} from "./query-builder.browser.js";
-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
-    });
-  }
-  /**
-   * ```javascript
-   * Add an IN filter
-   *
-   * .whereIn('token', ['EUR', 'USD'])
-   * ```
-   */
-  whereIn(field, value) {
-    return this.addIn({
-      fn: "whereIn",
-      field,
-      value
-    });
-  }
-  /**
-   * ```javascript
-   * Add an OR IN filter
-   *
-   * .orWhereIn('token', ['EUR', 'USD'])
-   * ```
-   */
-  orWhereIn(field, value) {
-    return this.addIn({
-      fn: "orWhereIn",
-      field,
-      value
-    });
-  }
-  /**
-   * ```javascript
-   * Add an IS NULL filter
-   *
-   * .whereNull('status_finalized_at')
-   * ```
-   */
-  whereNull(field) {
-    return this.addNull({
-      fn: "whereNull",
-      field
-    });
-  }
-  /**
-   * ```javascript
-   * Add an OR IS NULL filter
-   *
-   * .orWhereNull('status_finalized_at')
-   * ```
-   */
-  orWhereNull(field) {
-    return this.addNull({
-      fn: "orWhereNull",
-      field
-    });
-  }
-  /**
-   * ```javascript
-   * Add an NOT NULL filter
-   *
-   * .whereNotNull('status_finalized_at')
-   * ```
-   */
-  whereNotNull(field) {
-    return this.addNull({
-      fn: "whereNotNull",
-      field
-    });
-  }
-  /**
-   * ```javascript
-   * Add an OR NOT NULL filter
-   *
-   * .orWhereNotNull('status_finalized_at')
-   * ```
-   */
-  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
-    });
-  }
-  /**
-   * ```javascript
-   * Add an IN filter for metadata field
-   *
-   * .whereMetadataIn('myCustomField', [9, 10])
-   * ```
-   */
-  whereMetadataIn(field, value) {
-    return this.addMetadataIn({
-      fn: "whereMetadataIn",
-      field,
-      value
-    });
-  }
-  /**
-   * ```javascript
-   * Add an OR IN filter for metadata field
-   *
-   * .orWhereMetadataIn('myCustomField', [9, 10])
-   * ```
-   */
-  orWhereMetadataIn(field, value) {
-    return this.addMetadataIn({
-      fn: "orWhereMetadataIn",
-      field,
-      value
-    });
-  }
-  /**
-   * ```javascript
-   * Add an IS NULL filter for metadata field
-   *
-   * .whereMetadataNull('myCustomField')
-   * ```
-   */
-  whereMetadataNull(field) {
-    return this.addMetadataNull({
-      fn: "whereMetadataNull",
-      field
-    });
-  }
-  /**
-   * ```javascript
-   * Add an OR IS NULL filter for metadata field
-   *
-   * .orWhereMetadataNull('myCustomField')
-   * ```
-   */
-  orWhereMetadataNull(field) {
-    return this.addMetadataNull({
-      fn: "orWhereMetadataNull",
-      field
-    });
-  }
-  /**
-   * ```javascript
-   * Add an NOT NULL filter for metadata field
-   *
-   * .whereMetadataNotNull('myCustomField')
-   * ```
-   */
-  whereMetadataNotNull(field) {
-    return this.addMetadataNull({
-      fn: "whereMetadataNotNull",
-      field
-    });
-  }
-  /**
-   * ```javascript
-   * Add an OR NOT NULL filter for metadata field
-   *
-   * .orWhereMetadataNotNull('myCustomField')
-   * ```
-   */
-  orWhereMetadataNotNull(field) {
-    return this.addMetadataNull({
-      fn: "orWhereMetadataNotNull",
-      field
-    });
-  }
-  // FILTERING FUNCTIONS
-};
-export {
-  AggregateQueryBuilder
-};