@freehour/supabase-core 1.5.3 → 1.5.4

package/dist/index.js

@@ -1,809 +1,566 @@
-import { assert as l } from "@freehour/assert";
-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 x extends E {
-  /**
-   * The ID of the file that was not found.
-   */
-  fileId;
-  /**
-   * The name of the bucket where the file was expected to be found.
-   */
-  bucket;
-  /**
-   * The path relative to the bucket root where the file was expected to be found.
-   */
-  path;
-  constructor(t, {
-    fileId: e,
-    bucket: r,
-    path: n
-  } = {}) {
-    super(t), this.fileId = e, this.bucket = r, this.path = n;
-  }
-}
-class S extends E {
-  /**
-   * The encountered expression that could not be parsed.
-   */
-  expression;
-  /**
-   * Additional context about the expected format or structure.
-   */
-  format;
-  constructor(t, {
-    expression: e,
-    format: r,
-    ...n
-  } = {}) {
-    super(t, n), this.expression = e, this.format = r;
-  }
-}
-class N extends E {
-  /**
-   * The schema where the record was expected to be found.
-   */
-  schema;
-  /**
-   * The table or view where the record was expected to be found.
-   */
-  relation;
-  /**
-   * The ID of the record that was not found.
-   */
-  id;
-  constructor(t, {
-    schema: e,
-    relation: r,
-    id: n
-  } = {}) {
-    super(t), this.schema = e, this.relation = r, this.id = n;
-  }
-}
-class P extends Error {
-  /**
-   * The MIME type that is unsupported.
-   */
-  value;
-  /**
-   * The list of supported MIME types.
-   */
-  supported;
-  constructor(t, {
-    value: e,
-    supported: r,
-    ...n
-  } = {}) {
-    super(t, n), this.value = e, this.supported = r;
-  }
-}
-const D = f.object({
-  code: f.string(),
-  details: f.string().nullable(),
-  hint: f.string().nullable(),
-  name: f.string().optional(),
-  message: f.string().optional()
+import { assert as e } from "@freehour/assert";
+import t from "zod";
+import { PostgrestError as n } from "@supabase/supabase-js";
+import * as r from "@supabase/postgrest-js";
+import { Mime as i } from "@freehour/mime";
+//#region lib/errors.ts
+var a = class extends Error {
+	constructor(e, t = {}) {
+		super(e, t), this.name = this.constructor.name, Error.captureStackTrace(this, this.constructor);
+	}
+}, o = class extends a {
+	fileId;
+	bucket;
+	path;
+	constructor(e, { fileId: t, bucket: n, path: r } = {}) {
+		super(e), this.fileId = t, this.bucket = n, this.path = r;
+	}
+}, s = class extends a {
+	expression;
+	format;
+	constructor(e, { expression: t, format: n, ...r } = {}) {
+		super(e, r), this.expression = t, this.format = n;
+	}
+}, c = class extends a {
+	schema;
+	relation;
+	id;
+	constructor(e, { schema: t, relation: n, id: r } = {}) {
+		super(e), this.schema = t, this.relation = n, this.id = r;
+	}
+}, l = class extends Error {
+	value;
+	supported;
+	constructor(e, { value: t, supported: n, ...r } = {}) {
+		super(e, r), this.value = t, this.supported = n;
+	}
+}, u = t.object({
+	code: t.string(),
+	details: t.string().nullable(),
+	hint: t.string().nullable(),
+	name: t.string().optional(),
+	message: t.string().optional()
 });
-function J(s) {
-  return s instanceof j || D.safeParse(s).success;
-}
-function L(s, t = "/") {
-  const e = s.lastIndexOf(t);
-  return e === -1 ? ["", s] : [s.substring(0, e), s.substring(e + 1)];
-}
-function F(s) {
-  return Array.isArray(s) ? s : [s];
-}
-function M(s, t) {
-  return s.reduce((e, r) => {
-    const n = t(r);
-    return (e[n] ??= []).push(r), e;
-  }, {});
+function d(e) {
+	return e instanceof n || u.safeParse(e).success;
 }
-function A(s, t) {
-  const e = s.findIndex(t);
-  return e !== -1 && s.splice(e, 1), s;
+//#endregion
+//#region lib/utils.ts
+function f(e, t = "/") {
+	let n = e.lastIndexOf(t);
+	return n === -1 ? ["", e] : [e.substring(0, n), e.substring(n + 1)];
 }
-function z(s) {
-  return Object.entries(s);
+function p(e) {
+	return Array.isArray(e) ? e : [e];
 }
-class v {
-  database;
-  /**
-   * The name of the schema containing the view.
-   */
-  schema;
-  /**
-   * The name of the view or table that this service interacts with.
-   */
-  relation;
-  constructor({
-    database: t,
-    schema: e,
-    relation: r
-  }) {
-    this.database = t, this.schema = e, this.relation = r;
-  }
-  recordNotFoundError(t) {
-    return new N(`Record with id ${t} not found in ${this.schema}.${this.relation}`, {
-      schema: this.schema,
-      relation: this.relation,
-      id: t
-    });
-  }
-  /**
-   * The PostgREST query builder for this relation.
-   *
-   * @example
-   * const { data, error } = await dataService.query.select('*');
-   */
-  get query() {
-    return this.database.schema(this.schema).from(this.relation);
-  }
-  /**
-   * Performs a fuzzy search on the specified column of the relation.
-   * @returns The rows that match the search criteria in descending order of similarity.
-   * @throws DatabaseApiError if the query fails.
-   */
-  async fuzzySearch({
-    column: t,
-    searchTerm: e = "",
-    minSimilarity: r = 0,
-    limit: n = 64
-  }) {
-    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: n
-    }).throwOnError();
-    return i;
-  }
-  /**
-   * List all rows in the relation.
-   * Equivalent to `select('*')` with no filters or pagination.
-   * @returns Array of rows in the relation.
-   */
-  async list() {
-    const { data: t } = await this.query.select("*").throwOnError();
-    return t;
-  }
-  /**
-   * Gets a single row by its ID.
-   * @param id The ID of the row to find.
-   * @param columns The columns to select from the row. Defaults to all columns.
-   * @returns The found row or `undefined` if no row with the specified ID exists.
-   * @throws DatabaseApiError if the query fails.
-   */
-  async get(t, e = "*") {
-    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.
-   * @param id The ID of the row to find.
-   * @param columns The columns to select from the row. Defaults to all columns.
-   * @returns The found row.
-   * @throws RecordNotFoundError if no row with the specified ID exists.
-   * @throws DatabaseApiError if the query fails for any other reason.
-   */
-  async getOrThrow(t, e = "*") {
-    const r = await this.get(t, e);
-    if (r === void 0)
-      throw this.recordNotFoundError(t);
-    return r;
-  }
-  /**
-   * Deletes a row from the relation by its ID, i.e. by the `id` column.
-   * @param id The ID of the row to delete.
-   * @return The deleted row, or `undefined` if no row with the specified ID existed.
-   * @throws DatabaseApiError if the deletion fails.
-   */
-  async delete(t) {
-    const { data: e } = await this.query.delete().eq("id", t).select().throwOnError();
-    return e[0];
-  }
-  /**
-   * Deletes a row from the relation by its ID, throwing an error if no such row exists.
-   * @param id The ID of the row to delete.
-   * @returns The deleted row.
-   * @throws RecordNotFoundError if no row with the specified ID exists.
-   * @throws DatabaseApiError if the deletion fails for any other reason.
-   */
-  async deleteOrThrow(t) {
-    const e = await this.delete(t);
-    if (e === void 0)
-      throw this.recordNotFoundError(t);
-    return e;
-  }
-  /**
-   * Inserts a new row into the relation.
-   * @param insert The data to insert into the relation.
-   * @returns The inserted row.
-   * @throws DatabaseApiError if the insertion fails.
-   */
-  async insert(t) {
-    const { data: e } = await this.query.insert(t).select().single().throwOnError();
-    return e;
-  }
-  /**
-   * Inserts or updates a row in the relation.
-   * @param insert The data to insert or update in the relation.
-   * @returns The inserted or updated row.
-   * @throws DatabaseApiError if the upsert operation fails.
-   */
-  async upsert(t, {
-    onConflict: e,
-    ...r
-  } = {}) {
-    const { data: n } = await this.query.upsert(t, {
-      onConflict: e !== void 0 ? F(e).join(",") : void 0,
-      ...r
-    }).select().single().throwOnError();
-    return n;
-  }
-  /**
-   * Updates an existing row in the relation by its ID.
-   *
-   * @param id The ID of the row to update.
-   * @param update The data to update in the row.
-   * @returns The updated row.
-   * @throws DatabaseApiError if the update fails.
-   */
-  async update(t, e) {
-    const { data: r } = await this.query.update(e).eq("id", t).select().single().throwOnError();
-    return r;
-  }
+function m(e, t) {
+	return e.reduce((e, n) => {
+		let r = t(n);
+		return (e[r] ??= []).push(n), e;
+	}, {});
 }
-class B extends v {
-  constructor({
-    database: t,
-    schema: e,
-    table: r
-  }) {
-    super({
-      database: t,
-      schema: e,
-      relation: r
-    });
-  }
+function h(e, t) {
+	let n = e.findIndex(t);
+	return n !== -1 && e.splice(n, 1), e;
 }
-class C extends v {
-  constructor({
-    database: t,
-    schema: e,
-    view: r
-  }) {
-    super({
-      database: t,
-      schema: e,
-      relation: r
-    });
-  }
+function g(e) {
+	return Object.entries(e);
 }
-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;
-}
-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
-      }), [];
-    }
-  });
+//#endregion
+//#region lib/data-service.ts
+var _ = class {
+	database;
+	schema;
+	relation;
+	constructor({ database: e, schema: t, relation: n }) {
+		this.database = e, this.schema = t, this.relation = n;
+	}
+	recordNotFoundError(e) {
+		return new c(`Record with id ${e} not found in ${this.schema}.${this.relation}`, {
+			schema: this.schema,
+			relation: this.relation,
+			id: e
+		});
+	}
+	get query() {
+		return this.database.schema(this.schema).from(this.relation);
+	}
+	async fuzzySearch({ column: e, searchTerm: t = "", minSimilarity: n = 0, limit: r = 64 }) {
+		let { data: i } = await this.database.schema("core").rpc("fuzzy_search", {
+			relation: this.relation,
+			schema_name: this.schema,
+			column_name: e,
+			search_term: t,
+			min_similarity: n,
+			limit_results: r
+		}).throwOnError();
+		return i;
+	}
+	async list() {
+		let { data: e } = await this.query.select("*").throwOnError();
+		return e;
+	}
+	async get(e, t = "*") {
+		let { data: n } = await this.query.select(t).eq("id", e).throwOnError();
+		return n[0];
+	}
+	async getOrThrow(e, t = "*") {
+		let n = await this.get(e, t);
+		if (n === void 0) throw this.recordNotFoundError(e);
+		return n;
+	}
+	async delete(e) {
+		let { data: t } = await this.query.delete().eq("id", e).select().throwOnError();
+		return t[0];
+	}
+	async deleteOrThrow(e) {
+		let t = await this.delete(e);
+		if (t === void 0) throw this.recordNotFoundError(e);
+		return t;
+	}
+	async insert(e) {
+		let { data: t } = await this.query.insert(e).select().single().throwOnError();
+		return t;
+	}
+	async upsert(e, { onConflict: t, ...n } = {}) {
+		let { data: r } = await this.query.upsert(e, {
+			onConflict: t === void 0 ? void 0 : p(t).join(","),
+			...n
+		}).select().single().throwOnError();
+		return r;
+	}
+	async update(e, t) {
+		let { data: n } = await this.query.update(t).eq("id", e).select().single().throwOnError();
+		return n;
+	}
+}, v = class extends _ {
+	constructor({ database: e, schema: t, table: n }) {
+		super({
+			database: e,
+			schema: t,
+			relation: n
+		});
+	}
+}, y = class extends _ {
+	constructor({ database: e, schema: t, view: n }) {
+		super({
+			database: e,
+			schema: t,
+			relation: n
+		});
+	}
 };
-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 b(t) {
+	if (t.error) throw t.error;
+	return e(t.count !== null, "Response does not contain a count. Make sure to set the `count` option in the request."), t;
 }
-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
-      };
-    });
-  }
+//#endregion
+//#region lib/filter.ts
+var x = [
+	"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"
+], S = ["and", "or"], C = ",", w = "~", T = (e) => (n = {}) => {
+	let r = (e) => n[e] ?? e, i = Object.keys(e.shape);
+	return t.string().transform((e, t) => {
+		try {
+			return j(e, i, r);
+		} catch (n) {
+			return t.addIssue({
+				code: "custom",
+				input: e,
+				message: n instanceof Error ? n.message : void 0,
+				params: n instanceof s ? {
+					expression: n.expression,
+					format: n.format
+				} : void 0
+			}), [];
+		}
+	});
+};
+function E(e) {
+	return e.startsWith("not.") ? e.slice(4) : `not.${e}`;
 }
-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);
-  }
+function D(e) {
+	return {
+		...e,
+		op: E(e.op)
+	};
 }
-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);
-  }
+function O(e, t = (e) => e) {
+	if (e.type === "logical") {
+		let n = e.args.map((e) => O(e, t));
+		return `${e.op}(${n})`;
+	}
+	return `${t(e.key)}.${e.op}.${e.value}`;
 }
-class R {
-  supabase;
-  constructor({ supabase: t }) {
-    this.supabase = t;
-  }
-  schema(t) {
-    const e = this.supabase.schema(t);
-    return new Q(e);
-  }
-  relation(t, e) {
-    return new v({
-      database: this,
-      schema: t,
-      relation: e
-    });
-  }
-  table(t, e) {
-    return new B({
-      database: this,
-      schema: t,
-      table: e
-    });
-  }
-  view(t, e) {
-    return new C({
-      database: this,
-      schema: t,
-      view: e
-    });
-  }
+function k(e, t = (e) => e, n = "~") {
+	return e.map((e) => O(e, t)).join(n);
 }
-const st = R;
-class nt {
-  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, n;
-    for (; r; ) {
-      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(
-        ...i.filter((o, d) => c[d]).map(({ id: o }) => ({ fileId: o }))
-      ), { hasNext: r, nextCursor: n } = a;
-    }
-    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 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, ...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
-    }, c = this.preprocess(await r.text(), a);
-    return this.createEmbeddings(
-      n,
-      c,
-      a,
-      typeof e == "function" ? e(r, n) : e
-    );
-  }
-  async synchronize(t, e) {
-    const r = await this.getOutdatedEmbeddings(t);
-    return (await Promise.all(
-      r.map(
-        async (i) => this.ingest(i, e).then(() => ({
-          file: i,
-          success: !0,
-          error: null
-        })).catch((a) => a instanceof P ? null : {
-          file: i,
-          error: a,
-          success: !1
-        })
-      )
-    )).filter((i) => i !== null);
-  }
+function A(t, n = [], r = (e) => e) {
+	function i(e) {
+		let t = [], n = 0, r = "", i = !1;
+		for (let a of e) a === "\"" ? (i = !i, r += a) : a === "(" && !i ? (n++, r += a) : a === ")" && !i ? (n--, r += a) : a === "," && n === 0 && !i ? (t.push(r.trim()), r = "") : r += a;
+		return t;
+	}
+	if (t.endsWith(")")) {
+		if (t.startsWith("and(")) return {
+			type: "logical",
+			op: "and",
+			args: i(t.slice(4, -1)).map((e) => A(e, n, r))
+		};
+		if (t.startsWith("or(")) return {
+			type: "logical",
+			op: "or",
+			args: i(t.slice(3, -1)).map((e) => A(e, n, r))
+		};
+		if (t.startsWith("not.and(")) return {
+			type: "logical",
+			op: "not.and",
+			args: i(t.slice(8, -1)).map((e) => A(e, n, r))
+		};
+		if (t.startsWith("not.or(")) return {
+			type: "logical",
+			op: "not.or",
+			args: i(t.slice(7, -1)).map((e) => A(e, n, r))
+		};
+	}
+	let a = `^(${n.length === 0 ? "[a-zA-Z_][a-zA-Z0-9_]*" : n.join("|")})\\.((?:not\\.)?(?:${x.join("|")}))\\.(.+)$`, o = new RegExp(a).exec(t);
+	if (!o) throw new s(`Invalid filter expression '${t}'`, {
+		expression: t,
+		format: {
+			syntax: "key.(not.)op.value",
+			keys: n.length === 0 ? "*" : n,
+			operators: x
+		}
+	});
+	let [, c, l, u] = o;
+	return {
+		type: "condition",
+		key: r(c),
+		op: l,
+		value: e.defined(u)
+	};
 }
-const it = {
-  removeImagesFromMarkdown: {
-    name: "removeImagesFromMarkdown",
-    run(s, t) {
-      if (t.type === "text/markdown") {
-        const e = /!\[([^\]]*)\]\([^)]*\)/g;
-        return s.replace(e, (r, n) => `![${n}]()`);
-      }
-      return s;
-    }
-  },
-  removeLinksFromMarkdown: {
-    name: "removeLinksFromMarkdown",
-    run(s, t) {
-      if (t.type === "text/markdown") {
-        const e = /\[([^\]]*)\]\([^)]*\)/g;
-        return s.replace(e, (r, n) => `[${n}]()`);
-      }
-      return s;
-    }
-  }
-};
-class at {
-  client;
-  database;
-  constructor({
-    client: t,
-    database: e
-  }) {
-    this.client = t, this.database = e;
-  }
-  get files() {
-    return this.database.table("storage", "objects");
-  }
-  async getFileObject(t, e) {
-    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: n } = await this.client.from(t).listV2(e);
-    if (n)
-      throw n;
-    return r;
-  }
-  async getFileStorageLocation(t) {
-    if ("fileId" in t) {
-      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: 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: n } = await this.getFileObject(e, r);
-    return { fileId: n, bucket: e, path: r };
-  }
-  async getFileInfo(t) {
-    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: n,
-      metadata: c,
-      properties: c ? {
-        type: c.mimetype,
-        lastModified: new Date(c.lastModified).getTime()
-      } : {}
-    };
-  }
-  async getPublicURL(t, e) {
-    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: 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: 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: n = !1 } = {}) {
-    const { data: i, error: a } = await this.client.from(e).upload(
-      `${r}/${t.name}`,
-      t,
-      {
-        upsert: n
-      }
-    );
-    if (a)
-      throw a;
-    return {
-      fileId: i.id,
-      bucket: e,
-      path: i.path
-    };
-  }
-  async downloadFile(t) {
-    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] = L(n);
-    return {
-      fileId: e,
-      bucket: r,
-      path: n,
-      file: new File([a], o, i)
-    };
-  }
-  async deleteFiles(t) {
-    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(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: d.map((m) => m.path)
-    }));
-    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 m.map((g, b) => ({
-          fileId: l.notNull(g.id, "file id must not be null"),
-          bucket: o,
-          path: l.defined(d[b], "path must not be null")
-        }));
-      })
-    ))).flat();
-  }
+function j(e, t = [], n = (e) => e, r = "~") {
+	return e.length === 0 ? [] : e.split(r).map((e) => A(e, t, n));
 }
-export {
-  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
+//#endregion
+//#region lib/postgrest.ts
+var M = class t extends r.PostgrestFilterBuilder {
+	pagination;
+	constructor(e) {
+		super(e);
+	}
+	select(e = "*") {
+		return new t(super.select(p(e).join(",")));
+	}
+	where(e) {
+		if (e.type === "logical") {
+			let t = e.args.map((e) => O(e)).join(",");
+			this.url.searchParams.append(e.op, `(${t})`);
+		} else this.url.searchParams.append(e.key, `${e.op}.${e.value}`);
+		return this;
+	}
+	paginate(t, n, r) {
+		e(t >= 0, "Page index must be ≥ 0"), e(n >= 0, "Page limit must be ≥ 0");
+		let i = t * n, a = i + n - 1;
+		if (r !== void 0) {
+			if (i >= r) return this.limit(0);
+			if (a >= r) return this.range(i, r - 1);
+		}
+		return this.pagination = {
+			...this.pagination,
+			page: t,
+			limit: n,
+			count: r
+		}, this.range(i, a);
+	}
+	collect() {
+		return this.then(({ data: t, count: n, error: r, ...i }) => {
+			if (r) return {
+				data: t,
+				count: n,
+				error: r,
+				...i
+			};
+			let { page: a, limit: o, ...s } = e.defined(this.pagination, "Pagination is required for collect(). Make sure to call paginate() before collect()"), c = n ?? s.count;
+			return e(o > 0, "Page limit must be > 0"), e(Array.isArray(t), "Data must be an array for pagination, make sure to select multiple rows in query"), e(c !== void 0, "Row count is required for pagination, make sure to count in query or pass `count` in paginate()"), {
+				data: {
+					items: t,
+					totalItems: c,
+					page: a,
+					totalPages: Math.ceil(c / o),
+					limit: o
+				},
+				error: r,
+				count: n,
+				...i
+			};
+		});
+	}
+}, N = class extends r.PostgrestQueryBuilder {
+	constructor(e) {
+		super(e.url, e);
+	}
+	select(e = "*", t) {
+		return new M(super.select(p(e).join(","), t));
+	}
+	count(e = "exact") {
+		return new M(this.select("*", {
+			count: e,
+			head: !0
+		}));
+	}
+	insert(e, t) {
+		return new M(super.insert(e, t));
+	}
+	upsert(e, { onConflict: t, ...n } = {}) {
+		return new M(super.upsert(e, {
+			onConflict: p(t).join(","),
+			...n
+		}));
+	}
+	update(e, t) {
+		return new M(super.update(e, t));
+	}
+	delete() {
+		return new M(super.delete());
+	}
+}, P = class {
+	client;
+	constructor(e) {
+		this.client = e;
+	}
+	from(e) {
+		return new N(this.client.from(e));
+	}
+	rpc(e, t, n) {
+		return new M(this.client.rpc(e, t, n));
+	}
+}, F = class {
+	supabase;
+	constructor({ supabase: e }) {
+		this.supabase = e;
+	}
+	schema(e) {
+		return new P(this.supabase.schema(e));
+	}
+	relation(e, t) {
+		return new _({
+			database: this,
+			schema: e,
+			relation: t
+		});
+	}
+	table(e, t) {
+		return new v({
+			database: this,
+			schema: e,
+			table: t
+		});
+	}
+	view(e, t) {
+		return new y({
+			database: this,
+			schema: e,
+			view: t
+		});
+	}
+}, I = {
+	removeImagesFromMarkdown: {
+		name: "removeImagesFromMarkdown",
+		run(e, t) {
+			return t.type === "text/markdown" ? e.replace(/!\[([^\]]*)\]\([^)]*\)/g, (e, t) => `![${t}]()`) : e;
+		}
+	},
+	removeLinksFromMarkdown: {
+		name: "removeLinksFromMarkdown",
+		run(e, t) {
+			return t.type === "text/markdown" ? e.replace(/\[([^\]]*)\]\([^)]*\)/g, (e, t) => `[${t}]()`) : e;
+		}
+	}
+}, L = class {
+	preprocesses = [];
+	storage;
+	constructor({ storage: e }) {
+		this.storage = e;
+	}
+	async getOutdatedEmbeddings(e) {
+		let t = [], n = !0, r;
+		for (; n;) {
+			let { objects: i, ...a } = await this.storage.getFiles(e, { cursor: r }), o = await Promise.all(i.map(async (e) => {
+				let t = new Date(e.updated_at), n = await this.storage.getFileStorageLocation({ fileId: e.id }), r = await this.getEmbeddings(n);
+				return r.length === 0 || r.some((e) => e.createdAt < t);
+			}));
+			t.push(...i.filter((e, t) => o[t]).map(({ id: e }) => ({ fileId: e }))), {hasNext: n, nextCursor: r} = a;
+		}
+		return t;
+	}
+	preprocess(e, t) {
+		return this.preprocesses.forEach((n) => {
+			e = n.run(e, t);
+		}), e;
+	}
+	addPreprocessingStep(e) {
+		return this.preprocesses.push(e), this;
+	}
+	removePreprocessingStep(e) {
+		return h(this.preprocesses, (t) => t.name === e), this;
+	}
+	async get(e) {
+		let t = await this.storage.getFileStorageLocation(e);
+		return this.getEmbeddings(t);
+	}
+	async ingest(e, t) {
+		let { file: n, ...r } = await this.storage.downloadFile(e), a = i.parse(n.type);
+		if (a.type !== "text") throw new l(`Unsupported file type: ${a}. Only text files can be embedded.`);
+		await this.deleteEmbeddings(r);
+		let o = {
+			name: n.name,
+			type: n.type,
+			size: n.size
+		}, s = this.preprocess(await n.text(), o);
+		return this.createEmbeddings(r, s, o, typeof t == "function" ? t(n, r) : t);
+	}
+	async synchronize(e, t) {
+		let n = await this.getOutdatedEmbeddings(e);
+		return (await Promise.all(n.map(async (e) => this.ingest(e, t).then(() => ({
+			file: e,
+			success: !0,
+			error: null
+		})).catch((t) => t instanceof l ? null : {
+			file: e,
+			error: t,
+			success: !1
+		})))).filter((e) => e !== null);
+	}
+}, R = class {
+	client;
+	database;
+	constructor({ client: e, database: t }) {
+		this.client = e, this.database = t;
+	}
+	get files() {
+		return this.database.table("storage", "objects");
+	}
+	async getFileObject(e, t) {
+		let { data: n, error: r } = await this.client.from(e).info(t);
+		if (r) throw r;
+		return n;
+	}
+	async getFiles(e, t) {
+		let { data: n, error: r } = await this.client.from(e).listV2(t);
+		if (r) throw r;
+		return n;
+	}
+	async getFileStorageLocation(t) {
+		if ("fileId" in t) {
+			let { fileId: n } = t, r = await this.files.get(n, ["bucket_id", "path_tokens"]);
+			if (!r) throw new o(`File with ID ${n} not found`, { fileId: n });
+			return {
+				fileId: n,
+				bucket: e.notNull(r.bucket_id, "bucket_id must not be null"),
+				path: e.notNull(r.path_tokens, "path_tokens must not be null").join("/")
+			};
+		}
+		let { bucket: n, path: r } = t, { id: i } = await this.getFileObject(n, r);
+		return {
+			fileId: i,
+			bucket: n,
+			path: r
+		};
+	}
+	async getFileInfo(t) {
+		let { fileId: n, bucket: r, path: i } = await this.getFileStorageLocation(t), { id: a, bucketId: o, metadata: s, ...c } = await this.getFileObject(r, i);
+		return e(a === n, "file ID from storage client must match file ID from database"), e(o === r, "bucketId from storage client must match bucket from database"), {
+			...c,
+			fileId: n,
+			bucket: r,
+			path: i,
+			metadata: s,
+			properties: s ? {
+				type: s.mimetype,
+				lastModified: new Date(s.lastModified).getTime()
+			} : {}
+		};
+	}
+	async getPublicURL(e, t) {
+		let { bucket: n, path: r } = await this.getFileStorageLocation(e), { data: { publicUrl: i } } = this.client.from(n).getPublicUrl(r, t);
+		return i;
+	}
+	async existsFile(e) {
+		let { bucket: t, path: n } = await this.getFileStorageLocation(e), { data: r, error: i } = await this.client.from(t).exists(n);
+		if (i) throw i;
+		return r;
+	}
+	async assertExistsFile(e) {
+		let { bucket: t, path: n } = await this.getFileStorageLocation(e), { data: r, error: i } = await this.client.from(t).exists(n);
+		if (i) throw i;
+		if (!r) throw new o(`File not found in bucket '${t}' at path '${n}'`, {
+			bucket: t,
+			path: n
+		});
+	}
+	async uploadFile(e, { bucket: t, path: n }, { overwriteExisting: r = !1 } = {}) {
+		let { data: i, error: a } = await this.client.from(t).upload(`${n}/${e.name}`, e, { upsert: r });
+		if (a) throw a;
+		return {
+			fileId: i.id,
+			bucket: t,
+			path: i.path
+		};
+	}
+	async downloadFile(e) {
+		let { fileId: t, bucket: n, path: r, properties: i } = await this.getFileInfo(e), { data: a, error: o } = await this.client.from(n).download(r);
+		if (o) throw o;
+		let [, s] = f(r);
+		return {
+			fileId: t,
+			bucket: n,
+			path: r,
+			file: new File([a], s, i)
+		};
+	}
+	async deleteFiles(t) {
+		let n = t.filter((e) => "fileId" in e).map((e) => e.fileId), r = (await this.files.query.select(["bucket_id", "path_tokens"]).containedBy("id", n).throwOnError()).data.map(({ bucket_id: t, path_tokens: n }) => ({
+			bucket: e.notNull(t, "bucket_id must not be null"),
+			path: e.notNull(n, "path_tokens must not be null").join("/")
+		})), i = g(m(t.filter((e) => "path" in e).concat(r), (e) => e.bucket)).map(([e, t]) => ({
+			bucket: e,
+			paths: t.map((e) => e.path)
+		}));
+		return (await Promise.all(i.map(async ({ bucket: t, paths: n }) => this.client.from(t).remove(n).then(({ data: r, error: i }) => {
+			if (i) throw i;
+			return r.map((r, i) => ({
+				fileId: e.notNull(r.id, "file id must not be null"),
+				bucket: t,
+				path: e.defined(n[i], "path must not be null")
+			}));
+		})))).flat();
+	}
 };
+//#endregion
+export { _ as DataService, F as DatabaseService, L as EmbeddingService, o as FileNotFoundError, T as Filter, w as FilterChainSeparator, x as FilterOp, S as LogicalOp, C as LogicalOpSeparator, s as ParseError, P as PostgrestClient, u as PostgrestErrorInterface, M as PostgrestFilterBuilder, N as PostgrestQueryBuilder, c as RecordNotFoundError, R as StorageService, v as TableDataService, a as TracedError, l as UnsupportedMimeError, y as ViewDataService, b as assertCounted, p as coerceArray, k as encodeFilter, O as encodeFilterNode, g as entries, m as groupBy, d as isDatabaseApiError, D as negateFilterNode, E as negateOp, A as parseFilterExpression, j as parseFilterExpressionChain, I as preprocessingSteps, h as removeElement, f as splitPath };