syncora 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,82 @@
+import { Server } from 'node:http';
+import { d as SyncDocument, F as Filter, b as StoreSnapshot, C as ChangeEvent, a as ClientMessage } from './client-OmEeE-w1.cjs';
+export { S as ServerMessage, c as Subscription, e as SyncoraClient, f as SyncoraClientOptions } from './client-OmEeE-w1.cjs';
+
+interface SyncStore {
+    insert<T extends SyncDocument>(collection: string, document: Omit<T, "_id"> & {
+        _id?: string;
+    }): T;
+    update<T extends SyncDocument>(collection: string, id: string, patch: Partial<T>): T | undefined;
+    delete(collection: string, id: string): boolean;
+    find<T extends SyncDocument>(collection: string, filter?: Filter): T[];
+    findOne<T extends SyncDocument>(collection: string, id: string): T | undefined;
+    snapshot<T extends SyncDocument>(collection: string, filter?: Filter): StoreSnapshot<T>;
+    watch(handler: (event: ChangeEvent) => void): () => void;
+    version(collection: string): number;
+    reset(): void;
+}
+declare class MemoryStore implements SyncStore {
+    private collections;
+    private versions;
+    private watchers;
+    insert<T extends SyncDocument>(collection: string, doc: Omit<T, "_id"> & {
+        _id?: string;
+    }): T;
+    update<T extends SyncDocument>(collection: string, id: string, patch: Partial<T>): T | undefined;
+    delete(collection: string, id: string): boolean;
+    find<T extends SyncDocument>(collection: string, filter?: Filter): T[];
+    findOne<T extends SyncDocument>(collection: string, id: string): T | undefined;
+    snapshot<T extends SyncDocument>(collection: string, filter?: Filter): StoreSnapshot<T>;
+    watch(handler: (event: ChangeEvent) => void): () => void;
+    version(collection: string): number;
+    reset(): void;
+    private ensureCollection;
+    private bumpVersion;
+    private emit;
+}
+
+interface SyncServerOptions {
+    store?: SyncStore;
+    server?: Server;
+    port?: number;
+    host?: string;
+    path?: string;
+    authorize?: (handshake: {
+        headers: Record<string, string | string[] | undefined>;
+        url?: string;
+    }) => boolean | Promise<boolean>;
+    permit?: (clientId: string, message: ClientMessage) => boolean | Promise<boolean>;
+}
+declare class SyncServer {
+    readonly store: SyncStore;
+    private wss;
+    private clients;
+    private unwatch;
+    private serverVersion;
+    constructor(options?: SyncServerOptions);
+    address(): {
+        host: string;
+        port: number;
+    } | null;
+    close(): Promise<void>;
+    attachChangeStream(emitter: {
+        on: (event: "change", handler: (event: ChangeEvent) => void) => unknown;
+    }): () => void;
+    private handleConnection;
+    private handleMessage;
+    private handleSubscribe;
+    private handleMutation;
+    private fanoutEvent;
+}
+
+declare function applyEventToDocuments<T extends SyncDocument>(documents: T[], version: number, event: ChangeEvent, filter?: Filter): {
+    data: T[];
+    version: number;
+};
+declare function applyOptimisticInsert<T extends SyncDocument>(documents: T[], document: T): T[];
+declare function applyOptimisticUpdate<T extends SyncDocument>(documents: T[], id: string, patch: Partial<T>): T[];
+declare function applyOptimisticDelete<T extends SyncDocument>(documents: T[], id: string): T[];
+
+declare function matches(doc: SyncDocument, filter: Filter | undefined): boolean;
+
+export { ChangeEvent, ClientMessage, Filter, MemoryStore, StoreSnapshot, SyncDocument, SyncServer, type SyncServerOptions, type SyncStore, applyEventToDocuments, applyOptimisticDelete, applyOptimisticInsert, applyOptimisticUpdate, matches };

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+import { Server } from 'node:http';
+import { d as SyncDocument, F as Filter, b as StoreSnapshot, C as ChangeEvent, a as ClientMessage } from './client-OmEeE-w1.js';
+export { S as ServerMessage, c as Subscription, e as SyncoraClient, f as SyncoraClientOptions } from './client-OmEeE-w1.js';
+
+interface SyncStore {
+    insert<T extends SyncDocument>(collection: string, document: Omit<T, "_id"> & {
+        _id?: string;
+    }): T;
+    update<T extends SyncDocument>(collection: string, id: string, patch: Partial<T>): T | undefined;
+    delete(collection: string, id: string): boolean;
+    find<T extends SyncDocument>(collection: string, filter?: Filter): T[];
+    findOne<T extends SyncDocument>(collection: string, id: string): T | undefined;
+    snapshot<T extends SyncDocument>(collection: string, filter?: Filter): StoreSnapshot<T>;
+    watch(handler: (event: ChangeEvent) => void): () => void;
+    version(collection: string): number;
+    reset(): void;
+}
+declare class MemoryStore implements SyncStore {
+    private collections;
+    private versions;
+    private watchers;
+    insert<T extends SyncDocument>(collection: string, doc: Omit<T, "_id"> & {
+        _id?: string;
+    }): T;
+    update<T extends SyncDocument>(collection: string, id: string, patch: Partial<T>): T | undefined;
+    delete(collection: string, id: string): boolean;
+    find<T extends SyncDocument>(collection: string, filter?: Filter): T[];
+    findOne<T extends SyncDocument>(collection: string, id: string): T | undefined;
+    snapshot<T extends SyncDocument>(collection: string, filter?: Filter): StoreSnapshot<T>;
+    watch(handler: (event: ChangeEvent) => void): () => void;
+    version(collection: string): number;
+    reset(): void;
+    private ensureCollection;
+    private bumpVersion;
+    private emit;
+}
+
+interface SyncServerOptions {
+    store?: SyncStore;
+    server?: Server;
+    port?: number;
+    host?: string;
+    path?: string;
+    authorize?: (handshake: {
+        headers: Record<string, string | string[] | undefined>;
+        url?: string;
+    }) => boolean | Promise<boolean>;
+    permit?: (clientId: string, message: ClientMessage) => boolean | Promise<boolean>;
+}
+declare class SyncServer {
+    readonly store: SyncStore;
+    private wss;
+    private clients;
+    private unwatch;
+    private serverVersion;
+    constructor(options?: SyncServerOptions);
+    address(): {
+        host: string;
+        port: number;
+    } | null;
+    close(): Promise<void>;
+    attachChangeStream(emitter: {
+        on: (event: "change", handler: (event: ChangeEvent) => void) => unknown;
+    }): () => void;
+    private handleConnection;
+    private handleMessage;
+    private handleSubscribe;
+    private handleMutation;
+    private fanoutEvent;
+}
+
+declare function applyEventToDocuments<T extends SyncDocument>(documents: T[], version: number, event: ChangeEvent, filter?: Filter): {
+    data: T[];
+    version: number;
+};
+declare function applyOptimisticInsert<T extends SyncDocument>(documents: T[], document: T): T[];
+declare function applyOptimisticUpdate<T extends SyncDocument>(documents: T[], id: string, patch: Partial<T>): T[];
+declare function applyOptimisticDelete<T extends SyncDocument>(documents: T[], id: string): T[];
+
+declare function matches(doc: SyncDocument, filter: Filter | undefined): boolean;
+
+export { ChangeEvent, ClientMessage, Filter, MemoryStore, StoreSnapshot, SyncDocument, SyncServer, type SyncServerOptions, type SyncStore, applyEventToDocuments, applyOptimisticDelete, applyOptimisticInsert, applyOptimisticUpdate, matches };

package/dist/index.js

@@ -0,0 +1,457 @@
+import {
+  applyEventToDocuments,
+  applyOptimisticDelete,
+  applyOptimisticInsert,
+  applyOptimisticUpdate,
+  matches
+} from "./chunk-VZXBPBHO.js";
+
+// src/server.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { WebSocketServer } from "ws";
+
+// src/store.ts
+import { randomBytes } from "crypto";
+var MemoryStore = class {
+  collections = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  watchers = /* @__PURE__ */ new Set();
+  insert(collection, doc) {
+    const id = doc._id ?? `doc_${randomBytes(8).toString("hex")}`;
+    const map = this.ensureCollection(collection);
+    const document = { ...doc, _id: id };
+    map.set(id, document);
+    const version = this.bumpVersion(collection);
+    this.emit({ type: "insert", collection, document, version });
+    return document;
+  }
+  update(collection, id, patch) {
+    const map = this.collections.get(collection);
+    if (!map) return void 0;
+    const existing = map.get(id);
+    if (!existing) return void 0;
+    const updated = { ...existing, ...patch, _id: id };
+    map.set(id, updated);
+    const version = this.bumpVersion(collection);
+    this.emit({ type: "update", collection, documentId: id, patch, version });
+    return updated;
+  }
+  delete(collection, id) {
+    const map = this.collections.get(collection);
+    if (!map) return false;
+    if (!map.delete(id)) return false;
+    const version = this.bumpVersion(collection);
+    this.emit({ type: "delete", collection, documentId: id, version });
+    return true;
+  }
+  find(collection, filter) {
+    const map = this.collections.get(collection);
+    if (!map) return [];
+    const out = [];
+    for (const doc of map.values()) {
+      if (matches(doc, filter)) out.push(doc);
+    }
+    return out;
+  }
+  findOne(collection, id) {
+    return this.collections.get(collection)?.get(id);
+  }
+  snapshot(collection, filter) {
+    return { documents: this.find(collection, filter), version: this.version(collection) };
+  }
+  watch(handler) {
+    this.watchers.add(handler);
+    return () => this.watchers.delete(handler);
+  }
+  version(collection) {
+    return this.versions.get(collection) ?? 0;
+  }
+  reset() {
+    this.collections.clear();
+    this.versions.clear();
+  }
+  ensureCollection(collection) {
+    let map = this.collections.get(collection);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.collections.set(collection, map);
+    }
+    return map;
+  }
+  bumpVersion(collection) {
+    const next = this.version(collection) + 1;
+    this.versions.set(collection, next);
+    return next;
+  }
+  emit(event) {
+    for (const w of this.watchers) {
+      try {
+        w(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/server.ts
+var SyncServer = class {
+  store;
+  wss;
+  clients = /* @__PURE__ */ new Map();
+  unwatch;
+  serverVersion = 0;
+  constructor(options = {}) {
+    this.store = options.store ?? new MemoryStore();
+    const wssConfig = options.server ? { server: options.server, path: options.path } : { host: options.host ?? "127.0.0.1", port: options.port ?? 0, path: options.path };
+    this.wss = new WebSocketServer(wssConfig);
+    this.wss.on("connection", (socket, req) => this.handleConnection(socket, req, options.authorize, options.permit));
+    this.unwatch = this.store.watch((event) => this.fanoutEvent(event));
+  }
+  address() {
+    const a = this.wss.address();
+    if (typeof a === "string" || a === null) return null;
+    return { host: a.address, port: a.port };
+  }
+  async close() {
+    this.unwatch();
+    for (const session of this.clients.values()) {
+      try {
+        session.socket.close();
+      } catch {
+      }
+    }
+    this.clients.clear();
+    return new Promise((resolve) => this.wss.close(() => resolve()));
+  }
+  attachChangeStream(emitter) {
+    const handler = (event) => this.fanoutEvent(event);
+    emitter.on("change", handler);
+    return () => {
+      const off = emitter.off;
+      if (typeof off === "function") off.call(emitter, "change", handler);
+    };
+  }
+  async handleConnection(socket, req, authorize, permit) {
+    if (authorize) {
+      try {
+        const ok = await authorize({ headers: req.headers, url: req.url });
+        if (!ok) {
+          socket.close(4401, "unauthorized");
+          return;
+        }
+      } catch {
+        socket.close(4401, "unauthorized");
+        return;
+      }
+    }
+    const session = {
+      id: `c_${randomBytes2(8).toString("hex")}`,
+      socket,
+      subscriptions: /* @__PURE__ */ new Map()
+    };
+    this.clients.set(session.id, session);
+    socket.on("close", () => this.clients.delete(session.id));
+    socket.on("error", () => {
+    });
+    socket.on("message", (data) => {
+      this.handleMessage(session, data.toString(), permit).catch(() => {
+        send(socket, { type: "error", message: "internal error" });
+      });
+    });
+    send(socket, { type: "hello", clientId: session.id, serverVersion: this.serverVersion });
+  }
+  async handleMessage(session, raw, permit) {
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      send(session.socket, { type: "error", message: "invalid JSON" });
+      return;
+    }
+    if (permit) {
+      try {
+        const allowed = await permit(session.id, message);
+        if (!allowed) {
+          send(session.socket, { type: "error", message: "forbidden" });
+          return;
+        }
+      } catch {
+        send(session.socket, { type: "error", message: "permission check failed" });
+        return;
+      }
+    }
+    switch (message.type) {
+      case "subscribe":
+        return this.handleSubscribe(session, message);
+      case "unsubscribe":
+        session.subscriptions.delete(message.subscriptionId);
+        return;
+      case "mutation":
+        return this.handleMutation(session, message);
+      default:
+        send(session.socket, { type: "error", message: "unknown message type" });
+    }
+  }
+  handleSubscribe(session, message) {
+    session.subscriptions.set(message.subscriptionId, { collection: message.collection, filter: message.filter });
+    const snapshot = this.store.snapshot(message.collection, message.filter);
+    send(session.socket, {
+      type: "event",
+      subscriptionId: message.subscriptionId,
+      event: { type: "snapshot", collection: message.collection, documents: snapshot.documents, version: snapshot.version }
+    });
+  }
+  handleMutation(session, message) {
+    try {
+      if (message.op === "insert") {
+        if (!message.document) throw new Error("document required");
+        this.store.insert(message.collection, message.document);
+      } else if (message.op === "update") {
+        if (!message.documentId || !message.patch) throw new Error("documentId and patch required");
+        const result = this.store.update(message.collection, message.documentId, message.patch);
+        if (!result) throw new Error("not found");
+      } else if (message.op === "delete") {
+        if (!message.documentId) throw new Error("documentId required");
+        const ok = this.store.delete(message.collection, message.documentId);
+        if (!ok) throw new Error("not found");
+      }
+      send(session.socket, { type: "ack", mutationId: message.mutationId, ok: true });
+    } catch (err) {
+      send(session.socket, {
+        type: "ack",
+        mutationId: message.mutationId,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  fanoutEvent(event) {
+    this.serverVersion = Math.max(this.serverVersion, event.version);
+    for (const session of this.clients.values()) {
+      for (const [subscriptionId, sub] of session.subscriptions) {
+        if (sub.collection !== event.collection) continue;
+        if (!eventMatchesFilter(event, sub.filter)) continue;
+        send(session.socket, { type: "event", subscriptionId, event });
+      }
+    }
+  }
+};
+function eventMatchesFilter(event, filter) {
+  if (!filter) return true;
+  if (event.type === "snapshot") return true;
+  if (event.type === "delete") return true;
+  if (event.type === "insert") return matches(event.document, filter);
+  if (event.type === "update") return matches(event.patch, filter);
+  return true;
+}
+function send(socket, message) {
+  if (socket.readyState !== 1) return;
+  try {
+    socket.send(JSON.stringify(message));
+  } catch {
+  }
+}
+
+// src/client.ts
+var SyncoraClient = class {
+  url;
+  WS;
+  socket;
+  subscriptions = /* @__PURE__ */ new Map();
+  pendingMutations = /* @__PURE__ */ new Map();
+  reconnectDelay;
+  maxReconnectDelay;
+  currentDelay;
+  intentionalClose = false;
+  clientId;
+  outbox = [];
+  connectedListeners = /* @__PURE__ */ new Set();
+  disconnectedListeners = /* @__PURE__ */ new Set();
+  onError;
+  constructor(options) {
+    this.url = options.url;
+    this.WS = options.WebSocket ?? globalThis.WebSocket;
+    if (!this.WS) throw new Error("No WebSocket implementation. Pass options.WebSocket explicitly.");
+    this.reconnectDelay = options.reconnectDelayMs ?? 500;
+    this.maxReconnectDelay = options.maxReconnectDelayMs ?? 15e3;
+    this.currentDelay = this.reconnectDelay;
+    this.onError = options.onError;
+    if (options.onConnect) this.connectedListeners.add(options.onConnect);
+    if (options.onDisconnect) this.disconnectedListeners.add(options.onDisconnect);
+    this.connect();
+  }
+  isConnected() {
+    return this.socket?.readyState === 1;
+  }
+  close() {
+    this.intentionalClose = true;
+    this.socket?.close();
+  }
+  onConnect(handler) {
+    this.connectedListeners.add(handler);
+    return () => this.connectedListeners.delete(handler);
+  }
+  onDisconnect(handler) {
+    this.disconnectedListeners.add(handler);
+    return () => this.disconnectedListeners.delete(handler);
+  }
+  subscribe(collection, options = {}) {
+    const id = `sub_${cryptoRandom()}`;
+    const sub = {
+      id,
+      collection,
+      filter: options.filter,
+      data: [],
+      version: 0,
+      listeners: /* @__PURE__ */ new Set()
+    };
+    this.subscriptions.set(id, sub);
+    this.send({ type: "subscribe", subscriptionId: id, collection, filter: options.filter });
+    const api = {
+      id,
+      collection,
+      filter: options.filter,
+      get data() {
+        return sub.data;
+      },
+      get version() {
+        return sub.version;
+      },
+      unsubscribe: () => {
+        this.subscriptions.delete(id);
+        this.send({ type: "unsubscribe", subscriptionId: id });
+      },
+      onChange: (listener) => {
+        const bridge = (state) => {
+          listener({ data: state.data, version: state.version });
+        };
+        sub.listeners.add(bridge);
+        bridge({ data: sub.data, version: sub.version });
+        return () => sub.listeners.delete(bridge);
+      }
+    };
+    return api;
+  }
+  async mutate(collection, op, payload = {}) {
+    const mutationId = `mut_${cryptoRandom()}`;
+    const message = {
+      type: "mutation",
+      mutationId,
+      collection,
+      op,
+      ...payload
+    };
+    return new Promise((resolve, reject) => {
+      this.pendingMutations.set(mutationId, { resolve, reject });
+      this.send(message);
+    });
+  }
+  connect() {
+    this.intentionalClose = false;
+    let socket;
+    try {
+      socket = new this.WS(this.url);
+    } catch (err) {
+      this.onError?.(err);
+      this.scheduleReconnect();
+      return;
+    }
+    this.socket = socket;
+    socket.addEventListener("open", () => {
+      this.currentDelay = this.reconnectDelay;
+      for (const msg of this.outbox) {
+        try {
+          socket.send(JSON.stringify(msg));
+        } catch {
+        }
+      }
+      this.outbox = [];
+      for (const sub of this.subscriptions.values()) {
+        try {
+          socket.send(JSON.stringify({ type: "subscribe", subscriptionId: sub.id, collection: sub.collection, filter: sub.filter }));
+        } catch {
+        }
+      }
+    });
+    socket.addEventListener("message", (event) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(typeof event.data === "string" ? event.data : String(event.data));
+      } catch {
+        return;
+      }
+      this.handleMessage(parsed);
+    });
+    socket.addEventListener("error", (err) => this.onError?.(err));
+    socket.addEventListener("close", () => {
+      for (const listener of this.disconnectedListeners) listener();
+      if (!this.intentionalClose) this.scheduleReconnect();
+    });
+  }
+  scheduleReconnect() {
+    const delay = this.currentDelay;
+    this.currentDelay = Math.min(this.maxReconnectDelay, this.currentDelay * 2);
+    setTimeout(() => this.connect(), delay);
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "hello":
+        this.clientId = message.clientId;
+        for (const listener of this.connectedListeners) listener(message.clientId);
+        break;
+      case "event": {
+        const sub = this.subscriptions.get(message.subscriptionId);
+        if (!sub) return;
+        applyEventToSubscription(sub, message.event);
+        for (const l of sub.listeners) l({ data: sub.data, version: sub.version });
+        break;
+      }
+      case "ack": {
+        const pending = this.pendingMutations.get(message.mutationId);
+        if (!pending) return;
+        this.pendingMutations.delete(message.mutationId);
+        if (message.ok) pending.resolve();
+        else pending.reject(new Error(message.error ?? "mutation rejected"));
+        break;
+      }
+      case "error":
+        this.onError?.(new Error(message.message));
+        break;
+    }
+  }
+  send(message) {
+    if (this.socket && this.socket.readyState === 1) {
+      try {
+        this.socket.send(JSON.stringify(message));
+        return;
+      } catch {
+      }
+    }
+    this.outbox.push(message);
+  }
+};
+function applyEventToSubscription(sub, event) {
+  const { data, version } = applyEventToDocuments(sub.data, sub.version, event, sub.filter);
+  sub.data = data;
+  sub.version = version;
+}
+function cryptoRandom() {
+  const bytes = new Uint8Array(8);
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 8; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+export {
+  MemoryStore,
+  SyncServer,
+  SyncoraClient,
+  applyEventToDocuments,
+  applyOptimisticDelete,
+  applyOptimisticInsert,
+  applyOptimisticUpdate,
+  matches
+};
+//# sourceMappingURL=index.js.map