wapi-client 0.12.0-beta.3 → 0.12.5-beta.0

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

@@ -0,0 +1,373 @@
+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
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryBuilder
+});

package/dist/lib/query-builder/query-builder.d.ts

@@ -0,0 +1,79 @@
+import { Merge, RemoveMetadata, SearchableObject, OperatorType, SearchableInObject, SearchableNullObject } from './index';
+import { DbFilterType } from '../../db/consts';
+import { DbFilter, DbFilterAllowedValue, DbFilterFunctionBasic, DbFilterFunctionIn, DbFilterFunctionMetadataBasic, DbFilterFunctionMetadataIn, DbFilterFunctionMetadataNull, DbFilterFunctionNull, DbFilterOperatorAll, DbFilterOperatorEquals, DbFilterOperatorForNumbers, DbFilterOperatorForStrings } from '../../db/consts.enums';
+export type InnerWhereBuilder<SearchableBasic extends Zod.AnyZodObject, Searchable extends Zod.AnyZodObject> = ($queries: QueryBuilder<SearchableBasic, Searchable>) => QueryBuilder<SearchableBasic, Searchable> | void;
+export type InnerBuiltQuery = {
+    filter: DbFilter[];
+};
+export declare class QueryBuilder<SearchableBasic extends Zod.AnyZodObject, Searchable extends Zod.AnyZodObject> {
+    $queries: DbFilterType[];
+    $schemaBasic: SearchableBasic;
+    $schema: Searchable;
+    constructor($schemaBasic: SearchableBasic, $schema: Searchable, $queries?: DbFilterType[]);
+    toQuery(): {
+        [key: string]: unknown;
+        metadata?: {
+            [key: string]: import("zod").TypeOf<typeof import("../../db/consts").DbFilterAllowedValueSchema>;
+        };
+    } | DbFilterType[];
+    toJSON(): InnerBuiltQuery;
+    protected add(query: DbFilterType): QueryBuilder<SearchableBasic, Searchable>;
+    protected addWhere({ fn, field, operator, value, }: {
+        fn: DbFilterFunctionBasic;
+        field: InnerWhereBuilder<SearchableBasic, Searchable> | SearchableObject<Zod.input<Searchable>> | keyof Searchable;
+        operator?: DbFilterOperatorAll | DbFilterAllowedValue;
+        value?: DbFilterAllowedValue;
+    }): ReturnType<typeof this.add>;
+    protected addIn({ fn, field, value, }: {
+        fn: DbFilterFunctionIn;
+        field: string;
+        value: (string | number)[];
+    }): QueryBuilder<SearchableBasic, Searchable>;
+    protected addMetadataNull({ fn, field, }: {
+        fn: DbFilterFunctionMetadataNull;
+        field: string;
+    }): QueryBuilder<SearchableBasic, Searchable>;
+    protected addNull({ fn, field, }: {
+        fn: DbFilterFunctionNull;
+        field: string;
+    }): QueryBuilder<SearchableBasic, Searchable>;
+    protected addMetadata({ fn, field, operator, value, }: {
+        fn: DbFilterFunctionMetadataBasic;
+        field: string;
+        operator: DbFilterOperatorForStrings | DbFilterAllowedValue;
+        value?: DbFilterAllowedValue;
+    }): QueryBuilder<SearchableBasic, Searchable>;
+    protected addMetadataIn({ fn, field, value, }: {
+        fn: DbFilterFunctionMetadataIn;
+        field: string;
+        value: string[] | number[];
+    }): QueryBuilder<SearchableBasic, Searchable>;
+    where(field: SearchableObject<Zod.input<SearchableBasic>>): ReturnType<typeof this.add>;
+    where(field: InnerWhereBuilder<SearchableBasic, Searchable>): ReturnType<typeof this.add>;
+    where<F extends keyof RemoveMetadata<Zod.input<Searchable>>, V extends Zod.input<Merge<SearchableBasic, Searchable>>[F]>(field: F, operator: V): ReturnType<typeof this.add>;
+    where<F extends keyof RemoveMetadata<Zod.input<Searchable>>, V extends Zod.input<Merge<SearchableBasic, Searchable>>[F]>(field: F, operator: OperatorType<V>, value: V): ReturnType<typeof this.add>;
+    orWhere(field: SearchableObject<Zod.input<SearchableBasic>>): ReturnType<typeof this.add>;
+    orWhere(field: InnerWhereBuilder<SearchableBasic, Searchable>): ReturnType<typeof this.add>;
+    orWhere<F extends keyof RemoveMetadata<Zod.input<Searchable>>, V extends Zod.input<Merge<SearchableBasic, Searchable>>[F]>(field: F, operator: V): ReturnType<typeof this.add>;
+    orWhere<F extends keyof RemoveMetadata<Zod.input<Searchable>>, V extends Zod.input<Merge<SearchableBasic, Searchable>>[F]>(field: F, operator: OperatorType<V>, value: V): ReturnType<typeof this.add>;
+    whereIn<F extends keyof SearchableInObject<Zod.input<Searchable>>, V extends SearchableInObject<Zod.input<Searchable>>[F]>(field: F, value: V): ReturnType<typeof this.add>;
+    orWhereIn<F extends keyof SearchableInObject<Zod.input<Searchable>>, V extends SearchableInObject<Zod.input<Searchable>>[F]>(field: F, value: V): ReturnType<typeof this.add>;
+    whereNull<F extends keyof SearchableNullObject<Searchable>>(field: F): ReturnType<typeof this.add>;
+    orWhereNull<F extends keyof SearchableNullObject<Zod.input<Searchable>>>(field: F): ReturnType<typeof this.add>;
+    whereNotNull<F extends keyof SearchableNullObject<Zod.input<Searchable>>>(field: F): ReturnType<typeof this.add>;
+    orWhereNotNull<F extends keyof SearchableNullObject<Zod.input<Searchable>>>(field: F): ReturnType<typeof this.add>;
+    whereMetadata(field: string, value: DbFilterAllowedValue): ReturnType<typeof this.add>;
+    whereMetadata(field: string, operator: DbFilterOperatorEquals, value: boolean): ReturnType<typeof this.add>;
+    whereMetadata(field: string, operator: DbFilterOperatorForNumbers, value: number): ReturnType<typeof this.add>;
+    whereMetadata(field: string, operator: DbFilterOperatorForStrings, value: string): ReturnType<typeof this.add>;
+    orWhereMetadata(field: string, value: DbFilterAllowedValue): ReturnType<typeof this.add>;
+    orWhereMetadata(field: string, operator: DbFilterOperatorEquals, value: boolean): ReturnType<typeof this.add>;
+    orWhereMetadata(field: string, operator: DbFilterOperatorForNumbers, value: number): ReturnType<typeof this.add>;
+    orWhereMetadata(field: string, operator: DbFilterOperatorForStrings, value: string): ReturnType<typeof this.add>;
+    whereMetadataIn(field: string, value: string[] | number[]): ReturnType<typeof this.add>;
+    orWhereMetadataIn(field: string, value: string[] | number[]): ReturnType<typeof this.add>;
+    whereMetadataNull(field: string): ReturnType<typeof this.add>;
+    orWhereMetadataNull(field: string): ReturnType<typeof this.add>;
+    whereMetadataNotNull(field: string): ReturnType<typeof this.add>;
+    orWhereMetadataNotNull(field: string): ReturnType<typeof this.add>;
+}