@freehour/supabase-core 1.2.0 → 1.3.0

package/dist/index.js

@@ -45,7 +45,7 @@ class x extends k {
     super(t, a), this.expression = e, this.format = r;
   }
 }
-class $ extends k {
+class _ extends k {
   /**
    * The schema where the record was expected to be found.
    */
@@ -83,21 +83,21 @@ class I extends Error {
     super(t, a), this.value = e, this.supported = r;
   }
 }
-const _ = m.object({
+const $ = m.object({
   code: m.string(),
   details: m.string().nullable(),
   hint: m.string().nullable(),
   name: m.string().optional(),
   message: m.string().optional()
 });
-function G(s) {
-  return s instanceof P || _.safeParse(s).success;
+function H(s) {
+  return s instanceof P || $.safeParse(s).success;
 }
-const v = ["eq", "neq", "gt", "gte", "lt", "lte", "like", "ilike", "match", "imatch", "in", "is", "isdistinct", "fts", "plfts", "phfts", "wfts", "cs", "cd", "ov", "sl", "sr", "nxr", "nxl", "adj"], H = ["and", "or"], J = ",", O = "~", Q = (s) => (t = {}) => {
+const v = ["eq", "neq", "gt", "gte", "lt", "lte", "like", "ilike", "match", "imatch", "in", "is", "isdistinct", "fts", "plfts", "phfts", "wfts", "cs", "cd", "ov", "sl", "sr", "nxr", "nxl", "adj"], J = ["and", "or"], Q = ",", O = "~", X = (s) => (t = {}) => {
   const e = (a) => t[a] ?? a, r = Object.keys(s.shape);
   return m.string().transform((a, n) => {
     try {
-      return M(a, r, e);
+      return L(a, r, e);
     } catch (i) {
       return n.addIssue({
         code: "custom",
@@ -127,7 +127,7 @@ function q(s, t = (e) => e) {
   }
   return `${t(s.key)}.${s.op}.${s.value}`;
 }
-function L(s, t = (r) => r, e = O) {
+function D(s, t = (r) => r, e = O) {
   return s.map((r) => q(r, t)).join(e);
 }
 function y(s, t = [], e = (r) => r) {
@@ -182,14 +182,14 @@ function y(s, t = [], e = (r) => r) {
     value: l.defined(d)
   };
 }
-function M(s, t = [], e = (a) => a, r = O) {
+function L(s, t = [], e = (a) => a, r = O) {
   return s.length === 0 ? [] : s.split(r).map((a) => y(a, t, e));
 }
-function A(s, t = "/") {
+function M(s, t = "/") {
   const e = s.lastIndexOf(t);
   return e === -1 ? ["", s] : [s.substring(0, e), s.substring(e + 1)];
 }
-function D(s) {
+function A(s) {
   return Array.isArray(s) ? s : [s];
 }
 function z(s, t) {
@@ -214,44 +214,47 @@ const w = {
    * @example
    * const table = supabase.schema('public').from('my_table');
    * const {data, error} = await postgrestExtensions.query.enable(table)
-   *     .selectColumns(['id', 'name'])
+   *     .select(['id', 'name'])
    *     .then(({data}) => console.log(data)); // [{ id: 1, name: 'John' }, ...]
    */
   query: {
-    enable: (s) => Object.assign(s, {
-      /**
-       * Selects columns from the relation.
-       *
-       * @param columns The array of column names to select, or '*' to select all columns.
-       * @param options The options for the selection, such as count.
-       * @returns The PostgREST filter builder with selection applied and filter extension enabled.
-       */
-      select: (t, e) => w.filter.enable(
-        s.select(
-          D(t).join(","),
-          e
+    enable: (s) => Object.assign(
+      s,
+      {
+        /**
+         * Selects columns from the relation.
+         *
+         * @param columns The array of column names to select, or '*' to select all columns.
+         * @param options The options for the selection, such as count.
+         * @returns The PostgREST filter builder with selection applied and filter extension enabled.
+         */
+        select: (t, e) => w.filter.enable(
+          s.select(
+            A(t).join(","),
+            e
+          )
+        ),
+        /**
+         * Counts the number of rows in the relation.
+         * Does not select any columns, only counts the rows.
+         *
+         * @param method The counting method to use, defaults to 'exact'.
+         * @returns The PostgREST filter builder with counting applied and filter extension enabled.
+         */
+        count: (t = "exact") => w.filter.enable(
+          s.select("*", { count: t, head: !0 })
+        ),
+        /**
+         * Deletes rows from the relation.
+         * Returns a filter builder for further filtering before deletion.
+         *
+         * @returns The PostgREST filter builder with delete applied and filter extension enabled.
+         */
+        delete: () => w.filter.enable(
+          s.delete()
         )
-      ),
-      /**
-       * Counts the number of rows in the relation.
-       * Does not select any columns, only counts the rows.
-       *
-       * @param method The counting method to use, defaults to 'exact'.
-       * @returns The PostgREST filter builder with counting applied and filter extension enabled.
-       */
-      count: (t = "exact") => w.filter.enable(
-        s.select("*", { count: t, head: !0 })
-      ),
-      /**
-       * Deletes rows from the relation.
-       * Returns a filter builder for further filtering before deletion.
-       *
-       * @returns The PostgREST filter builder with delete applied and filter extension enabled.
-       */
-      delete: () => w.filter.enable(
-        s.delete()
-      )
-    })
+      }
+    )
   },
   /**
    * Filter extension for PostgREST queries.
@@ -261,78 +264,81 @@ const w = {
    * @example
    * const selection = supabase.schema('public').from('my_table').select('*', { count: 'exact' });
    * const {data, error} = await postgrestExtensions.filter.enable(selection)
-   *     .apply({ key: 'name', op: 'eq', value: 'John' })
+   *     .filter({ key: 'name', op: 'eq', value: 'John' })
    *     .paginate(1, 10)
    *     .collect();
    */
   filter: {
-    enable: (s, t = {}) => Object.assign(s, {
-      /**
-       * Applies a filter to the query.
-       * A filter is defined as an array of AST filter nodes including conditions and logical operators.
-       * @param filter The filter to apply.
-       */
-      apply: (e) => w.filter.enable(
-        (() => {
-          function r(a, n) {
-            if (n.type === "logical") {
-              const i = L(n.args, (c) => c, ",");
-              return n.op === "or" ? a.or(i) : n.op === "not.or" ? a.or(i, { referencedTable: "not" }) : r(a, {
-                type: "logical",
-                op: n.op === "and" ? "not.or" : "or",
-                args: n.args.map(N)
-              });
+    enable: (s, t = {}) => Object.assign(
+      s,
+      {
+        /**
+         * Applies a filter to the query.
+         * A filter is defined as an AST of filter nodes including conditions and logical operators.
+         * @param node The filter to apply.
+         */
+        filter: (e) => w.filter.enable(
+          (() => {
+            function r(a, n) {
+              if (n.type === "logical") {
+                const i = D(n.args, (c) => c, ",");
+                return n.op === "or" ? a.or(i) : n.op === "not.or" ? a.or(i, { referencedTable: "not" }) : r(a, {
+                  type: "logical",
+                  op: n.op === "and" ? "not.or" : "or",
+                  args: n.args.map(N)
+                });
+              }
+              return a.filter(n.key, n.op, n.value);
+            }
+            return r(s, e);
+          })(),
+          t
+        ),
+        /**
+         * Limits the range of results to a specific page given a page index and limit.
+         * @param page The page index (0-based).
+         * @param limit The number of items per page.
+         * @param count Optional count of total items, if known.
+         * If provided, it will be used to check if the pagination range is valid and resolve to an empty range if not.
+         */
+        paginate: (e, r, a) => w.filter.enable(
+          (() => {
+            l(e >= 0, "Page index must be ≥ 0"), l(r >= 0, "Page limit must be ≥ 0");
+            const n = e * r, i = n + r - 1;
+            if (a !== void 0) {
+              if (n >= a)
+                return s.limit(0);
+              if (i >= a)
+                return s.range(n, a - 1);
+            }
+            return s.range(n, i);
+          })(),
+          {
+            ...t,
+            pagination: {
+              page: e,
+              limit: r,
+              count: a
             }
-            return a.filter(n.key, n.op, n.value);
-          }
-          return e.reduce(r, s);
-        })(),
-        t
-      ),
-      /**
-       * Limits the range of results to a specific page given a page index and limit.
-       * @param page The page index (0-based).
-       * @param limit The number of items per page.
-       * @param count Optional count of total items, if known.
-       * If provided, it will be used to check if the pagination range is valid and resolve to an empty range if not.
-       */
-      paginate: (e, r, a) => w.filter.enable(
-        (() => {
-          l(e >= 0, "Page index must be ≥ 0"), l(r >= 0, "Page limit must be ≥ 0");
-          const n = e * r, i = n + r - 1;
-          if (a !== void 0) {
-            if (n >= a)
-              return s.limit(0);
-            if (i >= a)
-              return s.range(n, a - 1);
-          }
-          return s.range(n, i);
-        })(),
-        {
-          ...t,
-          pagination: {
-            page: e,
-            limit: r,
-            count: a
           }
-        }
-      ),
-      /**
-       * Collects the results of a pagination query.
-       * **Note:** For collect to work, paginate() must be called before collect() and the selection must include a `count`.
-       * @returns The paginated list of queried items.
-       */
-      collect: () => s.throwOnError().then((e) => {
-        const { data: r, count: a } = e, { page: n, limit: i, ...c } = l.defined(t.pagination, "Pagination context is required for collect(). Make sure to call paginate() before collect()"), o = a ?? c.count;
-        return l(i > 0, "Page limit must be > 0"), l(Array.isArray(r), "Data must be an array for pagination, make sure to select multiple rows in query"), l(o !== void 0, "Row count is required for pagination, make sure to count in query or pass `count` in paginate()"), {
-          items: r,
-          totalItems: o,
-          page: n,
-          totalPages: Math.ceil(o / i),
-          limit: i
-        };
-      })
-    })
+        ),
+        /**
+         * Collects the results of a pagination query.
+         * **Note:** For collect to work, paginate() must be called before collect() and the selection must include a `count`.
+         * @returns The paginated list of queried items.
+         */
+        collect: () => s.throwOnError().then((e) => {
+          const { data: r, count: a } = e, { page: n, limit: i, ...c } = l.defined(t.pagination, "Pagination context is required for collect(). Make sure to call paginate() before collect()"), o = a ?? c.count;
+          return l(i > 0, "Page limit must be > 0"), l(Array.isArray(r), "Data must be an array for pagination, make sure to select multiple rows in query"), l(o !== void 0, "Row count is required for pagination, make sure to count in query or pass `count` in paginate()"), {
+            items: r,
+            totalItems: o,
+            page: n,
+            totalPages: Math.ceil(o / i),
+            limit: i
+          };
+        })
+      }
+    )
   }
 };
 class F {
@@ -353,7 +359,7 @@ class F {
     this.database = t, this.schema = e, this.relation = r;
   }
   recordNotFoundError(t) {
-    return new $(`Record with id ${t} not found in ${this.schema}.${this.relation}`, {
+    return new _(`Record with id ${t} not found in ${this.schema}.${this.relation}`, {
       schema: this.schema,
       relation: this.relation,
       id: t
@@ -512,24 +518,18 @@ class U extends F {
     });
   }
 }
-function X(s) {
+function Y(s) {
   if (s.error)
     throw s.error;
   return l(s.count !== null, "Response does not contain a count. Make sure to set the `count` option in the request."), s;
 }
-class Y {
+class B {
   supabase;
   constructor({ supabase: t }) {
     this.supabase = t;
   }
-  get schema() {
-    return this.supabase.schema.bind(this.supabase);
-  }
-  get rpc() {
-    return this.supabase.rpc.bind(this.supabase);
-  }
-  get from() {
-    return this.supabase.from.bind(this.supabase);
+  schema(t) {
+    return this.supabase.schema(t);
   }
   relation(t, e) {
     return new F({
@@ -553,7 +553,8 @@ class Y {
     });
   }
 }
-class K {
+const K = B;
+class tt {
   preprocesses = [];
   storage;
   constructor({
@@ -631,7 +632,7 @@ class K {
     )).filter((n) => n !== null);
   }
 }
-const tt = {
+const et = {
   removeImagesFromMarkdown: {
     name: "removeImagesFromMarkdown",
     run(s, t) {
@@ -653,7 +654,7 @@ const tt = {
     }
   }
 };
-class et {
+class rt {
   client;
   database;
   constructor({
@@ -742,7 +743,7 @@ class et {
     const { fileId: e, bucket: r, path: a, properties: n } = await this.getFileInfo(t), { data: i, error: c } = await this.client.from(r).download(a);
     if (c)
       throw c;
-    const [, o] = A(a);
+    const [, o] = M(a);
     return {
       fileId: e,
       bucket: r,
@@ -775,35 +776,35 @@ class et {
 }
 export {
   F as DataService,
-  Y as DatabaseService,
-  K as EmbeddingService,
+  K as DatabaseService,
+  tt as EmbeddingService,
   E as FileNotFoundError,
-  Q as Filter,
+  X as Filter,
   O as FilterChainSeparator,
   v as FilterOp,
-  H as LogicalOp,
-  J as LogicalOpSeparator,
+  J as LogicalOp,
+  Q as LogicalOpSeparator,
   x as ParseError,
-  _ as PostgrestErrorInterface,
-  $ as RecordNotFoundError,
-  et as StorageService,
+  $ as PostgrestErrorInterface,
+  _ as RecordNotFoundError,
+  rt as StorageService,
   C as TableDataService,
   k as TracedError,
   I as UnsupportedMimeError,
   U as ViewDataService,
-  X as assertCounted,
-  D as coerceArray,
-  L as encodeFilter,
+  Y as assertCounted,
+  A as coerceArray,
+  D as encodeFilter,
   q as encodeFilterNode,
   W as entries,
   z as groupBy,
-  G as isDatabaseApiError,
+  H as isDatabaseApiError,
   N as negateFilterNode,
   j as negateOp,
   y as parseFilterExpression,
-  M as parseFilterExpressionChain,
+  L as parseFilterExpressionChain,
   w as postgrestExtensions,
-  tt as preprocessingSteps,
+  et as preprocessingSteps,
   T as removeElement,
-  A as splitPath
+  M as splitPath
 };

package/dist/postgrest-extensions.d.ts

@@ -1,8 +1,8 @@
 import { PostgrestClientOptions, PostgrestFilterBuilder, PostgrestQueryBuilder, UnstableGetResult } from '@supabase/postgrest-js';
 import { GenericSchema, GenericTable, GenericView } from './database';
-import { Filter } from './filter';
+import { FilterNode } from './filter';
 import { CountMethod, Select, SelectColumns, SelectOptions } from './select';
-import { ElementOf } from './utils';
+import { ElementOf, OmitFrom } from './utils';
 /**
  * Paginated list of items with pagination info.
  */
@@ -31,7 +31,7 @@ interface PostgrestFilterExtensionContext {
  * @example
  * const selection = supabase.schema('public').from('my_table').select('*', { count: 'exact' });
  * const {data, error} = await postgrestExtensions.filter.enable(selection)
- *     .apply({ key: 'name', op: 'eq', value: 'John' })
+ *     .filter({ key: 'name', op: 'eq', value: 'John' })
  *     .paginate(1, 10)
  *     .collect();
  */
@@ -44,13 +44,13 @@ export declare const postgrestExtensions: {
      * @example
      * const table = supabase.schema('public').from('my_table');
      * const {data, error} = await postgrestExtensions.query.enable(table)
-     *     .selectColumns(['id', 'name'])
+     *     .select(['id', 'name'])
      *     .then(({data}) => console.log(data)); // [{ id: 1, name: 'John' }, ...]
      */
     readonly query: {
         readonly enable: <ClientOptions extends PostgrestClientOptions, Schema extends GenericSchema, Relation extends GenericTable | GenericView, RelationName = unknown, Relationships = Relation extends {
             Relationships: infer R;
-        } ? R : unknown>(builder: PostgrestQueryBuilder<ClientOptions, Schema, Relation, RelationName, Relationships>) => PostgrestQueryBuilder<ClientOptions, Schema, Relation, RelationName, Relationships> & {
+        } ? R : unknown>(builder: PostgrestQueryBuilder<ClientOptions, Schema, Relation, RelationName, Relationships>) => OmitFrom<PostgrestQueryBuilder<ClientOptions, Schema, Relation, RelationName, Relationships>, "select" | "delete"> & {
             /**
              * Selects columns from the relation.
              *
@@ -58,13 +58,13 @@ export declare const postgrestExtensions: {
              * @param options The options for the selection, such as count.
              * @returns The PostgREST filter builder with selection applied and filter extension enabled.
              */
-            select: <Columns extends SelectColumns<Relation["Row"]>>(columns: Columns, options?: SelectOptions) => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], Select<Relation["Row"], Columns>[], RelationName, Relationships, "GET"> & {
+            select: <Columns extends SelectColumns<Relation["Row"]>>(columns: Columns, options?: SelectOptions) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], Select<Relation["Row"], Columns>[], RelationName, Relationships, "GET">, "filter"> & {
                 /**
                  * Applies a filter to the query.
-                 * A filter is defined as an array of AST filter nodes including conditions and logical operators.
-                 * @param filter The filter to apply.
+                 * A filter is defined as an AST of filter nodes including conditions and logical operators.
+                 * @param node The filter to apply.
                  */
-                apply: <K extends string = string>(filter: Filter<K>) => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], Select<Relation["Row"], Columns>[], RelationName, Relationships, "GET"> & /*elided*/ any;
+                filter: <K extends string = string>(node: FilterNode<K>) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], Select<Relation["Row"], Columns>[], RelationName, Relationships, "GET">, "filter"> & /*elided*/ any;
                 /**
                  * Limits the range of results to a specific page given a page index and limit.
                  * @param page The page index (0-based).
@@ -72,7 +72,7 @@ export declare const postgrestExtensions: {
                  * @param count Optional count of total items, if known.
                  * If provided, it will be used to check if the pagination range is valid and resolve to an empty range if not.
                  */
-                paginate: (page: number, limit: number, count?: number) => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], Select<Relation["Row"], Columns>[], RelationName, Relationships, "GET"> & /*elided*/ any;
+                paginate: (page: number, limit: number, count?: number) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], Select<Relation["Row"], Columns>[], RelationName, Relationships, "GET">, "filter"> & /*elided*/ any;
                 /**
                  * Collects the results of a pagination query.
                  * **Note:** For collect to work, paginate() must be called before collect() and the selection must include a `count`.
@@ -87,13 +87,13 @@ export declare const postgrestExtensions: {
              * @param method The counting method to use, defaults to 'exact'.
              * @returns The PostgREST filter builder with counting applied and filter extension enabled.
              */
-            count: (method?: CountMethod) => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], UnstableGetResult<Schema, Relation["Row"], RelationName, Relationships, "*", ClientOptions>[], RelationName, Relationships, "GET"> & {
+            count: (method?: CountMethod) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], UnstableGetResult<Schema, Relation["Row"], RelationName, Relationships, "*", ClientOptions>[], RelationName, Relationships, "GET">, "filter"> & {
                 /**
                  * Applies a filter to the query.
-                 * A filter is defined as an array of AST filter nodes including conditions and logical operators.
-                 * @param filter The filter to apply.
+                 * A filter is defined as an AST of filter nodes including conditions and logical operators.
+                 * @param node The filter to apply.
                  */
-                apply: <K extends string = string>(filter: Filter<K>) => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], UnstableGetResult<Schema, Relation["Row"], RelationName, Relationships, "*", ClientOptions>[], RelationName, Relationships, "GET"> & /*elided*/ any;
+                filter: <K extends string = string>(node: FilterNode<K>) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], UnstableGetResult<Schema, Relation["Row"], RelationName, Relationships, "*", ClientOptions>[], RelationName, Relationships, "GET">, "filter"> & /*elided*/ any;
                 /**
                  * Limits the range of results to a specific page given a page index and limit.
                  * @param page The page index (0-based).
@@ -101,7 +101,7 @@ export declare const postgrestExtensions: {
                  * @param count Optional count of total items, if known.
                  * If provided, it will be used to check if the pagination range is valid and resolve to an empty range if not.
                  */
-                paginate: (page: number, limit: number, count?: number) => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], UnstableGetResult<Schema, Relation["Row"], RelationName, Relationships, "*", ClientOptions>[], RelationName, Relationships, "GET"> & /*elided*/ any;
+                paginate: (page: number, limit: number, count?: number) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], UnstableGetResult<Schema, Relation["Row"], RelationName, Relationships, "*", ClientOptions>[], RelationName, Relationships, "GET">, "filter"> & /*elided*/ any;
                 /**
                  * Collects the results of a pagination query.
                  * **Note:** For collect to work, paginate() must be called before collect() and the selection must include a `count`.
@@ -115,13 +115,13 @@ export declare const postgrestExtensions: {
              *
              * @returns The PostgREST filter builder with delete applied and filter extension enabled.
              */
-            delete: () => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "DELETE"> & {
+            delete: () => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "DELETE">, "filter"> & {
                 /**
                  * Applies a filter to the query.
-                 * A filter is defined as an array of AST filter nodes including conditions and logical operators.
-                 * @param filter The filter to apply.
+                 * A filter is defined as an AST of filter nodes including conditions and logical operators.
+                 * @param node The filter to apply.
                  */
-                apply: <K extends string = string>(filter: Filter<K>) => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "DELETE"> & /*elided*/ any;
+                filter: <K extends string = string>(node: FilterNode<K>) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "DELETE">, "filter"> & /*elided*/ any;
                 /**
                  * Limits the range of results to a specific page given a page index and limit.
                  * @param page The page index (0-based).
@@ -129,7 +129,7 @@ export declare const postgrestExtensions: {
                  * @param count Optional count of total items, if known.
                  * If provided, it will be used to check if the pagination range is valid and resolve to an empty range if not.
                  */
-                paginate: (page: number, limit: number, count?: number) => PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "DELETE"> & /*elided*/ any;
+                paginate: (page: number, limit: number, count?: number) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Relation["Row"], null, RelationName, Relationships, "DELETE">, "filter"> & /*elided*/ any;
                 /**
                  * Collects the results of a pagination query.
                  * **Note:** For collect to work, paginate() must be called before collect() and the selection must include a `count`.
@@ -147,18 +147,18 @@ export declare const postgrestExtensions: {
      * @example
      * const selection = supabase.schema('public').from('my_table').select('*', { count: 'exact' });
      * const {data, error} = await postgrestExtensions.filter.enable(selection)
-     *     .apply({ key: 'name', op: 'eq', value: 'John' })
+     *     .filter({ key: 'name', op: 'eq', value: 'John' })
      *     .paginate(1, 10)
      *     .collect();
      */
     readonly filter: {
-        readonly enable: <ClientOptions extends PostgrestClientOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, Result, RelationName = unknown, Relationships = unknown, Method = unknown>(builder: PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method>, context?: PostgrestFilterExtensionContext) => PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method> & {
+        readonly enable: <ClientOptions extends PostgrestClientOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, Result, RelationName = unknown, Relationships = unknown, Method = unknown>(builder: PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method>, context?: PostgrestFilterExtensionContext) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method>, "filter"> & {
             /**
              * Applies a filter to the query.
-             * A filter is defined as an array of AST filter nodes including conditions and logical operators.
-             * @param filter The filter to apply.
+             * A filter is defined as an AST of filter nodes including conditions and logical operators.
+             * @param node The filter to apply.
              */
-            apply: <K extends string = string>(filter: Filter<K>) => PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method> & /*elided*/ any;
+            filter: <K extends string = string>(node: FilterNode<K>) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method>, "filter"> & /*elided*/ any;
             /**
              * Limits the range of results to a specific page given a page index and limit.
              * @param page The page index (0-based).
@@ -166,7 +166,7 @@ export declare const postgrestExtensions: {
              * @param count Optional count of total items, if known.
              * If provided, it will be used to check if the pagination range is valid and resolve to an empty range if not.
              */
-            paginate: (page: number, limit: number, count?: number) => PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method> & /*elided*/ any;
+            paginate: (page: number, limit: number, count?: number) => OmitFrom<PostgrestFilterBuilder<ClientOptions, Schema, Row, Result, RelationName, Relationships, Method>, "filter"> & /*elided*/ any;
             /**
              * Collects the results of a pagination query.
              * **Note:** For collect to work, paginate() must be called before collect() and the selection must include a `count`.

package/dist/postgrest-extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgrest-extensions.d.ts","sourceRoot":"","sources":["../lib/postgrest-extensions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,qBAAqB,EAA4B,MAAM,wBAAwB,CAAC;AAE9I,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAc,MAAM,UAAU,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGzC;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,IAAI;IAC/B,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,UAAU,+BAA+B;IACrC,UAAU,CAAC,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACL;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;IAC5B;;;;;;;;;;OAUG;;0BAGK,aAAa,SAAS,sBAAsB,EAC5C,MAAM,SAAS,aAAa,EAC5B,QAAQ,SAAS,YAAY,GAAG,WAAW,EAC3C,YAAY,YACZ,aAAa;2BAAqC,MAAM,CAAC;kCAEhD,qBAAqB,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,aAAa,CAAC;YAE5F;;;;;;eAMG;qBAEC,OAAO,SAAS,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,WACvC,OAAO,YAAY,aAAa;gBA2D3C;;;;mBAIG;wBACK,CAAC,SAAS,MAAM;gBAgCxB;;;;;;mBAMG;iCACc,MAAM,SAAS,MAAM,UAAU,MAAM;gBA8BtD;;;;mBAIG;;;YA/HH;;;;;;eAMG;6BACa,WAAW;gBA0C3B;;;;mBAIG;wBACK,CAAC,SAAS,MAAM;gBAgCxB;;;;;;mBAMG;iCACc,MAAM,SAAS,MAAM,UAAU,MAAM;gBA8BtD;;;;mBAIG;;;YApHH;;;;;eAKG;;gBAiCH;;;;mBAIG;wBACK,CAAC,SAAS,MAAM;gBAgCxB;;;;;;mBAMG;iCACc,MAAM,SAAS,MAAM,UAAU,MAAM;gBA8BtD;;;;mBAIG;;;;;IAxGX;;;;;;;;;;;OAWG;;0BAGK,aAAa,SAAS,sBAAsB,EAC5C,MAAM,SAAS,aAAa,EAC5B,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,MAAM,EACN,YAAY,YACZ,aAAa,YACb,MAAM,qBAEG,sBAAsB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,CAAC,YAC/F,+BAA+B;YAGxC;;;;eAIG;oBACK,CAAC,SAAS,MAAM,mBAAmB,MAAM,CAAC,CAAC,CAAC;YAgCpD;;;;;;eAMG;6BACc,MAAM,SAAS,MAAM,UAAU,MAAM;YA8BtD;;;;eAIG;;;;CAoBL,CAAC"}
+{"version":3,"file":"postgrest-extensions.d.ts","sourceRoot":"","sources":["../lib/postgrest-extensions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,qBAAqB,EAA4B,MAAM,wBAAwB,CAAC;AAE9I,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClF,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnD;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,IAAI;IAC/B,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,UAAU,+BAA+B;IACrC,UAAU,CAAC,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACL;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;IAC5B;;;;;;;;;;OAUG;;0BAGK,aAAa,SAAS,sBAAsB,EAC5C,MAAM,SAAS,aAAa,EAC5B,QAAQ,SAAS,YAAY,GAAG,WAAW,EAC3C,YAAY,YACZ,aAAa;2BAAqC,MAAM,CAAC;kCAEhD,qBAAqB,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,aAAa,CAAC;YAIxF;;;;;;eAMG;qBAEC,OAAO,SAAS,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,WACvC,OAAO,YAAY,aAAa;gBA8D3C;;;;mBAIG;yBACM,CAAC,SAAS,MAAM;gBAgCzB;;;;;;mBAMG;iCACc,MAAM,SAAS,MAAM,UAAU,MAAM;gBA8BtD;;;;mBAIG;;;YAlIH;;;;;;eAMG;6BACa,WAAW;gBA6C3B;;;;mBAIG;yBACM,CAAC,SAAS,MAAM;gBAgCzB;;;;;;mBAMG;iCACc,MAAM,SAAS,MAAM,UAAU,MAAM;gBA8BtD;;;;mBAIG;;;YAvHH;;;;;eAKG;;gBAoCH;;;;mBAIG;yBACM,CAAC,SAAS,MAAM;gBAgCzB;;;;;;mBAMG;iCACc,MAAM,SAAS,MAAM,UAAU,MAAM;gBA8BtD;;;;mBAIG;;;;;IA1Gf;;;;;;;;;;;OAWG;;0BAGK,aAAa,SAAS,sBAAsB,EAC5C,MAAM,SAAS,aAAa,EAC5B,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,MAAM,EACN,YAAY,YACZ,aAAa,YACb,MAAM,qBAEG,sBAAsB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,CAAC,YAC/F,+BAA+B;YAKpC;;;;eAIG;qBACM,CAAC,SAAS,MAAM,iBAAiB,UAAU,CAAC,CAAC,CAAC;YAgCvD;;;;;;eAMG;6BACc,MAAM,SAAS,MAAM,UAAU,MAAM;YA8BtD;;;;eAIG;;;;CAqBT,CAAC"}

package/package.json

@@ -3,7 +3,7 @@
     "private": false,
     "displayName": "Supabase-Core",
     "description": "Lightweight services for supabase to make it easier to work with databases, tables and storage buckets",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "type": "module",
     "repository": {
         "type": "git",