@freehour/supabase-core 1.0.3 → 1.1.1

package/dist/index.js

@@ -1,6 +1,7 @@
-import { assert as o } from "@freehour/assert";
-import d from "zod";
-import { PostgrestError as _ } from "@supabase/supabase-js";
+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 {
   constructor(t, e = {}) {
     super(t, e), this.name = this.constructor.name, Error.captureStackTrace(this, this.constructor);
@@ -21,13 +22,13 @@ class E extends k {
   path;
   constructor(t, {
     fileId: e,
-    bucket: a,
-    path: n
+    bucket: r,
+    path: a
   } = {}) {
-    super(t), this.fileId = e, this.bucket = a, this.path = n;
+    super(t), this.fileId = e, this.bucket = r, this.path = a;
   }
 }
-class q extends k {
+class x extends k {
   /**
    * The encountered expression that could not be parsed.
    */
@@ -36,15 +37,15 @@ class q extends k {
    * Additional context about the expected format or structure.
    */
   format;
-  constructor(t = "Expression could not be parsed", {
+  constructor(t, {
     expression: e,
-    format: a,
-    ...n
+    format: r,
+    ...a
   } = {}) {
-    super(t, n), this.expression = e, this.format = a;
+    super(t, a), this.expression = e, this.format = r;
   }
 }
-class S extends k {
+class _ extends k {
   /**
    * The schema where the record was expected to be found.
    */
@@ -59,33 +60,50 @@ class S extends k {
   id;
   constructor(t, {
     schema: e,
-    relation: a,
-    id: n
+    relation: r,
+    id: a
+  } = {}) {
+    super(t), this.schema = e, this.relation = r, this.id = a;
+  }
+}
+class I extends Error {
+  /**
+   * The MIME type that is unsupported.
+   */
+  value;
+  /**
+   * The list of supported MIME types.
+   */
+  supported;
+  constructor(t, {
+    value: e,
+    supported: r,
+    ...a
   } = {}) {
-    super(t), this.schema = e, this.relation = a, this.id = n;
+    super(t, a), this.value = e, this.supported = r;
   }
 }
-const $ = d.object({
-  code: d.string(),
-  details: d.string().nullable(),
-  hint: d.string().nullable(),
-  name: d.string().optional(),
-  message: d.string().optional()
+const $ = m.object({
+  code: m.string(),
+  details: m.string().nullable(),
+  hint: m.string().nullable(),
+  name: m.string().optional(),
+  message: m.string().optional()
 });
-function V(r) {
-  return r instanceof _ || $.safeParse(r).success;
+function G(s) {
+  return s instanceof P || $.safeParse(s).success;
 }
-const I = ["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"], Z = ["and", "or"], G = ",", v = "~", H = (r) => (t = {}) => {
-  const e = (n) => t[n] ?? n, a = Object.keys(r.shape);
-  return d.string().transform((n, s) => {
+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 e = (a) => t[a] ?? a, r = Object.keys(s.shape);
+  return m.string().transform((a, n) => {
     try {
-      return A(n, a, e);
+      return M(a, r, e);
     } catch (i) {
-      return s.addIssue({
+      return n.addIssue({
         code: "custom",
-        input: n,
+        input: a,
         message: i instanceof Error ? i.message : void 0,
-        params: i instanceof q ? {
+        params: i instanceof x ? {
           expression: i.expression,
           format: i.format
         } : void 0
@@ -93,97 +111,101 @@ const I = ["eq", "neq", "gt", "gte", "lt", "lte", "like", "ilike", "match", "ima
     }
   });
 };
-function P(r) {
-  return r.startsWith("not.") ? r.slice(4) : `not.${r}`;
+function j(s) {
+  return s.startsWith("not.") ? s.slice(4) : `not.${s}`;
 }
-function N(r) {
+function N(s) {
   return {
-    ...r,
-    op: P(r.op)
+    ...s,
+    op: j(s.op)
   };
 }
-function x(r, t = (e) => e) {
-  if (r.type === "logical") {
-    const e = r.args.map((a) => x(a, t));
-    return `${r.op}(${e})`;
+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(r.key)}.${r.op}.${r.value}`;
+  return `${t(s.key)}.${s.op}.${s.value}`;
 }
-function j(r, t = (a) => a, e = v) {
-  return r.map((a) => x(a, t)).join(e);
+function L(s, t = (r) => r, e = O) {
+  return s.map((r) => q(r, t)).join(e);
 }
-function g(r, t = [], e = (a) => a) {
-  function a(l) {
-    const b = [];
-    let y = 0, h = "";
-    for (const f of l)
-      f === "(" ? (y++, h += f) : f === ")" ? (y--, h += f) : f === "," && y === 0 ? (b.push(h.trim()), h = "") : h += f;
-    return h && b.push(h.trim()), b;
-  }
-  if (r.endsWith(")")) {
-    if (r.startsWith("and("))
+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: a(r.slice(4, -1)).map((l) => g(l, t, e))
+        args: r(s.slice(4, -1)).map((u) => y(u, t, e))
       };
-    if (r.startsWith("or("))
+    if (s.startsWith("or("))
       return {
         type: "logical",
         op: "or",
-        args: a(r.slice(3, -1)).map((l) => g(l, t, e))
+        args: r(s.slice(3, -1)).map((u) => y(u, t, e))
       };
-    if (r.startsWith("not.and("))
+    if (s.startsWith("not.and("))
       return {
         type: "logical",
         op: "not.and",
-        args: a(r.slice(8, -1)).map((l) => g(l, t, e))
+        args: r(s.slice(8, -1)).map((u) => y(u, t, e))
       };
-    if (r.startsWith("not.or("))
+    if (s.startsWith("not.or("))
       return {
         type: "logical",
         op: "not.or",
-        args: a(r.slice(7, -1)).map((l) => g(l, t, e))
+        args: r(s.slice(7, -1)).map((u) => y(u, t, e))
       };
   }
-  const s = `^(${t.length === 0 ? "[a-zA-Z_][a-zA-Z0-9_]*" : t.join("|")})\\.((?:not\\.)?(?:${I.join("|")}))\\.(.+)$`, c = new RegExp(s).exec(r);
+  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 q(`Invalid filter expression '${r}'`, {
-      expression: r,
+    throw new x(`Invalid filter expression '${s}'`, {
+      expression: s,
       format: {
         syntax: "key.(not.)op.value",
         keys: t.length === 0 ? "*" : t,
-        operators: I
+        operators: v
       }
     });
-  const [, u, m, w] = c;
+  const [, o, h, d] = c;
   return {
     type: "condition",
-    key: e(u),
-    op: m,
-    value: o.defined(w)
+    key: e(o),
+    op: h,
+    value: l.defined(d)
   };
 }
-function A(r, t = [], e = (n) => n, a = v) {
-  return r.length === 0 ? [] : r.split(a).map((n) => g(n, t, e));
+function M(s, t = [], e = (a) => a, r = O) {
+  return s.length === 0 ? [] : s.split(r).map((a) => y(a, t, e));
 }
-function D(r, t = "/") {
-  const e = r.lastIndexOf(t);
-  return e === -1 ? ["", r] : [r.substring(0, e), r.substring(e + 1)];
+function A(s, t = "/") {
+  const e = s.lastIndexOf(t);
+  return e === -1 ? ["", s] : [s.substring(0, e), s.substring(e + 1)];
 }
-function O(r) {
-  return Array.isArray(r) ? r : [r];
+function D(s) {
+  return Array.isArray(s) ? s : [s];
 }
-function z(r, t) {
-  return r.reduce((e, a) => {
-    const n = t(a);
-    return (e[n] ??= []).push(a), e;
+function z(s, t) {
+  return s.reduce((e, r) => {
+    const a = t(r);
+    return (e[a] ??= []).push(r), e;
   }, {});
 }
-function T(r) {
-  return Object.entries(r);
+function T(s, t) {
+  const e = s.findIndex(t);
+  return e !== -1 && s.splice(e, 1), s;
 }
-const p = {
+function W(s) {
+  return Object.entries(s);
+}
+const w = {
   /**
    * Query extension for PostgREST queries.
    * Supports typesafe column selection and counting.
@@ -196,7 +218,7 @@ const p = {
    *     .then(({data}) => console.log(data)); // [{ id: 1, name: 'John' }, ...]
    */
   query: {
-    enable: (r) => Object.assign(r, {
+    enable: (s) => Object.assign(s, {
       /**
        * Selects columns from the relation.
        *
@@ -204,9 +226,9 @@ const p = {
        * @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) => p.filter.enable(
-        r.select(
-          O(t).join(","),
+      select: (t, e) => w.filter.enable(
+        s.select(
+          D(t).join(","),
           e
         )
       ),
@@ -217,8 +239,8 @@ const p = {
        * @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") => p.filter.enable(
-        r.select("*", { count: t, head: !0 })
+      count: (t = "exact") => w.filter.enable(
+        s.select("*", { count: t, head: !0 })
       ),
       /**
        * Deletes rows from the relation.
@@ -226,8 +248,8 @@ const p = {
        *
        * @returns The PostgREST filter builder with delete applied and filter extension enabled.
        */
-      delete: () => p.filter.enable(
-        r.delete()
+      delete: () => w.filter.enable(
+        s.delete()
       )
     })
   },
@@ -244,26 +266,26 @@ const p = {
    *     .collect();
    */
   filter: {
-    enable: (r, t = {}) => Object.assign(r, {
+    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) => p.filter.enable(
+      apply: (e) => w.filter.enable(
         (() => {
-          function a(n, s) {
-            if (s.type === "logical") {
-              const i = j(s.args, (c) => c, ",");
-              return s.op === "or" ? n.or(i) : s.op === "not.or" ? n.or(i, { referencedTable: "not" }) : a(n, {
+          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: s.op === "and" ? "not.or" : "or",
-                args: s.args.map(N)
+                op: n.op === "and" ? "not.or" : "or",
+                args: n.args.map(N)
               });
             }
-            return n.filter(s.key, s.op, s.value);
+            return a.filter(n.key, n.op, n.value);
           }
-          return e.reduce(a, r);
+          return e.reduce(r, s);
         })(),
         t
       ),
@@ -274,24 +296,24 @@ const p = {
        * @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, a, n) => p.filter.enable(
+      paginate: (e, r, a) => w.filter.enable(
         (() => {
-          o(e >= 0, "Page index must be ≥ 0"), o(a >= 0, "Page limit must be ≥ 0");
-          const s = e * a, i = s + a - 1;
-          if (n !== void 0) {
-            if (s >= n)
-              return r.limit(0);
-            if (i >= n)
-              return r.range(s, n - 1);
+          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 r.range(s, i);
+          return s.range(n, i);
         })(),
         {
           ...t,
           pagination: {
             page: e,
-            limit: a,
-            count: n
+            limit: r,
+            count: a
           }
         }
       ),
@@ -300,13 +322,13 @@ const p = {
        * **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: () => r.throwOnError().then((e) => {
-        const { data: a, count: n } = e, { page: s, limit: i, ...c } = o.defined(t.pagination, "Pagination context is required for collect(). Make sure to call paginate() before collect()"), u = n ?? c.count;
-        return o(i > 0, "Page limit must be > 0"), o(Array.isArray(a), "Data must be an array for pagination, make sure to select multiple rows in query"), o(u !== void 0, "Row count is required for pagination, make sure to count in query or pass `count` in paginate()"), {
-          items: a,
-          totalItems: u,
-          page: s,
-          totalPages: Math.ceil(u / i),
+      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
         };
       })
@@ -326,12 +348,12 @@ class F {
   constructor({
     database: t,
     schema: e,
-    relation: a
+    relation: r
   }) {
-    this.database = t, this.schema = e, this.relation = a;
+    this.database = t, this.schema = e, this.relation = r;
   }
   recordNotFoundError(t) {
-    return new S(`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
@@ -345,7 +367,7 @@ class F {
    */
   get query() {
     const t = this.database.schema(this.schema).from(this.relation);
-    return p.query.enable(t);
+    return w.query.enable(t);
   }
   /**
    * Performs a fuzzy search on the specified column of the relation.
@@ -355,18 +377,18 @@ class F {
   async fuzzySearch({
     column: t,
     searchTerm: e = "",
-    minSimilarity: a = 0,
-    limit: n = 64
+    minSimilarity: r = 0,
+    limit: a = 64
   }) {
-    const { data: s } = await this.database.schema("supabase_core").rpc("fuzzy_search", {
+    const { data: n } = await this.database.schema("supabase_core").rpc("fuzzy_search", {
       relation: this.relation,
       schema_name: this.schema,
       column_name: t,
       search_term: e,
-      min_similarity: a,
-      limit_results: n
+      min_similarity: r,
+      limit_results: a
     }).throwOnError();
-    return s;
+    return n;
   }
   /**
    * List all rows in the relation.
@@ -385,8 +407,8 @@ class F {
    * @throws DatabaseApiError if the query fails.
    */
   async get(t, e = "*") {
-    const { data: a } = await this.query.select(e).eq("id", t).throwOnError();
-    return a[0];
+    const { data: r } = await this.query.select(e).eq("id", t).throwOnError();
+    return r[0];
   }
   /**
    * Gets a single row by its ID, throwing an error if no such row exists.
@@ -397,10 +419,10 @@ class F {
    * @throws DatabaseApiError if the query fails for any other reason.
    */
   async getOrThrow(t, e = "*") {
-    const a = await this.get(t, e);
-    if (a === void 0)
+    const r = await this.get(t, e);
+    if (r === void 0)
       throw this.recordNotFoundError(t);
-    return a;
+    return r;
   }
   /**
    * Deletes a row from the relation by its ID, i.e. by the `id` column.
@@ -438,19 +460,18 @@ class F {
   /**
    * Inserts or updates a row in the relation.
    * @param insert The data to insert or update in the relation.
-   * @param options Options for the upsert operation, such as conflict resolution.
    * @returns The inserted or updated row.
    * @throws DatabaseApiError if the upsert operation fails.
    */
   async upsert(t, {
     onConflict: e,
-    ...a
+    ...r
   } = {}) {
-    const { data: n } = await this.query.upsert(t, {
+    const { data: a } = await this.query.upsert(t, {
       onConflict: e?.join(","),
-      ...a
+      ...r
     }).select().single().throwOnError();
-    return n;
+    return a;
   }
   /**
    * Updates an existing row in the relation by its ID.
@@ -461,42 +482,42 @@ class F {
    * @throws DatabaseApiError if the update fails.
    */
   async update(t, e) {
-    const { data: a } = await this.query.update(e).eq("id", t).select().single().throwOnError();
-    return a;
+    const { data: r } = await this.query.update(e).eq("id", t).select().single().throwOnError();
+    return r;
   }
 }
-class M extends F {
+class C extends F {
   constructor({
     database: t,
     schema: e,
-    table: a
+    table: r
   }) {
     super({
       database: t,
       schema: e,
-      relation: a
+      relation: r
     });
   }
 }
-class R extends F {
+class U extends F {
   constructor({
     database: t,
     schema: e,
-    view: a
+    view: r
   }) {
     super({
       database: t,
       schema: e,
-      relation: a
+      relation: r
     });
   }
 }
-function J(r) {
-  if (r.error)
-    throw r.error;
-  return o(r.count !== null, "Response does not contain a count. Make sure to set the `count` option in the request."), r;
+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 Q {
+class Y {
   supabase;
   constructor({ supabase: t }) {
     this.supabase = t;
@@ -518,39 +539,121 @@ class Q {
     });
   }
   table(t, e) {
-    return new M({
+    return new C({
       database: this,
       schema: t,
       table: e
     });
   }
   view(t, e) {
-    return new R({
+    return new U({
       database: this,
       schema: t,
       view: e
     });
   }
 }
-function W(r) {
-  return {
-    id: r.id,
-    bucket: o.notNull(r.bucket_id, "bucket_id must not be null"),
-    path: o.defined(r.path_tokens?.join("/"), "path_tokens must not be null")
-  };
-}
-function B(r) {
-  const t = o.notNull(r.metadata, "metadata must not be null");
-  return {
-    ...W(r),
-    metadata: t,
-    properties: {
-      type: t.mimetype,
-      lastModified: new Date(t.lastModified).getTime()
+class K {
+  preprocesses = [];
+  storage;
+  constructor({
+    storage: t
+  }) {
+    this.storage = t;
+  }
+  /**
+   * Retrieves a list of files in the specified bucket that have either no embeddings or embeddings that are outdated.
+   * Note: The base implementation of this method is expensive to run.
+   * It is recommended to override it with a more efficient implementation (e.g. using pure SQL) if possible.
+   *
+   * @param bucket The name of the bucket to check for outdated embeddings.
+   * @returns A promise that resolves to an array of file references with outdated embeddings.
+   */
+  async getOutdatedEmbeddings(t) {
+    const e = [];
+    let r = !0, a;
+    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);
+        })
+      );
+      e.push(
+        ...n.filter((o, h) => c[h]).map(({ id: o }) => ({ fileId: o }))
+      ), { hasNext: r, nextCursor: a } = i;
     }
-  };
+    return e;
+  }
+  preprocess(t, e) {
+    return this.preprocesses.forEach((r) => {
+      t = r.run(t, e);
+    }), t;
+  }
+  addPreprocessingStep(t) {
+    return this.preprocesses.push(t), this;
+  }
+  removePreprocessingStep(t) {
+    return T(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 = {
+      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);
+  }
+  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,
+          success: !0,
+          error: null
+        })).catch((i) => i instanceof I ? null : {
+          file: n,
+          error: i,
+          success: !1
+        })
+      )
+    )).filter((n) => n !== null);
+  }
 }
-class X {
+const tt = {
+  removeImagesFromMarkdown: {
+    name: "removeImagesFromMarkdown",
+    run(s, t) {
+      if (t.type === "text/markdown") {
+        const e = /!\[([^\]]*)\]\([^)]*\)/g;
+        return s.replace(e, (r, a) => `![${a}]()`);
+      }
+      return s;
+    }
+  },
+  removeLinksFromMarkdown: {
+    name: "removeLinksFromMarkdown",
+    run(s, t) {
+      if (t.type === "text/markdown") {
+        const e = /\[([^\]]*)\]\([^)]*\)/g;
+        return s.replace(e, (r, a) => `[${a}]()`);
+      }
+      return s;
+    }
+  }
+};
+class et {
   client;
   database;
   constructor({
@@ -562,134 +665,145 @@ class X {
   get files() {
     return this.database.table("storage", "objects");
   }
-  async uploadFile({
-    bucket: t,
-    path: e,
-    file: a,
-    overwriteExisting: n = !1
-  }) {
-    const { data: s, error: i } = await this.client.from(t).upload(
-      `${e}/${a.name}`,
-      a,
+  async getFileObject(t, e) {
+    const { data: r, error: a } = await this.client.from(t).info(e);
+    if (a)
+      throw a;
+    return r;
+  }
+  async getFiles(t, e) {
+    const { data: r, error: a } = await this.client.from(t).listV2(e);
+    if (a)
+      throw a;
+    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 });
+      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("/")
+      };
+    }
+    const { bucket: e, path: r } = t, { id: a } = await this.getFileObject(e, r);
+    return { fileId: a, 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"), {
+      ...o,
+      fileId: e,
+      bucket: r,
+      path: a,
+      metadata: c,
+      properties: c ? {
+        type: c.mimetype,
+        lastModified: new Date(c.lastModified).getTime()
+      } : {}
+    };
+  }
+  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;
+  }
+  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;
+  }
+  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 });
+  }
+  async uploadFile(t, { bucket: e, path: r }, { overwriteExisting: a = !1 } = {}) {
+    const { data: n, error: i } = await this.client.from(e).upload(
+      `${r}/${t.name}`,
+      t,
       {
-        upsert: n
+        upsert: a
       }
     );
     if (i)
       throw i;
     return {
-      id: s.id,
-      bucket: t,
-      path: s.path
+      fileId: n.id,
+      bucket: e,
+      path: n.path
     };
   }
   async downloadFile(t) {
-    const { bucket: e, path: a, properties: n } = "fileId" in t ? await this.getFileStorageInfo(t.fileId) : t, { data: s, error: i } = await this.client.from(e).download(a);
-    if (i)
-      throw i;
-    const [, c] = D(a);
-    return new File([s], c, n);
+    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);
+    return {
+      fileId: e,
+      bucket: r,
+      path: a,
+      file: new File([i], o, n)
+    };
   }
   async deleteFiles(t) {
-    const e = "fileIds" in t ? (await this.files.query.select(["bucket_id", "path_tokens"]).containedBy("id", t.fileIds).throwOnError()).data.map(({ bucket_id: s, path_tokens: i }) => ({
-      bucket: o.notNull(s, "bucket_id must not be null"),
-      paths: o.notNull(i, "path_tokens must not be null").join("/")
-    })) : O(t), a = T(
-      z(e, (s) => s.bucket)
-    ).map(([s, i]) => ({
-      bucket: s,
-      paths: i.flatMap((c) => c.paths)
-    })).filter(({ paths: s }) => s.length > 0);
-    return (await Promise.all(a.map(
-      async ({ bucket: s, paths: i }) => this.client.from(s).remove(i).then(({ data: c, error: u }) => {
+    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 }) => ({
+      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]) => ({
+      bucket: o,
+      paths: h.map((d) => d.path)
+    }));
+    return (await Promise.all(i.map(
+      async ({ bucket: o, paths: h }) => this.client.from(o).remove(h).then(({ data: d, error: u }) => {
         if (u)
           throw u;
-        return c.map((m, w) => ({
-          id: o.notNull(m.id, "file id must not be null"),
-          bucket: s,
-          path: o.defined(i[w])
+        return d.map((p, b) => ({
+          fileId: l.notNull(p.id, "file id must not be null"),
+          bucket: o,
+          path: l.defined(h[b], "path must not be null")
         }));
       })
     ))).flat();
   }
-  async existsFile(t) {
-    const { bucket: e, path: a } = "fileId" in t ? await this.getFileStorageInfo(t.fileId) : t, { data: n, error: s } = await this.client.from(e).exists(a);
-    if (s)
-      throw s;
-    return n;
-  }
-  async assertExistsFile(t) {
-    const { bucket: e, path: a } = "fileId" in t ? await this.getFileStorageInfo(t.fileId) : t, { data: n, error: s } = await this.client.from(e).exists(a);
-    if (s)
-      throw s;
-    if (!n)
-      throw new E(`File not found in bucket '${e}' at path '${a}'`, { bucket: e, path: a });
-  }
-  async getFiles({
-    bucket: t,
-    ...e
-  }) {
-    const { data: a, error: n } = await this.client.from(t).listV2(e);
-    if (n)
-      throw n;
-    return a;
-  }
-  async getFileStorageInfo(t) {
-    const e = await this.files.get(t, ["bucket_id", "path_tokens", "metadata"]);
-    if (!e)
-      throw new E(`File with ID ${t} not found`, { fileId: t });
-    return B({
-      id: t,
-      ...e
-    });
-  }
-  async getFileInfo(t) {
-    const { bucket: e, path: a } = "fileId" in t ? await this.getFileStorageInfo(t.fileId) : t, { data: n, error: s } = await this.client.from(e).info(a);
-    if (s)
-      throw s;
-    return n;
-  }
-  async getPublicURL({
-    transform: t,
-    download: e,
-    ...a
-  }) {
-    const { bucket: n, path: s } = "fileId" in a ? await this.getFileStorageInfo(a.fileId) : a, { data: { publicUrl: i } } = this.client.from(n).getPublicUrl(s, {
-      transform: t,
-      download: e
-    });
-    return i;
-  }
 }
 export {
   F as DataService,
-  Q as DatabaseService,
+  Y as DatabaseService,
+  K as EmbeddingService,
   E as FileNotFoundError,
-  H as Filter,
-  v as FilterChainSeparator,
-  I as FilterOp,
-  Z as LogicalOp,
-  G as LogicalOpSeparator,
-  q as ParseError,
+  Q as Filter,
+  O as FilterChainSeparator,
+  v as FilterOp,
+  H as LogicalOp,
+  J as LogicalOpSeparator,
+  x as ParseError,
   $ as PostgrestErrorInterface,
-  S as RecordNotFoundError,
-  X as StorageService,
-  M as TableDataService,
+  _ as RecordNotFoundError,
+  et as StorageService,
+  C as TableDataService,
   k as TracedError,
-  R as ViewDataService,
-  J as assertCounted,
-  O as coerceArray,
-  j as encodeFilter,
-  x as encodeFilterNode,
-  T as entries,
+  I as UnsupportedMimeError,
+  U as ViewDataService,
+  X as assertCounted,
+  D as coerceArray,
+  L as encodeFilter,
+  q as encodeFilterNode,
+  W as entries,
   z as groupBy,
-  V as isDatabaseApiError,
+  G as isDatabaseApiError,
   N as negateFilterNode,
-  P as negateOp,
-  g as parseFilterExpression,
-  A as parseFilterExpressionChain,
-  p as postgrestExtensions,
-  D as splitPath,
-  B as toStorageInfo,
-  W as toStorageLocation
+  j as negateOp,
+  y as parseFilterExpression,
+  M as parseFilterExpressionChain,
+  w as postgrestExtensions,
+  tt as preprocessingSteps,
+  T as removeElement,
+  A as splitPath
 };