wapi-client 0.17.18 → 0.18.0-beta.1

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

@@ -22,9 +22,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/lib/query-builder/find-query-builder.ts
 import { mergeFnOptionsOrderBy } from "../utils.js";
 import { hardValidate } from "../validation.js";
-import {
-  QueryBuilder
-} from "./query-builder.js";
+import { QueryBuilder } from "./query-builder.js";
 function queryBuilderOrderByToTxOrderBy(input) {
   return input.map((item) => {
     if (typeof item === "string") {
@@ -222,199 +220,6 @@ var FindQueryBuilder = class _FindQueryBuilder extends QueryBuilder {
       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
-    });
-  }
-  /**
-   * ```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 {
   FindQueryBuilder

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

@@ -26,6 +26,10 @@ __export(query_builder_exports, {
 });
 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,
@@ -33,35 +37,28 @@ function getWhereObject({
   value
 }) {
   if (Array.isArray(value)) {
-    return {
-      function: fn,
-      inner: value
-    };
-  }
-  if (typeof value === "object" && operator && field && "foreign" in value && Object.keys(value).length === 1) {
-    return {
-      function: fn,
-      operator,
-      field,
-      value: value.foreign
-    };
+    return { function: fn, inner: value };
   }
   if (typeof value === "object") {
-    return {
-      function: fn,
-      value
-    };
+    if (operator && field && isForeignValue(value)) {
+      return { function: fn, operator, field, value: value.foreign };
+    }
+    return { function: fn, value };
   }
-  operator != null ? operator : operator = "=";
   if (!field) {
     throw new TypeError("FIELD_IS_REQUIRED");
   }
-  return {
-    function: fn,
-    field,
-    operator,
-    value
-  };
+  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 = []) {
@@ -98,32 +95,42 @@ var QueryBuilder = class _QueryBuilder {
         this.$schemaBasic,
         this.$schema
       );
-      const res = field(inner);
-      if (res === false) {
+      if (field(inner) === false) {
         return this;
       }
-      if (!inner || !(inner instanceof _QueryBuilder)) {
-        throw new TypeError("Inner Builder must return QueryBuilderInner");
-      }
-      return this.add(
-        getWhereObject({
-          function: fn,
-          value: inner.toQuery()
-        })
-      );
+      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
-        })
-      );
+      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);
@@ -131,41 +138,30 @@ var QueryBuilder = class _QueryBuilder {
     if (operator === void 0) {
       throw new TypeError("Operator is required");
     }
-    if (typeof operator !== "string" || !(operator in import_index.DbFilterOperatorAllEnum) || value === void 0) {
-      operator = (0, import_index.validateQueryBuilderSchema)(fieldShape, operator);
-      if (operator === void 0) {
+    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 operator === "object") {
-        return this.add(
-          getWhereObject({
-            function: fn,
-            value: {
-              [field]: operator
-            }
-          })
-        );
-      }
-      return this.add(
-        getWhereObject({
+      if (typeof validated === "object") {
+        return getWhereObject({
           function: fn,
-          field,
-          value: operator
-        })
-      );
+          value: { [field]: validated }
+        });
+      }
+      return getWhereObject({ function: fn, field, value: validated });
     }
-    value = (0, import_index.validateQueryBuilderSchema)(fieldShape, value);
-    if (value === void 0) {
+    const validatedValue = (0, import_index.validateQueryBuilderSchema)(fieldShape, value);
+    if (validatedValue === void 0) {
       throw new Error("undefined value");
     }
-    return this.add(
-      getWhereObject({
-        function: fn,
-        field,
-        operator,
-        value
-      })
-    );
+    return getWhereObject({
+      function: fn,
+      field,
+      operator,
+      value: validatedValue
+    });
   }
   addIn({
     fn,
@@ -175,7 +171,7 @@ var QueryBuilder = class _QueryBuilder {
     if (!field) {
       throw new TypeError("Field is required");
     }
-    if (!(field in this.$schema.shape)) {
+    if (!(field in this.$schema.shape) && !(0, import_consts.isMetadataDotFilterField)(field)) {
       throw new TypeError("Invalid field");
     }
     if (!value) {
@@ -212,12 +208,14 @@ var QueryBuilder = class _QueryBuilder {
     if (!field) {
       throw new TypeError("Field is required");
     }
-    if (!(field in this.$schema.shape)) {
+    if (!(field in this.$schema.shape) && !(0, import_consts.isMetadataDotFilterField)(field)) {
       throw new TypeError("Invalid field");
     }
-    this.$schema.parse({
-      [field]: null
-    });
+    if (!(0, import_consts.isMetadataDotFilterField)(field)) {
+      this.$schema.parse({
+        [field]: null
+      });
+    }
     return this.add({
       function: fn,
       field
@@ -232,15 +230,12 @@ var QueryBuilder = class _QueryBuilder {
     if (typeof field !== "string") {
       throw new TypeError("expected field to be string");
     }
-    if (!value) {
-      value = operator;
-      operator = "=";
-    }
+    const normalized = normalizeOperatorValue(operator, value);
     return this.add({
       function: fn,
       field,
-      operator,
-      value
+      operator: normalized.operator,
+      value: normalized.value
     });
   }
   addMetadataIn({

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

@@ -7,6 +7,10 @@ import {
   DbFilterOperatorAllEnum,
   validateQueryBuilderSchema
 } from "./index.browser.js";
+import { isMetadataDotFilterField } from "../../db/consts.browser.js";
+function isForeignValue(value) {
+  return "foreign" in value && Object.keys(value).length === 1;
+}
 function getWhereObject({
   function: fn,
   field,
@@ -14,35 +18,28 @@ function getWhereObject({
   value
 }) {
   if (Array.isArray(value)) {
-    return {
-      function: fn,
-      inner: value
-    };
-  }
-  if (typeof value === "object" && operator && field && "foreign" in value && Object.keys(value).length === 1) {
-    return {
-      function: fn,
-      operator,
-      field,
-      value: value.foreign
-    };
+    return { function: fn, inner: value };
   }
   if (typeof value === "object") {
-    return {
-      function: fn,
-      value
-    };
+    if (operator && field && isForeignValue(value)) {
+      return { function: fn, operator, field, value: value.foreign };
+    }
+    return { function: fn, value };
   }
-  operator != null ? operator : operator = "=";
   if (!field) {
     throw new TypeError("FIELD_IS_REQUIRED");
   }
-  return {
-    function: fn,
-    field,
-    operator,
-    value
-  };
+  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 = []) {
@@ -79,32 +76,42 @@ var QueryBuilder = class _QueryBuilder {
         this.$schemaBasic,
         this.$schema
       );
-      const res = field(inner);
-      if (res === false) {
+      if (field(inner) === false) {
         return this;
       }
-      if (!inner || !(inner instanceof _QueryBuilder)) {
-        throw new TypeError("Inner Builder must return QueryBuilderInner");
-      }
-      return this.add(
-        getWhereObject({
-          function: fn,
-          value: inner.toQuery()
-        })
-      );
+      return this.add(getWhereObject({ function: fn, value: inner.toQuery() }));
     }
     if (typeof field === "object") {
       const validObject = validateQueryBuilderSchema(this.$schemaBasic, field);
-      return this.add(
-        getWhereObject({
-          function: fn,
-          value: validObject
-        })
-      );
+      return this.add(getWhereObject({ function: fn, value: validObject }));
     }
     if (typeof field !== "string") {
       throw new TypeError("Field is required");
     }
+    if (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);
@@ -112,41 +119,30 @@ var QueryBuilder = class _QueryBuilder {
     if (operator === void 0) {
       throw new TypeError("Operator is required");
     }
-    if (typeof operator !== "string" || !(operator in DbFilterOperatorAllEnum) || value === void 0) {
-      operator = validateQueryBuilderSchema(fieldShape, operator);
-      if (operator === void 0) {
+    const operatorSlotHoldsValue = typeof operator !== "string" || !(operator in DbFilterOperatorAllEnum) || value === void 0;
+    if (operatorSlotHoldsValue) {
+      const validated = validateQueryBuilderSchema(fieldShape, operator);
+      if (validated === void 0) {
         throw new TypeError("unexpectedly value needed");
       }
-      if (typeof operator === "object") {
-        return this.add(
-          getWhereObject({
-            function: fn,
-            value: {
-              [field]: operator
-            }
-          })
-        );
-      }
-      return this.add(
-        getWhereObject({
+      if (typeof validated === "object") {
+        return getWhereObject({
           function: fn,
-          field,
-          value: operator
-        })
-      );
+          value: { [field]: validated }
+        });
+      }
+      return getWhereObject({ function: fn, field, value: validated });
     }
-    value = validateQueryBuilderSchema(fieldShape, value);
-    if (value === void 0) {
+    const validatedValue = validateQueryBuilderSchema(fieldShape, value);
+    if (validatedValue === void 0) {
       throw new Error("undefined value");
     }
-    return this.add(
-      getWhereObject({
-        function: fn,
-        field,
-        operator,
-        value
-      })
-    );
+    return getWhereObject({
+      function: fn,
+      field,
+      operator,
+      value: validatedValue
+    });
   }
   addIn({
     fn,
@@ -156,7 +152,7 @@ var QueryBuilder = class _QueryBuilder {
     if (!field) {
       throw new TypeError("Field is required");
     }
-    if (!(field in this.$schema.shape)) {
+    if (!(field in this.$schema.shape) && !isMetadataDotFilterField(field)) {
       throw new TypeError("Invalid field");
     }
     if (!value) {
@@ -193,12 +189,14 @@ var QueryBuilder = class _QueryBuilder {
     if (!field) {
       throw new TypeError("Field is required");
     }
-    if (!(field in this.$schema.shape)) {
+    if (!(field in this.$schema.shape) && !isMetadataDotFilterField(field)) {
       throw new TypeError("Invalid field");
     }
-    this.$schema.parse({
-      [field]: null
-    });
+    if (!isMetadataDotFilterField(field)) {
+      this.$schema.parse({
+        [field]: null
+      });
+    }
     return this.add({
       function: fn,
       field
@@ -213,15 +211,12 @@ var QueryBuilder = class _QueryBuilder {
     if (typeof field !== "string") {
       throw new TypeError("expected field to be string");
     }
-    if (!value) {
-      value = operator;
-      operator = "=";
-    }
+    const normalized = normalizeOperatorValue(operator, value);
     return this.add({
       function: fn,
       field,
-      operator,
-      value
+      operator: normalized.operator,
+      value: normalized.value
     });
   }
   addMetadataIn({