@afribase/afribase-js 0.2.0

package/dist/index.js

@@ -0,0 +1,1979 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AfribaseAuthClient: () => AfribaseAuthClient,
+  AfribaseClient: () => AfribaseClient,
+  AfribaseFunctionsClient: () => AfribaseFunctionsClient,
+  AfribaseQueryBuilder: () => AfribaseQueryBuilder,
+  AfribaseRealtimeClient: () => AfribaseRealtimeClient,
+  AfribaseRpcBuilder: () => AfribaseRpcBuilder,
+  AfribaseStorageClient: () => AfribaseStorageClient,
+  RealtimeChannel: () => RealtimeChannel,
+  StorageFileApi: () => StorageFileApi,
+  containedBy: () => containedBy,
+  contains: () => contains,
+  createClient: () => createClient,
+  csv: () => csv,
+  db: () => db,
+  del: () => del,
+  eq: () => eq,
+  explain: () => explain,
+  geojson: () => geojson,
+  gt: () => gt,
+  gte: () => gte,
+  ilike: () => ilike,
+  insert: () => insert,
+  is: () => is,
+  isIn: () => isIn,
+  like: () => like,
+  limit: () => limit,
+  lt: () => lt,
+  lte: () => lte,
+  match: () => match,
+  maybeSingle: () => maybeSingle,
+  neq: () => neq,
+  not: () => not,
+  or: () => or,
+  order: () => order,
+  range: () => range,
+  select: () => select,
+  single: () => single,
+  textSearch: () => textSearch,
+  update: () => update,
+  upsert: () => upsert
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/fetch.ts
+var import_cross_fetch = __toESM(require("cross-fetch"));
+var _fetch = typeof globalThis !== "undefined" && globalThis.fetch ? globalThis.fetch : import_cross_fetch.default;
+async function resolveFetch(customFetch) {
+  if (customFetch) return customFetch;
+  return _fetch;
+}
+async function fetchWithAuth(url, options) {
+  const fetchFn = await resolveFetch(options.customFetch);
+  const headers = {
+    "apikey": options.apiKey,
+    ...options.headers
+  };
+  if (options.accessToken) {
+    headers["Authorization"] = `Bearer ${options.accessToken}`;
+  } else {
+    headers["Authorization"] = `Bearer ${options.apiKey}`;
+  }
+  return fetchFn(url, {
+    method: options.method || "GET",
+    headers,
+    body: options.body
+  });
+}
+async function handleResponse(response) {
+  if (!response.ok) {
+    let errorBody;
+    try {
+      errorBody = await response.json();
+    } catch {
+      errorBody = { message: await response.text() };
+    }
+    return {
+      data: null,
+      error: {
+        message: errorBody.message || errorBody.msg || `Request failed with status ${response.status}`,
+        status: response.status,
+        ...errorBody
+      }
+    };
+  }
+  if (response.status === 204) {
+    return { data: null, error: null };
+  }
+  try {
+    const data = await response.json();
+    return { data, error: null };
+  } catch {
+    return { data: null, error: null };
+  }
+}
+
+// src/lib/AfribaseAuthClient.ts
+var STORAGE_KEY = "afribase.auth.token";
+var AfribaseAuthClient = class {
+  constructor(options) {
+    this.currentSession = null;
+    this.refreshTimer = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.listenerIdCounter = 0;
+    this.url = options.url.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.autoRefresh = options.autoRefreshToken ?? true;
+    this.persistSession = options.persistSession ?? true;
+    this.customFetch = options.customFetch;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Session Management
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Initialize the auth client — restores persisted session and emits INITIAL_SESSION.
+   * Call this once after creating the client.
+   */
+  async initialize() {
+    try {
+      const stored = this._getStoredSession();
+      if (stored) {
+        if (this._isSessionExpired(stored)) {
+          const { data, error } = await this._refreshSession(stored.refresh_token);
+          if (!error && data) {
+            this._setSession(data);
+            this._notifyListeners("INITIAL_SESSION", data);
+            return { data: { session: data }, error: null };
+          }
+          this._removeSession();
+          this._notifyListeners("INITIAL_SESSION", null);
+          return { data: { session: null }, error: null };
+        }
+        this._setSession(stored);
+        this._notifyListeners("INITIAL_SESSION", stored);
+        return { data: { session: stored }, error: null };
+      }
+      this._notifyListeners("INITIAL_SESSION", null);
+      return { data: { session: null }, error: null };
+    } catch (err) {
+      return { data: { session: null }, error: err };
+    }
+  }
+  /**
+   * Returns the current session if it exists.
+   */
+  async getSession() {
+    return { data: { session: this.currentSession }, error: null };
+  }
+  /**
+   * Returns the current user if authenticated.
+   */
+  async getUser() {
+    if (!this.currentSession?.access_token) {
+      return { data: { user: null }, error: { message: "Not authenticated" } };
+    }
+    const resp = await fetchWithAuth(`${this.url}/user`, {
+      apiKey: this.apiKey,
+      accessToken: this.currentSession.access_token,
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.data && this.currentSession) {
+      this.currentSession.user = result.data;
+    }
+    return { data: { user: result.data }, error: result.error };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Sign Up / Sign In
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Create a new user with email/phone and password.
+   */
+  async signUp(credentials) {
+    const body = { password: credentials.password };
+    if (credentials.email) body.email = credentials.email;
+    if (credentials.phone) body.phone = credentials.phone;
+    if (credentials.options?.data) body.data = credentials.options.data;
+    if (credentials.options?.captchaToken) body.gotcha = credentials.options.captchaToken;
+    const resp = await fetchWithAuth(`${this.url}/signup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      apiKey: this.apiKey,
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.error) return { data: { user: null, session: null }, error: result.error };
+    const data = result.data;
+    if (data.access_token) {
+      const session = this._makeSession(data);
+      this._setSession(session);
+      this._notifyListeners("SIGNED_IN", session);
+      return { data: { user: session.user, session }, error: null };
+    }
+    return { data: { user: data, session: null }, error: null };
+  }
+  /**
+   * Sign in with email/phone and password.
+   */
+  async signInWithPassword(credentials) {
+    const body = { password: credentials.password };
+    if (credentials.email) body.email = credentials.email;
+    if (credentials.phone) body.phone = credentials.phone;
+    if (credentials.options?.captchaToken) body.gotcha = credentials.options.captchaToken;
+    const resp = await fetchWithAuth(`${this.url}/token?grant_type=password`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      apiKey: this.apiKey,
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.error) return { data: { user: null, session: null }, error: result.error };
+    const session = this._makeSession(result.data);
+    this._setSession(session);
+    this._notifyListeners("SIGNED_IN", session);
+    return { data: { user: session.user, session }, error: null };
+  }
+  /**
+   * Sign in with a third-party OAuth provider.
+   * Returns a URL to redirect the user to.
+   */
+  async signInWithOAuth(credentials) {
+    const params = new URLSearchParams();
+    if (credentials.options?.redirectTo) params.set("redirect_to", credentials.options.redirectTo);
+    if (credentials.options?.scopes) params.set("scopes", credentials.options.scopes);
+    if (credentials.options?.queryParams) {
+      for (const [k, v] of Object.entries(credentials.options.queryParams)) {
+        params.set(k, v);
+      }
+    }
+    const qs = params.toString();
+    const url = `${this.url}/authorize?provider=${credentials.provider}${qs ? "&" + qs : ""}`;
+    return { data: { provider: credentials.provider, url }, error: null };
+  }
+  /**
+   * Sign in with a one-time password (magic link or SMS OTP).
+   */
+  async signInWithOtp(credentials) {
+    const body = {};
+    if (credentials.email) body.email = credentials.email;
+    if (credentials.phone) body.phone = credentials.phone;
+    if (credentials.options?.data) body.data = credentials.options.data;
+    if (credentials.options?.captchaToken) body.gotcha = credentials.options.captchaToken;
+    if (credentials.options?.shouldCreateUser !== void 0) body.create_user = credentials.options.shouldCreateUser;
+    const resp = await fetchWithAuth(`${this.url}/otp`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      apiKey: this.apiKey,
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Verify an OTP or magic link token.
+   */
+  async verifyOtp(params) {
+    const body = { token: params.token, type: params.type };
+    if (params.email) body.email = params.email;
+    if (params.phone) body.phone = params.phone;
+    const resp = await fetchWithAuth(`${this.url}/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      apiKey: this.apiKey,
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.error) return { data: { user: null, session: null }, error: result.error };
+    if (result.data?.access_token) {
+      const session = this._makeSession(result.data);
+      this._setSession(session);
+      this._notifyListeners("SIGNED_IN", session);
+      return { data: { user: session.user, session }, error: null };
+    }
+    return { data: result.data, error: null };
+  }
+  /**
+   * Sign in anonymously — creates an anonymous user.
+   */
+  async signInAnonymously(options) {
+    const body = {};
+    if (options?.data) body.data = options.data;
+    if (options?.captchaToken) body.gotcha = options.captchaToken;
+    const resp = await fetchWithAuth(`${this.url}/signup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      apiKey: this.apiKey,
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.error) return { data: { user: null, session: null }, error: result.error };
+    if (result.data?.access_token) {
+      const session = this._makeSession(result.data);
+      this._setSession(session);
+      this._notifyListeners("SIGNED_IN", session);
+      return { data: { user: session.user, session }, error: null };
+    }
+    return { data: result.data, error: null };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Password Recovery & User Updates
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Sends a password reset email.
+   */
+  async resetPasswordForEmail(email, options) {
+    const body = { email };
+    if (options?.redirectTo) body.redirect_to = options.redirectTo;
+    if (options?.captchaToken) body.gotcha = options.captchaToken;
+    const resp = await fetchWithAuth(`${this.url}/recover`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      apiKey: this.apiKey,
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Update the current user (email, phone, password, metadata).
+   */
+  async updateUser(attributes) {
+    if (!this.currentSession?.access_token) {
+      return { data: { user: null }, error: { message: "Not authenticated" } };
+    }
+    const resp = await fetchWithAuth(`${this.url}/user`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(attributes),
+      apiKey: this.apiKey,
+      accessToken: this.currentSession.access_token,
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (!result.error && result.data && this.currentSession) {
+      this.currentSession.user = result.data;
+      this._persistSession(this.currentSession);
+      this._notifyListeners("USER_UPDATED", this.currentSession);
+    }
+    return { data: { user: result.data }, error: result.error };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Sign Out
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Sign out the current user.
+   */
+  async signOut() {
+    if (this.currentSession?.access_token) {
+      try {
+        await fetchWithAuth(`${this.url}/logout`, {
+          method: "POST",
+          apiKey: this.apiKey,
+          accessToken: this.currentSession.access_token,
+          customFetch: this.customFetch
+        });
+      } catch {
+      }
+    }
+    this._removeSession();
+    this._notifyListeners("SIGNED_OUT", null);
+    return { error: null };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Auth State Change
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Listen for auth state changes.
+   * Returns a subscription object with an unsubscribe method.
+   */
+  onAuthStateChange(callback) {
+    const id = `auth-listener-${++this.listenerIdCounter}`;
+    this.listeners.set(id, callback);
+    setTimeout(() => {
+      callback("INITIAL_SESSION", this.currentSession);
+    }, 0);
+    return {
+      data: {
+        subscription: {
+          id,
+          unsubscribe: () => {
+            this.listeners.delete(id);
+          }
+        }
+      }
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Token Refresh
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Manually refresh the session token.
+   */
+  async refreshSession() {
+    if (!this.currentSession?.refresh_token) {
+      return { data: { session: null }, error: { message: "No refresh token" } };
+    }
+    const { data, error } = await this._refreshSession(this.currentSession.refresh_token);
+    if (error) return { data: { session: null }, error };
+    if (data) {
+      this._setSession(data);
+      this._notifyListeners("TOKEN_REFRESHED", data);
+    }
+    return { data: { session: data }, error: null };
+  }
+  /**
+   * Set the session manually (useful for server-side auth).
+   */
+  async setSession(params) {
+    const resp = await fetchWithAuth(`${this.url}/user`, {
+      apiKey: this.apiKey,
+      accessToken: params.access_token,
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.error) return { data: { session: null }, error: result.error };
+    const session = {
+      access_token: params.access_token,
+      refresh_token: params.refresh_token,
+      expires_in: 3600,
+      expires_at: Math.floor(Date.now() / 1e3) + 3600,
+      token_type: "bearer",
+      user: result.data
+    };
+    this._setSession(session);
+    this._notifyListeners("SIGNED_IN", session);
+    return { data: { session }, error: null };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Helpers — Access Token for other clients
+  // ─────────────────────────────────────────────────────────────────────
+  /** @internal */
+  get accessToken() {
+    return this.currentSession?.access_token ?? null;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Private Helpers
+  // ─────────────────────────────────────────────────────────────────────
+  _makeSession(data) {
+    const expiresAt = data.expires_at ?? Math.floor(Date.now() / 1e3) + (data.expires_in || 3600);
+    return {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token,
+      expires_in: data.expires_in || 3600,
+      expires_at: expiresAt,
+      token_type: data.token_type || "bearer",
+      user: data.user || data
+    };
+  }
+  _setSession(session) {
+    this.currentSession = session;
+    this._persistSession(session);
+    this._scheduleRefresh(session);
+  }
+  _removeSession() {
+    this.currentSession = null;
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    this._clearStoredSession();
+  }
+  async _refreshSession(refreshToken) {
+    const resp = await fetchWithAuth(`${this.url}/token?grant_type=refresh_token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refresh_token: refreshToken }),
+      apiKey: this.apiKey,
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.error) return { data: null, error: result.error };
+    return { data: this._makeSession(result.data), error: null };
+  }
+  _scheduleRefresh(session) {
+    if (!this.autoRefresh) return;
+    if (this.refreshTimer) clearTimeout(this.refreshTimer);
+    const expiresAt = session.expires_at ?? Math.floor(Date.now() / 1e3) + session.expires_in;
+    const now = Math.floor(Date.now() / 1e3);
+    const refreshIn = Math.max((expiresAt - now - 60) * 1e3, 1e3);
+    this.refreshTimer = setTimeout(async () => {
+      if (this.currentSession?.refresh_token) {
+        const { data, error } = await this._refreshSession(this.currentSession.refresh_token);
+        if (!error && data) {
+          this._setSession(data);
+          this._notifyListeners("TOKEN_REFRESHED", data);
+        } else {
+          this._removeSession();
+          this._notifyListeners("SIGNED_OUT", null);
+        }
+      }
+    }, refreshIn);
+  }
+  _isSessionExpired(session) {
+    if (!session.expires_at) return false;
+    return Math.floor(Date.now() / 1e3) >= session.expires_at;
+  }
+  _notifyListeners(event, session) {
+    for (const cb of this.listeners.values()) {
+      try {
+        cb(event, session);
+      } catch {
+      }
+    }
+  }
+  // Storage helpers (localStorage in browser, no-op in Node)
+  _persistSession(session) {
+    if (!this.persistSession) return;
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+        globalThis.localStorage.setItem(STORAGE_KEY, JSON.stringify(session));
+      }
+    } catch {
+    }
+  }
+  _getStoredSession() {
+    if (!this.persistSession) return null;
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+        const raw = globalThis.localStorage.getItem(STORAGE_KEY);
+        return raw ? JSON.parse(raw) : null;
+      }
+    } catch {
+    }
+    return null;
+  }
+  _clearStoredSession() {
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+        globalThis.localStorage.removeItem(STORAGE_KEY);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/lib/AfribaseRealtimeClient.ts
+function getWebSocketImpl() {
+  if (typeof WebSocket !== "undefined") return WebSocket;
+  try {
+    const ws = globalThis.require?.("ws") ?? new Function('return require("ws")')();
+    return ws;
+  } catch {
+    throw new Error(
+      'WebSocket is not available. In Node.js, install the "ws" package: npm install ws'
+    );
+  }
+}
+var WS_OPEN = 1;
+var RealtimeChannel = class {
+  constructor(topic, params, sendMessage, removeChannel) {
+    this.params = params;
+    this.sendMessage = sendMessage;
+    this.removeChannel = removeChannel;
+    this.bindings = [];
+    this.presenceState = {};
+    this._status = "CLOSED";
+    this.topic = topic;
+    this.presenceKey = params.config?.presence?.key || "";
+  }
+  on(type, filter, callback) {
+    this.bindings.push({ type, filter, callback });
+    return this;
+  }
+  /**
+   * Subscribe to the channel — starts receiving events.
+   */
+  subscribe(callback) {
+    const joinConfig = { topic: this.topic };
+    const pgBindings = this.bindings.filter((b) => b.type === "postgres_changes");
+    if (pgBindings.length > 0) {
+      joinConfig.postgres_changes = pgBindings.map((b) => ({
+        event: b.filter?.event || "*",
+        schema: b.filter?.schema || "public",
+        table: b.filter?.table || "*",
+        filter: b.filter?.filter
+      }));
+    }
+    if (this.params.config?.broadcast) {
+      joinConfig.broadcast = this.params.config.broadcast;
+    }
+    if (this.params.config?.presence) {
+      joinConfig.presence = this.params.config.presence;
+    }
+    this.sendMessage({
+      topic: this.topic,
+      event: "phx_join",
+      payload: joinConfig,
+      ref: null
+    });
+    this._status = "SUBSCRIBED";
+    if (callback) {
+      setTimeout(() => callback("SUBSCRIBED"), 0);
+    }
+    return this;
+  }
+  /**
+   * Send a broadcast message to all subscribers.
+   */
+  send(payload) {
+    this.sendMessage({
+      topic: this.topic,
+      event: payload.event,
+      payload: payload.payload,
+      ref: null
+    });
+    return this;
+  }
+  /**
+   * Track presence for the current user.
+   */
+  track(payload) {
+    this.sendMessage({
+      topic: this.topic,
+      event: "presence",
+      payload: { type: "track", ...payload, key: this.presenceKey },
+      ref: null
+    });
+    return this;
+  }
+  /**
+   * Untrack presence for the current user.
+   */
+  untrack() {
+    this.sendMessage({
+      topic: this.topic,
+      event: "presence",
+      payload: { type: "untrack", key: this.presenceKey },
+      ref: null
+    });
+    return this;
+  }
+  /**
+   * Get current presence state.
+   */
+  presenceState_() {
+    return { ...this.presenceState };
+  }
+  /**
+   * Unsubscribe from this channel.
+   */
+  unsubscribe() {
+    this.sendMessage({
+      topic: this.topic,
+      event: "phx_leave",
+      payload: {},
+      ref: null
+    });
+    this._status = "CLOSED";
+    this.removeChannel(this.topic);
+  }
+  get status() {
+    return this._status;
+  }
+  /** @internal — called by the RealtimeClient when a message arrives */
+  _handleMessage(msg) {
+    if (msg.payload?.type === "postgres_changes") {
+      const pgPayload = msg.payload;
+      for (const binding of this.bindings) {
+        if (binding.type !== "postgres_changes") continue;
+        const f = binding.filter;
+        if (f?.schema && f.schema !== pgPayload.schema) continue;
+        if (f?.table && f.table !== pgPayload.table) continue;
+        if (f?.event && f.event !== "*" && f.event !== pgPayload.eventType) continue;
+        binding.callback(pgPayload);
+      }
+      return;
+    }
+    if (msg.payload?.type === "presence_state" || msg.payload?.type === "presence_diff") {
+      if (msg.payload.type === "presence_state") {
+        this.presenceState = msg.payload.state || {};
+      } else if (msg.payload.type === "presence_diff") {
+        const { joins, leaves } = msg.payload;
+        if (joins) {
+          for (const [key, val] of Object.entries(joins)) {
+            this.presenceState[key] = val.metas;
+          }
+        }
+        if (leaves) {
+          for (const key of Object.keys(leaves)) {
+            delete this.presenceState[key];
+          }
+        }
+      }
+      for (const binding of this.bindings) {
+        if (binding.type !== "presence") continue;
+        if (binding.filter?.event === "sync" || binding.filter?.event === msg.payload.type) {
+          binding.callback({
+            type: msg.payload.type,
+            presenceState: this.presenceState,
+            joins: msg.payload.joins,
+            leaves: msg.payload.leaves
+          });
+        }
+      }
+      return;
+    }
+    for (const binding of this.bindings) {
+      if (binding.type !== "broadcast") continue;
+      if (binding.filter?.event === msg.event || binding.filter?.event === "*") {
+        binding.callback({ type: "broadcast", event: msg.event, payload: msg.payload });
+      }
+    }
+  }
+};
+var AfribaseRealtimeClient = class {
+  constructor(options) {
+    this.ws = null;
+    this.channels = /* @__PURE__ */ new Map();
+    this.heartbeatTimer = null;
+    this.reconnectTimer = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 10;
+    this.reconnectBaseDelay = 1e3;
+    this.connected = false;
+    this.url = options.url.replace(/^http/, "ws").replace(/\/$/, "") + "/realtime/v1/websocket";
+    this.apiKey = options.apiKey;
+    this.accessToken = options.accessToken ?? null;
+  }
+  /**
+   * Set the access token (called by AfribaseClient when auth state changes).
+   */
+  setAuth(token) {
+    this.accessToken = token;
+    if (this.ws && this.ws.readyState === WS_OPEN) {
+      this._send({
+        topic: "phoenix",
+        event: "access_token",
+        payload: { access_token: token },
+        ref: null
+      });
+    }
+  }
+  /**
+   * Create a channel for a given topic.
+   */
+  channel(topic, options = {}) {
+    const normalizedTopic = topic.startsWith("realtime:") ? topic : `realtime:${topic}`;
+    if (this.channels.has(normalizedTopic)) {
+      return this.channels.get(normalizedTopic);
+    }
+    const ch = new RealtimeChannel(
+      normalizedTopic,
+      options,
+      (msg) => this._send(msg),
+      (t) => this.channels.delete(t)
+    );
+    this.channels.set(normalizedTopic, ch);
+    if (!this.ws) {
+      this._connect();
+    }
+    return ch;
+  }
+  /**
+   * Remove all channels and disconnect.
+   */
+  removeAllChannels() {
+    for (const ch of this.channels.values()) {
+      ch.unsubscribe();
+    }
+    this.channels.clear();
+    this._disconnect();
+  }
+  /**
+   * Disconnect the WebSocket.
+   */
+  disconnect() {
+    this._disconnect();
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Private
+  // ─────────────────────────────────────────────────────────────────────
+  _connect() {
+    if (this.ws) return;
+    try {
+      const WSImpl = getWebSocketImpl();
+      const params = new URLSearchParams({
+        apikey: this.apiKey,
+        vsn: "1.0.0"
+      });
+      if (this.accessToken) {
+        params.set("token", this.accessToken);
+      }
+      this.ws = new WSImpl(`${this.url}?${params.toString()}`);
+    } catch (err) {
+      this._scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      this._startHeartbeat();
+      for (const ch of this.channels.values()) {
+        if (ch.status === "CLOSED") {
+          ch.subscribe();
+        }
+      }
+    };
+    this.ws.onmessage = (ev) => {
+      try {
+        const msg = JSON.parse(typeof ev.data === "string" ? ev.data : ev.data.toString());
+        this._handleMessage(msg);
+      } catch {
+      }
+    };
+    this.ws.onclose = () => {
+      this.connected = false;
+      this._stopHeartbeat();
+      this.ws = null;
+      if (this.channels.size > 0) {
+        this._scheduleReconnect();
+      }
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  _disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this._stopHeartbeat();
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  _send(msg) {
+    if (this.ws && this.ws.readyState === WS_OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  _handleMessage(msg) {
+    if (msg.topic === "phoenix" && msg.event === "phx_reply") return;
+    const ch = this.channels.get(msg.topic);
+    if (ch) {
+      ch._handleMessage(msg);
+    }
+  }
+  _startHeartbeat() {
+    this._stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this._send({ topic: "phoenix", event: "heartbeat", payload: {}, ref: null });
+    }, 3e4);
+  }
+  _stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  _scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) return;
+    const delay = Math.min(
+      this.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts),
+      3e4
+    );
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this._connect();
+    }, delay);
+  }
+};
+
+// src/lib/AfribaseStorageClient.ts
+var AfribaseStorageClient = class {
+  constructor(options) {
+    this.url = options.url.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.getAccessToken = options.getAccessToken;
+    this.customFetch = options.customFetch;
+  }
+  /**
+   * Get a reference to a specific bucket for file operations.
+   */
+  from(bucketId) {
+    return new StorageFileApi(
+      this.url,
+      bucketId,
+      this.apiKey,
+      this.getAccessToken,
+      this.customFetch
+    );
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Bucket Management
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * List all buckets.
+   */
+  async listBuckets() {
+    const resp = await fetchWithAuth(`${this.url}/bucket`, {
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Get a bucket by ID.
+   */
+  async getBucket(id) {
+    const resp = await fetchWithAuth(`${this.url}/bucket/${id}`, {
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Create a new bucket.
+   */
+  async createBucket(id, options) {
+    const resp = await fetchWithAuth(`${this.url}/bucket`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        id,
+        name: id,
+        public: options?.public ?? false,
+        file_size_limit: options?.fileSizeLimit,
+        allowed_mime_types: options?.allowedMimeTypes
+      }),
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Update a bucket.
+   */
+  async updateBucket(id, options) {
+    const resp = await fetchWithAuth(`${this.url}/bucket/${id}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        public: options.public,
+        file_size_limit: options.fileSizeLimit,
+        allowed_mime_types: options.allowedMimeTypes
+      }),
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Delete a bucket (must be empty).
+   */
+  async deleteBucket(id) {
+    const resp = await fetchWithAuth(`${this.url}/bucket/${id}`, {
+      method: "DELETE",
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Empty a bucket (remove all files).
+   */
+  async emptyBucket(id) {
+    const resp = await fetchWithAuth(`${this.url}/bucket/${id}/empty`, {
+      method: "POST",
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+};
+var StorageFileApi = class {
+  constructor(storageUrl, bucketId, apiKey, getAccessToken, customFetch) {
+    this.storageUrl = storageUrl;
+    this.bucketId = bucketId;
+    this.apiKey = apiKey;
+    this.getAccessToken = getAccessToken;
+    this.customFetch = customFetch;
+  }
+  /**
+   * Upload a file to the bucket.
+   */
+  async upload(path, fileBody, options) {
+    const contentType = options?.contentType || "application/octet-stream";
+    const headers = {
+      "Content-Type": contentType
+    };
+    if (options?.cacheControl) headers["Cache-Control"] = options.cacheControl;
+    if (options?.upsert) headers["x-upsert"] = "true";
+    const resp = await fetchWithAuth(
+      `${this.storageUrl}/object/${this.bucketId}/${path}`,
+      {
+        method: "POST",
+        headers,
+        body: fileBody,
+        apiKey: this.apiKey,
+        accessToken: this.getAccessToken(),
+        customFetch: this.customFetch
+      }
+    );
+    const result = await handleResponse(resp);
+    if (result.error) return { data: null, error: result.error };
+    return {
+      data: {
+        path,
+        id: result.data?.id ?? result.data?.Key,
+        fullPath: `${this.bucketId}/${path}`
+      },
+      error: null
+    };
+  }
+  /**
+   * Update (replace) an existing file.
+   */
+  async update(path, fileBody, options) {
+    const contentType = options?.contentType || "application/octet-stream";
+    const headers = {
+      "Content-Type": contentType,
+      "x-upsert": "true"
+    };
+    if (options?.cacheControl) headers["Cache-Control"] = options.cacheControl;
+    const resp = await fetchWithAuth(
+      `${this.storageUrl}/object/${this.bucketId}/${path}`,
+      {
+        method: "POST",
+        headers,
+        body: fileBody,
+        apiKey: this.apiKey,
+        accessToken: this.getAccessToken(),
+        customFetch: this.customFetch
+      }
+    );
+    const result = await handleResponse(resp);
+    if (result.error) return { data: null, error: result.error };
+    return {
+      data: {
+        path,
+        id: result.data?.id ?? result.data?.Key,
+        fullPath: `${this.bucketId}/${path}`
+      },
+      error: null
+    };
+  }
+  /**
+   * Download a file from the bucket.
+   */
+  async download(path, options) {
+    const params = new URLSearchParams();
+    if (options?.transform) {
+      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.resize) params.set("resize", options.transform.resize);
+      if (options.transform.quality) params.set("quality", String(options.transform.quality));
+      if (options.transform.format) params.set("format", options.transform.format);
+    }
+    const qs = params.toString();
+    const url = `${this.storageUrl}/object/${this.bucketId}/${path}${qs ? "?" + qs : ""}`;
+    const fetchFn = this.customFetch || (globalThis.fetch ?? (await import("cross-fetch")).default);
+    const headers = {
+      "apikey": this.apiKey
+    };
+    const token = this.getAccessToken();
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    else headers["Authorization"] = `Bearer ${this.apiKey}`;
+    const resp = await fetchFn(url, { headers });
+    if (!resp.ok) {
+      let errorBody;
+      try {
+        errorBody = await resp.json();
+      } catch {
+        errorBody = { message: `Download failed with status ${resp.status}` };
+      }
+      return { data: null, error: errorBody };
+    }
+    const blob = await resp.blob();
+    return { data: blob, error: null };
+  }
+  /**
+   * List objects in the bucket.
+   */
+  async list(path, options) {
+    const body = {
+      prefix: path || ""
+    };
+    if (options?.limit) body.limit = options.limit;
+    if (options?.offset) body.offset = options.offset;
+    if (options?.sortBy) body.sortBy = options.sortBy;
+    const resp = await fetchWithAuth(`${this.storageUrl}/object/list/${this.bucketId}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Move a file to a new path within the same bucket.
+   */
+  async move(fromPath, toPath) {
+    const resp = await fetchWithAuth(`${this.storageUrl}/object/move`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        bucketId: this.bucketId,
+        sourceKey: fromPath,
+        destinationKey: toPath
+      }),
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Copy a file to a new path within the same bucket.
+   */
+  async copy(fromPath, toPath) {
+    const resp = await fetchWithAuth(`${this.storageUrl}/object/copy`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        bucketId: this.bucketId,
+        sourceKey: fromPath,
+        destinationKey: toPath
+      }),
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Remove one or more files from the bucket.
+   */
+  async remove(paths) {
+    const resp = await fetchWithAuth(`${this.storageUrl}/object/${this.bucketId}`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prefixes: paths }),
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    return handleResponse(resp);
+  }
+  /**
+   * Create a signed URL for temporary access to a private file.
+   */
+  async createSignedUrl(path, expiresIn, options) {
+    const body = {
+      expiresIn
+    };
+    if (options?.download) {
+      body.download = typeof options.download === "string" ? options.download : true;
+    }
+    if (options?.transform) body.transform = options.transform;
+    const resp = await fetchWithAuth(`${this.storageUrl}/object/sign/${this.bucketId}/${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.error) return { data: null, error: result.error };
+    const signedUrl = result.data?.signedURL || result.data?.signedUrl;
+    return {
+      data: {
+        signedUrl: signedUrl?.startsWith("http") ? signedUrl : `${this.storageUrl}${signedUrl}`,
+        path,
+        token: result.data?.token || ""
+      },
+      error: null
+    };
+  }
+  /**
+   * Create signed URLs for multiple files.
+   */
+  async createSignedUrls(paths, expiresIn) {
+    const resp = await fetchWithAuth(`${this.storageUrl}/object/sign/${this.bucketId}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ expiresIn, paths }),
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    const result = await handleResponse(resp);
+    if (result.error) return { data: null, error: result.error };
+    const urls = (result.data || []).map((item) => ({
+      signedUrl: item.signedURL?.startsWith("http") ? item.signedURL : `${this.storageUrl}${item.signedURL}`,
+      path: item.path,
+      token: item.token || ""
+    }));
+    return { data: urls, error: null };
+  }
+  /**
+   * Get the public URL for a file in a public bucket.
+   */
+  getPublicUrl(path, options) {
+    const params = new URLSearchParams();
+    if (options?.download) {
+      params.set("download", typeof options.download === "string" ? options.download : "");
+    }
+    if (options?.transform) {
+      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.resize) params.set("resize", options.transform.resize);
+      if (options.transform.quality) params.set("quality", String(options.transform.quality));
+      if (options.transform.format) params.set("format", options.transform.format);
+    }
+    const qs = params.toString();
+    const publicUrl = `${this.storageUrl}/object/public/${this.bucketId}/${path}${qs ? "?" + qs : ""}`;
+    return { data: { publicUrl } };
+  }
+};
+
+// src/lib/AfribaseFunctionsClient.ts
+var AfribaseFunctionsClient = class {
+  constructor(options) {
+    this.url = options.url.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.getAccessToken = options.getAccessToken;
+    this.customFetch = options.customFetch;
+  }
+  /**
+   * Invoke an edge function by name.
+   *
+   * @example
+   * const { data, error } = await client.functions.invoke('hello-world', {
+   *   body: { name: 'Afribase' },
+   * });
+   */
+  async invoke(functionName, options) {
+    const method = options?.method || "POST";
+    const headers = {
+      ...options?.headers
+    };
+    let body = void 0;
+    if (options?.body !== void 0) {
+      if (typeof options.body === "string" || options.body instanceof Blob || options.body instanceof ArrayBuffer || options.body instanceof FormData) {
+        body = options.body;
+      } else {
+        headers["Content-Type"] = headers["Content-Type"] || "application/json";
+        body = JSON.stringify(options.body);
+      }
+    }
+    if (options?.region) {
+      headers["x-region"] = options.region;
+    }
+    const resp = await fetchWithAuth(`${this.url}/${functionName}`, {
+      method,
+      headers,
+      body,
+      apiKey: this.apiKey,
+      accessToken: this.getAccessToken(),
+      customFetch: this.customFetch
+    });
+    const contentType = resp.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      return handleResponse(resp);
+    }
+    if (!resp.ok) {
+      const text2 = await resp.text();
+      return {
+        data: null,
+        error: { message: text2, status: resp.status }
+      };
+    }
+    const text = await resp.text();
+    return { data: text, error: null };
+  }
+};
+
+// src/lib/AfribaseQueryBuilder.ts
+var AfribaseQueryBuilder = class {
+  constructor(url, options) {
+    this._method = null;
+    this._body = void 0;
+    this._isSingle = false;
+    this._isMaybeSingle = false;
+    this._isHead = false;
+    this._countType = null;
+    this._url = url;
+    this._apiKey = options.apiKey;
+    this._accessToken = options.accessToken;
+    this._customFetch = options.customFetch;
+    this._query = new URLSearchParams();
+    this._headers = {
+      "Content-Type": "application/json",
+      "Prefer": "return=representation"
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // CRUD Operations
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Perform a SELECT query.
+   */
+  select(columns = "*", options) {
+    this._method = "GET";
+    this._query.set("select", columns);
+    if (options?.count) {
+      this._countType = options.count;
+      this._headers["Prefer"] = `count=${options.count}`;
+    }
+    if (options?.head) {
+      this._isHead = true;
+      this._method = "HEAD";
+    }
+    return this;
+  }
+  /**
+   * Perform an INSERT.
+   */
+  insert(values, options) {
+    this._method = "POST";
+    this._body = values;
+    const prefer = ["return=representation"];
+    if (options?.count) {
+      this._countType = options.count;
+      prefer.push(`count=${options.count}`);
+    }
+    if (options?.defaultToNull === false) prefer.push("missing=default");
+    this._headers["Prefer"] = prefer.join(",");
+    return this;
+  }
+  /**
+   * Perform an UPSERT (insert or update on conflict).
+   */
+  upsert(values, options) {
+    this._method = "POST";
+    this._body = values;
+    const prefer = ["return=representation", "resolution=merge-duplicates"];
+    if (options?.ignoreDuplicates) {
+      prefer[1] = "resolution=ignore-duplicates";
+    }
+    if (options?.count) {
+      this._countType = options.count;
+      prefer.push(`count=${options.count}`);
+    }
+    if (options?.defaultToNull === false) prefer.push("missing=default");
+    if (options?.onConflict) this._query.set("on_conflict", options.onConflict);
+    this._headers["Prefer"] = prefer.join(",");
+    return this;
+  }
+  /**
+   * Perform an UPDATE (must be combined with filters).
+   */
+  update(values, options) {
+    this._method = "PATCH";
+    this._body = values;
+    const prefer = ["return=representation"];
+    if (options?.count) {
+      this._countType = options.count;
+      prefer.push(`count=${options.count}`);
+    }
+    this._headers["Prefer"] = prefer.join(",");
+    return this;
+  }
+  /**
+   * Perform a DELETE (must be combined with filters).
+   */
+  delete(options) {
+    this._method = "DELETE";
+    const prefer = ["return=representation"];
+    if (options?.count) {
+      this._countType = options.count;
+      prefer.push(`count=${options.count}`);
+    }
+    this._headers["Prefer"] = prefer.join(",");
+    return this;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Filters
+  // ─────────────────────────────────────────────────────────────────────
+  eq(column, value) {
+    this._query.append(column, `eq.${value}`);
+    return this;
+  }
+  neq(column, value) {
+    this._query.append(column, `neq.${value}`);
+    return this;
+  }
+  gt(column, value) {
+    this._query.append(column, `gt.${value}`);
+    return this;
+  }
+  gte(column, value) {
+    this._query.append(column, `gte.${value}`);
+    return this;
+  }
+  lt(column, value) {
+    this._query.append(column, `lt.${value}`);
+    return this;
+  }
+  lte(column, value) {
+    this._query.append(column, `lte.${value}`);
+    return this;
+  }
+  like(column, pattern) {
+    this._query.append(column, `like.${pattern}`);
+    return this;
+  }
+  ilike(column, pattern) {
+    this._query.append(column, `ilike.${pattern}`);
+    return this;
+  }
+  is(column, value) {
+    this._query.append(column, `is.${value}`);
+    return this;
+  }
+  in(column, values) {
+    const cleanedValues = values.map(
+      (v) => typeof v === "string" ? `"${v}"` : v
+    );
+    this._query.append(column, `in.(${cleanedValues.join(",")})`);
+    return this;
+  }
+  contains(column, value) {
+    if (Array.isArray(value)) {
+      this._query.append(column, `cs.{${value.join(",")}}`);
+    } else if (typeof value === "object") {
+      this._query.append(column, `cs.${JSON.stringify(value)}`);
+    } else {
+      this._query.append(column, `cs.${value}`);
+    }
+    return this;
+  }
+  containedBy(column, value) {
+    if (Array.isArray(value)) {
+      this._query.append(column, `cd.{${value.join(",")}}`);
+    } else if (typeof value === "object") {
+      this._query.append(column, `cd.${JSON.stringify(value)}`);
+    } else {
+      this._query.append(column, `cd.${value}`);
+    }
+    return this;
+  }
+  /**
+   * Full text search using to_tsquery.
+   */
+  textSearch(column, query, options) {
+    let op = "fts";
+    if (options?.type === "plain") op = "plfts";
+    else if (options?.type === "phrase") op = "phfts";
+    else if (options?.type === "websearch") op = "wfts";
+    const configStr = options?.config ? `(${options.config})` : "";
+    this._query.append(column, `${op}${configStr}.${query}`);
+    return this;
+  }
+  /**
+   * Negate a filter.
+   */
+  not(column, operator, value) {
+    this._query.append(column, `not.${operator}.${value}`);
+    return this;
+  }
+  /**
+   * Combine filters with OR.
+   */
+  or(filters, options) {
+    const key = options?.foreignTable ? `${options.foreignTable}.or` : "or";
+    this._query.append(key, `(${filters})`);
+    return this;
+  }
+  /**
+   * Generic filter — any PostgREST operator.
+   */
+  filter(column, operator, value) {
+    this._query.append(column, `${operator}.${value}`);
+    return this;
+  }
+  /**
+   * Match multiple column values (shorthand for multiple .eq).
+   */
+  match(query) {
+    for (const [key, value] of Object.entries(query)) {
+      this._query.append(key, `eq.${value}`);
+    }
+    return this;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Modifiers
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Order results.
+   */
+  order(column, options) {
+    const direction = options?.ascending === false ? "desc" : "asc";
+    const nulls = options?.nullsFirst ? ".nullsfirst" : ".nullslast";
+    const key = options?.foreignTable ? `${options.foreignTable}.order` : "order";
+    this._query.append(key, `${column}.${direction}${nulls}`);
+    return this;
+  }
+  /**
+   * Limit the number of results.
+   */
+  limit(count, options) {
+    const key = options?.foreignTable ? `${options.foreignTable}.limit` : "limit";
+    this._query.set(key, String(count));
+    return this;
+  }
+  /**
+   * Paginate with offset.
+   */
+  range(from, to, options) {
+    const key = options?.foreignTable ? `${options.foreignTable}.offset` : "offset";
+    this._query.set(key, String(from));
+    const limitKey = options?.foreignTable ? `${options.foreignTable}.limit` : "limit";
+    this._query.set(limitKey, String(to - from + 1));
+    this._headers["Range"] = `${from}-${to}`;
+    this._headers["Range-Unit"] = "items";
+    return this;
+  }
+  /**
+   * Return a single row (throws if 0 or 2+ rows).
+   */
+  single() {
+    this._isSingle = true;
+    this._headers["Accept"] = "application/vnd.pgrst.object+json";
+    return this;
+  }
+  /**
+   * Return at most one row (returns null if 0 rows).
+   */
+  maybeSingle() {
+    this._isMaybeSingle = true;
+    this._headers["Accept"] = "application/vnd.pgrst.object+json";
+    return this;
+  }
+  /**
+   * Return as CSV.
+   */
+  csv() {
+    this._headers["Accept"] = "text/csv";
+    return this;
+  }
+  /**
+   * Return a GeoJSON response.
+   */
+  geojson() {
+    this._headers["Accept"] = "application/geo+json";
+    return this;
+  }
+  /**
+   * Limit the fields returned (PostgREST explain).
+   */
+  explain(options) {
+    const parts = ["application/vnd.pgrst.plan"];
+    if (options?.analyze) parts.push("analyze");
+    if (options?.verbose) parts.push("verbose");
+    if (options?.settings) parts.push("settings");
+    if (options?.buffers) parts.push("buffers");
+    if (options?.format) parts.push(options.format);
+    this._headers["Accept"] = parts.join("+");
+    return this;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Execute
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Execute the query and return the results.
+   */
+  async then(onfulfilled, onrejected) {
+    let res;
+    try {
+      res = await this._execute();
+    } catch (err) {
+      if (onrejected) return Promise.resolve(onrejected(err));
+      throw err;
+    }
+    if (onfulfilled) return Promise.resolve(onfulfilled(res));
+    return res;
+  }
+  async _execute() {
+    const method = this._method || "GET";
+    const queryString = this._query.toString();
+    const requestUrl = queryString ? `${this._url}?${queryString}` : this._url;
+    const resp = await fetchWithAuth(requestUrl, {
+      method,
+      headers: this._headers,
+      body: this._body ? JSON.stringify(this._body) : void 0,
+      apiKey: this._apiKey,
+      accessToken: this._accessToken,
+      customFetch: this._customFetch
+    });
+    let count = null;
+    if (this._countType) {
+      const contentRange = resp.headers.get("content-range");
+      if (contentRange) {
+        const match2 = contentRange.match(/\/(\d+)/);
+        if (match2) count = parseInt(match2[1], 10);
+      }
+    }
+    if (!resp.ok) {
+      let errorBody;
+      try {
+        errorBody = await resp.json();
+      } catch {
+        errorBody = { message: await resp.text() };
+      }
+      return {
+        data: null,
+        error: {
+          message: errorBody.message || `Request failed with status ${resp.status}`,
+          details: errorBody.details || "",
+          hint: errorBody.hint || "",
+          code: errorBody.code || String(resp.status)
+        },
+        count,
+        status: resp.status,
+        statusText: resp.statusText
+      };
+    }
+    if (this._isHead || method === "HEAD") {
+      return { data: null, error: null, count, status: resp.status, statusText: resp.statusText };
+    }
+    if (resp.status === 204) {
+      return { data: null, error: null, count, status: resp.status, statusText: resp.statusText };
+    }
+    let data;
+    const contentType = resp.headers.get("content-type") || "";
+    if (contentType.includes("text/csv") || contentType.includes("geo+json") || contentType.includes("pgrst.plan")) {
+      data = await resp.text();
+    } else {
+      data = await resp.json();
+    }
+    if (this._isMaybeSingle && (resp.status === 406 || data === null)) {
+      return { data: null, error: null, count, status: 200, statusText: "OK" };
+    }
+    return { data, error: null, count, status: resp.status, statusText: resp.statusText };
+  }
+};
+var AfribaseRpcBuilder = class {
+  constructor(url, fnName, params, options) {
+    this._isSingle = false;
+    this._countType = null;
+    this._url = `${url}/rpc/${fnName}`;
+    this._apiKey = options.apiKey;
+    this._accessToken = options.accessToken;
+    this._customFetch = options.customFetch;
+    this._params = params;
+    this._query = new URLSearchParams();
+    this._headers = {
+      "Content-Type": "application/json",
+      "Prefer": "return=representation"
+    };
+    this._method = options.get ? "GET" : "POST";
+    if (options.count) {
+      this._countType = options.count;
+      this._headers["Prefer"] = `count=${options.count}`;
+    }
+    if (this._method === "GET" && params) {
+      for (const [key, value] of Object.entries(params)) {
+        this._query.set(key, String(value));
+      }
+    }
+  }
+  single() {
+    this._isSingle = true;
+    this._headers["Accept"] = "application/vnd.pgrst.object+json";
+    return this;
+  }
+  maybeSingle() {
+    this._headers["Accept"] = "application/vnd.pgrst.object+json";
+    return this;
+  }
+  select(columns = "*") {
+    this._query.set("select", columns);
+    return this;
+  }
+  order(column, options) {
+    const direction = options?.ascending === false ? "desc" : "asc";
+    this._query.append("order", `${column}.${direction}`);
+    return this;
+  }
+  limit(count) {
+    this._query.set("limit", String(count));
+    return this;
+  }
+  range(from, to) {
+    this._query.set("offset", String(from));
+    this._query.set("limit", String(to - from + 1));
+    this._headers["Range"] = `${from}-${to}`;
+    this._headers["Range-Unit"] = "items";
+    return this;
+  }
+  eq(column, value) {
+    this._query.append(column, `eq.${value}`);
+    return this;
+  }
+  filter(column, operator, value) {
+    this._query.append(column, `${operator}.${value}`);
+    return this;
+  }
+  async then(onfulfilled, onrejected) {
+    let res;
+    try {
+      res = await this._execute();
+    } catch (err) {
+      if (onrejected) return Promise.resolve(onrejected(err));
+      throw err;
+    }
+    if (onfulfilled) return Promise.resolve(onfulfilled(res));
+    return res;
+  }
+  async _execute() {
+    const queryString = this._query.toString();
+    const requestUrl = queryString ? `${this._url}?${queryString}` : this._url;
+    const resp = await fetchWithAuth(requestUrl, {
+      method: this._method,
+      headers: this._headers,
+      body: this._method === "POST" ? JSON.stringify(this._params) : void 0,
+      apiKey: this._apiKey,
+      accessToken: this._accessToken,
+      customFetch: this._customFetch
+    });
+    let count = null;
+    if (this._countType) {
+      const contentRange = resp.headers.get("content-range");
+      if (contentRange) {
+        const match2 = contentRange.match(/\/(\d+)/);
+        if (match2) count = parseInt(match2[1], 10);
+      }
+    }
+    if (!resp.ok) {
+      let errorBody;
+      try {
+        errorBody = await resp.json();
+      } catch {
+        errorBody = { message: await resp.text() };
+      }
+      return {
+        data: null,
+        error: {
+          message: errorBody.message || `RPC failed with status ${resp.status}`,
+          details: errorBody.details || "",
+          hint: errorBody.hint || "",
+          code: errorBody.code || String(resp.status)
+        },
+        count,
+        status: resp.status,
+        statusText: resp.statusText
+      };
+    }
+    if (resp.status === 204) {
+      return { data: null, error: null, count, status: 204, statusText: "No Content" };
+    }
+    const data = await resp.json();
+    return { data, error: null, count, status: resp.status, statusText: resp.statusText };
+  }
+};
+
+// src/lib/modular.ts
+async function db(builder, ...ops) {
+  let current = builder;
+  for (const op of ops) {
+    current = op(current);
+  }
+  return current;
+}
+var select = (columns = "*", options) => (b) => b.select(columns, options);
+var insert = (values, options) => (b) => b.insert(values, options);
+var update = (values, options) => (b) => b.update(values, options);
+var upsert = (values, options) => (b) => b.upsert(values, options);
+var del = (options) => (b) => b.delete(options);
+var eq = (column, value) => (b) => b.eq(column, value);
+var neq = (column, value) => (b) => b.neq(column, value);
+var gt = (column, value) => (b) => b.gt(column, value);
+var gte = (column, value) => (b) => b.gte(column, value);
+var lt = (column, value) => (b) => b.lt(column, value);
+var lte = (column, value) => (b) => b.lte(column, value);
+var like = (column, pattern) => (b) => b.like(column, pattern);
+var ilike = (column, pattern) => (b) => b.ilike(column, pattern);
+var is = (column, value) => (b) => b.is(column, value);
+var isIn = (column, values) => (b) => b.in(column, values);
+var contains = (column, value) => (b) => b.contains(column, value);
+var containedBy = (column, value) => (b) => b.containedBy(column, value);
+var textSearch = (column, query, options) => (b) => b.textSearch(column, query, options);
+var not = (column, operator, value) => (b) => b.not(column, operator, value);
+var or = (filters, options) => (b) => b.or(filters, options);
+var match = (query) => (b) => b.match(query);
+var order = (column, options) => (b) => b.order(column, options);
+var limit = (count, options) => (b) => b.limit(count, options);
+var range = (from, to, options) => (b) => b.range(from, to, options);
+var single = () => (b) => b.single();
+var maybeSingle = () => (b) => b.maybeSingle();
+var csv = () => (b) => b.csv();
+var geojson = () => (b) => b.geojson();
+var explain = (options) => (b) => b.explain(options);
+
+// src/index.ts
+var AfribaseClient = class {
+  constructor(baseUrl, anonKey, options) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.anonKey = anonKey;
+    this.customFetch = options?.fetch;
+    const authUrl = options?.authUrl || `${this.baseUrl}/auth/v1`;
+    this.restUrl = options?.restUrl || `${this.baseUrl}/rest/v1`;
+    const realtimeUrl = options?.realtimeUrl || this.baseUrl;
+    const storageUrl = options?.storageUrl || `${this.baseUrl}/storage/v1`;
+    const functionsUrl = options?.functionsUrl || `${this.baseUrl}/functions/v1`;
+    this.auth = new AfribaseAuthClient({
+      url: authUrl,
+      apiKey: anonKey,
+      autoRefreshToken: options?.autoRefreshToken ?? true,
+      persistSession: options?.persistSession ?? true,
+      customFetch: this.customFetch
+    });
+    this.realtimeClient = new AfribaseRealtimeClient({
+      url: realtimeUrl,
+      apiKey: anonKey,
+      accessToken: this.auth.accessToken
+    });
+    this.storage = new AfribaseStorageClient({
+      url: storageUrl,
+      apiKey: anonKey,
+      getAccessToken: () => this.auth.accessToken,
+      customFetch: this.customFetch
+    });
+    this.functions = new AfribaseFunctionsClient({
+      url: functionsUrl,
+      apiKey: anonKey,
+      getAccessToken: () => this.auth.accessToken,
+      customFetch: this.customFetch
+    });
+    this.auth.onAuthStateChange((_event, session) => {
+      this.realtimeClient.setAuth(session?.access_token ?? null);
+    });
+    this.auth.initialize();
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Database (PostgREST)
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Query a table via PostgREST.
+   *
+   * @example
+   * const { data } = await afribase.from('users').select('*').eq('id', 1);
+   * const { data } = await afribase.from('posts').select('*, comments(*)').order('created_at', { ascending: false }).limit(10);
+   */
+  from(table) {
+    return new AfribaseQueryBuilder(`${this.restUrl}/${table}`, {
+      apiKey: this.anonKey,
+      accessToken: this.auth.accessToken,
+      customFetch: this.customFetch
+    });
+  }
+  /**
+   * Call a Postgres function (RPC).
+   *
+   * @example
+   * const { data } = await afribase.rpc('get_top_users', { limit_count: 10 });
+   */
+  rpc(fn, params = {}, options) {
+    return new AfribaseRpcBuilder(this.restUrl, fn, params, {
+      apiKey: this.anonKey,
+      accessToken: this.auth.accessToken,
+      customFetch: this.customFetch,
+      head: options?.head,
+      count: options?.count,
+      get: options?.get
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Realtime
+  // ─────────────────────────────────────────────────────────────────────
+  /**
+   * Create a realtime channel.
+   *
+   * @example
+   * const channel = afribase.channel('room:lobby');
+   * channel.on('broadcast', { event: 'message' }, (payload) => console.log(payload)).subscribe();
+   */
+  channel(name, options) {
+    return this.realtimeClient.channel(name, options);
+  }
+  /**
+   * Remove all realtime channels and disconnect.
+   */
+  removeAllChannels() {
+    this.realtimeClient.removeAllChannels();
+  }
+  /**
+   * Get the underlying realtime client.
+   */
+  get realtime() {
+    return this.realtimeClient;
+  }
+};
+var createClient = (baseUrl, anonKey, options) => {
+  return new AfribaseClient(baseUrl, anonKey, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AfribaseAuthClient,
+  AfribaseClient,
+  AfribaseFunctionsClient,
+  AfribaseQueryBuilder,
+  AfribaseRealtimeClient,
+  AfribaseRpcBuilder,
+  AfribaseStorageClient,
+  RealtimeChannel,
+  StorageFileApi,
+  containedBy,
+  contains,
+  createClient,
+  csv,
+  db,
+  del,
+  eq,
+  explain,
+  geojson,
+  gt,
+  gte,
+  ilike,
+  insert,
+  is,
+  isIn,
+  like,
+  limit,
+  lt,
+  lte,
+  match,
+  maybeSingle,
+  neq,
+  not,
+  or,
+  order,
+  range,
+  select,
+  single,
+  textSearch,
+  update,
+  upsert
+});