reflectdb 0.1.0

package/dist/svelte/index.js

@@ -0,0 +1,262 @@
+import {
+  SyncClient,
+  pushSafely
+} from "../shared/esm-ytrd3hbq.js";
+import"../shared/esm-rw7jjtrv.js";
+import"../shared/esm-3tkwvysa.js";
+import"../shared/esm-b7xs9cde.js";
+
+// src/svelte/stores.ts
+function createBrowserWsTransport(url) {
+  let ws = null;
+  let handler = null;
+  let intentionalClose = false;
+  const sendQueue = [];
+  function ensureConnected() {
+    if (ws && ws.readyState !== WebSocket.CLOSED && ws.readyState !== WebSocket.CLOSING) {
+      return ws;
+    }
+    const socket = new WebSocket(url);
+    socket.onopen = () => {
+      for (const msg of sendQueue) {
+        socket.send(JSON.stringify(msg));
+      }
+      sendQueue.length = 0;
+    };
+    socket.onmessage = (event) => {
+      try {
+        handler?.(JSON.parse(event.data));
+      } catch (err) {
+        console.warn("[reflectdb] svelte WS: malformed message ignored:", err instanceof Error ? err.message : String(err));
+      }
+    };
+    socket.onclose = () => {
+      ws = null;
+      if (!intentionalClose) {
+        handler?.({ type: "disconnect", reason: "transport_closed" });
+      }
+    };
+    ws = socket;
+    return socket;
+  }
+  return {
+    async send(message) {
+      const socket = ensureConnected();
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(JSON.stringify(message));
+      } else {
+        sendQueue.push(message);
+      }
+    },
+    subscribe(h) {
+      handler = h;
+    },
+    async close() {
+      intentionalClose = true;
+      if (ws) {
+        ws.close();
+        ws = null;
+      }
+    }
+  };
+}
+function stableKey(params) {
+  if (!params)
+    return "";
+  return JSON.stringify(params, Object.keys(params).sort());
+}
+function createSyncStore(config) {
+  const managedTables = new Set(config.tables ?? []);
+  const clientId = config.clientId ?? `browser-${crypto.randomUUID().slice(0, 8)}`;
+  const transport = createBrowserWsTransport(config.url);
+  const client = new SyncClient({
+    clientId,
+    transport,
+    token: config.token,
+    storage: config.storage,
+    onReauth: () => config.onReauth?.() ?? Promise.reject(new Error("No onReauth handler")),
+    onError: (err) => config.onError?.(err)
+  });
+  const unmanagedRefCounts = new Map;
+  const unmanagedParamKeys = new Map;
+  const status = {
+    subscribe(cb) {
+      cb(client.getState());
+      return client.subscribe(() => {
+        cb(client.getState());
+      });
+    }
+  };
+  const pendingCount = {
+    subscribe(cb) {
+      cb(client.getPendingCount());
+      return client.subscribe(() => {
+        cb(client.getPendingCount());
+      });
+    }
+  };
+  function sync(table, options) {
+    const isManaged = managedTables.has(table);
+    const paramKey = stableKey(options?.params);
+    const rows = {
+      subscribe(cb) {
+        if (!isManaged) {
+          const currentParamKey = unmanagedParamKeys.get(table);
+          const count = unmanagedRefCounts.get(table) ?? 0;
+          if (count === 0 || currentParamKey !== paramKey) {
+            if (currentParamKey !== undefined && currentParamKey !== paramKey) {
+              client.unsync(table);
+            }
+            client.sync(table, options?.params, options?.window ? { window: options.window } : undefined);
+            client.scheduleBootstrap();
+            unmanagedParamKeys.set(table, paramKey);
+          }
+          unmanagedRefCounts.set(table, count + 1);
+        }
+        cb(client.getRows(table, { includeDeleted: options?.includeDeleted }));
+        const unsub = client.subscribeTable(table, () => {
+          cb(client.getRows(table, { includeDeleted: options?.includeDeleted }));
+        });
+        return () => {
+          unsub();
+          if (!isManaged) {
+            const count = (unmanagedRefCounts.get(table) ?? 1) - 1;
+            if (count <= 0) {
+              unmanagedRefCounts.delete(table);
+              unmanagedParamKeys.delete(table);
+              client.unsync(table);
+            } else {
+              unmanagedRefCounts.set(table, count);
+            }
+          }
+        };
+      }
+    };
+    const insert = (rowId, payload) => {
+      client.insert(table, rowId, payload);
+      pushSafely(client);
+    };
+    const update = (rowId, payload) => {
+      client.update(table, rowId, payload);
+      pushSafely(client);
+    };
+    const remove = (rowId) => {
+      client.delete(table, rowId);
+      pushSafely(client);
+    };
+    return { rows, insert, update, remove };
+  }
+  function row(table, rowId) {
+    return {
+      subscribe(cb) {
+        cb(client.getRow(table, rowId));
+        return client.subscribeTable(table, () => {
+          cb(client.getRow(table, rowId));
+        });
+      }
+    };
+  }
+  function ephemeral(cfg) {
+    let current = {};
+    const timers = new Map;
+    const subscribers = new Set;
+    function notifySubscribers() {
+      for (const sub of subscribers) {
+        sub(current);
+      }
+    }
+    const unsub = client.subscribeEphemeral(cfg.key, (event) => {
+      current = { ...current, [event.userId]: event.data };
+      notifySubscribers();
+      if (cfg.ttlMs) {
+        const existing = timers.get(event.userId);
+        if (existing) {
+          clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+          const next = { ...current };
+          delete next[event.userId];
+          current = next;
+          timers.delete(event.userId);
+          notifySubscribers();
+        }, cfg.ttlMs);
+        timers.set(event.userId, timer);
+      }
+    });
+    const events = {
+      subscribe(cb) {
+        subscribers.add(cb);
+        cb(current);
+        return () => {
+          subscribers.delete(cb);
+        };
+      }
+    };
+    const broadcast = (data) => client.sendEphemeral({
+      key: cfg.key,
+      userId: cfg.userId,
+      data,
+      ttlMs: cfg.ttlMs
+    });
+    const destroy = () => {
+      unsub();
+      for (const timer of timers.values()) {
+        clearTimeout(timer);
+      }
+      timers.clear();
+      subscribers.clear();
+    };
+    return { events, broadcast, destroy };
+  }
+  function totalCount(table) {
+    return {
+      subscribe(cb) {
+        cb(client.getTotalCount(table));
+        return client.subscribeTable(table, () => {
+          cb(client.getTotalCount(table));
+        });
+      }
+    };
+  }
+  function loadMore(table, count) {
+    client.loadMore(table, count);
+  }
+  async function connectLifecycle() {
+    if (config.storage) {
+      await client.init();
+    }
+    await client.connect();
+    for (const table of managedTables) {
+      await client.sync(table);
+    }
+    await client.resume();
+  }
+  async function close() {
+    await client.close();
+  }
+  return {
+    client,
+    status,
+    pendingCount,
+    sync,
+    row,
+    ephemeral,
+    totalCount,
+    loadMore,
+    connect: connectLifecycle,
+    close
+  };
+}
+// src/svelte/typed.ts
+function createSyncSvelte() {
+  function createStore(config) {
+    const store = createSyncStore(config);
+    return store;
+  }
+  return { createStore };
+}
+export {
+  createSyncSvelte,
+  createSyncStore,
+  createBrowserWsTransport
+};

package/dist/transport/bun-ws.d.ts

@@ -0,0 +1,215 @@
+type OpType = "insert" | "update" | "delete";
+type ErrorReason = "outside_shape" | "readonly_query" | "rate_limited" | "buffer_full" | "server_conflict" | "custom_conflict" | "merge_stale" | "clock_drift" | "replay" | "batch_too_large" | "schema_outdated" | "auth_revoked" | "compacted" | "mutation_rejected" | "server_error" | "unknown_query";
+interface HelloMessage {
+	type: "hello";
+	/** Highest protocol version the client prefers. Retained for back-compat. */
+	protocolVersion: number;
+	/** All versions the client can speak. Omit for legacy single-version clients. */
+	supportedVersions?: readonly number[];
+	clientId: string;
+	token: string;
+}
+interface BootstrapMessage {
+	type: "bootstrap";
+	syncParams?: Record<string, Record<string, unknown>>;
+}
+interface ResumeMessage {
+	type: "resume";
+	since: string;
+}
+interface OpsMessage {
+	type: "ops";
+	ops: ClientOp[];
+	token: string;
+}
+interface ClientOp {
+	id: string;
+	table: string;
+	op: OpType;
+	rowId: string;
+	payload: Record<string, unknown> | null;
+	hlc: string;
+	batchId?: string;
+	batchSize?: number;
+	batchSeq?: number;
+}
+interface SyncDeclareMessage {
+	type: "sync_declare";
+	table: string;
+	params?: Record<string, unknown>;
+	window?: number;
+}
+interface LoadMoreMessage {
+	type: "load_more";
+	table: string;
+	count: number;
+}
+interface UnsyncMessage {
+	type: "unsync";
+	table: string;
+}
+interface AuthMessage {
+	type: "auth";
+	token: string;
+}
+interface EphemeralMessage {
+	type: "ephemeral";
+	key: string;
+	userId: string;
+	data: Record<string, unknown>;
+	ttlMs?: number;
+}
+interface HelloAckMessage {
+	type: "hello_ack";
+	protocolVersion: number;
+	serverId: string;
+}
+interface HelloRejectMessage {
+	type: "hello_reject";
+	reason: string;
+	supported: number[];
+}
+interface SnapshotMessage {
+	type: "snapshot";
+	table: string;
+	rows: Record<string, unknown>[];
+	colClocks: Record<string, Record<string, string>>;
+	append?: boolean;
+	totalCount?: number;
+	/**
+	* Primary key column name for this table. Self-contained per message so the
+	* client doesn't depend on `bootstrap_complete.tableMeta` arriving first.
+	* When omitted (older servers), the client falls back to tableMeta, then "id".
+	*/
+	pk?: string;
+}
+interface BootstrapCompleteMessage {
+	type: "bootstrap_complete";
+	serverHlc: string;
+	tableMeta: Record<string, TableMeta>;
+}
+interface TableMeta {
+	serverSet: string[];
+	readonly: string[];
+	broadcast: "consistent" | "eager" | "eager-durable";
+	/** Primary key column name. Defaults to "id" when omitted (older servers). */
+	pk?: string;
+}
+interface DeltaMessage {
+	type: "delta";
+	table: string;
+	op: OpType;
+	rowId: string;
+	payload: Record<string, unknown> | null;
+	hlc: string;
+	colClocks?: Record<string, string>;
+}
+interface AckMessage {
+	type: "ack";
+	opIds: string[];
+}
+interface RejectMessage {
+	type: "reject";
+	opId?: string;
+	batchId?: string;
+	reason: ErrorReason;
+	serverRow?: Record<string, unknown>;
+}
+interface ResumeCompleteMessage {
+	type: "resume_complete";
+	serverHlc: string;
+}
+interface ResumeRejectedMessage {
+	type: "resume_rejected";
+	reason: string;
+	serverHlc: string;
+}
+interface ShapeChangedMessage {
+	type: "shape_changed";
+	table: string;
+	reason: "auth_changed" | "params_changed" | "server_policy";
+}
+interface DisconnectMessage {
+	type: "disconnect";
+	reason: string;
+}
+interface ReauthMessage {
+	type: "reauth";
+}
+interface CountChangedMessage {
+	type: "count_changed";
+	table: string;
+	totalCount: number;
+}
+interface EphemeralEvent {
+	type: "ephemeral";
+	key: string;
+	clientId: string;
+	userId: string;
+	data: Record<string, unknown>;
+	ttlMs?: number;
+}
+type ClientMessage = HelloMessage | BootstrapMessage | ResumeMessage | OpsMessage | SyncDeclareMessage | LoadMoreMessage | UnsyncMessage | AuthMessage | EphemeralMessage;
+type ServerMessage = HelloAckMessage | HelloRejectMessage | SnapshotMessage | BootstrapCompleteMessage | DeltaMessage | AckMessage | RejectMessage | ResumeCompleteMessage | ResumeRejectedMessage | ShapeChangedMessage | DisconnectMessage | ReauthMessage | EphemeralEvent | CountChangedMessage;
+interface ServerTransport {
+	/**
+	* Deliver a message to one client.
+	*
+	* MUST reject (ideally with `TransportSendError`) when the frame could not
+	* be handed to the peer — unknown/closed socket, full outbound queue, or a
+	* throw from the underlying socket. Resolving on a dropped frame makes the
+	* broadcast engine commit result-cache state the client never received.
+	*/
+	send(clientId: string, message: ServerMessage): Promise<void>;
+	broadcast(roomId: string, message: ServerMessage, exclude?: string): Promise<void>;
+	onMessage(handler: (clientId: string, message: ClientMessage) => void): void;
+	onConnect(handler: (clientId: string, req: Request) => void): void;
+	onDisconnect(handler: (clientId: string) => void): void;
+	close(): Promise<void>;
+	/**
+	* Force-disconnect a single client. Optional — if absent, the handler relies
+	* on the client honoring a `disconnect` server-message. Required for any
+	* transport that carries authentication state, since an adversarial client
+	* can otherwise ignore the message and continue using a revoked session.
+	*/
+	disconnect?(clientId: string): Promise<void> | void;
+}
+interface BunWsTransportData {
+	id: string;
+	/** Original upgrade request — forwarded to the onConnect handler if provided */
+	req?: Request;
+}
+/** Bun's ServerWebSocket shape (subset used by this transport) */
+interface BunServerWebSocket<T> {
+	data: T;
+	send(data: string): void;
+	ping?: (data?: string) => void;
+	close(): void;
+	readyState?: number;
+	/** Bun exposes queued-but-unflushed bytes here; used for backpressure. */
+	getBufferedAmount?: () => number;
+}
+interface BunWsServerConfig {
+	/** Max inbound message bytes before the connection is closed. Default: 1 MB. */
+	maxMessageBytes?: number;
+	/** Ping interval in ms. 0 disables. Default: 30_000. */
+	pingIntervalMs?: number;
+	/** Close a connection if no message/pong seen in this window. Default: 2× pingInterval. */
+	pongTimeoutMs?: number;
+	/**
+	* Outbound backpressure ceiling in bytes. `send` rejects once the socket has
+	* more than this queued, so a slow reader can't grow server memory without
+	* bound. 0 disables. Default: 8 MB.
+	*/
+	maxBufferedBytes?: number;
+}
+declare function createBunWsServerTransport(cfg?: BunWsServerConfig): {
+	transport: ServerTransport;
+	websocket: {
+		open(ws: BunServerWebSocket<BunWsTransportData>): void;
+		message(ws: BunServerWebSocket<BunWsTransportData>, data: string | Uint8Array): void;
+		close(ws: BunServerWebSocket<BunWsTransportData>): void;
+		pong?(ws: BunServerWebSocket<BunWsTransportData>): void;
+	};
+};
+export { createBunWsServerTransport, BunWsTransportData, BunWsServerConfig };

package/dist/transport/bun-ws.js

@@ -0,0 +1,140 @@
+import {
+  TransportSendError
+} from "../shared/esm-3tkwvysa.js";
+import"../shared/esm-b7xs9cde.js";
+
+// src/transport/bun-ws.ts
+function trySend(clientId, ws, data, maxBufferedBytes) {
+  if (ws.readyState !== undefined && ws.readyState !== 1) {
+    throw new TransportSendError(clientId, `bun-ws not open (readyState=${ws.readyState})`);
+  }
+  if (maxBufferedBytes > 0 && typeof ws.getBufferedAmount === "function") {
+    const buffered = ws.getBufferedAmount();
+    if (buffered > maxBufferedBytes) {
+      throw new TransportSendError(clientId, `bun-ws outbound buffer over limit (${buffered} > ${maxBufferedBytes})`);
+    }
+  }
+  try {
+    ws.send(data);
+  } catch (err) {
+    throw new TransportSendError(clientId, `bun-ws send failed: ${err instanceof Error ? err.message : String(err)}`, err);
+  }
+}
+function createBunWsServerTransport(cfg = {}) {
+  const clients = new Map;
+  const lastSeen = new Map;
+  const maxMessageBytes = cfg.maxMessageBytes ?? 1e6;
+  const pingIntervalMs = cfg.pingIntervalMs ?? 30000;
+  const pongTimeoutMs = cfg.pongTimeoutMs ?? pingIntervalMs * 2;
+  const maxBufferedBytes = cfg.maxBufferedBytes ?? 8000000;
+  let messageHandler = null;
+  let connectHandler = null;
+  let disconnectHandler = null;
+  let heartbeatTimer = null;
+  if (pingIntervalMs > 0) {
+    heartbeatTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, ws] of clients) {
+        const last = lastSeen.get(id) ?? now;
+        if (now - last > pongTimeoutMs) {
+          try {
+            ws.close();
+          } catch {}
+          continue;
+        }
+        try {
+          ws.ping?.();
+        } catch {}
+      }
+    }, pingIntervalMs);
+    if (typeof heartbeatTimer.unref === "function") {
+      heartbeatTimer.unref();
+    }
+  }
+  const websocket = {
+    open(ws) {
+      const { id, req } = ws.data;
+      clients.set(id, ws);
+      lastSeen.set(id, Date.now());
+      connectHandler?.(id, req ?? new Request("https://ws-connect"));
+    },
+    message(ws, data) {
+      const { id } = ws.data;
+      lastSeen.set(id, Date.now());
+      const byteLen = typeof data === "string" ? typeof Buffer !== "undefined" ? Buffer.byteLength(data, "utf8") : new Blob([data]).size : data.length;
+      if (byteLen > maxMessageBytes) {
+        console.warn(`[reflectdb] bun-ws: message from ${id} exceeds ${maxMessageBytes} bytes (${byteLen}), closing`);
+        try {
+          ws.close();
+        } catch {}
+        return;
+      }
+      const raw = typeof data === "string" ? data : new TextDecoder().decode(data);
+      try {
+        messageHandler?.(id, JSON.parse(raw));
+      } catch (err) {
+        console.warn(`[reflectdb] bun-ws: malformed message from ${id}:`, err instanceof Error ? err.message : String(err));
+      }
+    },
+    close(ws) {
+      const { id } = ws.data;
+      clients.delete(id);
+      lastSeen.delete(id);
+      disconnectHandler?.(id);
+    },
+    pong(ws) {
+      lastSeen.set(ws.data.id, Date.now());
+    }
+  };
+  const transport = {
+    async send(clientId, message) {
+      const ws = clients.get(clientId);
+      if (!ws) {
+        throw new TransportSendError(clientId, "no socket registered for client");
+      }
+      trySend(clientId, ws, JSON.stringify(message), maxBufferedBytes);
+    },
+    async broadcast(_roomId, message, exclude) {
+      const data = JSON.stringify(message);
+      for (const [id, ws] of clients) {
+        if (id === exclude)
+          continue;
+        try {
+          trySend(id, ws, data, maxBufferedBytes);
+        } catch (err) {
+          console.warn("[reflectdb] bun-ws broadcast skipped a client:", err instanceof Error ? err.message : err);
+        }
+      }
+    },
+    disconnect(clientId) {
+      const ws = clients.get(clientId);
+      if (!ws)
+        return;
+      try {
+        ws.close();
+      } catch {}
+      clients.delete(clientId);
+    },
+    onMessage(handler) {
+      messageHandler = handler;
+    },
+    onConnect(handler) {
+      connectHandler = handler;
+    },
+    onDisconnect(handler) {
+      disconnectHandler = handler;
+    },
+    async close() {
+      if (heartbeatTimer)
+        clearInterval(heartbeatTimer);
+      for (const ws of clients.values())
+        ws.close();
+      clients.clear();
+      lastSeen.clear();
+    }
+  };
+  return { transport, websocket };
+}
+export {
+  createBunWsServerTransport
+};