@freehour/supabase-core 1.3.0 → 1.4.0

package/dist/index.js

@@ -1,13 +1,14 @@
 import { assert as l } from "@freehour/assert";
-import m from "zod";
-import { PostgrestError as P } from "@supabase/supabase-js";
-import { Mime as S } from "@freehour/mime";
-class k extends Error {
+import f from "zod";
+import { PostgrestError as j } from "@supabase/supabase-js";
+import * as $ from "@supabase/postgrest-js";
+import { Mime as _ } from "@freehour/mime";
+class E extends Error {
   constructor(t, e = {}) {
     super(t, e), this.name = this.constructor.name, Error.captureStackTrace(this, this.constructor);
   }
 }
-class E extends k {
+class x extends E {
   /**
    * The ID of the file that was not found.
    */
@@ -23,12 +24,12 @@ class E extends k {
   constructor(t, {
     fileId: e,
     bucket: r,
-    path: a
+    path: n
   } = {}) {
-    super(t), this.fileId = e, this.bucket = r, this.path = a;
+    super(t), this.fileId = e, this.bucket = r, this.path = n;
   }
 }
-class x extends k {
+class S extends E {
   /**
    * The encountered expression that could not be parsed.
    */
@@ -40,12 +41,12 @@ class x extends k {
   constructor(t, {
     expression: e,
     format: r,
-    ...a
+    ...n
   } = {}) {
-    super(t, a), this.expression = e, this.format = r;
+    super(t, n), this.expression = e, this.format = r;
   }
 }
-class _ extends k {
+class N extends E {
   /**
    * The schema where the record was expected to be found.
    */
@@ -61,12 +62,12 @@ class _ extends k {
   constructor(t, {
     schema: e,
     relation: r,
-    id: a
+    id: n
   } = {}) {
-    super(t), this.schema = e, this.relation = r, this.id = a;
+    super(t), this.schema = e, this.relation = r, this.id = n;
   }
 }
-class I extends Error {
+class P extends Error {
   /**
    * The MIME type that is unsupported.
    */
@@ -78,270 +79,42 @@ class I extends Error {
   constructor(t, {
     value: e,
     supported: r,
-    ...a
+    ...n
   } = {}) {
-    super(t, a), this.value = e, this.supported = r;
+    super(t, n), this.value = e, this.supported = r;
   }
 }
-const $ = m.object({
-  code: m.string(),
-  details: m.string().nullable(),
-  hint: m.string().nullable(),
-  name: m.string().optional(),
-  message: m.string().optional()
+const D = f.object({
+  code: f.string(),
+  details: f.string().nullable(),
+  hint: f.string().nullable(),
+  name: f.string().optional(),
+  message: f.string().optional()
 });
-function H(s) {
-  return s instanceof P || $.safeParse(s).success;
+function J(s) {
+  return s instanceof j || D.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"], 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 L(a, r, e);
-    } catch (i) {
-      return n.addIssue({
-        code: "custom",
-        input: a,
-        message: i instanceof Error ? i.message : void 0,
-        params: i instanceof x ? {
-          expression: i.expression,
-          format: i.format
-        } : void 0
-      }), [];
-    }
-  });
-};
-function j(s) {
-  return s.startsWith("not.") ? s.slice(4) : `not.${s}`;
-}
-function N(s) {
-  return {
-    ...s,
-    op: j(s.op)
-  };
-}
-function q(s, t = (e) => e) {
-  if (s.type === "logical") {
-    const e = s.args.map((r) => q(r, t));
-    return `${s.op}(${e})`;
-  }
-  return `${t(s.key)}.${s.op}.${s.value}`;
-}
-function D(s, t = (r) => r, e = O) {
-  return s.map((r) => q(r, t)).join(e);
-}
-function y(s, t = [], e = (r) => r) {
-  function r(u) {
-    const p = [];
-    let b = 0, f = "";
-    for (const g of u)
-      g === "(" ? (b++, f += g) : g === ")" ? (b--, f += g) : g === "," && b === 0 ? (p.push(f.trim()), f = "") : f += g;
-    return f && p.push(f.trim()), p;
-  }
-  if (s.endsWith(")")) {
-    if (s.startsWith("and("))
-      return {
-        type: "logical",
-        op: "and",
-        args: r(s.slice(4, -1)).map((u) => y(u, t, e))
-      };
-    if (s.startsWith("or("))
-      return {
-        type: "logical",
-        op: "or",
-        args: r(s.slice(3, -1)).map((u) => y(u, t, e))
-      };
-    if (s.startsWith("not.and("))
-      return {
-        type: "logical",
-        op: "not.and",
-        args: r(s.slice(8, -1)).map((u) => y(u, t, e))
-      };
-    if (s.startsWith("not.or("))
-      return {
-        type: "logical",
-        op: "not.or",
-        args: r(s.slice(7, -1)).map((u) => y(u, t, e))
-      };
-  }
-  const n = `^(${t.length === 0 ? "[a-zA-Z_][a-zA-Z0-9_]*" : t.join("|")})\\.((?:not\\.)?(?:${v.join("|")}))\\.(.+)$`, c = new RegExp(n).exec(s);
-  if (!c)
-    throw new x(`Invalid filter expression '${s}'`, {
-      expression: s,
-      format: {
-        syntax: "key.(not.)op.value",
-        keys: t.length === 0 ? "*" : t,
-        operators: v
-      }
-    });
-  const [, o, h, d] = c;
-  return {
-    type: "condition",
-    key: e(o),
-    op: h,
-    value: l.defined(d)
-  };
-}
-function L(s, t = [], e = (a) => a, r = O) {
-  return s.length === 0 ? [] : s.split(r).map((a) => y(a, t, e));
-}
-function M(s, t = "/") {
+function L(s, t = "/") {
   const e = s.lastIndexOf(t);
   return e === -1 ? ["", s] : [s.substring(0, e), s.substring(e + 1)];
 }
-function A(s) {
+function F(s) {
   return Array.isArray(s) ? s : [s];
 }
-function z(s, t) {
+function M(s, t) {
   return s.reduce((e, r) => {
-    const a = t(r);
-    return (e[a] ??= []).push(r), e;
+    const n = t(r);
+    return (e[n] ??= []).push(r), e;
   }, {});
 }
-function T(s, t) {
+function A(s, t) {
   const e = s.findIndex(t);
   return e !== -1 && s.splice(e, 1), s;
 }
-function W(s) {
+function z(s) {
   return Object.entries(s);
 }
-const w = {
-  /**
-   * Query extension for PostgREST queries.
-   * Supports typesafe column selection and counting.
-   * This extension can be used with any PostgREST query builder.
-   *
-   * @example
-   * const table = supabase.schema('public').from('my_table');
-   * const {data, error} = await postgrestExtensions.query.enable(table)
-   *     .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(
-            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()
-        )
-      }
-    )
-  },
-  /**
-   * Filter extension for PostgREST queries.
-   * Supports applying filters, pagination and collecting results.
-   * This extension can be used with any PostgREST filter builder.
-   *
-   * @example
-   * const selection = supabase.schema('public').from('my_table').select('*', { count: 'exact' });
-   * const {data, error} = await postgrestExtensions.filter.enable(selection)
-   *     .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 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
-            }
-          }
-        ),
-        /**
-         * 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 {
+class v {
   database;
   /**
    * The name of the schema containing the view.
@@ -359,7 +132,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 N(`Record with id ${t} not found in ${this.schema}.${this.relation}`, {
       schema: this.schema,
       relation: this.relation,
       id: t
@@ -372,8 +145,7 @@ class F {
    * const { data, error } = await dataService.query.select('*');
    */
   get query() {
-    const t = this.database.schema(this.schema).from(this.relation);
-    return w.query.enable(t);
+    return this.database.schema(this.schema).from(this.relation);
   }
   /**
    * Performs a fuzzy search on the specified column of the relation.
@@ -384,17 +156,17 @@ class F {
     column: t,
     searchTerm: e = "",
     minSimilarity: r = 0,
-    limit: a = 64
+    limit: n = 64
   }) {
-    const { data: n } = await this.database.schema("core").rpc("fuzzy_search", {
+    const { data: i } = await this.database.schema("core").rpc("fuzzy_search", {
       relation: this.relation,
       schema_name: this.schema,
       column_name: t,
       search_term: e,
       min_similarity: r,
-      limit_results: a
+      limit_results: n
     }).throwOnError();
-    return n;
+    return i;
   }
   /**
    * List all rows in the relation.
@@ -473,11 +245,11 @@ class F {
     onConflict: e,
     ...r
   } = {}) {
-    const { data: a } = await this.query.upsert(t, {
-      onConflict: e?.join(","),
+    const { data: n } = await this.query.upsert(t, {
+      onConflict: e !== void 0 ? F(e).join(",") : void 0,
       ...r
     }).select().single().throwOnError();
-    return a;
+    return n;
   }
   /**
    * Updates an existing row in the relation by its ID.
@@ -492,7 +264,7 @@ class F {
     return r;
   }
 }
-class C extends F {
+class B extends v {
   constructor({
     database: t,
     schema: e,
@@ -505,7 +277,7 @@ class C extends F {
     });
   }
 }
-class U extends F {
+class C extends v {
   constructor({
     database: t,
     schema: e,
@@ -518,43 +290,265 @@ class U extends F {
     });
   }
 }
-function Y(s) {
+function X(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 B {
+const O = ["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"], Y = ["and", "or"], K = ",", q = "~", tt = (s) => (t = {}) => {
+  const e = (n) => t[n] ?? n, r = Object.keys(s.shape);
+  return f.string().transform((n, i) => {
+    try {
+      return W(n, r, e);
+    } catch (a) {
+      return i.addIssue({
+        code: "custom",
+        input: n,
+        message: a instanceof Error ? a.message : void 0,
+        params: a instanceof S ? {
+          expression: a.expression,
+          format: a.format
+        } : void 0
+      }), [];
+    }
+  });
+};
+function T(s) {
+  return s.startsWith("not.") ? s.slice(4) : `not.${s}`;
+}
+function et(s) {
+  return {
+    ...s,
+    op: T(s.op)
+  };
+}
+function I(s, t = (e) => e) {
+  if (s.type === "logical") {
+    const e = s.args.map((r) => I(r, t));
+    return `${s.op}(${e})`;
+  }
+  return `${t(s.key)}.${s.op}.${s.value}`;
+}
+function rt(s, t = (r) => r, e = q) {
+  return s.map((r) => I(r, t)).join(e);
+}
+function k(s, t = [], e = (r) => r) {
+  function r(u) {
+    const g = [];
+    let b = 0, w = "", y = !1;
+    for (const p of u)
+      p === '"' ? (y = !y, w += p) : p === "(" && !y ? (b++, w += p) : p === ")" && !y ? (b--, w += p) : p === "," && b === 0 && !y ? (g.push(w.trim()), w = "") : w += p;
+    return g;
+  }
+  if (s.endsWith(")")) {
+    if (s.startsWith("and("))
+      return {
+        type: "logical",
+        op: "and",
+        args: r(s.slice(4, -1)).map((u) => k(u, t, e))
+      };
+    if (s.startsWith("or("))
+      return {
+        type: "logical",
+        op: "or",
+        args: r(s.slice(3, -1)).map((u) => k(u, t, e))
+      };
+    if (s.startsWith("not.and("))
+      return {
+        type: "logical",
+        op: "not.and",
+        args: r(s.slice(8, -1)).map((u) => k(u, t, e))
+      };
+    if (s.startsWith("not.or("))
+      return {
+        type: "logical",
+        op: "not.or",
+        args: r(s.slice(7, -1)).map((u) => k(u, t, e))
+      };
+  }
+  const i = `^(${t.length === 0 ? "[a-zA-Z_][a-zA-Z0-9_]*" : t.join("|")})\\.((?:not\\.)?(?:${O.join("|")}))\\.(.+)$`, c = new RegExp(i).exec(s);
+  if (!c)
+    throw new S(`Invalid filter expression '${s}'`, {
+      expression: s,
+      format: {
+        syntax: "key.(not.)op.value",
+        keys: t.length === 0 ? "*" : t,
+        operators: O
+      }
+    });
+  const [, o, d, m] = c;
+  return {
+    type: "condition",
+    key: e(o),
+    op: d,
+    value: l.defined(m)
+  };
+}
+function W(s, t = [], e = (n) => n, r = q) {
+  return s.length === 0 ? [] : s.split(r).map((n) => k(n, t, e));
+}
+class h extends $.PostgrestFilterBuilder {
+  pagination;
+  constructor(t) {
+    super(t);
+  }
+  select(t = "*") {
+    const e = super.select(
+      F(t).join(",")
+    );
+    return new h(e);
+  }
+  /**
+   * Applies a filter to the query.
+   * A filter is defined as an AST of filter nodes including conditions and logical operators.
+   * @param filter The filter to apply.
+   */
+  where(t) {
+    if (t.type === "logical") {
+      const e = t.args.map((r) => I(r)).join(",");
+      this.url.searchParams.append(t.op, `(${e})`);
+    } else
+      this.url.searchParams.append(t.key, `${t.op}.${t.value}`);
+    return this;
+  }
+  /**
+   * 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(t, e, r) {
+    l(t >= 0, "Page index must be ≥ 0"), l(e >= 0, "Page limit must be ≥ 0");
+    const n = t * e, i = n + e - 1;
+    if (r !== void 0) {
+      if (n >= r)
+        return this.limit(0);
+      if (i >= r)
+        return this.range(n, r - 1);
+    }
+    return this.pagination = {
+      ...this.pagination,
+      page: t,
+      limit: e,
+      count: r
+    }, this.range(n, 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() {
+    return this.then(({ data: t, count: e, error: r, ...n }) => {
+      if (r)
+        return { data: t, count: e, error: r, ...n };
+      const { page: i, limit: a, ...c } = l.defined(this.pagination, "Pagination is required for collect(). Make sure to call paginate() before collect()"), o = e ?? c.count;
+      return l(a > 0, "Page limit must be > 0"), l(Array.isArray(t), "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()"), {
+        data: {
+          items: t,
+          totalItems: o,
+          page: i,
+          totalPages: Math.ceil(o / a),
+          limit: a
+        },
+        error: r,
+        count: e,
+        ...n
+      };
+    });
+  }
+}
+class U extends $.PostgrestQueryBuilder {
+  constructor(t) {
+    super(t.url, t);
+  }
+  select(t = "*", e) {
+    const r = super.select(
+      F(t).join(","),
+      e
+    );
+    return new h(r);
+  }
+  /**
+   * 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") {
+    const e = this.select("*", { count: t, head: !0 });
+    return new h(e);
+  }
+  insert(t, e) {
+    const r = super.insert(t, e);
+    return new h(r);
+  }
+  upsert(t, { onConflict: e, ...r } = {}) {
+    const n = super.upsert(t, {
+      onConflict: F(e).join(","),
+      ...r
+    });
+    return new h(n);
+  }
+  // @ts-expect-error the signatures are compatible but typescript can't verify it
+  update(t, e) {
+    const r = super.update(t, e);
+    return new h(r);
+  }
+  delete() {
+    const t = super.delete();
+    return new h(t);
+  }
+}
+class Q {
+  client;
+  constructor(t) {
+    this.client = t;
+  }
+  from(t) {
+    const e = this.client.from(t);
+    return new U(e);
+  }
+  rpc(t, e, r) {
+    const n = this.client.rpc(t, e, r);
+    return new h(n);
+  }
+}
+class R {
   supabase;
   constructor({ supabase: t }) {
     this.supabase = t;
   }
   schema(t) {
-    return this.supabase.schema(t);
+    const e = this.supabase.schema(t);
+    return new Q(e);
   }
   relation(t, e) {
-    return new F({
+    return new v({
       database: this,
       schema: t,
       relation: e
     });
   }
   table(t, e) {
-    return new C({
+    return new B({
       database: this,
       schema: t,
       table: e
     });
   }
   view(t, e) {
-    return new U({
+    return new C({
       database: this,
       schema: t,
       view: e
     });
   }
 }
-const K = B;
-class tt {
+const st = R;
+class nt {
   preprocesses = [];
   storage;
   constructor({
@@ -572,17 +566,17 @@ class tt {
    */
   async getOutdatedEmbeddings(t) {
     const e = [];
-    let r = !0, a;
+    let r = !0, n;
     for (; r; ) {
-      const { objects: n, ...i } = await this.storage.getFiles(t, { cursor: a }), c = await Promise.all(
-        n.map(async (o) => {
-          const h = new Date(o.updated_at), d = await this.storage.getFileStorageLocation({ fileId: o.id }), u = await this.getEmbeddings(d);
-          return u.length === 0 || u.some((p) => p.createdAt < h);
+      const { objects: i, ...a } = await this.storage.getFiles(t, { cursor: n }), c = await Promise.all(
+        i.map(async (o) => {
+          const d = new Date(o.updated_at), m = await this.storage.getFileStorageLocation({ fileId: o.id }), u = await this.getEmbeddings(m);
+          return u.length === 0 || u.some((g) => g.createdAt < d);
         })
       );
       e.push(
-        ...n.filter((o, h) => c[h]).map(({ id: o }) => ({ fileId: o }))
-      ), { hasNext: r, nextCursor: a } = i;
+        ...i.filter((o, d) => c[d]).map(({ id: o }) => ({ fileId: o }))
+      ), { hasNext: r, nextCursor: n } = a;
     }
     return e;
   }
@@ -595,50 +589,50 @@ class tt {
     return this.preprocesses.push(t), this;
   }
   removePreprocessingStep(t) {
-    return T(this.preprocesses, (e) => e.name === t), this;
+    return A(this.preprocesses, (e) => e.name === t), this;
   }
   async get(t) {
     const e = await this.storage.getFileStorageLocation(t);
     return this.getEmbeddings(e);
   }
   async ingest(t, e) {
-    const { file: r, ...a } = await this.storage.downloadFile(t), n = S.parse(r.type);
-    if (n.type !== "text")
-      throw new I(`Unsupported file type: ${n}. Only text files can be embedded.`);
-    await this.deleteEmbeddings(a);
-    const i = {
+    const { file: r, ...n } = await this.storage.downloadFile(t), i = _.parse(r.type);
+    if (i.type !== "text")
+      throw new P(`Unsupported file type: ${i}. Only text files can be embedded.`);
+    await this.deleteEmbeddings(n);
+    const a = {
       name: r.name,
       type: r.type,
       size: r.size,
-      ...a,
-      ...typeof e == "function" ? e(r, a) : e
-    }, c = this.preprocess(await r.text(), i);
-    return this.createEmbeddings(a, c, i);
+      ...n,
+      ...typeof e == "function" ? e(r, n) : e
+    }, c = this.preprocess(await r.text(), a);
+    return this.createEmbeddings(n, c, a);
   }
   async synchronize(t, e) {
     const r = await this.getOutdatedEmbeddings(t);
     return (await Promise.all(
       r.map(
-        async (n) => this.ingest(n, e).then(() => ({
-          file: n,
+        async (i) => this.ingest(i, e).then(() => ({
+          file: i,
           success: !0,
           error: null
-        })).catch((i) => i instanceof I ? null : {
-          file: n,
-          error: i,
+        })).catch((a) => a instanceof P ? null : {
+          file: i,
+          error: a,
           success: !1
         })
       )
-    )).filter((n) => n !== null);
+    )).filter((i) => i !== null);
   }
 }
-const et = {
+const it = {
   removeImagesFromMarkdown: {
     name: "removeImagesFromMarkdown",
     run(s, t) {
       if (t.type === "text/markdown") {
         const e = /!\[([^\]]*)\]\([^)]*\)/g;
-        return s.replace(e, (r, a) => `![${a}]()`);
+        return s.replace(e, (r, n) => `![${n}]()`);
       }
       return s;
     }
@@ -648,13 +642,13 @@ const et = {
     run(s, t) {
       if (t.type === "text/markdown") {
         const e = /\[([^\]]*)\]\([^)]*\)/g;
-        return s.replace(e, (r, a) => `[${a}]()`);
+        return s.replace(e, (r, n) => `[${n}]()`);
       }
       return s;
     }
   }
 };
-class rt {
+class at {
   client;
   database;
   constructor({
@@ -667,38 +661,38 @@ class rt {
     return this.database.table("storage", "objects");
   }
   async getFileObject(t, e) {
-    const { data: r, error: a } = await this.client.from(t).info(e);
-    if (a)
-      throw a;
+    const { data: r, error: n } = await this.client.from(t).info(e);
+    if (n)
+      throw n;
     return r;
   }
   async getFiles(t, e) {
-    const { data: r, error: a } = await this.client.from(t).listV2(e);
-    if (a)
-      throw a;
+    const { data: r, error: n } = await this.client.from(t).listV2(e);
+    if (n)
+      throw n;
     return r;
   }
   async getFileStorageLocation(t) {
     if ("fileId" in t) {
-      const { fileId: n } = t, i = await this.files.get(n, ["bucket_id", "path_tokens"]);
-      if (!i)
-        throw new E(`File with ID ${n} not found`, { fileId: n });
+      const { fileId: i } = t, a = await this.files.get(i, ["bucket_id", "path_tokens"]);
+      if (!a)
+        throw new x(`File with ID ${i} not found`, { fileId: i });
       return {
-        fileId: n,
-        bucket: l.notNull(i.bucket_id, "bucket_id must not be null"),
-        path: l.notNull(i.path_tokens, "path_tokens must not be null").join("/")
+        fileId: i,
+        bucket: l.notNull(a.bucket_id, "bucket_id must not be null"),
+        path: l.notNull(a.path_tokens, "path_tokens must not be null").join("/")
       };
     }
-    const { bucket: e, path: r } = t, { id: a } = await this.getFileObject(e, r);
-    return { fileId: a, bucket: e, path: r };
+    const { bucket: e, path: r } = t, { id: n } = await this.getFileObject(e, r);
+    return { fileId: n, bucket: e, path: r };
   }
   async getFileInfo(t) {
-    const { fileId: e, bucket: r, path: a } = await this.getFileStorageLocation(t), { id: n, bucketId: i, metadata: c, ...o } = await this.getFileObject(r, a);
-    return l(n === e, "file ID from storage client must match file ID from database"), l(i === r, "bucketId from storage client must match bucket from database"), {
+    const { fileId: e, bucket: r, path: n } = await this.getFileStorageLocation(t), { id: i, bucketId: a, metadata: c, ...o } = await this.getFileObject(r, n);
+    return l(i === e, "file ID from storage client must match file ID from database"), l(a === r, "bucketId from storage client must match bucket from database"), {
       ...o,
       fileId: e,
       bucket: r,
-      path: a,
+      path: n,
       metadata: c,
       properties: c ? {
         type: c.mimetype,
@@ -707,104 +701,106 @@ class rt {
     };
   }
   async getPublicURL(t, e) {
-    const { bucket: r, path: a } = await this.getFileStorageLocation(t), { data: { publicUrl: n } } = this.client.from(r).getPublicUrl(a, e);
-    return n;
+    const { bucket: r, path: n } = await this.getFileStorageLocation(t), { data: { publicUrl: i } } = this.client.from(r).getPublicUrl(n, e);
+    return i;
   }
   async existsFile(t) {
-    const { bucket: e, path: r } = await this.getFileStorageLocation(t), { data: a, error: n } = await this.client.from(e).exists(r);
-    if (n)
-      throw n;
-    return a;
+    const { bucket: e, path: r } = await this.getFileStorageLocation(t), { data: n, error: i } = await this.client.from(e).exists(r);
+    if (i)
+      throw i;
+    return n;
   }
   async assertExistsFile(t) {
-    const { bucket: e, path: r } = await this.getFileStorageLocation(t), { data: a, error: n } = await this.client.from(e).exists(r);
-    if (n)
-      throw n;
-    if (!a)
-      throw new E(`File not found in bucket '${e}' at path '${r}'`, { bucket: e, path: r });
+    const { bucket: e, path: r } = await this.getFileStorageLocation(t), { data: n, error: i } = await this.client.from(e).exists(r);
+    if (i)
+      throw i;
+    if (!n)
+      throw new x(`File not found in bucket '${e}' at path '${r}'`, { bucket: e, path: r });
   }
-  async uploadFile(t, { bucket: e, path: r }, { overwriteExisting: a = !1 } = {}) {
-    const { data: n, error: i } = await this.client.from(e).upload(
+  async uploadFile(t, { bucket: e, path: r }, { overwriteExisting: n = !1 } = {}) {
+    const { data: i, error: a } = await this.client.from(e).upload(
       `${r}/${t.name}`,
       t,
       {
-        upsert: a
+        upsert: n
       }
     );
-    if (i)
-      throw i;
+    if (a)
+      throw a;
     return {
-      fileId: n.id,
+      fileId: i.id,
       bucket: e,
-      path: n.path
+      path: i.path
     };
   }
   async downloadFile(t) {
-    const { fileId: e, bucket: r, path: a, properties: n } = await this.getFileInfo(t), { data: i, error: c } = await this.client.from(r).download(a);
+    const { fileId: e, bucket: r, path: n, properties: i } = await this.getFileInfo(t), { data: a, error: c } = await this.client.from(r).download(n);
     if (c)
       throw c;
-    const [, o] = M(a);
+    const [, o] = L(n);
     return {
       fileId: e,
       bucket: r,
-      path: a,
-      file: new File([i], o, n)
+      path: n,
+      file: new File([a], o, i)
     };
   }
   async deleteFiles(t) {
-    const e = t.filter((o) => "fileId" in o).map((o) => o.fileId), a = (await this.files.query.select(["bucket_id", "path_tokens"]).containedBy("id", e).throwOnError()).data.map(({ bucket_id: o, path_tokens: h }) => ({
+    const e = t.filter((o) => "fileId" in o).map((o) => o.fileId), n = (await this.files.query.select(["bucket_id", "path_tokens"]).containedBy("id", e).throwOnError()).data.map(({ bucket_id: o, path_tokens: d }) => ({
       bucket: l.notNull(o, "bucket_id must not be null"),
-      path: l.notNull(h, "path_tokens must not be null").join("/")
-    })), n = t.filter((o) => "path" in o).concat(a), i = W(
-      z(n, (o) => o.bucket)
-    ).map(([o, h]) => ({
+      path: l.notNull(d, "path_tokens must not be null").join("/")
+    })), i = t.filter((o) => "path" in o).concat(n), a = z(
+      M(i, (o) => o.bucket)
+    ).map(([o, d]) => ({
       bucket: o,
-      paths: h.map((d) => d.path)
+      paths: d.map((m) => m.path)
     }));
-    return (await Promise.all(i.map(
-      async ({ bucket: o, paths: h }) => this.client.from(o).remove(h).then(({ data: d, error: u }) => {
+    return (await Promise.all(a.map(
+      async ({ bucket: o, paths: d }) => this.client.from(o).remove(d).then(({ data: m, error: u }) => {
         if (u)
           throw u;
-        return d.map((p, b) => ({
-          fileId: l.notNull(p.id, "file id must not be null"),
+        return m.map((g, b) => ({
+          fileId: l.notNull(g.id, "file id must not be null"),
           bucket: o,
-          path: l.defined(h[b], "path must not be null")
+          path: l.defined(d[b], "path must not be null")
         }));
       })
     ))).flat();
   }
 }
 export {
-  F as DataService,
-  K as DatabaseService,
-  tt as EmbeddingService,
-  E as FileNotFoundError,
-  X as Filter,
-  O as FilterChainSeparator,
-  v as FilterOp,
-  J as LogicalOp,
-  Q as LogicalOpSeparator,
-  x as ParseError,
-  $ as PostgrestErrorInterface,
-  _ as RecordNotFoundError,
-  rt as StorageService,
-  C as TableDataService,
-  k as TracedError,
-  I as UnsupportedMimeError,
-  U as ViewDataService,
-  Y as assertCounted,
-  A as coerceArray,
-  D as encodeFilter,
-  q as encodeFilterNode,
-  W as entries,
-  z as groupBy,
-  H as isDatabaseApiError,
-  N as negateFilterNode,
-  j as negateOp,
-  y as parseFilterExpression,
-  L as parseFilterExpressionChain,
-  w as postgrestExtensions,
-  et as preprocessingSteps,
-  T as removeElement,
-  M as splitPath
+  v as DataService,
+  st as DatabaseService,
+  nt as EmbeddingService,
+  x as FileNotFoundError,
+  tt as Filter,
+  q as FilterChainSeparator,
+  O as FilterOp,
+  Y as LogicalOp,
+  K as LogicalOpSeparator,
+  S as ParseError,
+  Q as PostgrestClient,
+  D as PostgrestErrorInterface,
+  h as PostgrestFilterBuilder,
+  U as PostgrestQueryBuilder,
+  N as RecordNotFoundError,
+  at as StorageService,
+  B as TableDataService,
+  E as TracedError,
+  P as UnsupportedMimeError,
+  C as ViewDataService,
+  X as assertCounted,
+  F as coerceArray,
+  rt as encodeFilter,
+  I as encodeFilterNode,
+  z as entries,
+  M as groupBy,
+  J as isDatabaseApiError,
+  et as negateFilterNode,
+  T as negateOp,
+  k as parseFilterExpression,
+  W as parseFilterExpressionChain,
+  it as preprocessingSteps,
+  A as removeElement,
+  L as splitPath
 };