syncora 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+- Initial public release.

package/LICENSE

@@ -0,0 +1,15 @@
+MIT License
+
+Copyright (c) 2026 Aftab Ahmad Khan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

package/README.md

@@ -0,0 +1,149 @@
+# syncora
+
+**Topics:** `mern` · `mern-packages` · `merndev` · `mongodb` · `nodejs` · `npm-pm` · `observability` · `optimistic` · `react` · `realtime` · `subscription` · `sync` · `syncora` · `typescript` · `websocket`
+
+Realtime sync engine for MERN apps. Subscribe to collections from the browser with a single hook, get live updates over WebSockets, mutate with optimistic UI, and reconnect transparently. Works with the built-in in-memory store, your MongoDB change stream, or any custom backing store you plug in.
+
+## Install
+
+```bash
+npm install syncora
+```
+
+(`react` is an optional peer for the React hook.)
+
+## Server
+
+```ts
+import { createServer } from "node:http";
+import { SyncServer } from "syncora";
+
+const http = createServer();
+const sync = new SyncServer({ server: http });
+
+http.listen(4000);
+```
+
+Or stand it up standalone:
+
+```ts
+const sync = new SyncServer({ port: 4000 });
+console.log("listening on", sync.address());
+```
+
+Insert/update/delete via the store and every subscribed client gets the change:
+
+```ts
+sync.store.insert("todos", { _id: "t1", title: "Buy milk", done: false });
+sync.store.update("todos", "t1", { done: true });
+sync.store.delete("todos", "t1");
+```
+
+### Plug in MongoDB change streams
+
+```ts
+import { EventEmitter } from "node:events";
+import { MongoClient } from "mongodb";
+
+const emitter = new EventEmitter();
+const off = sync.attachChangeStream(emitter);
+
+const mongo = await MongoClient.connect(process.env.MONGODB_URI!);
+const todos = mongo.db().collection("todos");
+todos.watch().on("change", (event) => {
+  if (event.operationType === "insert") {
+    emitter.emit("change", {
+      type: "insert",
+      collection: "todos",
+      document: event.fullDocument,
+      version: Number(event.clusterTime.toString()),
+    });
+  }
+  // …handle update / delete similarly
+});
+```
+
+## Vanilla client
+
+```ts
+import { SyncoraClient } from "syncora";
+
+const client = new SyncoraClient({ url: "ws://localhost:4000" });
+
+const todos = client.subscribe("todos", { filter: { done: false } });
+todos.onChange(({ data }) => console.log(data));
+
+await client.mutate("todos", "insert", { document: { _id: "t9", title: "Ship it" } });
+await client.mutate("todos", "update", { documentId: "t9", patch: { done: true } });
+await client.mutate("todos", "delete", { documentId: "t9" });
+```
+
+Reconnects with exponential back-off, replays queued mutations and resubscribes on every reconnect.
+
+## React hook
+
+```tsx
+import { SyncoraClient } from "syncora";
+import { createSyncoraHooks } from "syncora/react";
+
+const client = new SyncoraClient({ url: "ws://localhost:4000" });
+export const { useSyncora } = createSyncoraHooks(client);
+
+export function Todos() {
+  const { data, insert, update, remove, isConnected } = useSyncora<{ _id: string; title: string; done: boolean }>(
+    "todos",
+    { filter: { done: false }, optimistic: true },
+  );
+
+  return (
+    <div>
+      <p>{isConnected ? "live" : "reconnecting…"}</p>
+      <ul>
+        {data.map((t) => (
+          <li key={t._id}>
+            <input type="checkbox" checked={t.done} onChange={() => update(t._id, { done: !t.done })} />
+            {t.title}
+            <button onClick={() => remove(t._id)}>delete</button>
+          </li>
+        ))}
+      </ul>
+      <button onClick={() => insert({ _id: crypto.randomUUID(), title: "New", done: false })}>add</button>
+    </div>
+  );
+}
+```
+
+With `optimistic: true`, mutations are applied to the local cache immediately and reconciled when the server acks (or reverted on the next snapshot).
+
+## Filter operators
+
+`syncora` ships a tiny filter engine compatible with the most common MongoDB operators:
+
+- equality and dotted paths (`{ "user.name": "alice" }`)
+- `$eq`, `$ne`, `$in`, `$nin`, `$gt`, `$gte`, `$lt`, `$lte`, `$exists`
+- `$or`, `$and`
+
+## Auth & permissions
+
+```ts
+new SyncServer({
+  authorize: ({ headers }) => Boolean(headers["x-token"]),
+  permit: (clientId, message) =>
+    message.type !== "mutation" || message.collection !== "secrets",
+});
+```
+
+## Custom stores
+
+Implement the `SyncStore` interface to back syncora with Postgres, Redis, or anything else:
+
+```ts
+import { SyncServer, type SyncStore } from "syncora";
+
+const myStore: SyncStore = { /* … */ };
+const sync = new SyncServer({ store: myStore });
+```
+
+## License
+
+MIT

package/dist/chunk-VZXBPBHO.js

@@ -0,0 +1,116 @@
+// src/filter.ts
+function matches(doc, filter) {
+  if (!filter) return true;
+  for (const [key, expected] of Object.entries(filter)) {
+    if (key === "$or" && Array.isArray(expected)) {
+      if (!expected.some((sub) => matches(doc, sub))) return false;
+      continue;
+    }
+    if (key === "$and" && Array.isArray(expected)) {
+      if (!expected.every((sub) => matches(doc, sub))) return false;
+      continue;
+    }
+    const actual = lookupPath(doc, key);
+    if (!matchValue(actual, expected)) return false;
+  }
+  return true;
+}
+function matchValue(actual, expected) {
+  if (expected && typeof expected === "object" && !Array.isArray(expected)) {
+    const exp = expected;
+    if (Object.keys(exp).some((k) => k.startsWith("$"))) {
+      for (const [op, val] of Object.entries(exp)) {
+        switch (op) {
+          case "$eq":
+            if (actual !== val) return false;
+            break;
+          case "$ne":
+            if (actual === val) return false;
+            break;
+          case "$in":
+            if (!Array.isArray(val) || !val.includes(actual)) return false;
+            break;
+          case "$nin":
+            if (!Array.isArray(val) || val.includes(actual)) return false;
+            break;
+          case "$gt":
+            if (!(typeof actual === "number" && typeof val === "number" && actual > val)) return false;
+            break;
+          case "$gte":
+            if (!(typeof actual === "number" && typeof val === "number" && actual >= val)) return false;
+            break;
+          case "$lt":
+            if (!(typeof actual === "number" && typeof val === "number" && actual < val)) return false;
+            break;
+          case "$lte":
+            if (!(typeof actual === "number" && typeof val === "number" && actual <= val)) return false;
+            break;
+          case "$exists":
+            if (Boolean(val) !== (actual !== void 0)) return false;
+            break;
+          default:
+            return false;
+        }
+      }
+      return true;
+    }
+  }
+  return actual === expected;
+}
+function lookupPath(source, path) {
+  if (!path.includes(".")) return source[path];
+  let cur = source;
+  for (const part of path.split(".")) {
+    if (cur && typeof cur === "object" && part in cur) {
+      cur = cur[part];
+    } else {
+      return void 0;
+    }
+  }
+  return cur;
+}
+
+// src/apply.ts
+function applyEventToDocuments(documents, version, event, filter) {
+  if (event.type === "snapshot") {
+    const next = event.documents.filter((d) => matches(d, filter));
+    return { data: next, version: event.version };
+  }
+  if (event.type === "insert") {
+    if (!matches(event.document, filter)) return { data: documents, version: event.version };
+    const next = [...documents.filter((d) => d._id !== event.document._id), event.document];
+    return { data: next, version: event.version };
+  }
+  if (event.type === "update") {
+    const next = documents.map(
+      (d) => d._id === event.documentId ? { ...d, ...event.patch, _id: d._id } : d
+    );
+    if (filter) {
+      const filtered = next.filter((d) => matches(d, filter));
+      return { data: filtered, version: event.version };
+    }
+    return { data: next, version: event.version };
+  }
+  if (event.type === "delete") {
+    return { data: documents.filter((d) => d._id !== event.documentId), version: event.version };
+  }
+  return { data: documents, version };
+}
+function applyOptimisticInsert(documents, document) {
+  return [...documents.filter((d) => d._id !== document._id), document];
+}
+function applyOptimisticUpdate(documents, id, patch) {
+  return documents.map((d) => d._id === id ? { ...d, ...patch, _id: id } : d);
+}
+function applyOptimisticDelete(documents, id) {
+  return documents.filter((d) => d._id !== id);
+}
+
+export {
+  matches,
+  applyEventToDocuments,
+  applyOptimisticInsert,
+  applyOptimisticUpdate,
+  applyOptimisticDelete
+};
+//# sourceMappingURL=chunk-VZXBPBHO.js.map

package/dist/chunk-VZXBPBHO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filter.ts","../src/apply.ts"],"sourcesContent":["import type { Filter, SyncDocument } from \"./types.js\";\n\nexport function matches(doc: SyncDocument, filter: Filter | undefined): boolean {\n  if (!filter) return true;\n  for (const [key, expected] of Object.entries(filter)) {\n    if (key === \"$or\" && Array.isArray(expected)) {\n      if (!expected.some((sub) => matches(doc, sub as Filter))) return false;\n      continue;\n    }\n    if (key === \"$and\" && Array.isArray(expected)) {\n      if (!expected.every((sub) => matches(doc, sub as Filter))) return false;\n      continue;\n    }\n    const actual = lookupPath(doc as Record<string, unknown>, key);\n    if (!matchValue(actual, expected)) return false;\n  }\n  return true;\n}\n\nfunction matchValue(actual: unknown, expected: unknown): boolean {\n  if (expected && typeof expected === \"object\" && !Array.isArray(expected)) {\n    const exp = expected as Record<string, unknown>;\n    if (Object.keys(exp).some((k) => k.startsWith(\"$\"))) {\n      for (const [op, val] of Object.entries(exp)) {\n        switch (op) {\n          case \"$eq\": if (actual !== val) return false; break;\n          case \"$ne\": if (actual === val) return false; break;\n          case \"$in\":\n            if (!Array.isArray(val) || !val.includes(actual)) return false;\n            break;\n          case \"$nin\":\n            if (!Array.isArray(val) || val.includes(actual)) return false;\n            break;\n          case \"$gt\": if (!(typeof actual === \"number\" && typeof val === \"number\" && actual > val)) return false; break;\n          case \"$gte\": if (!(typeof actual === \"number\" && typeof val === \"number\" && actual >= val)) return false; break;\n          case \"$lt\": if (!(typeof actual === \"number\" && typeof val === \"number\" && actual < val)) return false; break;\n          case \"$lte\": if (!(typeof actual === \"number\" && typeof val === \"number\" && actual <= val)) return false; break;\n          case \"$exists\":\n            if (Boolean(val) !== (actual !== undefined)) return false;\n            break;\n          default:\n            return false;\n        }\n      }\n      return true;\n    }\n  }\n  return actual === expected;\n}\n\nfunction lookupPath(source: Record<string, unknown>, path: string): unknown {\n  if (!path.includes(\".\")) return source[path];\n  let cur: unknown = source;\n  for (const part of path.split(\".\")) {\n    if (cur && typeof cur === \"object\" && part in (cur as Record<string, unknown>)) {\n      cur = (cur as Record<string, unknown>)[part];\n    } else {\n      return undefined;\n    }\n  }\n  return cur;\n}\n","import { matches } from \"./filter.js\";\nimport type { ChangeEvent, Filter, SyncDocument } from \"./types.js\";\n\nexport function applyEventToDocuments<T extends SyncDocument>(\n  documents: T[],\n  version: number,\n  event: ChangeEvent,\n  filter?: Filter,\n): { data: T[]; version: number } {\n  if (event.type === \"snapshot\") {\n    const next = (event.documents as T[]).filter((d) => matches(d, filter));\n    return { data: next, version: event.version };\n  }\n  if (event.type === \"insert\") {\n    if (!matches(event.document, filter)) return { data: documents, version: event.version };\n    const next = [...documents.filter((d) => d._id !== event.document._id), event.document as T];\n    return { data: next, version: event.version };\n  }\n  if (event.type === \"update\") {\n    const next = documents.map((d) =>\n      d._id === event.documentId ? ({ ...d, ...event.patch, _id: d._id } as T) : d,\n    );\n    if (filter) {\n      const filtered = next.filter((d) => matches(d, filter));\n      return { data: filtered, version: event.version };\n    }\n    return { data: next, version: event.version };\n  }\n  if (event.type === \"delete\") {\n    return { data: documents.filter((d) => d._id !== event.documentId), version: event.version };\n  }\n  return { data: documents, version };\n}\n\nexport function applyOptimisticInsert<T extends SyncDocument>(documents: T[], document: T): T[] {\n  return [...documents.filter((d) => d._id !== document._id), document];\n}\n\nexport function applyOptimisticUpdate<T extends SyncDocument>(\n  documents: T[],\n  id: string,\n  patch: Partial<T>,\n): T[] {\n  return documents.map((d) => (d._id === id ? ({ ...d, ...patch, _id: id } as T) : d));\n}\n\nexport function applyOptimisticDelete<T extends SyncDocument>(documents: T[], id: string): T[] {\n  return documents.filter((d) => d._id !== id);\n}\n"],"mappings":"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","names":[]}

package/dist/client-OmEeE-w1.d.cts

@@ -0,0 +1,136 @@
+interface SyncDocument {
+    _id: string;
+    [key: string]: unknown;
+}
+type ChangeEvent<T extends SyncDocument = SyncDocument> = {
+    type: "insert";
+    collection: string;
+    document: T;
+    version: number;
+} | {
+    type: "update";
+    collection: string;
+    documentId: string;
+    patch: Partial<T>;
+    version: number;
+} | {
+    type: "delete";
+    collection: string;
+    documentId: string;
+    version: number;
+} | {
+    type: "snapshot";
+    collection: string;
+    documents: T[];
+    version: number;
+};
+type ClientMessage = {
+    type: "subscribe";
+    subscriptionId: string;
+    collection: string;
+    filter?: Record<string, unknown>;
+} | {
+    type: "unsubscribe";
+    subscriptionId: string;
+} | {
+    type: "mutation";
+    mutationId: string;
+    collection: string;
+    op: "insert" | "update" | "delete";
+    document?: SyncDocument;
+    patch?: Partial<SyncDocument>;
+    documentId?: string;
+};
+type ServerMessage = {
+    type: "hello";
+    clientId: string;
+    serverVersion: number;
+} | {
+    type: "event";
+    subscriptionId: string;
+    event: ChangeEvent;
+} | {
+    type: "ack";
+    mutationId: string;
+    ok: boolean;
+    error?: string;
+} | {
+    type: "error";
+    message: string;
+};
+interface Filter {
+    [field: string]: unknown;
+}
+interface StoreSnapshot<T extends SyncDocument = SyncDocument> {
+    documents: T[];
+    version: number;
+}
+
+type WSLike = {
+    send(data: string): void;
+    close(): void;
+    addEventListener(event: "open", cb: () => void): void;
+    addEventListener(event: "close", cb: () => void): void;
+    addEventListener(event: "error", cb: (event: unknown) => void): void;
+    addEventListener(event: "message", cb: (event: {
+        data: unknown;
+    }) => void): void;
+    readyState?: number;
+};
+type WSConstructor = new (url: string) => WSLike;
+interface SyncoraClientOptions {
+    url: string;
+    WebSocket?: WSConstructor;
+    reconnectDelayMs?: number;
+    maxReconnectDelayMs?: number;
+    onConnect?: (clientId: string) => void;
+    onDisconnect?: () => void;
+    onError?: (error: unknown) => void;
+}
+interface Subscription<T extends SyncDocument = SyncDocument> {
+    id: string;
+    collection: string;
+    filter?: Filter;
+    data: T[];
+    version: number;
+    unsubscribe(): void;
+    onChange(listener: (state: {
+        data: T[];
+        version: number;
+    }) => void): () => void;
+}
+declare class SyncoraClient {
+    private url;
+    private WS;
+    private socket?;
+    private subscriptions;
+    private pendingMutations;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private currentDelay;
+    private intentionalClose;
+    private clientId?;
+    private outbox;
+    private connectedListeners;
+    private disconnectedListeners;
+    private onError?;
+    constructor(options: SyncoraClientOptions);
+    isConnected(): boolean;
+    close(): void;
+    onConnect(handler: (clientId: string) => void): () => void;
+    onDisconnect(handler: () => void): () => void;
+    subscribe<T extends SyncDocument = SyncDocument>(collection: string, options?: {
+        filter?: Filter;
+    }): Subscription<T>;
+    mutate(collection: string, op: "insert" | "update" | "delete", payload?: {
+        document?: SyncDocument;
+        documentId?: string;
+        patch?: Partial<SyncDocument>;
+    }): Promise<void>;
+    private connect;
+    private scheduleReconnect;
+    private handleMessage;
+    private send;
+}
+
+export { type ChangeEvent as C, type Filter as F, type ServerMessage as S, type ClientMessage as a, type StoreSnapshot as b, type Subscription as c, type SyncDocument as d, SyncoraClient as e, type SyncoraClientOptions as f };

package/dist/client-OmEeE-w1.d.ts

@@ -0,0 +1,136 @@
+interface SyncDocument {
+    _id: string;
+    [key: string]: unknown;
+}
+type ChangeEvent<T extends SyncDocument = SyncDocument> = {
+    type: "insert";
+    collection: string;
+    document: T;
+    version: number;
+} | {
+    type: "update";
+    collection: string;
+    documentId: string;
+    patch: Partial<T>;
+    version: number;
+} | {
+    type: "delete";
+    collection: string;
+    documentId: string;
+    version: number;
+} | {
+    type: "snapshot";
+    collection: string;
+    documents: T[];
+    version: number;
+};
+type ClientMessage = {
+    type: "subscribe";
+    subscriptionId: string;
+    collection: string;
+    filter?: Record<string, unknown>;
+} | {
+    type: "unsubscribe";
+    subscriptionId: string;
+} | {
+    type: "mutation";
+    mutationId: string;
+    collection: string;
+    op: "insert" | "update" | "delete";
+    document?: SyncDocument;
+    patch?: Partial<SyncDocument>;
+    documentId?: string;
+};
+type ServerMessage = {
+    type: "hello";
+    clientId: string;
+    serverVersion: number;
+} | {
+    type: "event";
+    subscriptionId: string;
+    event: ChangeEvent;
+} | {
+    type: "ack";
+    mutationId: string;
+    ok: boolean;
+    error?: string;
+} | {
+    type: "error";
+    message: string;
+};
+interface Filter {
+    [field: string]: unknown;
+}
+interface StoreSnapshot<T extends SyncDocument = SyncDocument> {
+    documents: T[];
+    version: number;
+}
+
+type WSLike = {
+    send(data: string): void;
+    close(): void;
+    addEventListener(event: "open", cb: () => void): void;
+    addEventListener(event: "close", cb: () => void): void;
+    addEventListener(event: "error", cb: (event: unknown) => void): void;
+    addEventListener(event: "message", cb: (event: {
+        data: unknown;
+    }) => void): void;
+    readyState?: number;
+};
+type WSConstructor = new (url: string) => WSLike;
+interface SyncoraClientOptions {
+    url: string;
+    WebSocket?: WSConstructor;
+    reconnectDelayMs?: number;
+    maxReconnectDelayMs?: number;
+    onConnect?: (clientId: string) => void;
+    onDisconnect?: () => void;
+    onError?: (error: unknown) => void;
+}
+interface Subscription<T extends SyncDocument = SyncDocument> {
+    id: string;
+    collection: string;
+    filter?: Filter;
+    data: T[];
+    version: number;
+    unsubscribe(): void;
+    onChange(listener: (state: {
+        data: T[];
+        version: number;
+    }) => void): () => void;
+}
+declare class SyncoraClient {
+    private url;
+    private WS;
+    private socket?;
+    private subscriptions;
+    private pendingMutations;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private currentDelay;
+    private intentionalClose;
+    private clientId?;
+    private outbox;
+    private connectedListeners;
+    private disconnectedListeners;
+    private onError?;
+    constructor(options: SyncoraClientOptions);
+    isConnected(): boolean;
+    close(): void;
+    onConnect(handler: (clientId: string) => void): () => void;
+    onDisconnect(handler: () => void): () => void;
+    subscribe<T extends SyncDocument = SyncDocument>(collection: string, options?: {
+        filter?: Filter;
+    }): Subscription<T>;
+    mutate(collection: string, op: "insert" | "update" | "delete", payload?: {
+        document?: SyncDocument;
+        documentId?: string;
+        patch?: Partial<SyncDocument>;
+    }): Promise<void>;
+    private connect;
+    private scheduleReconnect;
+    private handleMessage;
+    private send;
+}
+
+export { type ChangeEvent as C, type Filter as F, type ServerMessage as S, type ClientMessage as a, type StoreSnapshot as b, type Subscription as c, type SyncDocument as d, SyncoraClient as e, type SyncoraClientOptions as f };