wapi-client 0.12.3 → 0.12.5-beta.1

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

@@ -0,0 +1,283 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/lib/query-builder/find-query-builder.ts
+import { mergeFnOptionsOrderBy } from "../utils";
+import { hardValidate } from "../validation";
+import {
+  QueryBuilder
+} from "./query-builder";
+function queryBuilderOrderByToTxOrderBy(input) {
+  return input.map((item) => {
+    if (typeof item === "string") {
+      if (item.includes(" ")) {
+        throw new TypeError("invalid order option: " + item);
+      }
+      return {
+        field: item,
+        direction: "asc"
+      };
+    }
+    return {
+      field: item.column,
+      direction: item.order,
+      nulls: item.nulls
+    };
+  });
+}
+var FindQueryBuilder = class _FindQueryBuilder extends QueryBuilder {
+  constructor({
+    $queries,
+    $options,
+    start,
+    schema,
+    schemaBasic,
+    optionsSchema
+  }) {
+    super(schemaBasic, schema, $queries);
+    __publicField(this, "$options");
+    __publicField(this, "$optionsSchema");
+    __publicField(this, "$start");
+    this.$options = $options;
+    this.$optionsSchema = optionsSchema;
+    this.$start = start;
+  }
+  add(addQuery) {
+    return new _FindQueryBuilder({
+      $queries: [...this.$queries, addQuery],
+      $options: this.$options,
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  start() {
+    return this.$start(this.toJSON());
+  }
+  toJSON() {
+    return {
+      filter: super.toQuery(),
+      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();
+  }
+  select(first, ...select) {
+    var _a, _b;
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadProps(__spreadValues({}, this.$options), {
+        deselect: void 0,
+        select: Array.from(
+          /* @__PURE__ */ new Set([first, ...select, ...(_b = (_a = this.$options) == null ? void 0 : _a.select) != null ? _b : []])
+        )
+      }),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  deselect(first, ...deselect) {
+    var _a, _b;
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadProps(__spreadValues({}, this.$options), {
+        select: void 0,
+        deselect: Array.from(
+          /* @__PURE__ */ new Set([first, ...deselect, ...(_b = (_a = this.$options) == null ? void 0 : _a.deselect) != null ? _b : []])
+        )
+      }),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  de() {
+    return [];
+  }
+  options(options) {
+    const validatedOptions = hardValidate(this.$optionsSchema, options);
+    const mergedOptions = mergeFnOptionsOrderBy(validatedOptions);
+    return new _FindQueryBuilder({
+      $queries: this.$queries,
+      $options: __spreadValues(__spreadValues({}, this.$options), mergedOptions),
+      start: this.$start,
+      schemaBasic: this.$schemaBasic,
+      schema: this.$schema,
+      optionsSchema: this.$optionsSchema
+    });
+  }
+  limit(limit) {
+    return this.options({
+      limit
+    });
+  }
+  offset(offset) {
+    return this.options({
+      offset
+    });
+  }
+  orderBy(input, direction, nullsDirection) {
+    if (!Array.isArray(input) && typeof input !== "string") {
+      throw new TypeError("invalid input");
+    }
+    if (Array.isArray(input)) {
+      return this.options({
+        order: queryBuilderOrderByToTxOrderBy(input)
+      });
+    }
+    const internalArr = [input];
+    if (direction) {
+      internalArr.push(direction);
+    }
+    if (nullsDirection) {
+      internalArr.push("nulls", nullsDirection);
+    }
+    return this.options({
+      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
+    });
+  }
+  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 {
+  FindQueryBuilder
+};

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

@@ -0,0 +1,38 @@
+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);
+}

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,43 @@
+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/index.d.ts

@@ -0,0 +1,47 @@
+import { DbFilterOperatorEquals, DbFilterOperatorForNumbers, DbFilterOperatorForStrings } from '../../db/consts.enums';
+export declare const DbFilterOperatorAllEnum: Readonly<{
+    "=": "=";
+    ">=": ">=";
+    "<=": "<=";
+    "<": "<";
+    ">": ">";
+    like: "like";
+    ilike: "ilike";
+}>;
+export type Merge<T, K> = T & Omit<K, keyof T>;
+export type RemoveNull<T> = T extends null ? never : T;
+export type SearchableObject<T extends {}> = {
+    [k in keyof T]?: RemoveNull<T[k]>;
+};
+export type SearchableInObject<T extends {}> = {
+    [k in keyof T as T[k] extends string | number ? k : never]?: RemoveNull<T[k]>[];
+};
+export type SearchableNullObject<T extends {}> = {
+    [k in keyof T as T[k] extends null ? k : never]: null;
+};
+export type StringKeyObject = {
+    [key: string]: unknown;
+};
+export type RemoveMetadata<T extends {}> = Omit<T, 'metadata'>;
+export type OperatorType<I> = I extends boolean | 'foreign' ? DbFilterOperatorEquals : I extends number | 'datetime' ? DbFilterOperatorForNumbers : DbFilterOperatorForStrings;
+export declare function validateQueryBuilderSchema<Input extends Zod.ZodTypeAny>(schema: Input, value: unknown): Zod.infer<Input>;
+type AnyColumn<Col> = Col & string;
+type AnyAliasedColumn<Col> = `${AnyColumn<Col>} as ${string}`;
+type AnyMetadataColumn = `metadata.${string}`;
+type AnyAliasedMetadataColumn = `metadata.${string} as ${string}`;
+export type Selection<Columns> = AnyColumn<Columns> | AnyAliasedColumn<Columns>;
+export type SelectionWithMetadata<Columns> = Selection<Columns> | AnyMetadataColumn | AnyAliasedMetadataColumn;
+type IsNever<T> = [T] extends [never] ? true : false;
+type GetField<T, Cols> = T extends Cols ? T : never;
+type GetAlias<T> = T extends `${string} as ${infer Alias}` ? Alias : never;
+type GetFieldOfMetadataType<T> = T extends `metadata.${infer Field}` ? Field : never;
+type GetFieldOfMetadata<T> = IsNever<GetAlias<T>> extends false ? GetAlias<T> : GetFieldOfMetadataType<T>;
+type GetAliasOfInput<T, Cols> = GetField<T, Cols> | GetAlias<T> | GetFieldOfMetadata<T>;
+type GetDefaultAlias<T, Default> = T extends `${string} as ${infer Alias}` ? Alias : Default;
+export type GetSelectedObject<T, Cols, Return> = {
+    [k in T as GetAliasOfInput<k, Cols> & string]: Return;
+};
+export type GetDefaultAliasedObject<T, Default, Return> = {
+    [k in T as GetDefaultAlias<T, Default> & string]: Return;
+};
+export {};

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

@@ -0,0 +1,18 @@
+// src/lib/query-builder/index.ts
+import { DbFilterOperatorAllSchema } from "../../db/consts";
+import { InputError } from "../errors";
+import { createEnumFromTuple } from "../ts-utils";
+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
+};