reflectdb 0.1.0

package/dist/react/index.js

@@ -0,0 +1,366 @@
+import {
+  SyncClient,
+  pushSafely
+} from "../shared/esm-ytrd3hbq.js";
+import"../shared/esm-rw7jjtrv.js";
+import"../shared/esm-3tkwvysa.js";
+import"../shared/esm-b7xs9cde.js";
+
+// src/react/context.tsx
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+var SyncContext = createContext(null);
+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] react 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 SyncProvider({
+  url,
+  token,
+  tables,
+  clientId,
+  storage,
+  onReauth,
+  onError,
+  children
+}) {
+  const [ctx, setCtx] = useState(null);
+  const tablesKey = useMemo(() => JSON.stringify([...tables ?? []].sort()), [tables]);
+  const managedTables = useMemo(() => new Set(tables ?? []), [tablesKey]);
+  const onReauthRef = useRef(onReauth);
+  onReauthRef.current = onReauth;
+  const onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+  const tokenRef = useRef(token);
+  useEffect(() => {
+    tokenRef.current = token;
+  }, [token]);
+  useEffect(() => {
+    let cancelled = false;
+    const id = clientId ?? `browser-${crypto.randomUUID().slice(0, 8)}`;
+    const transport = createBrowserWsTransport(url);
+    const client = new SyncClient({
+      clientId: id,
+      transport,
+      token: tokenRef.current,
+      storage,
+      onReauth: () => onReauthRef.current?.() ?? Promise.reject(new Error("No onReauth handler")),
+      onError: (err) => onErrorRef.current?.(err)
+    });
+    (async () => {
+      if (storage) {
+        await client.init();
+        if (cancelled)
+          return;
+        setCtx({ client, managedTables });
+      }
+      await client.connect();
+      if (cancelled)
+        return;
+      for (const table of managedTables) {
+        await client.sync(table);
+      }
+      await client.resume();
+      if (cancelled)
+        return;
+      if (!storage) {
+        setCtx({ client, managedTables });
+      }
+    })();
+    return () => {
+      cancelled = true;
+      setCtx(null);
+      client.close();
+    };
+  }, [url, clientId, storage, managedTables]);
+  if (!ctx)
+    return null;
+  return /* @__PURE__ */ jsxDEV(SyncContext.Provider, {
+    value: ctx,
+    children
+  }, undefined, false, undefined, this);
+}
+function useSyncClient() {
+  const ctx = useContext(SyncContext);
+  if (!ctx) {
+    throw new Error("useSyncClient must be used within a <SyncProvider>");
+  }
+  return ctx.client;
+}
+// src/react/hooks.ts
+import {
+  useCallback,
+  useContext as useContext2,
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState as useState2,
+  useSyncExternalStore
+} from "react";
+function useSync(table, options) {
+  const ctx = useContext2(SyncContext);
+  if (!ctx) {
+    throw new Error("useSync must be used within a <SyncProvider>");
+  }
+  const { client, managedTables } = ctx;
+  useEffect2(() => {
+    if (managedTables.has(table))
+      return;
+    acquireSync(client, table, options?.params, options?.window ? { window: options.window } : undefined);
+    client.scheduleBootstrap();
+    return () => {
+      releaseSync(client, table);
+    };
+  }, [client, table, managedTables, stableKey(options?.params), options?.window]);
+  const subscribe = useCallback((listener) => client.subscribeTable(table, listener), [client, table]);
+  const version = useSyncExternalStore(subscribe, () => client.getTableVersion(table), () => client.getTableVersion(table));
+  const rows = useMemo2(() => client.getRows(table, { includeDeleted: options?.includeDeleted }), [client, table, version, options?.includeDeleted]);
+  const insert = useCallback((rowId, payload) => {
+    client.insert(table, rowId, payload);
+    pushSafely(client);
+  }, [client, table]);
+  const update = useCallback((rowId, payload) => {
+    client.update(table, rowId, payload);
+    pushSafely(client);
+  }, [client, table]);
+  const remove = useCallback((rowId) => {
+    client.delete(table, rowId);
+    pushSafely(client);
+  }, [client, table]);
+  return { rows, insert, update, remove };
+}
+function useSyncStatus() {
+  const client = useSyncClient();
+  const subscribe = useCallback((listener) => client.subscribe(listener), [client]);
+  return useSyncExternalStore(subscribe, () => client.getState(), () => client.getState());
+}
+function useRow(table, rowId) {
+  const client = useSyncClient();
+  const subscribe = useCallback((listener) => client.subscribeTable(table, listener), [client, table]);
+  const version = useSyncExternalStore(subscribe, () => client.getTableVersion(table), () => client.getTableVersion(table));
+  return useMemo2(() => client.getRow(table, rowId), [client, table, rowId, version]);
+}
+function usePendingCount() {
+  const client = useSyncClient();
+  const subscribe = useCallback((listener) => client.subscribe(listener), [client]);
+  const version = useSyncExternalStore(subscribe, () => client.getVersion(), () => client.getVersion());
+  return useMemo2(() => client.getPendingCount(), [client, version]);
+}
+function useEphemeral(config) {
+  const client = useSyncClient();
+  const [events, setEvents] = useState2({});
+  const timersRef = useRef2(new Map);
+  useEffect2(() => {
+    const unsub = client.subscribeEphemeral(config.key, (event) => {
+      setEvents((prev) => ({ ...prev, [event.userId]: event.data }));
+      if (config.ttlMs) {
+        const existing = timersRef.current.get(event.userId);
+        if (existing) {
+          clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+          setEvents((prev) => {
+            const next = { ...prev };
+            delete next[event.userId];
+            return next;
+          });
+          timersRef.current.delete(event.userId);
+        }, config.ttlMs);
+        timersRef.current.set(event.userId, timer);
+      }
+    });
+    return () => {
+      unsub();
+      for (const timer of timersRef.current.values()) {
+        clearTimeout(timer);
+      }
+      timersRef.current.clear();
+    };
+  }, [client, config.key, config.ttlMs]);
+  const broadcast = useCallback((data) => client.sendEphemeral({
+    key: config.key,
+    userId: config.userId,
+    data,
+    ttlMs: config.ttlMs
+  }), [client, config.key, config.userId, config.ttlMs]);
+  return { events, broadcast };
+}
+function useTotalCount(table) {
+  const client = useSyncClient();
+  const subscribe = useCallback((listener) => client.subscribeTable(table, listener), [client, table]);
+  const version = useSyncExternalStore(subscribe, () => client.getTableVersion(table), () => client.getTableVersion(table));
+  return useMemo2(() => client.getTotalCount(table), [client, table, version]);
+}
+function useLoadMore(table) {
+  const client = useSyncClient();
+  return useCallback((count) => {
+    client.loadMore(table, count);
+  }, [client, table]);
+}
+function stableKey(params) {
+  if (!params)
+    return "";
+  return JSON.stringify(params, Object.keys(params).sort());
+}
+var useSyncRefCounts = new WeakMap;
+var useSyncParamKeys = new WeakMap;
+function acquireSync(client, table, params, options) {
+  let counts = useSyncRefCounts.get(client);
+  if (!counts) {
+    counts = new Map;
+    useSyncRefCounts.set(client, counts);
+  }
+  let keys = useSyncParamKeys.get(client);
+  if (!keys) {
+    keys = new Map;
+    useSyncParamKeys.set(client, keys);
+  }
+  const key = stableKey(params);
+  const prev = keys.get(table);
+  const cnt = counts.get(table) ?? 0;
+  if (cnt === 0 || prev !== key) {
+    if (prev !== undefined && prev !== key)
+      client.unsync(table);
+    client.sync(table, params, options);
+    keys.set(table, key);
+  }
+  counts.set(table, cnt + 1);
+}
+function releaseSync(client, table) {
+  const counts = useSyncRefCounts.get(client);
+  const keys = useSyncParamKeys.get(client);
+  if (!counts || !keys)
+    return;
+  const cnt = (counts.get(table) ?? 1) - 1;
+  if (cnt <= 0) {
+    counts.delete(table);
+    keys.delete(table);
+    client.unsync(table);
+  } else {
+    counts.set(table, cnt);
+  }
+}
+// src/react/typed.ts
+import { useMemo as useMemo3 } from "react";
+function derivePresenceKey(name, params) {
+  if (!params)
+    return `presence:${name}`;
+  const sortedKeys = Object.keys(params).sort();
+  const stable = {};
+  for (const k of sortedKeys)
+    stable[k] = params[k];
+  return `presence:${name}:${JSON.stringify(stable)}`;
+}
+function createSyncReact(queries) {
+  function useSync2(...args) {
+    const [table, options] = args;
+    const result = useSync(table, options);
+    const def = queries?.[table];
+    if (def?.__view) {
+      return { rows: result.rows, loading: false };
+    }
+    return result;
+  }
+  function useRow2(table, rowId) {
+    return useRow(table, rowId);
+  }
+  function useTotalCount2(table) {
+    return useTotalCount(table);
+  }
+  function useLoadMore2(table) {
+    return useLoadMore(table);
+  }
+  function usePresence(...args) {
+    const name = args[0];
+    const params = args[1];
+    const def = queries?.[name] ?? {};
+    const ttlMs = def.ttlMs;
+    const client = useSyncClient();
+    const userId = client.config?.clientId ?? "anonymous";
+    const key = useMemo3(() => derivePresenceKey(name, params), [name, params]);
+    const { events, broadcast } = useEphemeral({
+      key,
+      userId,
+      ttlMs
+    });
+    const peers = useMemo3(() => Object.entries(events).map(([uid, state]) => ({
+      userId: uid,
+      state
+    })), [events]);
+    return { peers, set: broadcast };
+  }
+  return {
+    SyncProvider,
+    useSync: useSync2,
+    useSyncStatus,
+    useRow: useRow2,
+    usePendingCount,
+    useEphemeral,
+    usePresence,
+    useTotalCount: useTotalCount2,
+    useLoadMore: useLoadMore2
+  };
+}
+export {
+  useTotalCount,
+  useSyncStatus,
+  useSyncClient,
+  useSync,
+  useRow,
+  usePendingCount,
+  useLoadMore,
+  useEphemeral,
+  derivePresenceKey,
+  createSyncReact,
+  SyncProvider,
+  SyncContext
+};

package/dist/server/drizzle.d.ts

@@ -0,0 +1,233 @@
+type OpType = "insert" | "update" | "delete";
+interface AuthContext {
+	userId: string;
+	[key: string]: unknown;
+}
+interface DrizzleTableLike {
+	$inferSelect: Record<string, unknown>;
+	$inferInsert: Record<string, unknown>;
+}
+/**
+* Adapter contract for `server.tx({ atomic: true })` — pluggable so non-drizzle
+* data layers (kysely, prisma, raw SQL) can wrap their own BEGIN/COMMIT/ROLLBACK
+* without reflectdb hard-coding a drizzle dependency.
+*
+* Pass an adapter via:
+* - `server.tx({ atomic: <adapter> }, fn)` — per-call override.
+* - `ServerConfig.txAtomic` — server-wide default for `atomic: true`.
+*
+* If neither is supplied and `atomic: true` is requested, reflectdb falls back to
+* the bundled drizzle adapter via dynamic import (no top-level dep). When
+* drizzle isn't installed the fallback throws a clear error directing users to
+* supply a `txAtomic` adapter.
+*/
+interface TxAtomicAdapter {
+	/** Begin a transaction on the given db handle. */
+	begin(db: unknown): Promise<void>;
+	/** Commit the in-flight transaction. */
+	commit(db: unknown): Promise<void>;
+	/** Roll back the in-flight transaction. */
+	rollback(db: unknown): Promise<void>;
+}
+interface ResolvedOp {
+	type: OpType;
+	table: string;
+	rowId: string;
+	payload: Record<string, unknown> | null;
+	hlc: string;
+}
+interface MutationContext<TAuth extends AuthContext = AuthContext> {
+	auth: TAuth;
+	params: Record<string, unknown>;
+}
+type AuthorizeAction = {
+	type: "read";
+	table: string;
+	params: Record<string, unknown>;
+} | {
+	type: "write";
+	table: string;
+	op: ResolvedOp;
+};
+type Ctx<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = {
+	auth: TAuth;
+	params: TParams;
+};
+/**
+* Function-form scope returns an adapter-interpreted SQL fragment (e.g. a
+* drizzle `SQL`, a kysely `Expression<boolean>`, or a raw string). The generic
+* factory treats it as opaque (`unknown`) — ORM-specific helpers like
+* `drizzleTable` narrow the return type at their call site.
+*/
+type ScopeFn<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = (ctx: Ctx<TAuth, TParams>) => unknown;
+type ScopeOpt<
+	TRowKey extends string,
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = TRowKey | {
+	auth: keyof TAuth & string;
+	column: TRowKey;
+} | ScopeFn<TAuth, TParams>;
+type StampSource<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = "auth.userId" | "auth.name" | string | ((ctx: Ctx<TAuth, TParams>) => unknown);
+type ServerSetSource<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = unknown | ((ctx: Ctx<TAuth, TParams>) => unknown);
+type FieldPolicy<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = "server-only" | "insert-only" | {
+	write: (input: {
+		ctx: Ctx<TAuth, TParams>;
+		existing?: Record<string, unknown> | null;
+		payload: Record<string, unknown>;
+	}) => boolean | Promise<boolean>;
+};
+interface DefineTableOpts<
+	TRow extends Record<string, unknown> = Record<string, unknown>,
+	TAuth extends AuthContext = AuthContext,
+	TParams extends Record<string, unknown> = Record<string, unknown>
+> {
+	scope?: ScopeOpt<keyof TRow & string, TAuth, TParams>;
+	rowId?: string;
+	ownerStamp?: Partial<Record<keyof TRow & string, StampSource<TAuth, TParams>>>;
+	serverSet?: Partial<Record<keyof TRow & string, ServerSetSource<TAuth, TParams>>>;
+	policy?: {
+		read?: (input: {
+			ctx: Ctx<TAuth, TParams>;
+			existing?: Record<string, unknown> | null;
+		}) => boolean | Promise<boolean>;
+		insert?: (input: {
+			ctx: Ctx<TAuth, TParams>;
+			payload: Record<string, unknown>;
+		}) => boolean | Promise<boolean>;
+		update?: (input: {
+			ctx: Ctx<TAuth, TParams>;
+			existing: Record<string, unknown>;
+			payload: Record<string, unknown>;
+		}) => boolean | Promise<boolean>;
+		delete?: (input: {
+			ctx: Ctx<TAuth, TParams>;
+			existing: Record<string, unknown>;
+		}) => boolean | Promise<boolean>;
+		fields?: Partial<Record<keyof TRow & string, FieldPolicy<TAuth, TParams>>>;
+	};
+	hooks?: {
+		beforeInsert?: (input: {
+			payload: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		afterInsert?: (input: {
+			row: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		beforeUpdate?: (input: {
+			payload: Record<string, unknown>;
+			existing: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		afterUpdate?: (input: {
+			row: Record<string, unknown>;
+			previous: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		beforeDelete?: (input: {
+			existing: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		afterDelete?: (input: {
+			rowId: string;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+	};
+	query?: (ctx: Ctx<TAuth, TParams>, db: any) => unknown;
+	insert?: (input: {
+		payload: Record<string, unknown>;
+		existing?: Record<string, unknown> | null;
+		ctx: Ctx<TAuth, TParams>;
+		db: any;
+	}) => Promise<void> | void;
+	update?: (input: {
+		payload: Record<string, unknown>;
+		existing: Record<string, unknown>;
+		ctx: Ctx<TAuth, TParams>;
+		db: any;
+	}) => Promise<void> | void;
+	delete?: (input: {
+		rowId: string;
+		existing: Record<string, unknown> | null;
+		ctx: Ctx<TAuth, TParams>;
+		db: any;
+	}) => Promise<void> | void;
+	pk?: keyof TRow & string;
+}
+import { SQL as SQL_1rji } from "drizzle-orm";
+type SQL = SQL_1rji;
+type Ctx2<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = {
+	auth: TAuth;
+	params: TParams;
+};
+type DrizzleScopeFn<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = (ctx: Ctx2<TAuth, TParams>) => SQL;
+type DrizzleScopeOpt<
+	TRowKey extends string,
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = TRowKey | {
+	auth: keyof TAuth & string;
+	column: TRowKey;
+} | DrizzleScopeFn<TAuth, TParams>;
+/**
+* Drizzle-flavored options. Identical surface to `DefineTableOpts` except the
+* row type is derived from `$inferSelect` and function-form scope returns
+* drizzle's `SQL` (vs. the generic factory's `unknown`). Kept for backward
+* compat with the existing public `drizzleTable<TTable, ...>(opts)` call shape.
+*/
+interface DrizzleTableOpts<
+	TTable extends DrizzleTableLike,
+	TAuth extends AuthContext = AuthContext,
+	TParams extends Record<string, unknown> = Record<string, unknown>
+> extends Omit<DefineTableOpts<TTable["$inferSelect"], TAuth, TParams>, "scope"> {
+	scope?: DrizzleScopeOpt<keyof TTable["$inferSelect"] & string, TAuth, TParams>;
+}
+declare function drizzleTable<
+	TTable extends DrizzleTableLike,
+	TAuth extends AuthContext = AuthContext,
+	TParams extends Record<string, unknown> = Record<string, unknown>
+>(table: TTable, opts?: DrizzleTableOpts<TTable, TAuth, TParams>): {
+	query: (ctx: Ctx2<TAuth, TParams>, db: any) => unknown;
+	mutate: (op: ResolvedOp, ctx: MutationContext<TAuth>, db: any) => Promise<void>;
+	authorize: (action: AuthorizeAction, ctx: MutationContext<TAuth>, db: any) => Promise<void>;
+};
+/**
+* `TxAtomicAdapter` for drizzle handles. Uses raw SQL via `db.run(sql\`BEGIN\`)`
+* — drizzle's async `db.transaction(...)` is unsafe on the bun-sqlite dialect
+* (sync transaction commits before the async body finishes), so we route
+* through `db.run(...)` which is portable across sqlite and postgres adapters.
+*
+* Exported so users can pass it explicitly to `tx({ atomic: drizzleTxAtomic })`
+* or to `ServerConfig.txAtomic` — and so the server's lazy-loaded fallback
+* has a single source of truth.
+*/
+declare const drizzleTxAtomic: TxAtomicAdapter;
+export { drizzleTxAtomic, drizzleTable, DrizzleTableOpts };

package/dist/server/drizzle.js

@@ -0,0 +1,9 @@
+import {
+  drizzleTable,
+  drizzleTxAtomic
+} from "../shared/esm-z1xse19c.js";
+import"../shared/esm-b7xs9cde.js";
+export {
+  drizzleTxAtomic,
+  drizzleTable
+};