@linabase/js 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -0,0 +1,1118 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthClient: () => AuthClient,
+  BucketClient: () => BucketClient,
+  DatabaseClient: () => DatabaseClient,
+  FunctionsClient: () => FunctionsClient,
+  RpcClient: () => RpcClient,
+  StorageClient: () => StorageClient,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/database.ts
+var DatabaseClient = class {
+  request;
+  table;
+  params;
+  method = "GET";
+  body = null;
+  preferHeaders = [];
+  _single = false;
+  _maybeSingle = false;
+  _throwOnError = false;
+  _csv = false;
+  _abortSignal;
+  _schema;
+  constructor(request, table) {
+    this.request = request;
+    this.table = table;
+    this.params = new URLSearchParams();
+  }
+  // ─── Query Methods ──────────────────────────────────────
+  /** Select columns. Supports nested joins: "*, comments(*)" and aliases: "full_name:name" */
+  select(columns, options) {
+    this.method = "GET";
+    if (columns) this.params.set("select", columns);
+    if (options?.count) this.preferHeaders.push(`count=${options.count}`);
+    if (options?.head) this.method = "GET";
+    return this;
+  }
+  insert(data) {
+    this.method = "POST";
+    this.body = data;
+    this.preferHeaders.push("return=representation");
+    return this;
+  }
+  /** Upsert: insert or update on conflict. Uses merge-duplicates by default. */
+  upsert(data, options) {
+    this.method = "POST";
+    this.body = data;
+    this.preferHeaders.push("return=representation");
+    this.preferHeaders.push(
+      options?.ignoreDuplicates ? "resolution=ignore-duplicates" : "resolution=merge-duplicates"
+    );
+    if (options?.onConflict) {
+      this.params.set("on_conflict", options.onConflict);
+    }
+    return this;
+  }
+  update(data) {
+    this.method = "PATCH";
+    this.body = data;
+    this.preferHeaders.push("return=representation");
+    return this;
+  }
+  delete() {
+    this.method = "DELETE";
+    return this;
+  }
+  // ─── Comparison Filters ─────────────────────────────────
+  eq(column, value) {
+    this.params.set(column, `eq.${value}`);
+    return this;
+  }
+  neq(column, value) {
+    this.params.set(column, `neq.${value}`);
+    return this;
+  }
+  gt(column, value) {
+    this.params.set(column, `gt.${value}`);
+    return this;
+  }
+  gte(column, value) {
+    this.params.set(column, `gte.${value}`);
+    return this;
+  }
+  lt(column, value) {
+    this.params.set(column, `lt.${value}`);
+    return this;
+  }
+  lte(column, value) {
+    this.params.set(column, `lte.${value}`);
+    return this;
+  }
+  // ─── Pattern Matching ───────────────────────────────────
+  like(column, pattern) {
+    this.params.set(column, `like.${pattern}`);
+    return this;
+  }
+  ilike(column, pattern) {
+    this.params.set(column, `ilike.${pattern}`);
+    return this;
+  }
+  /** Regex match (~) when called with (column, pattern). Object-based multi-column filter when called with ({ col: val }). */
+  match(columnOrFilter, pattern) {
+    if (typeof columnOrFilter === "object") {
+      for (const [key, value] of Object.entries(columnOrFilter)) {
+        this.eq(key, value);
+      }
+    } else if (pattern !== void 0) {
+      this.params.set(columnOrFilter, `match.${pattern}`);
+    }
+    return this;
+  }
+  /** Case-insensitive regex match (~*) */
+  imatch(column, pattern) {
+    this.params.set(column, `imatch.${pattern}`);
+    return this;
+  }
+  // ─── Array/Set Filters ──────────────────────────────────
+  in(column, values) {
+    this.params.set(column, `in.(${values.join(",")})`);
+    return this;
+  }
+  /** Contains (@>) - array or JSONB containment */
+  contains(column, value) {
+    this.params.set(column, `cs.${JSON.stringify(value)}`);
+    return this;
+  }
+  /** Contained by (<@) */
+  containedBy(column, value) {
+    this.params.set(column, `cd.${JSON.stringify(value)}`);
+    return this;
+  }
+  /** Overlap (&&) - ranges or arrays */
+  overlaps(column, value) {
+    this.params.set(column, `ov.${JSON.stringify(value)}`);
+    return this;
+  }
+  // ─── Null/Boolean ───────────────────────────────────────
+  is(column, value) {
+    const v = value === null ? "null" : String(value);
+    this.params.set(column, `is.${v}`);
+    return this;
+  }
+  /** IS DISTINCT FROM */
+  isDistinct(column, value) {
+    this.params.set(column, `isdistinct.${value}`);
+    return this;
+  }
+  // ─── Negation ───────────────────────────────────────────
+  /** Negate a filter: not.eq, not.in, not.is, etc. */
+  not(column, operator, value) {
+    this.params.set(column, `not.${operator}.${value}`);
+    return this;
+  }
+  // ─── Logical ────────────────────────────────────────────
+  /** OR filter: or("age.gt.20,name.eq.John") */
+  or(filters) {
+    this.params.set("or", `(${filters})`);
+    return this;
+  }
+  // ─── Full-Text Search ───────────────────────────────────
+  /** to_tsquery */
+  textSearch(column, query, options) {
+    const op = options?.type === "plain" ? "plfts" : options?.type === "phrase" ? "phfts" : options?.type === "websearch" ? "wfts" : "fts";
+    this.params.set(column, `${op}.${query}`);
+    return this;
+  }
+  // ─── Ordering & Pagination ──────────────────────────────
+  order(column, options) {
+    const dir = options?.ascending === false ? "desc" : "asc";
+    const nulls = options?.nullsFirst === true ? ".nullsfirst" : options?.nullsFirst === false ? ".nullslast" : "";
+    this.params.set("order", `${column}.${dir}${nulls}`);
+    return this;
+  }
+  limit(count) {
+    this.params.set("limit", String(count));
+    return this;
+  }
+  offset(count) {
+    this.params.set("offset", String(count));
+    return this;
+  }
+  // ─── Count Options ──────────────────────────────────────
+  /** Request exact, estimated, or planned count via Prefer header */
+  count(type = "exact") {
+    this.preferHeaders.push(`count=${type}`);
+    return this;
+  }
+  // ─── Convenience Methods ───────────────────────────────
+  /** Return a single object instead of an array. Errors if 0 or >1 rows. */
+  single() {
+    this._single = true;
+    this._maybeSingle = false;
+    return this;
+  }
+  /** Return a single object or null. Errors only if >1 rows. */
+  maybeSingle() {
+    this._maybeSingle = true;
+    this._single = false;
+    return this;
+  }
+  /** Range-based pagination: range(0, 9) fetches the first 10 rows. */
+  range(from, to) {
+    this.params.set("limit", String(to - from + 1));
+    this.params.set("offset", String(from));
+    return this;
+  }
+  /** Throw an error instead of returning it in the result object. */
+  throwOnError() {
+    this._throwOnError = true;
+    return this;
+  }
+  /** Request CSV format. Returns raw CSV text in data instead of parsed objects. */
+  csv() {
+    this._csv = true;
+    return this;
+  }
+  /** Pass an AbortSignal for request cancellation. */
+  abortSignal(signal) {
+    this._abortSignal = signal;
+    return this;
+  }
+  /** Switch schema. Sets Accept-Profile (GET) or Content-Profile (POST/PATCH/DELETE). */
+  schema(schemaName) {
+    this._schema = schemaName;
+    return this;
+  }
+  // ─── Internal ──────────────────────────────────────────
+  reset() {
+    this.params = new URLSearchParams();
+    this.method = "GET";
+    this.body = null;
+    this.preferHeaders = [];
+    this._single = false;
+    this._maybeSingle = false;
+    this._throwOnError = false;
+    this._csv = false;
+    this._abortSignal = void 0;
+    this._schema = void 0;
+  }
+  // ─── Execution ──────────────────────────────────────────
+  async execute() {
+    const qs = this.params.toString();
+    const path = `/rest/v1/${this.table}${qs ? `?${qs}` : ""}`;
+    const isSingle = this._single;
+    const isMaybeSingle = this._maybeSingle;
+    const shouldThrow = this._throwOnError;
+    const isCsv = this._csv;
+    const abortSignal = this._abortSignal;
+    const schema = this._schema;
+    const headers = {};
+    if (this.preferHeaders.length) {
+      headers["Prefer"] = this.preferHeaders.join(", ");
+    }
+    if (isCsv) {
+      headers["Accept"] = "text/csv";
+    }
+    if (schema) {
+      if (this.method === "GET") {
+        headers["Accept-Profile"] = schema;
+      } else {
+        headers["Content-Profile"] = schema;
+      }
+    }
+    const makeError = (message) => {
+      const result = { data: null, error: { message }, count: null };
+      if (shouldThrow) throw new Error(message);
+      return result;
+    };
+    try {
+      const res = await this.request(path, {
+        method: this.method,
+        headers,
+        body: this.body ? JSON.stringify(this.body) : void 0,
+        signal: abortSignal
+      });
+      const countHeader = res.headers.get("X-Total-Count");
+      const totalCount = countHeader ? parseInt(countHeader) : null;
+      if (isCsv) {
+        if (!res.ok) {
+          const text = await res.text();
+          return makeError(text || res.statusText);
+        }
+        const csvText = await res.text();
+        return { data: csvText, error: null, count: totalCount };
+      }
+      const data = await res.json();
+      if (!res.ok) {
+        return makeError(data.error || res.statusText);
+      }
+      const rows = Array.isArray(data) ? data : [data];
+      if (isSingle) {
+        if (rows.length === 0) {
+          return makeError("No rows found");
+        }
+        if (rows.length > 1) {
+          return makeError("Multiple rows returned for single()");
+        }
+        const result = {
+          data: rows[0],
+          error: null,
+          count: totalCount
+        };
+        return result;
+      }
+      if (isMaybeSingle) {
+        if (rows.length > 1) {
+          return makeError("Multiple rows returned");
+        }
+        const result = {
+          data: rows.length === 1 ? rows[0] : null,
+          error: null,
+          count: totalCount ?? (rows.length === 0 ? 0 : 1)
+        };
+        return result;
+      }
+      return {
+        data: rows,
+        error: null,
+        count: totalCount
+      };
+    } catch (err) {
+      if (shouldThrow) throw err;
+      return {
+        data: null,
+        error: { message: err.message },
+        count: null
+      };
+    } finally {
+      this.reset();
+    }
+  }
+  /**
+   * Makes DatabaseClient thenable (await-able). Resolves to
+   * `{ data, error, count }` where data is permissively typed so
+   * callers can access properties without generated database types.
+   */
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+};
+var RpcClient = class {
+  request;
+  constructor(request) {
+    this.request = request;
+  }
+  /** Call a Postgres function: rpc("my_function", { arg1: "value" }, { count: "exact" }) */
+  async call(fn, args, options) {
+    const headers = {};
+    const preferParts = [];
+    if (options?.count) {
+      preferParts.push(`count=${options.count}`);
+    }
+    if (preferParts.length) {
+      headers["Prefer"] = preferParts.join(", ");
+    }
+    try {
+      const res = await this.request(`/rest/v1/rpc/${fn}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(args || {})
+      });
+      const countHeader = res.headers.get("X-Total-Count");
+      const totalCount = countHeader ? parseInt(countHeader) : null;
+      const data = await res.json();
+      if (!res.ok) {
+        const message = data.error || res.statusText;
+        if (options?.throwOnError) throw new Error(message);
+        return { data: null, error: { message }, count: null };
+      }
+      return {
+        data: Array.isArray(data) ? data : [data],
+        error: null,
+        count: totalCount
+      };
+    } catch (err) {
+      if (options?.throwOnError) throw err;
+      return { data: null, error: { message: err.message }, count: null };
+    }
+  }
+};
+
+// src/storage.ts
+var StorageClient = class {
+  request;
+  baseUrl;
+  constructor(request, baseUrl) {
+    this.request = request;
+    this.baseUrl = baseUrl || "";
+  }
+  from(bucket) {
+    return new BucketClient(this.request, bucket, this.baseUrl);
+  }
+  async listBuckets() {
+    try {
+      const res = await this.request("/api/storage/buckets");
+      const data = await res.json();
+      return { data: data.buckets || [], error: null };
+    } catch (err) {
+      return { data: [], error: { message: err.message } };
+    }
+  }
+  async createBucket(name, options) {
+    try {
+      const res = await this.request("/api/storage/buckets", {
+        method: "POST",
+        body: JSON.stringify({ name, isPublic: options?.public })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return { data: data.bucket, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+};
+var BucketClient = class {
+  request;
+  bucket;
+  baseUrl;
+  constructor(request, bucket, baseUrl) {
+    this.request = request;
+    this.bucket = bucket;
+    this.baseUrl = baseUrl || "";
+  }
+  async upload(path, file, options) {
+    try {
+      const formData = new FormData();
+      const blob = file instanceof Blob ? file : new Blob([file], { type: options?.contentType });
+      formData.append("file", blob, path);
+      const res = await this.request(
+        `/storage/${this.bucket}/${path}`,
+        {
+          method: "POST",
+          body: formData,
+          headers: {}
+          // Let browser set Content-Type for FormData
+        }
+      );
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async download(path) {
+    try {
+      const res = await this.request(
+        `/storage/${this.bucket}/${path}`
+      );
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
+        return { data: null, error: err };
+      }
+      const blob = await res.blob();
+      return { data: blob, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async list(prefix) {
+    try {
+      let url = `/api/storage/objects?bucketName=${this.bucket}`;
+      if (prefix) url += `&prefix=${encodeURIComponent(prefix)}`;
+      const res = await this.request(url);
+      const data = await res.json();
+      return { data: data.objects || [], error: null };
+    } catch (err) {
+      return { data: [], error: { message: err.message } };
+    }
+  }
+  async remove(pathOrPaths) {
+    const paths = Array.isArray(pathOrPaths) ? pathOrPaths : [pathOrPaths];
+    try {
+      const results = await Promise.all(
+        paths.map(async (p) => {
+          const res = await this.request(
+            `/storage/${this.bucket}/${p}`,
+            { method: "DELETE" }
+          );
+          if (!res.ok) {
+            const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
+            return { error: data };
+          }
+          return { error: null };
+        })
+      );
+      const firstError = results.find((r) => r.error);
+      return { data: firstError ? null : paths, error: firstError?.error ?? null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  getPublicUrl(path, options) {
+    let url;
+    if (options?.transform) {
+      const params = new URLSearchParams();
+      if (options.transform.width)
+        params.set("width", String(options.transform.width));
+      if (options.transform.height)
+        params.set("height", String(options.transform.height));
+      if (options.transform.quality)
+        params.set("quality", String(options.transform.quality));
+      if (options.transform.format)
+        params.set("format", options.transform.format);
+      url = `${this.baseUrl}/storage/transform/${this.bucket}/${path}?${params}`;
+    } else {
+      url = `${this.baseUrl}/public/${this.bucket}/${path}`;
+    }
+    return { data: { publicUrl: url } };
+  }
+  async createSignedUrl(path, expiresIn) {
+    try {
+      const res = await this.request(
+        `/storage/presign/download/${this.bucket}/${path}?expiresIn=${expiresIn}`
+      );
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return { data: { signedUrl: data.url || data.signedUrl }, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async createSignedUrls(paths, expiresIn) {
+    const results = await Promise.all(
+      paths.map(async (p) => {
+        const { data, error } = await this.createSignedUrl(p, expiresIn);
+        return { path: p, signedUrl: data?.signedUrl || "", error };
+      })
+    );
+    const hasError = results.find((r) => r.error);
+    if (hasError) return { data: null, error: hasError.error };
+    return {
+      data: results.map((r) => ({ path: r.path, signedUrl: r.signedUrl })),
+      error: null
+    };
+  }
+  async createSignedUploadUrl(path) {
+    try {
+      const res = await this.request(`/storage/presign/upload`, {
+        method: "POST",
+        body: JSON.stringify({ bucket: this.bucket, path })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return {
+        data: {
+          signedUrl: data.url || data.signedUrl,
+          token: data.token || "",
+          path
+        },
+        error: null
+      };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async move(fromPath, toPath) {
+    try {
+      const res = await this.request(`/storage/${this.bucket}/move`, {
+        method: "POST",
+        body: JSON.stringify({ from: fromPath, to: toPath })
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
+        return { error: data };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+  async copy(fromPath, toPath) {
+    try {
+      const res = await this.request(`/storage/${this.bucket}/copy`, {
+        method: "POST",
+        body: JSON.stringify({ from: fromPath, to: toPath })
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
+        return { error: data };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+};
+
+// src/auth.ts
+var AuthClient = class {
+  request;
+  listeners = [];
+  currentSession = null;
+  /**
+   * Callback that the parent LinabaseClient can set to update the Authorization
+   * header when the user signs in/out or a token is refreshed.
+   */
+  onSessionChange = null;
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Set (or clear) the current session. Use this to restore a persisted
+   * session on app launch (e.g., from AsyncStorage / SecureStore).
+   * Emits INITIAL_SESSION to onAuthStateChange listeners.
+   */
+  setSession(session) {
+    this.currentSession = session;
+    if (this.onSessionChange) this.onSessionChange(session);
+    this.emit("INITIAL_SESSION", session);
+  }
+  // ─── Email/Password ────────────────────────────────────────
+  async signUp(params) {
+    try {
+      const res = await this.request("/auth/v1/signup", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      const session = this.parseAuthResponse(data);
+      this.setSession(session);
+      this.emit("SIGNED_IN", session);
+      return { data: session, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async signIn(params) {
+    try {
+      const res = await this.request("/auth/v1/token?grant_type=password", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      const session = this.parseAuthResponse(data);
+      this.setSession(session);
+      this.emit("SIGNED_IN", session);
+      return { data: session, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  /** Supabase-compatible alias for signIn */
+  async signInWithPassword(params) {
+    return this.signIn(params);
+  }
+  // ─── ID Token (Mobile OAuth) ────────────────────────────────
+  async signInWithIdToken(params) {
+    try {
+      const res = await this.request("/auth/v1/token?grant_type=id_token", {
+        method: "POST",
+        body: JSON.stringify({
+          provider: params.provider,
+          id_token: params.token,
+          nonce: params.nonce
+        })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      const session = this.parseAuthResponse(data);
+      this.setSession(session);
+      this.emit("SIGNED_IN", session);
+      return { data: session, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  // ─── OAuth ─────────────────────────────────────────────────
+  signInWithOAuth(params) {
+    const queryParams = new URLSearchParams({ provider: params.provider });
+    if (params.redirectTo) queryParams.set("redirect_to", params.redirectTo);
+    const url = `/auth/v1/authorize?${queryParams}`;
+    if (typeof window !== "undefined") {
+      window.location.href = url;
+    }
+    return { url };
+  }
+  // ─── Session Management ────────────────────────────────────
+  async signOut() {
+    try {
+      await this.request("/auth/v1/logout", { method: "POST" });
+      this.setSession(null);
+      this.emit("SIGNED_OUT", null);
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+  async getSession() {
+    if (this.currentSession) {
+      const now = Math.floor(Date.now() / 1e3);
+      if (this.currentSession.expires_at <= now) {
+        const refreshed = await this.refreshSession();
+        if (refreshed.error) return { data: { session: null }, error: refreshed.error };
+        return { data: { session: this.currentSession }, error: null };
+      }
+      return { data: { session: this.currentSession }, error: null };
+    }
+    return { data: { session: null }, error: null };
+  }
+  async getUser() {
+    try {
+      const res = await this.request("/auth/v1/user");
+      const data = await res.json();
+      if (!res.ok) return { data: { user: null }, error: data };
+      return { data: { user: data }, error: null };
+    } catch (err) {
+      return { data: { user: null }, error: { message: err.message } };
+    }
+  }
+  async refreshSession() {
+    if (!this.currentSession?.refresh_token) {
+      return { data: null, error: { message: "No refresh token available" } };
+    }
+    try {
+      const res = await this.request("/auth/v1/token?grant_type=refresh_token", {
+        method: "POST",
+        body: JSON.stringify({ refresh_token: this.currentSession.refresh_token })
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        this.setSession(null);
+        this.emit("SIGNED_OUT", null);
+        return { data: null, error: data };
+      }
+      const session = this.parseAuthResponse(data);
+      this.setSession(session);
+      this.emit("TOKEN_REFRESHED", session);
+      return { data: session, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  // ─── Password Reset ────────────────────────────────────────
+  async resetPasswordForEmail(email, _options) {
+    try {
+      const res = await this.request("/auth/v1/recover", {
+        method: "POST",
+        body: JSON.stringify({ email })
+      });
+      if (!res.ok) {
+        const data = await res.json();
+        return { error: data };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+  async updatePassword(newPassword) {
+    return this.updateUser({ password: newPassword }).then((r) => ({ error: r.error }));
+  }
+  // ─── User Update ───────────────────────────────────────────
+  async updateUser(attributes) {
+    try {
+      const res = await this.request("/auth/v1/user", {
+        method: "PUT",
+        body: JSON.stringify({
+          email: attributes.email,
+          password: attributes.password,
+          user_metadata: attributes.data
+        })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: { user: null }, error: data };
+      return { data: { user: data }, error: null };
+    } catch (err) {
+      return { data: { user: null }, error: { message: err.message } };
+    }
+  }
+  // ─── Magic Link / OTP ──────────────────────────────────────
+  async signInWithOtp(params) {
+    try {
+      const res = await this.request("/auth/v1/magiclink", {
+        method: "POST",
+        body: JSON.stringify({
+          email: params.email,
+          redirect_to: params.options?.emailRedirectTo
+        })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async verifyOtp(params) {
+    try {
+      const res = await this.request("/auth/v1/verify", {
+        method: "POST",
+        body: JSON.stringify({
+          type: params.type || "email",
+          token: params.token
+        })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      this.emit("SIGNED_IN", data);
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  // ─── Admin ─────────────────────────────────────────────────
+  get admin() {
+    const request = this.request;
+    return {
+      async listUsers(params) {
+        try {
+          const qs = new URLSearchParams();
+          if (params?.page) qs.set("page", String(params.page));
+          if (params?.per_page) qs.set("per_page", String(params.per_page));
+          const res = await request(`/auth/v1/admin/users?${qs}`);
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: data };
+          return { data, error: null };
+        } catch (err) {
+          return { data: null, error: { message: err.message } };
+        }
+      },
+      async createUser(params) {
+        try {
+          const res = await request("/auth/v1/admin/users", {
+            method: "POST",
+            body: JSON.stringify(params)
+          });
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: data };
+          return { data, error: null };
+        } catch (err) {
+          return { data: null, error: { message: err.message } };
+        }
+      },
+      async getUserById(id) {
+        try {
+          const res = await request(`/auth/v1/admin/users/${id}`);
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: data };
+          return { data, error: null };
+        } catch (err) {
+          return { data: null, error: { message: err.message } };
+        }
+      },
+      async updateUserById(id, attributes) {
+        try {
+          const res = await request(`/auth/v1/admin/users/${id}`, {
+            method: "PUT",
+            body: JSON.stringify(attributes)
+          });
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: data };
+          return { data, error: null };
+        } catch (err) {
+          return { data: null, error: { message: err.message } };
+        }
+      },
+      async deleteUser(id) {
+        try {
+          const res = await request(`/auth/v1/admin/users/${id}`, {
+            method: "DELETE"
+          });
+          if (!res.ok) {
+            const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
+            return { error: data };
+          }
+          return { error: null };
+        } catch (err) {
+          return { error: { message: err.message } };
+        }
+      }
+    };
+  }
+  // ─── MFA / TOTP ────────────────────────────────────────────
+  get mfa() {
+    const request = this.request;
+    return {
+      async enroll(params) {
+        try {
+          const res = await request("/auth/v1/factors", {
+            method: "POST",
+            body: JSON.stringify({ factor_type: params.factorType, friendly_name: params.friendlyName })
+          });
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: data };
+          return { data, error: null };
+        } catch (err) {
+          return { data: null, error: { message: err.message } };
+        }
+      },
+      async challenge(params) {
+        try {
+          const res = await request(`/auth/v1/factors/${params.factorId}/challenge`, {
+            method: "POST"
+          });
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: data };
+          return { data, error: null };
+        } catch (err) {
+          return { data: null, error: { message: err.message } };
+        }
+      },
+      async verify(params) {
+        try {
+          const res = await request(`/auth/v1/factors/${params.factorId}/verify`, {
+            method: "POST",
+            body: JSON.stringify({ challenge_id: params.challengeId, code: params.code })
+          });
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: data };
+          return { data, error: null };
+        } catch (err) {
+          return { data: null, error: { message: err.message } };
+        }
+      },
+      async unenroll(params) {
+        try {
+          const res = await request(`/auth/v1/factors/${params.factorId}`, {
+            method: "DELETE"
+          });
+          if (!res.ok) {
+            const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
+            return { error: data };
+          }
+          return { error: null };
+        } catch (err) {
+          return { error: { message: err.message } };
+        }
+      },
+      async listFactors() {
+        try {
+          const res = await request("/auth/v1/factors");
+          const data = await res.json();
+          if (!res.ok) return { data: null, error: data };
+          return { data, error: null };
+        } catch (err) {
+          return { data: null, error: { message: err.message } };
+        }
+      }
+    };
+  }
+  // ─── Auth State Listener ───────────────────────────────────
+  onAuthStateChange(callback) {
+    this.listeners.push(callback);
+    return {
+      unsubscribe: () => {
+        this.listeners = this.listeners.filter((l) => l !== callback);
+      }
+    };
+  }
+  emit(event, session) {
+    for (const listener of this.listeners) {
+      listener(event, session);
+    }
+  }
+  parseAuthResponse(data) {
+    const user = data.user || {};
+    return {
+      access_token: data.session?.access_token || data.access_token,
+      refresh_token: data.session?.refresh_token || data.refresh_token,
+      token_type: data.session?.token_type || data.token_type || "bearer",
+      expires_in: data.session?.expires_in || data.expires_in || 3600,
+      expires_at: data.session?.expires_at || data.expires_at || Math.floor(Date.now() / 1e3) + 3600,
+      user: {
+        ...user,
+        // Supabase-compatible alias
+        user_metadata: user.raw_user_meta_data || user.user_metadata || {}
+      }
+    };
+  }
+};
+
+// src/functions.ts
+var FunctionsClient = class {
+  request;
+  constructor(request) {
+    this.request = request;
+  }
+  async invoke(name, options) {
+    try {
+      const method = options?.method || "POST";
+      const init = { method, headers: options?.headers };
+      if (options?.body && method !== "GET") {
+        init.body = JSON.stringify(options.body);
+      }
+      let path = `/functions/v1/${name}`;
+      if (options?.body && method === "GET") {
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(options.body)) {
+          if (v !== void 0 && v !== null) params.set(k, String(v));
+        }
+        path += `?${params}`;
+      }
+      const res = await this.request(path, init);
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+};
+
+// src/client.ts
+function createClient(config) {
+  const baseUrl = config.url.replace(/\/$/, "");
+  const apiKey = config.serviceRoleKey || config.anonKey || "";
+  let accessToken = null;
+  async function request(path, options = {}) {
+    const url = `${baseUrl}${path}`;
+    const mergedHeaders = {
+      "Content-Type": "application/json",
+      // Always send the API key for project identification
+      apikey: apiKey,
+      // Use access token if signed in; otherwise use the API key
+      Authorization: `Bearer ${accessToken || apiKey}`,
+      ...options.headers
+    };
+    if (!options.body) {
+      delete mergedHeaders["Content-Type"];
+    }
+    return fetch(url, {
+      ...options,
+      headers: mergedHeaders
+    });
+  }
+  const authClient = new AuthClient(request);
+  authClient.onSessionChange = (session) => {
+    accessToken = session?.access_token || null;
+  };
+  function buildClient(reqFn, branchSlug) {
+    const rc = new RpcClient(reqFn);
+    const ac = new AuthClient(reqFn);
+    ac.onSessionChange = (session) => {
+      accessToken = session?.access_token || null;
+    };
+    return {
+      from: (table) => new DatabaseClient(reqFn, table),
+      schema: (schemaName) => ({
+        from: (table) => {
+          const client = new DatabaseClient(reqFn, table);
+          client._schema = schemaName;
+          return client;
+        }
+      }),
+      rpc: (fn, args) => rc.call(fn, args),
+      storage: new StorageClient(reqFn, baseUrl),
+      auth: branchSlug ? authClient : ac,
+      functions: new FunctionsClient(reqFn),
+      /** Realtime channel (stub; not yet supported). Returns a chainable no-op. */
+      channel: (_name) => {
+        const noop = { on: () => noop, subscribe: () => noop, unsubscribe: () => {
+        } };
+        return noop;
+      },
+      /** Remove a realtime channel (stub; not yet supported). */
+      removeChannel: (_channel) => {
+      },
+      generateTypes: async () => {
+        const restUrl = baseUrl.replace(/:3100/, ":3107");
+        const headers = { Authorization: `Bearer ${apiKey}` };
+        if (branchSlug) headers["X-Branch"] = branchSlug;
+        const res = await fetch(`${restUrl}/rest/v1/types`, { headers });
+        return res.text();
+      },
+      branch: (slug) => {
+        if (branchSlug) throw new Error("Cannot nest branch() calls");
+        function branchRequest(path, options = {}) {
+          return reqFn(path, {
+            ...options,
+            headers: {
+              ...options.headers,
+              "X-Branch": slug
+            }
+          });
+        }
+        return buildClient(branchRequest, slug);
+      }
+    };
+  }
+  return buildClient(request);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthClient,
+  BucketClient,
+  DatabaseClient,
+  FunctionsClient,
+  RpcClient,
+  StorageClient,
+  createClient
+});