wapi-client 0.12.3 → 0.12.5-beta.1

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

@@ -0,0 +1,369 @@
+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.cjs');
+function getWhereObject({
+  function: fn,
+  field,
+  operator,
+  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
+    };
+  }
+  if (typeof value === "object") {
+    return {
+      function: fn,
+      value
+    };
+  }
+  operator != null ? operator : operator = "=";
+  if (!field) {
+    throw new TypeError("FIELD_IS_REQUIRED");
+  }
+  return {
+    function: fn,
+    field,
+    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
+      );
+      field(inner);
+      if (!inner || !(inner instanceof _QueryBuilder)) {
+        throw new TypeError("Inner Builder must return QueryBuilderInner");
+      }
+      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");
+    }
+    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");
+    }
+    if (typeof operator !== "string" || !(operator in import_index.DbFilterOperatorAllEnum) || value === void 0) {
+      operator = (0, import_index.validateQueryBuilderSchema)(fieldShape, operator);
+      if (operator === 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({
+          function: fn,
+          field,
+          value: operator
+        })
+      );
+    }
+    value = (0, import_index.validateQueryBuilderSchema)(fieldShape, value);
+    if (value === void 0) {
+      throw new Error("undefined value");
+    }
+    return this.add(
+      getWhereObject({
+        function: fn,
+        field,
+        operator,
+        value
+      })
+    );
+  }
+  addIn({
+    fn,
+    field,
+    value
+  }) {
+    if (!field) {
+      throw new TypeError("Field is required");
+    }
+    if (!(field in this.$schema.shape)) {
+      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)) {
+      throw new TypeError("Invalid 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");
+    }
+    if (!value) {
+      value = operator;
+      operator = "=";
+    }
+    return this.add({
+      function: fn,
+      field,
+      operator,
+      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
+    });
+  }
+  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
+};

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

@@ -0,0 +1,354 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/lib/query-builder/query-builder.ts
+import {
+  DbFilterOperatorAllEnum,
+  validateQueryBuilderSchema
+} from "./index.browser.js";
+function getWhereObject({
+  function: fn,
+  field,
+  operator,
+  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
+    };
+  }
+  if (typeof value === "object") {
+    return {
+      function: fn,
+      value
+    };
+  }
+  operator != null ? operator : operator = "=";
+  if (!field) {
+    throw new TypeError("FIELD_IS_REQUIRED");
+  }
+  return {
+    function: fn,
+    field,
+    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
+      );
+      field(inner);
+      if (!inner || !(inner instanceof _QueryBuilder)) {
+        throw new TypeError("Inner Builder must return QueryBuilderInner");
+      }
+      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
+        })
+      );
+    }
+    if (typeof field !== "string") {
+      throw new TypeError("Field is required");
+    }
+    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");
+    }
+    if (typeof operator !== "string" || !(operator in DbFilterOperatorAllEnum) || value === void 0) {
+      operator = validateQueryBuilderSchema(fieldShape, operator);
+      if (operator === 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({
+          function: fn,
+          field,
+          value: operator
+        })
+      );
+    }
+    value = validateQueryBuilderSchema(fieldShape, value);
+    if (value === void 0) {
+      throw new Error("undefined value");
+    }
+    return this.add(
+      getWhereObject({
+        function: fn,
+        field,
+        operator,
+        value
+      })
+    );
+  }
+  addIn({
+    fn,
+    field,
+    value
+  }) {
+    if (!field) {
+      throw new TypeError("Field is required");
+    }
+    if (!(field in this.$schema.shape)) {
+      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)) {
+      throw new TypeError("Invalid 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");
+    }
+    if (!value) {
+      value = operator;
+      operator = "=";
+    }
+    return this.add({
+      function: fn,
+      field,
+      operator,
+      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
+    });
+  }
+  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 {
+  QueryBuilder
+};