@freehour/supabase-core 1.0.0

package/dist/index.js

@@ -0,0 +1,695 @@
+import { assert as o } from "@freehour/assert";
+import d from "zod";
+import { PostgrestError as S } from "@supabase/supabase-js";
+class k extends Error {
+  constructor(t, e = {}) {
+    super(t, e), this.name = this.constructor.name, Error.captureStackTrace(this, this.constructor);
+  }
+}
+class E extends k {
+  /**
+   * 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: a,
+    path: n
+  } = {}) {
+    super(t), this.fileId = e, this.bucket = a, this.path = n;
+  }
+}
+class q extends k {
+  /**
+   * The encountered expression that could not be parsed.
+   */
+  expression;
+  /**
+   * Additional context about the expected format or structure.
+   */
+  format;
+  constructor(t = "Expression could not be parsed", {
+    expression: e,
+    format: a,
+    ...n
+  } = {}) {
+    super(t, n), this.expression = e, this.format = a;
+  }
+}
+class _ extends k {
+  /**
+   * 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: a,
+    id: n
+  } = {}) {
+    super(t), this.schema = e, this.relation = a, this.id = n;
+  }
+}
+const $ = d.object({
+  code: d.string(),
+  details: d.string().nullable(),
+  hint: d.string().nullable(),
+  name: d.string().optional(),
+  message: d.string().optional()
+});
+function V(r) {
+  return r instanceof S || $.safeParse(r).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) => {
+    try {
+      return A(n, a, e);
+    } catch (i) {
+      return s.addIssue({
+        code: "custom",
+        input: n,
+        message: i instanceof Error ? i.message : void 0,
+        params: i instanceof q ? {
+          expression: i.expression,
+          format: i.format
+        } : void 0
+      }), [];
+    }
+  });
+};
+function P(r) {
+  return r.startsWith("not.") ? r.slice(4) : `not.${r}`;
+}
+function N(r) {
+  return {
+    ...r,
+    op: P(r.op)
+  };
+}
+function x(r, t = (e) => e) {
+  if (r.type === "logical") {
+    const e = r.args.map((a) => x(a, t));
+    return `${r.op}(${e})`;
+  }
+  return `${t(r.key)}.${r.op}.${r.value}`;
+}
+function j(r, t = (a) => a, e = v) {
+  return r.map((a) => x(a, 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("))
+      return {
+        type: "logical",
+        op: "and",
+        args: a(r.slice(4, -1)).map((l) => g(l, t, e))
+      };
+    if (r.startsWith("or("))
+      return {
+        type: "logical",
+        op: "or",
+        args: a(r.slice(3, -1)).map((l) => g(l, t, e))
+      };
+    if (r.startsWith("not.and("))
+      return {
+        type: "logical",
+        op: "not.and",
+        args: a(r.slice(8, -1)).map((l) => g(l, t, e))
+      };
+    if (r.startsWith("not.or("))
+      return {
+        type: "logical",
+        op: "not.or",
+        args: a(r.slice(7, -1)).map((l) => g(l, 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);
+  if (!c)
+    throw new q(`Invalid filter expression '${r}'`, {
+      expression: r,
+      format: {
+        syntax: "key.(not.)op.value",
+        keys: t.length === 0 ? "*" : t,
+        operators: I
+      }
+    });
+  const [, u, m, w] = c;
+  return {
+    type: "condition",
+    key: e(u),
+    op: m,
+    value: o.defined(w)
+  };
+}
+function A(r, t = [], e = (n) => n, a = v) {
+  return r.length === 0 ? [] : r.split(a).map((n) => g(n, t, e));
+}
+function D(r, t = "/") {
+  const e = r.lastIndexOf(t);
+  return e === -1 ? ["", r] : [r.substring(0, e), r.substring(e + 1)];
+}
+function O(r) {
+  return Array.isArray(r) ? r : [r];
+}
+function z(r, t) {
+  return r.reduce((e, a) => {
+    const n = t(a);
+    return (e[n] ??= []).push(a), e;
+  }, {});
+}
+function T(r) {
+  return Object.entries(r);
+}
+const p = {
+  /**
+   * 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)
+   *     .selectColumns(['id', 'name'])
+   *     .then(({data}) => console.log(data)); // [{ id: 1, name: 'John' }, ...]
+   */
+  query: {
+    enable: (r) => Object.assign(r, {
+      /**
+       * 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) => p.filter.enable(
+        r.select(
+          O(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") => p.filter.enable(
+        r.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: () => p.filter.enable(
+        r.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)
+   *     .apply({ key: 'name', op: 'eq', value: 'John' })
+   *     .paginate(1, 10)
+   *     .collect();
+   */
+  filter: {
+    enable: (r, t = {}) => Object.assign(r, {
+      /**
+       * 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(
+        (() => {
+          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, {
+                type: "logical",
+                op: s.op === "and" ? "not.or" : "or",
+                args: s.args.map(N)
+              });
+            }
+            return n.filter(s.key, s.op, s.value);
+          }
+          return e.reduce(a, r);
+        })(),
+        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, a, n) => p.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);
+          }
+          return r.range(s, i);
+        })(),
+        {
+          ...t,
+          pagination: {
+            page: e,
+            limit: a,
+            count: n
+          }
+        }
+      ),
+      /**
+       * 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: () => 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),
+          limit: i
+        };
+      })
+    })
+  }
+};
+class F {
+  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: a
+  }) {
+    this.database = t, this.schema = e, this.relation = a;
+  }
+  recordNotFoundError(t) {
+    return new _(`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() {
+    const t = this.database.schema(this.schema).from(this.relation);
+    return p.query.enable(t);
+  }
+  /**
+   * 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: a = 0,
+    limit: n = 64
+  }) {
+    const { data: s } = await this.database.schema("core").rpc("fuzzy_search", {
+      relation: this.relation,
+      schema_name: this.schema,
+      column_name: t,
+      search_term: e,
+      min_similarity: a,
+      limit_results: n
+    }).throwOnError();
+    return s;
+  }
+  /**
+   * 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: a } = await this.query.select(e).eq("id", t).throwOnError();
+    return a[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 a = await this.get(t, e);
+    if (a === void 0)
+      throw this.recordNotFoundError(t);
+    return a;
+  }
+  /**
+   * 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.
+   * @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
+  } = {}) {
+    const { data: n } = await this.query.upsert(t, {
+      onConflict: e?.join(","),
+      ...a
+    }).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: a } = await this.query.update(e).eq("id", t).select().single().throwOnError();
+    return a;
+  }
+}
+class M extends F {
+  constructor({
+    database: t,
+    schema: e,
+    table: a
+  }) {
+    super({
+      database: t,
+      schema: e,
+      relation: a
+    });
+  }
+}
+class R extends F {
+  constructor({
+    database: t,
+    schema: e,
+    view: a
+  }) {
+    super({
+      database: t,
+      schema: e,
+      relation: a
+    });
+  }
+}
+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;
+}
+class Q {
+  supabase;
+  constructor({ supabase: t }) {
+    this.supabase = t;
+  }
+  get schema() {
+    return this.supabase.schema.bind(this.supabase);
+  }
+  get rpc() {
+    return this.supabase.rpc.bind(this.supabase);
+  }
+  get from() {
+    return this.supabase.from.bind(this.supabase);
+  }
+  relation(t, e) {
+    return new F({
+      database: this,
+      schema: t,
+      relation: e
+    });
+  }
+  table(t, e) {
+    return new M({
+      database: this,
+      schema: t,
+      table: e
+    });
+  }
+  view(t, e) {
+    return new R({
+      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 X {
+  client;
+  database;
+  constructor({
+    client: t,
+    database: e
+  }) {
+    this.client = t, this.database = e;
+  }
+  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,
+      {
+        upsert: n
+      }
+    );
+    if (i)
+      throw i;
+    return {
+      id: s.id,
+      bucket: t,
+      path: s.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);
+  }
+  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 }) => {
+        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])
+        }));
+      })
+    ))).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,
+  E as FileNotFoundError,
+  H as Filter,
+  v as FilterChainSeparator,
+  I as FilterOp,
+  Z as LogicalOp,
+  G as LogicalOpSeparator,
+  q as ParseError,
+  $ as PostgrestErrorInterface,
+  _ as RecordNotFoundError,
+  X as StorageService,
+  M as TableDataService,
+  k as TracedError,
+  R as ViewDataService,
+  J as assertCounted,
+  O as coerceArray,
+  j as encodeFilter,
+  x as encodeFilterNode,
+  T as entries,
+  z as groupBy,
+  V 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
+};

package/dist/json.d.ts

@@ -0,0 +1,4 @@
+export type Json = string | number | boolean | null | {
+    [key: string]: Json | undefined;
+} | Json[];
+//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../lib/json.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,GACV,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;CAAE,GACnC,IAAI,EAAE,CAAC"}