wapi-client 0.18.0-beta.5 → 0.18.0

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

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/index.ts
+var query_builder_exports = {};
+__export(query_builder_exports, {
+  DbFilterOperatorAllEnum: () => DbFilterOperatorAllEnum,
+  validateQueryBuilderSchema: () => validateQueryBuilderSchema
+});
+module.exports = __toCommonJS(query_builder_exports);
+var import_consts = require("../../db/consts.browser.cjs");
+var import_errors = require("../errors.browser.cjs");
+var import_ts_utils = require("../ts-utils.browser.cjs");
+var DbFilterOperatorAllEnum = (0, import_ts_utils.createEnumFromTuple)(
+  import_consts.DbFilterOperatorAllSchema.options
+);
+function validateQueryBuilderSchema(schema, value) {
+  const { data, error } = schema.safeParse(value);
+  if (!error) {
+    return data;
+  }
+  throw new import_errors.InputError("INVALID_COMPLEX_FILTER", error.format(), error.message);
+}

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

@@ -0,0 +1,18 @@
+// src/lib/query-builder/index.ts
+import { DbFilterOperatorAllSchema } from "../../db/consts.browser.js";
+import { InputError } from "../errors.browser.js";
+import { createEnumFromTuple } from "../ts-utils.browser.js";
+var DbFilterOperatorAllEnum = createEnumFromTuple(
+  DbFilterOperatorAllSchema.options
+);
+function validateQueryBuilderSchema(schema, value) {
+  const { data, error } = schema.safeParse(value);
+  if (!error) {
+    return data;
+  }
+  throw new InputError("INVALID_COMPLEX_FILTER", error.format(), error.message);
+}
+export {
+  DbFilterOperatorAllEnum,
+  validateQueryBuilderSchema
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/index.ts
+var query_builder_exports = {};
+__export(query_builder_exports, {
+  DbFilterOperatorAllEnum: () => DbFilterOperatorAllEnum,
+  validateQueryBuilderSchema: () => validateQueryBuilderSchema
+});
+module.exports = __toCommonJS(query_builder_exports);
+var import_consts = require("../../db/consts.cjs");
+var import_errors = require("../errors.cjs");
+var import_ts_utils = require("../ts-utils.cjs");
+var DbFilterOperatorAllEnum = (0, import_ts_utils.createEnumFromTuple)(
+  import_consts.DbFilterOperatorAllSchema.options
+);
+function validateQueryBuilderSchema(schema, value) {
+  const { data, error } = schema.safeParse(value);
+  if (!error) {
+    return data;
+  }
+  throw new import_errors.InputError("INVALID_COMPLEX_FILTER", error.format(), error.message);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DbFilterOperatorAllEnum,
+  validateQueryBuilderSchema
+});

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

@@ -0,0 +1,452 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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/query-builder.ts
+var query_builder_exports = {};
+__export(query_builder_exports, {
+  QueryBuilder: () => QueryBuilder
+});
+module.exports = __toCommonJS(query_builder_exports);
+var import_index = require("./index.browser.cjs");
+var import_consts = require("../../db/consts.browser.cjs");
+function isForeignValue(value) {
+  return "foreign" in value && Object.keys(value).length === 1;
+}
+function getWhereObject({
+  function: fn,
+  field,
+  operator,
+  value
+}) {
+  if (Array.isArray(value)) {
+    return { function: fn, inner: value };
+  }
+  if (typeof value === "object") {
+    if (operator && field && isForeignValue(value)) {
+      return { function: fn, operator, field, value: value.foreign };
+    }
+    return { function: fn, value };
+  }
+  if (!field) {
+    throw new TypeError("FIELD_IS_REQUIRED");
+  }
+  return { function: fn, field, operator: operator != null ? operator : "=", value };
+}
+function normalizeOperatorValue(operator, value) {
+  if (value === void 0) {
+    value = operator;
+    operator = "=";
+  }
+  if (value === void 0) {
+    throw new TypeError("Invalid comparison value: undefined not allowed");
+  }
+  return { operator: operator != null ? operator : "=", value };
+}
+var QueryBuilder = class _QueryBuilder {
+  constructor($schemaBasic, $schema, $queries = []) {
+    __publicField(this, "$queries", []);
+    __publicField(this, "$schemaBasic");
+    __publicField(this, "$schema");
+    this.$queries = $queries != null ? $queries : [];
+    this.$schemaBasic = $schemaBasic;
+    this.$schema = $schema;
+  }
+  toQuery() {
+    if (this.$queries.length === 1 && "value" in this.$queries[0] && typeof this.$queries[0].value === "object" && !("field" in this.$queries[0])) {
+      return this.$queries[0].value;
+    }
+    return this.$queries;
+  }
+  toJSON() {
+    return {
+      filter: JSON.parse(JSON.stringify(this.toQuery()))
+    };
+  }
+  add(query) {
+    this.$queries.push(query);
+    return this;
+  }
+  addWhere({
+    fn,
+    field,
+    operator,
+    value
+  }) {
+    if (typeof field === "function") {
+      const inner = new _QueryBuilder(
+        this.$schemaBasic,
+        this.$schema
+      );
+      if (field(inner) === false) {
+        return this;
+      }
+      return this.add(getWhereObject({ function: fn, value: inner.toQuery() }));
+    }
+    if (typeof field === "object") {
+      const validObject = (0, import_index.validateQueryBuilderSchema)(this.$schemaBasic, field);
+      return this.add(getWhereObject({ function: fn, value: validObject }));
+    }
+    if (typeof field !== "string") {
+      throw new TypeError("Field is required");
+    }
+    if ((0, import_consts.isMetadataDotFilterField)(field)) {
+      return this.add(this.buildMetadataFilter(fn, field, operator, value));
+    }
+    return this.add(this.buildFieldFilter(fn, field, operator, value));
+  }
+  /**
+   * Build a comparison against a `metadata.x` dot-path field. The two-argument
+   * form (`.where('metadata.x', value)`) carries the value in the operator slot.
+   */
+  buildMetadataFilter(fn, field, operator, value) {
+    const normalized = normalizeOperatorValue(operator, value);
+    return {
+      function: fn,
+      field,
+      operator: normalized.operator,
+      value: normalized.value
+    };
+  }
+  /**
+   * Build a comparison against a schema field. The two-argument form
+   * (`.where('token', 'EUR')`) carries the value in the operator slot with an
+   * implied equals; the three-argument form supplies a real operator.
+   */
+  buildFieldFilter(fn, field, operator, value) {
+    const fieldShape = this.$schemaBasic.shape[field] || this.$schema.shape[field];
+    if (!fieldShape) {
+      throw new TypeError("Invalid field:" + field);
+    }
+    if (operator === void 0) {
+      throw new TypeError("Operator is required");
+    }
+    const operatorSlotHoldsValue = typeof operator !== "string" || !(operator in import_index.DbFilterOperatorAllEnum) || value === void 0;
+    if (operatorSlotHoldsValue) {
+      const validated = (0, import_index.validateQueryBuilderSchema)(fieldShape, operator);
+      if (validated === void 0) {
+        throw new TypeError("unexpectedly value needed");
+      }
+      if (typeof validated === "object") {
+        return getWhereObject({
+          function: fn,
+          value: { [field]: validated }
+        });
+      }
+      return getWhereObject({ function: fn, field, value: validated });
+    }
+    const validatedValue = (0, import_index.validateQueryBuilderSchema)(fieldShape, value);
+    if (validatedValue === void 0) {
+      throw new Error("undefined value");
+    }
+    return getWhereObject({
+      function: fn,
+      field,
+      operator,
+      value: validatedValue
+    });
+  }
+  addIn({
+    fn,
+    field,
+    value
+  }) {
+    if (!field) {
+      throw new TypeError("Field is required");
+    }
+    if (!(field in this.$schema.shape) && !(0, import_consts.isMetadataDotFilterField)(field)) {
+      throw new TypeError("Invalid field");
+    }
+    if (!value) {
+      throw new TypeError("Value is required");
+    }
+    if (!Array.isArray(value)) {
+      throw new TypeError("Expected value to be array");
+    }
+    return this.add({
+      function: fn,
+      field,
+      value
+    });
+  }
+  addMetadataNull({
+    fn,
+    field
+  }) {
+    if (!field) {
+      throw new TypeError("Field is required");
+    }
+    if (typeof field !== "string") {
+      throw new TypeError("Invalid field");
+    }
+    return this.add({
+      function: fn,
+      field
+    });
+  }
+  addNull({
+    fn,
+    field
+  }) {
+    if (!field) {
+      throw new TypeError("Field is required");
+    }
+    if (!(field in this.$schema.shape) && !(0, import_consts.isMetadataDotFilterField)(field)) {
+      throw new TypeError("Invalid field");
+    }
+    if (!(0, import_consts.isMetadataDotFilterField)(field)) {
+      this.$schema.parse({
+        [field]: null
+      });
+    }
+    return this.add({
+      function: fn,
+      field
+    });
+  }
+  addMetadata({
+    fn,
+    field,
+    operator,
+    value
+  }) {
+    if (typeof field !== "string") {
+      throw new TypeError("expected field to be string");
+    }
+    const normalized = normalizeOperatorValue(operator, value);
+    return this.add({
+      function: fn,
+      field,
+      operator: normalized.operator,
+      value: normalized.value
+    });
+  }
+  addMetadataIn({
+    fn,
+    field,
+    value
+  }) {
+    if (typeof field !== "string") {
+      throw new TypeError("expected field to be string");
+    }
+    if (!Array.isArray(value)) {
+      throw new TypeError("expected value to be an array");
+    }
+    return this.add({
+      function: fn,
+      field,
+      value
+      // TODO: should this be (string | number)[]
+    });
+  }
+  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
+};