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

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

@@ -0,0 +1,220 @@
+var __defProp = Object.defineProperty;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/lib/query-builder/reverse-query-builder.ts
+import { mergeFnOptionsOrderBy } from "../utils.browser.js";
+import { hardValidate } from "../validation.browser.js";
+import { QueryBuilder } from "./query-builder.browser.js";
+var ReverseQueryBuilder = class _ReverseQueryBuilder extends 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 = hardValidate(this.$optionsSchema, options);
+    const mergedOptions = 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 = 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
+};
+export {
+  ReverseQueryBuilder
+};

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

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

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

@@ -0,0 +1,65 @@
+import { Merge, OperatorType, RemoveMetadata, SearchableInObject, SearchableNullObject, SearchableObject, StringKeyObject } from '.';
+import { DbFilterType } from '../../db/consts';
+import { DbFilter, DbFilterAllowedValue, DbFilterOperatorEquals, DbFilterOperatorForNumbers, DbFilterOperatorForStrings } from '../../db/consts.enums';
+import { ReadStream } from '../isomorphic/node/streams';
+import { StreamPromise } from '../stream-promise';
+import { InnerWhereBuilder, QueryBuilder } from './query-builder';
+export type BuiltReverseQuery<Options extends Zod.ZodTypeAny, ReverseSchema extends Zod.ZodTypeAny> = {
+    filter: DbFilter[];
+    options: Zod.infer<Options>;
+    reverse: Zod.infer<ReverseSchema>;
+};
+export declare class ReverseQueryBuilder<SearchableBasic extends Zod.AnyZodObject, Searchable extends Zod.AnyZodObject, Options extends Zod.ZodTypeAny, ReverseSchema extends Zod.ZodTypeAny, Result extends StringKeyObject> extends QueryBuilder<SearchableBasic, Searchable> {
+    $options: Zod.infer<Options>;
+    $optionsSchema: Options;
+    $start: (q: BuiltReverseQuery<Options, ReverseSchema>) => StreamPromise<Result>;
+    $reverseSchema: Zod.ZodTypeAny;
+    $reverse?: Zod.infer<ReverseSchema>;
+    constructor({ $queries, $options, start, schema, schemaBasic, optionsSchema, reverse, reverseSchema, }: {
+        start: (q: BuiltReverseQuery<Options, ReverseSchema>) => StreamPromise<Result>;
+        schemaBasic: SearchableBasic;
+        schema: Searchable;
+        optionsSchema: Options;
+        $queries?: DbFilterType[];
+        $options?: Zod.infer<Options>;
+        reverse?: Zod.infer<ReverseSchema>;
+        reverseSchema: Zod.ZodTypeAny;
+    });
+    protected add(addQuery: DbFilterType): ReverseQueryBuilder<SearchableBasic, Searchable, Options, ReverseSchema, Result>;
+    private start;
+    toJSON(): BuiltReverseQuery<Options, ReverseSchema>;
+    then<TResult1 = Result, TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: Error) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+    catch<TResult2 = never>(onerror: (reason: Error) => TResult2 | PromiseLike<TResult2>): Promise<Result | TResult2>;
+    finally(fn: () => void): Promise<Result>;
+    stream(): ReadStream;
+    options(options: Zod.input<Options>): ReverseQueryBuilder<SearchableBasic, Searchable, Options, ReverseSchema, Result>;
+    reverse(input: Zod.input<ReverseSchema>): ReverseQueryBuilder<SearchableBasic, Searchable, Options, ReverseSchema, Result>;
+    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>;
+}