@regular-software/sync-hono 0.3.0

package/README.md

@@ -0,0 +1,5 @@
+# @regular-software/sync-hono
+
+Hono adapter for regular software sync servers.
+
+This is a 0.x package; APIs may change between minor versions.

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { Hono, type Context } from "hono";
+import type { SyncRequest, SyncResult } from "@regular-software/sync-protocol";
+export type SyncHonoEngine<TContext = undefined> = {
+    syncSince(request: SyncRequest, context: TContext): SyncResult | Promise<SyncResult>;
+    getVersion?(): number;
+};
+export type SyncContextResolver<TContext> = (context: Context) => TContext | Promise<TContext>;
+export type SyncEventListener = (version: number) => void;
+export declare class SyncEventHub {
+    private readonly listeners;
+    private lastVersion;
+    subscribe(listener: SyncEventListener): () => void;
+    publish(version: number): void;
+}
+export declare function createSyncHono<TContext = undefined>(options: {
+    engine: SyncHonoEngine<TContext>;
+    getContext?: SyncContextResolver<TContext>;
+    events?: SyncEventHub;
+    pollIntervalMs?: number;
+}): {
+    app: Hono;
+    events: SyncEventHub;
+    stop(): void;
+};

package/dist/index.js

@@ -0,0 +1,115 @@
+// packages/hono/src/index.ts
+import { Hono } from "hono";
+var SyncEventHub = class {
+  listeners = /* @__PURE__ */ new Set();
+  lastVersion = 0;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  publish(version) {
+    if (version <= this.lastVersion) {
+      return;
+    }
+    this.lastVersion = version;
+    for (const listener of this.listeners) {
+      listener(version);
+    }
+  }
+};
+function createSyncHono(options) {
+  const events = options.events ?? new SyncEventHub();
+  const app = new Hono();
+  app.get("/sync", async (context) => {
+    const version = Number(context.req.query("version"));
+    const replicaId = context.req.query("replicaId");
+    const schemaVersion = Number(context.req.query("schemaVersion"));
+    const schemaFingerprint = context.req.query("schemaFingerprint");
+    if (!Number.isSafeInteger(version) || version < 0 || !Number.isSafeInteger(schemaVersion) || schemaVersion <= 0 || schemaFingerprint === void 0) {
+      return context.json({ error: "Invalid synchronization request" }, 400);
+    }
+    try {
+      const resolvedContext = options.getContext ? await options.getContext(context) : void 0;
+      return context.json(
+        await options.engine.syncSince(
+          {
+            version,
+            ...replicaId ? { replicaId } : {},
+            schemaVersion,
+            schemaFingerprint
+          },
+          resolvedContext
+        )
+      );
+    } catch (error) {
+      if (error instanceof Error && error.name === "SyncSchemaMismatchError") {
+        const expected = error.expected;
+        return context.json({ error: error.message, expected }, 409);
+      }
+      throw error;
+    }
+  });
+  app.get("/sync-events", (context) => {
+    const encoder = new TextEncoder();
+    let closed = false;
+    let unsubscribe = () => {
+    };
+    let heartbeat;
+    let controller;
+    const close = () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      unsubscribe();
+      if (heartbeat) {
+        clearInterval(heartbeat);
+      }
+      controller?.close();
+    };
+    const stream = new ReadableStream({
+      start(nextController) {
+        controller = nextController;
+        unsubscribe = events.subscribe((version) => {
+          if (!closed) {
+            controller?.enqueue(encoder.encode(`data: ${version}
+
+`));
+          }
+        });
+        heartbeat = setInterval(() => {
+          if (!closed) {
+            controller?.enqueue(encoder.encode(": heartbeat\n\n"));
+          }
+        }, 3e4);
+        context.req.raw.signal.addEventListener("abort", close, { once: true });
+      },
+      cancel: close
+    });
+    return new Response(stream, {
+      headers: {
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Content-Type": "text/event-stream"
+      }
+    });
+  });
+  const pollIntervalMs = options.pollIntervalMs ?? 1e3;
+  const poll = options.engine.getVersion && pollIntervalMs > 0 ? setInterval(() => {
+    events.publish(options.engine.getVersion?.() ?? 0);
+  }, pollIntervalMs) : void 0;
+  poll?.unref?.();
+  return {
+    app,
+    events,
+    stop() {
+      if (poll) {
+        clearInterval(poll);
+      }
+    }
+  };
+}
+export {
+  SyncEventHub,
+  createSyncHono
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@regular-software/sync-hono",
+  "version": "0.3.0",
+  "type": "module",
+  "description": "Hono adapter for regular software sync servers.",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "repository": {"type": "git", "url": "https://github.com/regular-software/sync.git", "directory": "packages/hono"},
+  "bugs": {"url": "https://github.com/regular-software/sync/issues"},
+  "homepage": "https://github.com/regular-software/sync#readme",
+  "engines": {"node": ">=20"},
+  "publishConfig": {"access": "public"},
+  "dependencies": {
+    "@regular-software/sync-protocol": "0.3.0",
+    "hono": "^4.13.5"
+  }
+}