@kividb/client 0.1.0

package/dist/index.js

@@ -0,0 +1,792 @@
+// src/http.ts
+async function request(url, init = {}) {
+  const { token, headers, ...rest } = init;
+  const merged = new Headers(headers);
+  if (token) merged.set("Authorization", `Bearer ${token}`);
+  if (rest.body && !merged.has("Content-Type")) {
+    merged.set("Content-Type", "application/json");
+  }
+  let res;
+  try {
+    res = await fetch(url, { ...rest, headers: merged });
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : "Network request failed.";
+    return { data: null, error: { message, status: 0 } };
+  }
+  if (res.status === 204) return { data: null, error: null };
+  const text = await res.text();
+  const body = text ? safeJson(text) : null;
+  if (!res.ok) {
+    const { error: message, ...details } = body ?? {};
+    return {
+      data: null,
+      error: {
+        message: message ?? res.statusText ?? "Request failed.",
+        status: res.status,
+        details: Object.keys(details).length ? details : void 0
+      }
+    };
+  }
+  return { data: body, error: null };
+}
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/auth.ts
+var AuthClient = class {
+  constructor(base, project, session, autoRefresh = true) {
+    this.base = base;
+    this.project = project;
+    this.session = session;
+    this.autoRefresh = autoRefresh;
+  }
+  base;
+  project;
+  session;
+  autoRefresh;
+  url(path) {
+    return `${this.base}/${this.project}${path}`;
+  }
+  /** Register an email/password user. Returns a session only if autoconfirm is on server-side. */
+  async signUp(params) {
+    const res = await request(
+      this.url("/signup"),
+      { method: "POST", body: JSON.stringify(params) }
+    );
+    if (res.data && "access_token" in res.data) {
+      await this.session.set(res.data, "SIGNED_IN");
+    }
+    return res;
+  }
+  async signInWithPassword(params) {
+    return this.token("password", params);
+  }
+  /** Passwordless — triggers a magic-link email. The link resolves via `verifyOtp`. */
+  signInWithOtp(params) {
+    return request(this.url("/magiclink"), {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Build the URL the browser should navigate to in order to start an OAuth
+   * flow. We return the URL rather than redirecting so the caller controls
+   * navigation (and so this works outside a browser). `redirectTo` is where the
+   * provider bounces back with a one-time `?code=` to feed to `exchangeCodeForSession`.
+   */
+  getOAuthUrl(params) {
+    const q = new URLSearchParams({
+      provider: params.provider,
+      redirect_to: params.redirectTo
+    });
+    if (params.linkToken) q.set("link_token", params.linkToken);
+    return `${this.url("/authorize")}?${q.toString()}`;
+  }
+  /** Trade the one-time `?code=` from an OAuth redirect for a real session. */
+  exchangeCodeForSession(code) {
+    return this.token("oauth_code", { code });
+  }
+  /** Rotate the refresh token for a fresh access token. Defaults to the stored session's. */
+  async refreshSession(refreshToken) {
+    const token = refreshToken ?? this.session.get()?.refresh_token;
+    if (!token) {
+      return { data: null, error: { message: "No refresh token available.", status: 400 } };
+    }
+    const res = await this.token("refresh_token", { refresh_token: token });
+    if (res.data) await this.session.set(res.data, "TOKEN_REFRESHED");
+    return res;
+  }
+  async signOut() {
+    const refresh = this.session.get()?.refresh_token;
+    const res = await request(this.url("/logout"), {
+      method: "POST",
+      body: JSON.stringify(refresh ? { refresh_token: refresh } : {})
+    });
+    await this.session.set(null, "SIGNED_OUT");
+    return res;
+  }
+  /** The currently stored session (in-memory / from the store). No network call. */
+  getSession() {
+    return this.session.get();
+  }
+  /**
+   * Fetch the live user record for the signed-in session. This is also the
+   * canonical server-side "is this token still valid?" check (there is no local
+   * JWKS verification yet — see README). On a 401 it transparently rotates the
+   * refresh token once and retries, which is what middleware leans on to keep a
+   * session alive across requests.
+   */
+  async getUser() {
+    let res = await request(this.url("/user"), { token: this.session.accessToken() });
+    if (this.autoRefresh && res.error?.status === 401 && this.session.get()?.refresh_token) {
+      const refreshed = await this.refreshSession();
+      if (refreshed.data) {
+        res = await request(this.url("/user"), { token: this.session.accessToken() });
+      }
+    }
+    return res;
+  }
+  updateUser(params) {
+    return request(this.url("/user"), {
+      method: "PUT",
+      token: this.session.accessToken(),
+      body: JSON.stringify(params)
+    });
+  }
+  resetPasswordForEmail(email) {
+    return request(this.url("/recover"), {
+      method: "POST",
+      body: JSON.stringify({ email })
+    });
+  }
+  /** Consume an emailed one-time token (confirmation / recovery / magiclink) for a session. */
+  async verifyOtp(params) {
+    const res = await request(this.url("/verify"), {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+    if (res.data) await this.session.set(res.data, "SIGNED_IN");
+    return res;
+  }
+  /** Subscribe to sign-in / sign-out / refresh transitions. Returns an unsubscribe fn. */
+  onAuthStateChange(listener) {
+    return this.session.onChange(listener);
+  }
+  async token(grantType, body) {
+    const res = await request(
+      `${this.url("/token")}?grant_type=${grantType}`,
+      { method: "POST", body: JSON.stringify(body) }
+    );
+    if (res.data && grantType !== "refresh_token") {
+      await this.session.set(res.data, "SIGNED_IN");
+    }
+    return res;
+  }
+};
+
+// src/cookies.ts
+function sessionCookieName(project) {
+  return `kdb-${project}-auth`;
+}
+function cookieSessionStore(project, cookies) {
+  const name = sessionCookieName(project);
+  return {
+    get() {
+      const raw = cookies.getAll().find((c) => c.name === name)?.value;
+      if (!raw) return null;
+      try {
+        return JSON.parse(decodeURIComponent(raw));
+      } catch {
+        return null;
+      }
+    },
+    set(session) {
+      if (!session) {
+        cookies.setAll([{ name, value: "", options: { path: "/", maxAge: 0 } }]);
+        return;
+      }
+      cookies.setAll([
+        {
+          name,
+          value: encodeURIComponent(JSON.stringify(session)),
+          options: {
+            path: "/",
+            sameSite: "lax",
+            // ~1 year; the access token inside still expires in 1h and is
+            // refreshed via the rotating refresh token.
+            maxAge: 60 * 60 * 24 * 365
+          }
+        }
+      ]);
+    }
+  };
+}
+function documentCookieMethods() {
+  return {
+    getAll() {
+      if (typeof document === "undefined" || !document.cookie) return [];
+      return document.cookie.split("; ").map((pair) => {
+        const eq = pair.indexOf("=");
+        return { name: pair.slice(0, eq), value: pair.slice(eq + 1) };
+      });
+    },
+    setAll(toSet) {
+      if (typeof document === "undefined") return;
+      for (const { name, value, options } of toSet) {
+        document.cookie = serializeCookie(name, value, options);
+      }
+    }
+  };
+}
+function serializeCookie(name, value, options = {}) {
+  const parts = [`${name}=${value}`];
+  parts.push(`Path=${options.path ?? "/"}`);
+  if (options.maxAge !== void 0) parts.push(`Max-Age=${options.maxAge}`);
+  if (options.domain) parts.push(`Domain=${options.domain}`);
+  if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+  if (options.sameSite) parts.push(`SameSite=${capitalize(options.sameSite)}`);
+  if (options.secure) parts.push("Secure");
+  return parts.join("; ");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/jwt.ts
+function projectFromAnonKey(anonKey) {
+  const parts = anonKey.split(".");
+  if (parts.length < 2) {
+    throw new Error("Invalid kividb key: expected a JWT (header.payload.signature).");
+  }
+  let payload;
+  try {
+    payload = JSON.parse(base64UrlDecode(parts[1]));
+  } catch {
+    throw new Error("Invalid kividb key: could not decode the JWT payload.");
+  }
+  if (typeof payload.ref !== "string" || !payload.ref) {
+    throw new Error("kividb key has no `ref` claim \u2014 cannot determine the project slug.");
+  }
+  return payload.ref;
+}
+function base64UrlDecode(segment) {
+  const base64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+  if (typeof atob !== "function") {
+    throw new Error("No base64 decoder (atob) available in this runtime.");
+  }
+  const binary = atob(padded);
+  const bytes = Uint8Array.from(binary, (ch) => ch.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+
+// src/postgrest.ts
+var FromBuilder = class {
+  constructor(ctx, table) {
+    this.ctx = ctx;
+    this.table = table;
+  }
+  ctx;
+  table;
+  select(columns = "*") {
+    return new FilterBuilder(this.ctx, this.table, "GET", { select: columns });
+  }
+  insert(values) {
+    return new FilterBuilder(this.ctx, this.table, "POST", {}, values);
+  }
+  update(values) {
+    return new FilterBuilder(this.ctx, this.table, "PATCH", {}, values);
+  }
+  delete() {
+    return new FilterBuilder(this.ctx, this.table, "DELETE", {});
+  }
+};
+var FilterBuilder = class {
+  constructor(ctx, table, method, reserved, body) {
+    this.ctx = ctx;
+    this.table = table;
+    this.method = method;
+    this.reserved = reserved;
+    this.body = body;
+  }
+  ctx;
+  table;
+  method;
+  reserved;
+  body;
+  filters = [];
+  orders = [];
+  limitValue;
+  offsetValue;
+  eq(column, value) {
+    return this.filter(column, "eq", value);
+  }
+  neq(column, value) {
+    return this.filter(column, "neq", value);
+  }
+  gt(column, value) {
+    return this.filter(column, "gt", value);
+  }
+  gte(column, value) {
+    return this.filter(column, "gte", value);
+  }
+  lt(column, value) {
+    return this.filter(column, "lt", value);
+  }
+  lte(column, value) {
+    return this.filter(column, "lte", value);
+  }
+  like(column, pattern) {
+    return this.filter(column, "like", pattern);
+  }
+  ilike(column, pattern) {
+    return this.filter(column, "ilike", pattern);
+  }
+  /** Only `null`, `true`, `false` are accepted by the server for `is`. */
+  is(column, value) {
+    return this.filter(column, "is", value === null ? "null" : String(value));
+  }
+  order(column, opts = {}) {
+    this.orders.push(`${column}.${opts.ascending === false ? "desc" : "asc"}`);
+    return this;
+  }
+  limit(count) {
+    this.limitValue = count;
+    return this;
+  }
+  offset(count) {
+    this.offsetValue = count;
+    return this;
+  }
+  /** Inclusive range helper, like supabase-js. `range(0, 9)` → first 10 rows. */
+  range(from, to) {
+    this.offsetValue = from;
+    this.limitValue = to - from + 1;
+    return this;
+  }
+  filter(column, op, value) {
+    this.filters.push([column, `${op}.${String(value)}`]);
+    return this;
+  }
+  buildUrl() {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(this.reserved)) params.set(key, value);
+    for (const [column, expr] of this.filters) params.append(column, expr);
+    if (this.orders.length) params.set("order", this.orders.join(","));
+    if (this.limitValue !== void 0) params.set("limit", String(this.limitValue));
+    if (this.offsetValue !== void 0) params.set("offset", String(this.offsetValue));
+    const query = params.toString();
+    const path = `${this.ctx.rest}/${this.ctx.project}/${this.table}`;
+    return query ? `${path}?${query}` : path;
+  }
+  execute() {
+    const token = this.ctx.session.accessToken() ?? this.ctx.anonKey;
+    return request(this.buildUrl(), {
+      method: this.method,
+      token,
+      body: this.body !== void 0 ? JSON.stringify(this.body) : void 0
+    });
+  }
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+};
+
+// src/realtime.ts
+var RealtimeChannel = class {
+  constructor(topic, client) {
+    this.topic = topic;
+    this.client = client;
+  }
+  topic;
+  client;
+  /** @internal */
+  bindings = [];
+  subscribed = false;
+  on(type, filter, cb) {
+    if (type === "broadcast") {
+      this.bindings.push({ kind: "broadcast", event: String(filter.event), cb });
+    } else if (type === "presence") {
+      this.bindings.push({ kind: "presence", cb });
+    } else if (type === "postgres_changes") {
+      this.bindings.push({
+        kind: "postgres_changes",
+        table: String(filter.table),
+        event: filter.event ?? "*",
+        cb
+      });
+    }
+    return this;
+  }
+  /** Open the connection (if needed) and register this channel's topic. */
+  subscribe() {
+    this.subscribed = true;
+    this.client._attach(this);
+    return this;
+  }
+  /** Send a broadcast to every other subscriber on this topic (no self-echo). */
+  send(message) {
+    this.client._send({ type: "broadcast", topic: this.topic, event: message.event, payload: message.payload });
+  }
+  /** Advertise presence state for this client on the topic. */
+  track(payload = {}) {
+    this.client._send({ type: "presence", event: "track", topic: this.topic, payload });
+  }
+  untrack() {
+    this.client._send({ type: "presence", event: "untrack", topic: this.topic });
+  }
+  unsubscribe() {
+    this.subscribed = false;
+    this.client._send({ type: "unsubscribe", topic: this.topic });
+    this.client._detach(this);
+  }
+  /** @internal The subscribe frame the server expects for this channel. */
+  _subscribeFrame() {
+    const changes = this.bindings.filter((b) => b.kind === "postgres_changes").map((b) => ({ table: b.table, event: b.event }));
+    return {
+      type: "subscribe",
+      topic: this.topic,
+      presence: this.bindings.some((b) => b.kind === "presence"),
+      postgres_changes: changes
+    };
+  }
+  /** @internal */
+  get isSubscribed() {
+    return this.subscribed;
+  }
+};
+var RealtimeClient = class {
+  constructor(base, project, anonKey, session) {
+    this.base = base;
+    this.project = project;
+    this.anonKey = anonKey;
+    this.session = session;
+  }
+  base;
+  project;
+  anonKey;
+  session;
+  socket = null;
+  channels = /* @__PURE__ */ new Map();
+  outbox = [];
+  reconnectAttempts = 0;
+  closedByUser = false;
+  channel(topic) {
+    const existing = this.channels.get(topic);
+    if (existing) return existing;
+    const channel = new RealtimeChannel(topic, this);
+    this.channels.set(topic, channel);
+    return channel;
+  }
+  /** Tear everything down. Call on app unmount / sign-out. */
+  disconnect() {
+    this.closedByUser = true;
+    this.socket?.close();
+    this.socket = null;
+    this.channels.clear();
+  }
+  /** @internal */
+  _attach(channel) {
+    this.channels.set(channel.topic, channel);
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this._send(channel._subscribeFrame());
+    } else {
+      this.connect();
+    }
+  }
+  /** @internal */
+  _detach(channel) {
+    this.channels.delete(channel.topic);
+  }
+  /** @internal Queues until the socket is open, then flushes in order. */
+  _send(frame) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify(frame));
+    } else {
+      this.outbox.push(frame);
+      this.connect();
+    }
+  }
+  connect() {
+    if (this.socket && this.socket.readyState <= WebSocket.OPEN) return;
+    this.closedByUser = false;
+    const token = this.session.accessToken() ?? this.anonKey;
+    const url = `${this.base}/${this.project}?token=${encodeURIComponent(token)}`;
+    const socket = new WebSocket(url);
+    this.socket = socket;
+    socket.onopen = () => {
+      this.reconnectAttempts = 0;
+      for (const channel of this.channels.values()) {
+        if (channel.isSubscribed) socket.send(JSON.stringify(channel._subscribeFrame()));
+      }
+      while (this.outbox.length) socket.send(JSON.stringify(this.outbox.shift()));
+    };
+    socket.onmessage = (ev) => this.dispatch(ev.data);
+    socket.onclose = () => {
+      this.socket = null;
+      if (!this.closedByUser && this.channels.size) this.scheduleReconnect();
+    };
+    socket.onerror = () => socket.close();
+  }
+  scheduleReconnect() {
+    const delay = Math.min(1e3 * 2 ** this.reconnectAttempts, 1e4);
+    this.reconnectAttempts += 1;
+    setTimeout(() => {
+      if (!this.closedByUser) this.connect();
+    }, delay);
+  }
+  dispatch(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(String(raw));
+    } catch {
+      return;
+    }
+    const topic = msg.topic;
+    const channel = topic ? this.channels.get(topic) : void 0;
+    if (!channel) return;
+    for (const binding of channel.bindings) {
+      if (msg.type === "broadcast" && binding.kind === "broadcast") {
+        if (binding.event === "*" || binding.event === msg.event) {
+          binding.cb({ event: msg.event, payload: msg.payload });
+        }
+      } else if (msg.type === "presence" && binding.kind === "presence") {
+        binding.cb(msg.state ?? {});
+      } else if (msg.type === "postgres_changes" && binding.kind === "postgres_changes") {
+        const change = msg.payload;
+        const tableMatch = binding.table === change.table;
+        const eventMatch = binding.event === "*" || binding.event === change.eventType;
+        if (tableMatch && eventMatch) binding.cb(change);
+      }
+    }
+  }
+};
+
+// src/session.ts
+var SessionManager = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  current = null;
+  listeners = /* @__PURE__ */ new Set();
+  /** Load any persisted session on startup. Safe to call more than once. */
+  async hydrate() {
+    if (this.current) return this.current;
+    if (this.store) {
+      this.current = await this.store.get() ?? null;
+    }
+    return this.current;
+  }
+  /**
+   * Synchronous hydrate for stores that read synchronously (cookies,
+   * localStorage). SSR needs the session in memory before the first request in
+   * the same tick — an awaited hydrate would be too late. No-ops for async stores.
+   */
+  hydrateSync() {
+    if (this.current || !this.store) return;
+    const maybe = this.store.get();
+    if (maybe && typeof maybe.then === "function") return;
+    this.current = maybe ?? null;
+  }
+  get() {
+    return this.current;
+  }
+  /** The token data requests should send: the user's, or null to fall back to the anon key. */
+  accessToken() {
+    return this.current?.access_token ?? null;
+  }
+  async set(session, event) {
+    this.current = session;
+    await this.store?.set(session);
+    for (const listener of this.listeners) listener(event, session);
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+};
+
+// src/storage.ts
+function encodePath(path) {
+  return path.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+}
+var BucketApi = class {
+  constructor(ctx, bucket) {
+    this.ctx = ctx;
+    this.bucket = bucket;
+  }
+  ctx;
+  bucket;
+  token() {
+    return this.ctx.session.accessToken() ?? this.ctx.anonKey;
+  }
+  objectUrl(path) {
+    return `${this.ctx.storage}/${this.ctx.project}/object/${encodeURIComponent(this.bucket)}/${encodePath(path)}`;
+  }
+  /** Upload (or overwrite) an object. */
+  upload(path, body, options = {}) {
+    const contentType = options.contentType ?? (typeof Blob !== "undefined" && body instanceof Blob && body.type ? body.type : "application/octet-stream");
+    return request(this.objectUrl(path), {
+      method: "PUT",
+      token: this.token(),
+      headers: { "Content-Type": contentType },
+      body
+    });
+  }
+  /** Download an object's bytes. */
+  async download(path) {
+    try {
+      const res = await fetch(this.objectUrl(path), {
+        headers: { Authorization: `Bearer ${this.token()}` }
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => null);
+        return {
+          data: null,
+          error: { message: body?.error ?? res.statusText, status: res.status }
+        };
+      }
+      return { data: await res.blob(), error: null };
+    } catch (cause) {
+      const message = cause instanceof Error ? cause.message : "Network request failed.";
+      return { data: null, error: { message, status: 0 } };
+    }
+  }
+  /** Delete one or more objects. */
+  async remove(paths) {
+    let removed = 0;
+    for (const path of paths) {
+      const res = await request(this.objectUrl(path), {
+        method: "DELETE",
+        token: this.token()
+      });
+      if (res.error) return { data: null, error: res.error };
+      removed++;
+    }
+    return { data: { removed }, error: null };
+  }
+  /** List objects in the bucket, optionally under a path prefix. */
+  list(prefix) {
+    const qs = prefix ? `?prefix=${encodeURIComponent(prefix)}` : "";
+    return request(
+      `${this.ctx.storage}/${this.ctx.project}/list/${encodeURIComponent(this.bucket)}${qs}`,
+      { token: this.token() }
+    );
+  }
+  /** Mint a time-boxed signed URL for a private object (default 1 hour). */
+  createSignedUrl(path, expiresIn = 3600) {
+    return request(
+      `${this.ctx.storage}/${this.ctx.project}/sign/${encodeURIComponent(this.bucket)}/${encodePath(path)}`,
+      {
+        method: "POST",
+        token: this.token(),
+        body: JSON.stringify({ expiresIn })
+      }
+    );
+  }
+  /** The token-less public URL for an object in a public bucket. */
+  getPublicUrl(path) {
+    return `${this.ctx.storage}/${this.ctx.project}/public/${encodeURIComponent(this.bucket)}/${encodePath(path)}`;
+  }
+  /** A transform (render) URL — resize/reformat an image on the fly. */
+  getRenderUrl(path, transform = {}) {
+    const params = new URLSearchParams();
+    if (transform.width) params.set("width", String(transform.width));
+    if (transform.height) params.set("height", String(transform.height));
+    if (transform.resize) params.set("resize", transform.resize);
+    if (transform.format) params.set("format", transform.format);
+    if (transform.quality) params.set("quality", String(transform.quality));
+    const qs = params.toString();
+    return `${this.ctx.storage}/${this.ctx.project}/render/${encodeURIComponent(this.bucket)}/${encodePath(path)}${qs ? `?${qs}` : ""}`;
+  }
+};
+var StorageClient = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** Operate on a bucket. */
+  from(bucket) {
+    return new BucketApi(this.ctx, bucket);
+  }
+};
+
+// src/index.ts
+function resolveEndpoints(url, options) {
+  const base = url.replace(/\/+$/, "");
+  const wsBase = base.replace(/^http/i, "ws");
+  return {
+    rest: options.rest ?? `${base}/rest`,
+    auth: options.auth ?? `${base}/auth`,
+    realtime: options.realtime ?? `${wsBase}/realtime`,
+    storage: options.storage ?? `${base}/storage`
+  };
+}
+var KividbClient = class {
+  constructor(url, anonKey, options = {}) {
+    this.url = url;
+    this.anonKey = anonKey;
+    this.project = options.project ?? projectFromAnonKey(anonKey);
+    this.endpoints = resolveEndpoints(url, options);
+    this.session = new SessionManager(options.store);
+    this.auth = new AuthClient(
+      this.endpoints.auth,
+      this.project,
+      this.session,
+      options.autoRefresh ?? true
+    );
+    this.realtime = new RealtimeClient(
+      this.endpoints.realtime,
+      this.project,
+      anonKey,
+      this.session
+    );
+    this.storage = new StorageClient({
+      storage: this.endpoints.storage,
+      project: this.project,
+      anonKey,
+      session: this.session
+    });
+    this.session.hydrateSync();
+    void this.session.hydrate();
+  }
+  url;
+  anonKey;
+  auth;
+  realtime;
+  storage;
+  project;
+  endpoints;
+  session;
+  /** Start a query against a table. */
+  from(table) {
+    return new FromBuilder(
+      { rest: this.endpoints.rest, project: this.project, anonKey: this.anonKey, session: this.session },
+      table
+    );
+  }
+  /** Open (or reuse) a realtime channel for a topic. */
+  channel(topic) {
+    return this.realtime.channel(topic);
+  }
+};
+function createClient(url, anonKey, options) {
+  return new KividbClient(url, anonKey, options);
+}
+function createBrowserClient(url, anonKey, options = {}) {
+  const project = options.project ?? projectFromAnonKey(anonKey);
+  return new KividbClient(url, anonKey, {
+    ...options,
+    project,
+    store: cookieSessionStore(project, documentCookieMethods())
+  });
+}
+function createServerClient(url, anonKey, options) {
+  const { cookies, ...rest } = options;
+  const project = rest.project ?? projectFromAnonKey(anonKey);
+  return new KividbClient(url, anonKey, {
+    ...rest,
+    project,
+    store: cookieSessionStore(project, cookies)
+  });
+}
+export {
+  AuthClient,
+  FilterBuilder,
+  FromBuilder,
+  KividbClient,
+  RealtimeChannel,
+  RealtimeClient,
+  StorageClient,
+  createBrowserClient,
+  createClient,
+  createServerClient,
+  projectFromAnonKey,
+  sessionCookieName
+};