wapi-client 0.12.3 → 0.12.5-beta.1

package/dist/lib/query-builder/query-builder.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";
+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
+};

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

@@ -0,0 +1,237 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 __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/reverse-query-builder.ts
+var reverse_query_builder_exports = {};
+__export(reverse_query_builder_exports, {
+  ReverseQueryBuilder: () => ReverseQueryBuilder
+});
+module.exports = __toCommonJS(reverse_query_builder_exports);
+var import_utils = require('../utils.cjs');
+var import_validation = require('../validation.cjs');
+var import_query_builder = require('./query-builder.cjs');
+var ReverseQueryBuilder = class _ReverseQueryBuilder extends import_query_builder.QueryBuilder {
+  constructor({
+    $queries,
+    $options,
+    start,
+    schema,
+    schemaBasic,
+    optionsSchema,
+    reverse,
+    reverseSchema
+  }) {
+    super(schemaBasic, schema, $queries);
+    __publicField(this, "$options");
+    __publicField(this, "$optionsSchema");
+    __publicField(this, "$start");
+    __publicField(this, "$reverseSchema");
+    __publicField(this, "$reverse");
+    this.$options = $options;
+    this.$optionsSchema = optionsSchema;
+    this.$start = start;
+    this.$reverse = reverse;
+    this.$reverseSchema = reverseSchema;
+  }
+  add(addQuery) {
+    return new _ReverseQueryBuilder({
+      $queries: [...this.$queries, addQuery],
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema,
+      reverse: this.$reverse,
+      reverseSchema: this.$reverseSchema
+    });
+  }
+  start() {
+    return this.$start(this.toJSON());
+  }
+  toJSON() {
+    return {
+      filter: super.toQuery(),
+      reverse: this.$reverse,
+      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();
+  }
+  options(options) {
+    const validatedOptions = (0, import_validation.hardValidate)(this.$optionsSchema, options);
+    const mergedOptions = (0, import_utils.mergeFnOptionsOrderBy)(validatedOptions);
+    return new _ReverseQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadValues(__spreadValues({}, this.$options), mergedOptions),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema,
+      reverse: this.$reverse,
+      reverseSchema: this.$reverseSchema
+    });
+  }
+  reverse(input) {
+    var _a;
+    const valid = (0, import_validation.hardValidate)(this.$reverseSchema, input);
+    return new _ReverseQueryBuilder({
+      $queries: this.$queries,
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema,
+      reverseSchema: this.$reverseSchema,
+      reverse: __spreadValues(__spreadValues({}, (_a = this.$reverse) != null ? _a : {}), valid)
+    });
+  }
+  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
+};