reflectdb 0.1.0

package/dist/vanilla/index.js

@@ -0,0 +1,278 @@
+import {
+  SyncClient,
+  pushSafely
+} from "../shared/esm-ytrd3hbq.js";
+import"../shared/esm-rw7jjtrv.js";
+import"../shared/esm-3tkwvysa.js";
+import"../shared/esm-b7xs9cde.js";
+
+// src/vanilla/sync.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) => {
+      handler?.(JSON.parse(event.data));
+    };
+    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 createSync(config) {
+  const clientId = config.clientId ?? `browser-${crypto.randomUUID().slice(0, 8)}`;
+  const transport = createBrowserWsTransport(config.url);
+  const managedTables = new Set(config.tables ?? []);
+  const unmanagedRefCounts = new Map;
+  const unmanagedParamKeys = new Map;
+  function stableKey(obj) {
+    if (!obj)
+      return "";
+    const keys = Object.keys(obj).sort();
+    return keys.map((k) => `${k}:${JSON.stringify(obj[k])}`).join("|");
+  }
+  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)
+  });
+  async function connect() {
+    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();
+  }
+  function getState() {
+    return client.getState();
+  }
+  function onStateChange(cb) {
+    let lastState = client.getState();
+    return client.subscribe(() => {
+      const current = client.getState();
+      if (current !== lastState) {
+        lastState = current;
+        cb(current);
+      }
+    });
+  }
+  function getPendingCount() {
+    return client.getPendingCount();
+  }
+  function onPendingChange(cb) {
+    let lastCount = client.getPendingCount();
+    return client.subscribe(() => {
+      const current = client.getPendingCount();
+      if (current !== lastCount) {
+        lastCount = current;
+        cb(current);
+      }
+    });
+  }
+  function sync(table, options) {
+    const isManaged = managedTables.has(table);
+    const paramKey = stableKey(options?.params);
+    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);
+    }
+    return {
+      getRows(getOptions) {
+        return client.getRows(table, {
+          includeDeleted: getOptions?.includeDeleted ?? options?.includeDeleted
+        });
+      },
+      insert(rowId, payload) {
+        client.insert(table, rowId, payload);
+        pushSafely(client);
+      },
+      update(rowId, payload) {
+        client.update(table, rowId, payload);
+        pushSafely(client);
+      },
+      remove(rowId) {
+        client.delete(table, rowId);
+        pushSafely(client);
+      },
+      onChange(cb) {
+        return client.subscribeTable(table, cb);
+      },
+      destroy() {
+        if (isManaged)
+          return;
+        const count = (unmanagedRefCounts.get(table) ?? 1) - 1;
+        if (count <= 0) {
+          unmanagedRefCounts.delete(table);
+          unmanagedParamKeys.delete(table);
+          client.unsync(table);
+        } else {
+          unmanagedRefCounts.set(table, count);
+        }
+      }
+    };
+  }
+  function getRow(table, rowId) {
+    return client.getRow(table, rowId);
+  }
+  function onRowChange(table, rowId, cb) {
+    return client.subscribeTable(table, () => {
+      cb(client.getRow(table, rowId));
+    });
+  }
+  function ephemeral(ephConfig) {
+    let events = {};
+    const timers = new Map;
+    const changeListeners = new Set;
+    function notifyChange() {
+      for (const listener of changeListeners) {
+        listener(events);
+      }
+    }
+    const unsub = client.subscribeEphemeral(ephConfig.key, (event) => {
+      events = { ...events, [event.userId]: event.data };
+      if (ephConfig.ttlMs) {
+        const existing = timers.get(event.userId);
+        if (existing) {
+          clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+          const next = { ...events };
+          delete next[event.userId];
+          events = next;
+          timers.delete(event.userId);
+          notifyChange();
+        }, ephConfig.ttlMs);
+        timers.set(event.userId, timer);
+      }
+      notifyChange();
+    });
+    return {
+      getEvents() {
+        return events;
+      },
+      broadcast(data) {
+        return client.sendEphemeral({
+          key: ephConfig.key,
+          userId: ephConfig.userId,
+          data,
+          ttlMs: ephConfig.ttlMs
+        });
+      },
+      onChange(cb) {
+        changeListeners.add(cb);
+        return () => {
+          changeListeners.delete(cb);
+        };
+      },
+      destroy() {
+        unsub();
+        for (const timer of timers.values()) {
+          clearTimeout(timer);
+        }
+        timers.clear();
+        changeListeners.clear();
+      }
+    };
+  }
+  function getTotalCount(table) {
+    return client.getTotalCount(table);
+  }
+  function onTotalCountChange(table, cb) {
+    let lastCount = client.getTotalCount(table);
+    return client.subscribeTable(table, () => {
+      const current = client.getTotalCount(table);
+      if (current !== lastCount) {
+        lastCount = current;
+        cb(current);
+      }
+    });
+  }
+  function loadMore(table, count) {
+    client.loadMore(table, count);
+  }
+  return {
+    client,
+    connect,
+    close,
+    getState,
+    onStateChange,
+    getPendingCount,
+    onPendingChange,
+    sync,
+    getRow,
+    onRowChange,
+    ephemeral,
+    getTotalCount,
+    onTotalCountChange,
+    loadMore
+  };
+}
+// src/vanilla/typed.ts
+function createSyncVanilla() {
+  return {
+    createSync(config) {
+      const base = createSync(config);
+      return base;
+    }
+  };
+}
+export {
+  createSyncVanilla,
+  createSync,
+  createBrowserWsTransport
+};

package/package.json

@@ -0,0 +1,253 @@
+{
+	"name": "reflectdb",
+	"version": "0.1.0",
+	"description": "Real-time sync engine for TypeScript — a server database and offline-first browser clients stay in sync, with optimistic writes and typed queries.",
+	"keywords": [
+		"sync",
+		"sync-engine",
+		"sync-server",
+		"data-sync",
+		"state-sync",
+		"real-time",
+		"realtime",
+		"replication",
+		"live-query",
+		"local-first",
+		"offline-first",
+		"offline",
+		"optimistic-updates",
+		"conflict-resolution",
+		"last-write-wins",
+		"eventual-consistency",
+		"hybrid-logical-clock",
+		"hlc",
+		"op-log",
+		"websocket",
+		"sse",
+		"server-sent-events",
+		"long-polling",
+		"multiplayer",
+		"collaborative",
+		"collaborative-editing",
+		"presence",
+		"typescript",
+		"type-safe",
+		"react",
+		"react-hooks",
+		"svelte",
+		"drizzle",
+		"drizzle-orm",
+		"kysely",
+		"indexeddb",
+		"postgres",
+		"sqlite",
+		"bun"
+	],
+	"homepage": "https://github.com/TimMikeladze/reflectdb#readme",
+	"bugs": {
+		"url": "https://github.com/TimMikeladze/reflectdb/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/TimMikeladze/reflectdb.git"
+	},
+	"funding": "https://github.com/sponsors/TimMikeladze",
+	"license": "MIT",
+	"author": "Tim Mikeladze <tim.mikeladze@gmail.com> (https://github.com/TimMikeladze)",
+	"type": "module",
+	"sideEffects": false,
+	"engines": {
+		"node": ">=22"
+	},
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"main": "./dist/cjs/core/index.cjs",
+	"module": "./dist/core/index.js",
+	"types": "./dist/core/index.d.ts",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/core/index.d.ts",
+				"default": "./dist/core/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/core/index.d.cts",
+				"default": "./dist/cjs/core/index.cjs"
+			}
+		},
+		"./core": {
+			"import": {
+				"types": "./dist/core/index.d.ts",
+				"default": "./dist/core/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/core/index.d.cts",
+				"default": "./dist/cjs/core/index.cjs"
+			}
+		},
+		"./client": {
+			"import": {
+				"types": "./dist/client/index.d.ts",
+				"default": "./dist/client/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/client/index.d.cts",
+				"default": "./dist/cjs/client/index.cjs"
+			}
+		},
+		"./server": {
+			"import": {
+				"types": "./dist/server/index.d.ts",
+				"default": "./dist/server/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/server/index.d.cts",
+				"default": "./dist/cjs/server/index.cjs"
+			}
+		},
+		"./server/drizzle": {
+			"import": {
+				"types": "./dist/server/drizzle.d.ts",
+				"default": "./dist/server/drizzle.js"
+			},
+			"require": {
+				"types": "./dist/cjs/server/drizzle.d.cts",
+				"default": "./dist/cjs/server/drizzle.cjs"
+			}
+		},
+		"./transport/ws": {
+			"import": {
+				"types": "./dist/transport/ws.d.ts",
+				"default": "./dist/transport/ws.js"
+			},
+			"require": {
+				"types": "./dist/cjs/transport/ws.d.cts",
+				"default": "./dist/cjs/transport/ws.cjs"
+			}
+		},
+		"./transport/bun-ws": {
+			"import": {
+				"types": "./dist/transport/bun-ws.d.ts",
+				"default": "./dist/transport/bun-ws.js"
+			},
+			"require": {
+				"types": "./dist/cjs/transport/bun-ws.d.cts",
+				"default": "./dist/cjs/transport/bun-ws.cjs"
+			}
+		},
+		"./transport/sse": {
+			"import": {
+				"types": "./dist/transport/sse.d.ts",
+				"default": "./dist/transport/sse.js"
+			},
+			"require": {
+				"types": "./dist/cjs/transport/sse.d.cts",
+				"default": "./dist/cjs/transport/sse.cjs"
+			}
+		},
+		"./transport/polling": {
+			"import": {
+				"types": "./dist/transport/polling.d.ts",
+				"default": "./dist/transport/polling.js"
+			},
+			"require": {
+				"types": "./dist/cjs/transport/polling.d.cts",
+				"default": "./dist/cjs/transport/polling.cjs"
+			}
+		},
+		"./react": {
+			"import": {
+				"types": "./dist/react/index.d.ts",
+				"default": "./dist/react/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/react/index.d.cts",
+				"default": "./dist/cjs/react/index.cjs"
+			}
+		},
+		"./svelte": {
+			"import": {
+				"types": "./dist/svelte/index.d.ts",
+				"default": "./dist/svelte/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/svelte/index.d.cts",
+				"default": "./dist/cjs/svelte/index.cjs"
+			}
+		},
+		"./vanilla": {
+			"import": {
+				"types": "./dist/vanilla/index.d.ts",
+				"default": "./dist/vanilla/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/vanilla/index.d.cts",
+				"default": "./dist/cjs/vanilla/index.cjs"
+			}
+		},
+		"./client/storage/indexeddb": {
+			"import": {
+				"types": "./dist/client/storage/indexeddb.d.ts",
+				"default": "./dist/client/storage/indexeddb.js"
+			},
+			"require": {
+				"types": "./dist/cjs/client/storage/indexeddb.d.cts",
+				"default": "./dist/cjs/client/storage/indexeddb.cjs"
+			}
+		},
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"build": "bunup --filter esm && bunup --filter cjs",
+		"format": "oxfmt",
+		"lint": "oxlint",
+		"prepare": "bun simple-git-hooks",
+		"release": "bumpp --commit --push --tag",
+		"test": "bun test",
+		"test:coverage": "bun test --coverage",
+		"test:watch": "bun test --watch",
+		"test:ui": "bun test/ui/server.tsx",
+		"test:sync": "bun test/ui/test-sync.ts",
+		"type-check": "tsc --noEmit",
+		"verify:exports": "bun scripts/verify-exports.ts",
+		"verify:node": "bun scripts/verify-node-consumer.ts"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.3.10",
+		"@types/react": "^19.2.14",
+		"@types/react-dom": "^19.2.3",
+		"bumpp": "^10.4.1",
+		"bunup": "^0.16.31",
+		"drizzle-orm": "^0.45.1",
+		"fake-indexeddb": "^6.2.5",
+		"kysely": "^0.28.12",
+		"oxfmt": "^0.36.0",
+		"oxlint": "^1.51.0",
+		"react-dom": "^19.2.4",
+		"simple-git-hooks": "^2.13.1",
+		"typescript": "^5.9.3"
+	},
+	"peerDependencies": {
+		"drizzle-orm": ">=0.40.0",
+		"react": ">=18.0.0",
+		"typescript": ">=4.5.0"
+	},
+	"peerDependenciesMeta": {
+		"drizzle-orm": {
+			"optional": true
+		},
+		"react": {
+			"optional": true
+		},
+		"typescript": {
+			"optional": true
+		}
+	},
+	"simple-git-hooks": {
+		"pre-commit": "bun run lint && bun run type-check"
+	}
+}