@pol-studios/db 1.0.0 → 1.0.1

package/dist/parser/index.d.ts

@@ -0,0 +1,366 @@
+import { PostgrestBuilder, PostgrestSingleResponse, PostgrestMaybeSingleResponse, PostgrestResponse, PostgrestQueryBuilder } from '@supabase/postgrest-js';
+export { G as GetResult, S as SelectQueryError } from '../select-query-parser-CGI40aOg.js';
+export { F as Fetch, k as GenericFunction, i as GenericNonUpdatableView, G as GenericSchema, a as GenericTable, h as GenericUpdatableView, j as GenericView, b as PostgrestError, f as PostgrestMaybeSingleResponse, g as PostgrestResponse, d as PostgrestResponseFailure, c as PostgrestResponseSuccess, e as PostgrestSingleResponse, P as Prettify } from '../types-DjuX1XHy.js';
+
+/**
+ * A function that validates whether the given input is an object of type Type
+ * @returns true if obj is of type Type, false if not
+ */
+type FilterFn<Type extends Record<string, unknown>> = (obj: unknown) => obj is Type;
+/**
+ * The supported value types
+ */
+type ValueType = number | string | boolean | null | Date | object;
+/**
+ * A function implementing a FilterOperators
+ * @param columnValue the value of the input object to test the filter against
+ * @param filterValue the value of the filter, e.g. in .eq('colname', 'filterValue'), 'filterValue' would be the filterValue
+ * @returns true if the filter applies, false if not
+ */
+type OperatorFn = (columnValue: any, filterValue: any) => boolean;
+/**
+ * All supported operators of PostgREST
+ */
+type PostgrestFilterOperator = 'or' | 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd' | 'fts' | 'plfts';
+/**
+ * An object describing a selected path of a query
+ *
+ */
+type Path = {
+    /**
+     * The aliased path if a column or relation name mapping is used within the path
+     */
+    alias?: string;
+    /**
+     * The "real" path of a column
+     */
+    path: string;
+    /**
+     * The full declaration of a column that includes alias, hints and inner joins
+     */
+    declaration: string;
+};
+/**
+ * A decomposed filter applied to a query
+ */
+type FilterDefinition = {
+    /**
+     * The path to which the filter is applied
+     */
+    path: string;
+    /**
+     * The aliased path if a column or relation name mapping is used
+     */
+    alias?: string;
+    /**
+     * The operator that is applied
+     */
+    operator: PostgrestFilterOperator;
+    /**
+     * Whether or not to negate the results of the filter, e.g. when .not('name', 'eq', 'Paris') is applied
+     */
+    negate: boolean;
+    /**
+     * The value of the filter
+     */
+    value: ValueType;
+};
+/**
+ * A json representation of PostgREST filters that are applied to a query
+ */
+type FilterDefinitions = ({
+    or: FilterDefinitions;
+} | {
+    and: FilterDefinitions;
+} | FilterDefinition)[];
+type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+declare const isAndFilter: (f: ArrayElement<FilterDefinitions>) => f is {
+    and: FilterDefinitions;
+};
+declare const isOrFilter: (f: ArrayElement<FilterDefinitions>) => f is {
+    or: FilterDefinitions;
+};
+declare const isFilterDefinition: (f: ArrayElement<FilterDefinitions>) => f is FilterDefinition;
+type OrderDefinition = {
+    column: string;
+    ascending: boolean;
+    nullsFirst: boolean;
+    foreignTable?: string;
+};
+
+declare const SUPPORTED_OPERATORS: string[];
+type PostgrestQueryParserOptions = {
+    /**
+     * If defined, will use only filters that apply to the given paths
+     */
+    exclusivePaths?: string[];
+};
+declare class PostgrestQueryParser {
+    readonly opts?: PostgrestQueryParserOptions;
+    private readonly _params;
+    private _filters;
+    private _paths;
+    constructor(query: string, opts?: PostgrestQueryParserOptions);
+    /**
+     * Getter that returns the paths and their aliases that the query selects. Will do the computation only once.
+     *
+     * ```js
+     * const p = new PostgrestParser(
+     * supabaseClient.from("test")
+     *    .select(
+     *      `name,
+     *       city:cities (
+     *        test:name
+     *      ),
+     *      countries (
+     *        capital,
+     *        population,
+     *        some_ref (
+     *          test:first,
+     *          second
+     *        )
+     *      )`
+     *    );
+     * console.log(p.paths);
+     * //  [
+     * //    { alias: undefined, path: "name" },
+     * //    { alias: "city.test", path: "cities.name" },
+     * //    { alias: undefined, path: "countries.capital" },
+     * //    { alias: undefined, path: "countries.population" },
+     * //    {
+     * //      alias: "countries.some_ref.test",
+     * //      path: "countries.some_ref.first",
+     * //    },
+     * //    { alias: undefined, path: "countries.some_ref.second" },
+     * //  ];
+     * ```
+     *
+     * @returns an array of paths that the query selects, containing the columns and aliases
+     */
+    get paths(): Path[];
+    /**
+     * Getter that returns the filters that this query applies in a json object.
+     *
+     * ```js
+     * const p = new PostgrestParser(
+     * supabaseClient.from("test").select('*')
+     *  .or("full_name.eq.20,test.neq.true,and(full_name.eq.Test Name,email.eq.test@mail.com)")
+     *  .eq("id", "123")
+     *  .contains("id", "456")
+     * );
+     *
+     * console.log(p.filters);
+     *
+     * // [
+     * //   {
+     * //     or: [
+     * //       {
+     * //         path: "full_name",
+     * //         negate: false,
+     * //         operator: "eq",
+     * //         value: 20,
+     * //       },
+     * //       {
+     * //         path: "test",
+     * //         negate: false,
+     * //         operator: "neq",
+     * //         value: true,
+     * //       },
+     * //       {
+     * //         and: [
+     * //           {
+     * //             path: "full_name",
+     * //             negate: false,
+     * //             operator: "eq",
+     * //             value: "Test Name",
+     * //           },
+     * //           {
+     * //             path: "email",
+     * //             negate: false,
+     * //             operator: "eq",
+     * //             value: "test@mail.com",
+     * //           },
+     * //         ],
+     * //       },
+     * //     ],
+     * //   },
+     * //   {
+     * //     path: "id",
+     * //     negate: false,
+     * //     operator: "eq",
+     * //     value: 123,
+     * //   },
+     * //   {
+     * //     path: "id",
+     * //     negate: false,
+     * //     operator: "cs",
+     * //     value: 456,
+     * //   },
+     * // ];
+     * ```
+     *
+     * @returns a FilterDefinitions object
+     */
+    get filters(): FilterDefinitions;
+    private parseFilterString;
+}
+
+declare class PostgrestParser<Result> extends PostgrestQueryParser {
+    readonly opts?: PostgrestQueryParserOptions;
+    private readonly _url;
+    private readonly _headers;
+    private readonly _body;
+    readonly method: "GET" | "HEAD" | "POST" | "PATCH" | "DELETE";
+    readonly select: string;
+    readonly queryKey: string;
+    readonly bodyKey: string | undefined;
+    readonly count: string | null;
+    readonly schema: string;
+    readonly table: string;
+    readonly isHead: boolean | undefined;
+    readonly limit: number | undefined;
+    readonly offset: number | undefined;
+    readonly orderBy: OrderDefinition[];
+    readonly orderByKey: string;
+    readonly searchParams: URLSearchParams;
+    constructor(fb: PostgrestBuilder<any, Result>, opts?: PostgrestQueryParserOptions);
+}
+
+declare class PostgrestFilter<Result extends Record<string, unknown>> {
+    readonly params: {
+        filters: FilterDefinitions;
+        paths: Path[];
+    };
+    private _fn;
+    private _selectFn;
+    private _filtersFn;
+    private _filterPaths;
+    constructor(params: {
+        filters: FilterDefinitions;
+        paths: Path[];
+    });
+    static fromQuery(query: string, opts?: PostgrestQueryParserOptions): PostgrestFilter<Record<string, unknown>>;
+    static fromBuilder<Result extends Record<string, unknown> = Record<string, unknown>>(fb: PostgrestBuilder<any, Result>, opts?: PostgrestQueryParserOptions): PostgrestFilter<Result>;
+    denormalize<Type extends Record<string, unknown>>(obj: Type): Type;
+    apply(obj: unknown): obj is Result;
+    applyFilters(obj: unknown): obj is Result;
+    hasFiltersOnPaths(paths: string[]): boolean;
+    applyFiltersOnPaths(obj: unknown, paths: string[]): obj is Result;
+    hasPaths(obj: unknown): obj is Result;
+    private hasPathRecursive;
+    private applyFilterFn;
+    private buildFilterFn;
+}
+
+/**
+ * Denormalize a normalized response object using the paths of the target query
+ * **/
+declare const denormalize: <R extends Record<string, unknown>>(paths: Path[], obj: R) => R;
+
+declare function binarySearch<Type>(arr: Type[], el: Type, compare: (a: Type, b: Type) => number): number;
+
+type AnyPostgrestResponse<Result> = PostgrestSingleResponse<Result> | PostgrestMaybeSingleResponse<Result> | PostgrestResponse<Result>;
+declare const isAnyPostgrestResponse: <Result>(q: unknown) => q is AnyPostgrestResponse<Result>;
+type PostgrestPaginationResponse<Result> = Result[];
+declare const isPostgrestPaginationResponse: <Result>(q: unknown) => q is PostgrestPaginationResponse<Result>;
+type PostgrestHasMorePaginationResponse<Result> = {
+    data: Result[];
+    hasMore: boolean;
+};
+declare const isPostgrestHasMorePaginationResponse: <Result>(q: unknown) => q is PostgrestHasMorePaginationResponse<Result>;
+
+type PostgrestPaginationCacheData<Result> = Result[][];
+declare const isPostgrestPaginationCacheData: <Result>(q: unknown) => q is PostgrestPaginationCacheData<Result>;
+type PostgrestHasMorePaginationCacheData<Result> = PostgrestHasMorePaginationResponse<Result>[];
+declare const isPostgrestHasMorePaginationCacheData: <Result>(q: unknown) => q is PostgrestHasMorePaginationCacheData<Result>;
+
+/**
+ * Encodes an object by url-encoding an ordered lists of all paths and their values.
+ */
+declare const encodeObject: (obj: Record<string, unknown>) => string;
+
+declare const extractPathsFromFilters: (f: FilterDefinitions, p: Path[]) => Path[];
+
+declare const filterFilterDefinitionsByPaths: (f: FilterDefinitions, paths: string[]) => FilterDefinitions;
+
+declare const findFilters: (f: FilterDefinitions, by: Partial<FilterDefinition>) => FilterDefinition[];
+
+declare const findIndexOrdered: <Type extends Record<string, unknown>>(input: Type, currentData: Type[], orderBy: OrderDefinition[]) => number;
+
+/**
+ * Returns the index of the last element in the array where predicate is true, and -1
+ * otherwise.
+ * @param array The source array to search in
+ * @param predicate find calls predicate once for each element of the array, in descending
+ * order, until it finds one where predicate returns true. If such an element is found,
+ * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
+ */
+declare function findLastIndex<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): number;
+
+declare const get: (obj: any, path: string, defaultValue?: any) => any;
+
+declare const getTable: (query: PostgrestBuilder<any, any> | PostgrestQueryBuilder<any, any, any>) => string;
+
+type NestedPath = {
+    alias?: string;
+    path: string;
+    declaration: string;
+    paths: (Path | NestedPath)[];
+};
+declare const isNestedPath: (p: Path | NestedPath) => p is NestedPath;
+declare const groupPathsRecursive: (paths: Path[]) => (Path | NestedPath)[];
+
+declare const ifDateGetTime: (v: unknown) => unknown;
+
+/**
+ * Check if a value is a valid ISO DateTime string
+ * @param v
+ * @returns
+ */
+declare const isISODateString: (v: unknown) => boolean;
+
+/**
+ *
+ * @param i Ahhh gotta love typescript
+ * @returns
+ */
+declare const isNotNull: <I>(i: I | null) => i is I;
+
+declare const isObject: (v: unknown) => v is Record<string, unknown>;
+
+declare const isPostgrestBuilder: <Result>(q: unknown) => q is PostgrestBuilder<any, Result>;
+
+/**
+ * An object containing all PostgrestFilterOperator implementations
+ */
+declare const OPERATOR_MAP: {
+    [Key in PostgrestFilterOperator]?: OperatorFn;
+};
+
+/**
+ * Parses orderByKey back to OrderDefinition
+ * @param key generated by PostgrestParser
+ * @returns The parsed OrderDefinition
+ */
+declare const parseOrderByKey: (v: string) => OrderDefinition[];
+
+declare const parseSelectParam: (s: string, currentPath?: Path) => Path[];
+
+/**
+ * Safely parse any value to a ValueType
+ * @param v Any value
+ * @returns a ValueType
+ */
+declare const parseValue: (v: any) => ValueType;
+
+declare const removeAliasFromDeclaration: (d: string) => string;
+
+declare const removeFirstPathElement: (p: Path) => Path;
+
+declare const setFilterValue: (searchParams: URLSearchParams, path: string, op: string, value: string) => void;
+
+declare const sortSearchParams: (params: URLSearchParams) => URLSearchParams;
+
+declare const buildSortedComparator: <Type extends Record<string, unknown>>(orderBy: OrderDefinition[]) => (a: Type, b: Type) => 0 | 1 | -1;
+
+export { type AnyPostgrestResponse, type FilterDefinition, type FilterDefinitions, type FilterFn, type NestedPath, OPERATOR_MAP, type OperatorFn, type OrderDefinition, type Path, PostgrestFilter, type PostgrestFilterOperator, type PostgrestHasMorePaginationCacheData, type PostgrestHasMorePaginationResponse, type PostgrestPaginationCacheData, type PostgrestPaginationResponse, PostgrestParser, PostgrestQueryParser, type PostgrestQueryParserOptions, SUPPORTED_OPERATORS, type ValueType, binarySearch, buildSortedComparator, denormalize, encodeObject, extractPathsFromFilters, filterFilterDefinitionsByPaths, findFilters, findIndexOrdered, findLastIndex, get, getTable, groupPathsRecursive, ifDateGetTime, isAndFilter, isAnyPostgrestResponse, isFilterDefinition, isISODateString, isNestedPath, isNotNull, isObject, isOrFilter, isPostgrestBuilder, isPostgrestHasMorePaginationCacheData, isPostgrestHasMorePaginationResponse, isPostgrestPaginationCacheData, isPostgrestPaginationResponse, parseOrderByKey, parseSelectParam, parseValue, removeAliasFromDeclaration, removeFirstPathElement, setFilterValue, sortSearchParams };

package/dist/parser/index.js

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/categories.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/categories.js
 var require_categories = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/categories.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/categories.js"(exports, module) {
     module.exports = [
       {
         "name": "C",
@@ -248,9 +248,9 @@ var require_categories = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/properties.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/properties.js
 var require_properties = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/properties.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/properties.js"(exports, module) {
     module.exports = [
       {
         "name": "ASCII",
@@ -295,9 +295,9 @@ var require_properties = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/scripts.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/scripts.js
 var require_scripts = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/scripts.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/scripts.js"(exports, module) {
     module.exports = [
       {
         "name": "Adlam",
@@ -1559,15 +1559,15 @@ var OPERATOR_MAP = {
   )
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/xregexp.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/xregexp.js
 var REGEX_DATA = "xregexp";
 var features = {
   astral: false,
   namespacing: true
 };
 var fixed = {};
-var regexCache = {};
-var patternCache = {};
+var regexCache = /* @__PURE__ */ Object.create(null);
+var patternCache = /* @__PURE__ */ Object.create(null);
 var tokens = [];
 var defaultScope = "default";
 var classScope = "class";
@@ -1873,7 +1873,7 @@ function XRegExp(pattern, flags) {
   );
 }
 XRegExp.prototype = new RegExp();
-XRegExp.version = "5.1.1";
+XRegExp.version = "5.1.2";
 XRegExp._clipDuplicates = clipDuplicates;
 XRegExp._hasNativeFlag = hasNativeFlag;
 XRegExp._dec = dec;
@@ -1913,9 +1913,9 @@ XRegExp.cache = (pattern, flags) => {
 };
 XRegExp.cache.flush = (cacheName) => {
   if (cacheName === "patterns") {
-    patternCache = {};
+    patternCache = /* @__PURE__ */ Object.create(null);
   } else {
-    regexCache = {};
+    regexCache = /* @__PURE__ */ Object.create(null);
   }
 };
 XRegExp.escape = (str) => String(nullThrows(str)).replace(/[\\\[\]{}()*+?.^$|]/g, "\\$&").replace(/[\s#\-,]/g, (match) => `\\u${pad4(hex(match.charCodeAt(0)))}`);
@@ -2368,7 +2368,7 @@ XRegExp.addToken(
 );
 var xregexp_default = XRegExp;
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/build.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/build.js
 var build_default = (XRegExp2) => {
   const REGEX_DATA2 = "xregexp";
   const subParts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g;
@@ -2492,7 +2492,7 @@ var build_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/matchrecursive.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/matchrecursive.js
 var matchrecursive_default = (XRegExp2) => {
   function row(name, value, start, end) {
     return {
@@ -2622,7 +2622,7 @@ var matchrecursive_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-base.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-base.js
 var unicode_base_default = (XRegExp2) => {
   const unicode = {};
   const unicodeTypes = {};
@@ -2774,7 +2774,7 @@ var unicode_base_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-categories.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-categories.js
 var import_categories = __toESM(require_categories());
 var unicode_categories_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2783,7 +2783,7 @@ var unicode_categories_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(import_categories.default);
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-properties.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-properties.js
 var import_properties = __toESM(require_properties());
 var unicode_properties_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2799,7 +2799,7 @@ var unicode_properties_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(unicodeData);
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-scripts.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-scripts.js
 var import_scripts = __toESM(require_scripts());
 var unicode_scripts_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2808,7 +2808,7 @@ var unicode_scripts_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(import_scripts.default, "Script");
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/index.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/index.js
 build_default(xregexp_default);
 matchrecursive_default(xregexp_default);
 unicode_base_default(xregexp_default);
@@ -3684,35 +3684,35 @@ export {
 
 xregexp/src/xregexp.js:
   (*!
-   * XRegExp 5.1.1
+   * XRegExp 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2007-present MIT License
    *)
 
 xregexp/src/addons/build.js:
   (*!
-   * XRegExp.build 5.1.1
+   * XRegExp.build 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2012-present MIT License
    *)
 
 xregexp/src/addons/matchrecursive.js:
   (*!
-   * XRegExp.matchRecursive 5.1.1
+   * XRegExp.matchRecursive 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2009-present MIT License
    *)
 
 xregexp/src/addons/unicode-base.js:
   (*!
-   * XRegExp Unicode Base 5.1.1
+   * XRegExp Unicode Base 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2008-present MIT License
    *)
 
 xregexp/src/addons/unicode-categories.js:
   (*!
-   * XRegExp Unicode Categories 5.1.1
+   * XRegExp Unicode Categories 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2010-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>
@@ -3720,7 +3720,7 @@ xregexp/src/addons/unicode-categories.js:
 
 xregexp/src/addons/unicode-properties.js:
   (*!
-   * XRegExp Unicode Properties 5.1.1
+   * XRegExp Unicode Properties 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2012-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>
@@ -3728,7 +3728,7 @@ xregexp/src/addons/unicode-properties.js:
 
 xregexp/src/addons/unicode-scripts.js:
   (*!
-   * XRegExp Unicode Scripts 5.1.1
+   * XRegExp Unicode Scripts 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2010-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>