@sveltebase/sync 1.0.0

package/dist/client/index.js

@@ -0,0 +1,326 @@
+import Dexie, {} from "dexie";
+import { parseSyncMessage } from "../protocol.js";
+import { useLiveQuery } from "./live.svelte.js";
+export { useLiveQuery };
+export class SyncClient {
+    db;
+    wsUrl;
+    socket;
+    tableConfigs;
+    reconnectTimer;
+    pingInterval;
+    closedByClient = false;
+    activeChannels = new Set();
+    // Mutations waiting for ack/reject from server
+    pendingMutations = new Map();
+    // Mutations queued to be sent when connection is established
+    mutationQueue = [];
+    constructor(options) {
+        this.wsUrl = options.url;
+        this.tableConfigs = options.tables;
+        // Initialize Dexie database
+        this.db = new Dexie(options.name);
+        const schema = {};
+        for (const [tableName, config] of Object.entries(options.tables)) {
+            schema[tableName] = config.indexes;
+        }
+        this.db.version(1).stores(schema);
+        if (typeof window !== "undefined") {
+            this.connect();
+        }
+    }
+    connect() {
+        if (this.closedByClient)
+            return;
+        const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+        const host = window.location.host;
+        const fullUrl = this.wsUrl.startsWith("ws://") || this.wsUrl.startsWith("wss://")
+            ? this.wsUrl
+            : `${protocol}//${host}${this.wsUrl}`;
+        this.socket = new WebSocket(fullUrl);
+        this.socket.addEventListener("open", async () => {
+            console.log("SyncClient: WebSocket connected");
+            this.activeChannels.clear();
+            this.startHeartbeat();
+            // Re-subscribe to all tables (delta-sync aware)
+            for (const config of Object.values(this.tableConfigs)) {
+                await this.subscribeToChannel(config.channel);
+            }
+            // Re-send all pending unacknowledged mutations
+            for (const mut of this.pendingMutations.values()) {
+                this.socket?.send(JSON.stringify({
+                    type: "mutate",
+                    id: mut.id,
+                    channel: mut.channel,
+                    action: mut.action,
+                    key: mut.key,
+                    data: mut.data,
+                }));
+            }
+            // Flush queued mutations
+            this.flushMutationQueue();
+        });
+        this.socket.addEventListener("message", async (message) => {
+            if (typeof message.data !== "string")
+                return;
+            if (message.data === "pong")
+                return;
+            const msg = parseSyncMessage(message.data);
+            if (!msg)
+                return;
+            await this.handleServerMessage(msg);
+        });
+        this.socket.addEventListener("close", () => {
+            this.socket = undefined;
+            this.stopHeartbeat();
+            if (!this.closedByClient) {
+                this.reconnectTimer = setTimeout(() => this.connect(), 2000);
+            }
+        });
+        this.socket.addEventListener("error", (err) => {
+            console.error("SyncClient: WebSocket error", err);
+        });
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.pingInterval = setInterval(() => {
+            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                this.socket.send(JSON.stringify({ type: "ping" }));
+            }
+        }, 55000); // 55 seconds
+    }
+    stopHeartbeat() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = undefined;
+        }
+    }
+    async subscribeToChannel(channel) {
+        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+            const tableName = this.findTableByChannel(channel);
+            let since;
+            if (tableName) {
+                try {
+                    const table = this.db.table(tableName);
+                    const latestRow = await table.orderBy("updatedAt").last();
+                    if (latestRow && latestRow.updatedAt) {
+                        since = latestRow.updatedAt;
+                    }
+                }
+                catch {
+                    // Ignore if query fails or table is empty
+                }
+            }
+            this.socket.send(JSON.stringify({ type: "subscribe", channel, since }));
+            this.activeChannels.add(channel);
+        }
+    }
+    flushMutationQueue() {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN)
+            return;
+        while (this.mutationQueue.length > 0) {
+            const mut = this.mutationQueue.shift();
+            this.socket.send(JSON.stringify({
+                type: "mutate",
+                id: mut.id,
+                channel: mut.channel,
+                action: mut.action,
+                key: mut.key,
+                data: mut.data,
+            }));
+        }
+    }
+    async safePutRow(tableName, data) {
+        const table = this.db.table(tableName);
+        if (!data || !data.id)
+            return;
+        const existing = await table.get(data.id);
+        if (existing && existing.updatedAt && data.updatedAt) {
+            const existingTime = new Date(existing.updatedAt).getTime();
+            const incomingTime = new Date(data.updatedAt).getTime();
+            if (incomingTime < existingTime) {
+                // Ignore older update (Last-Write-Wins)
+                return;
+            }
+        }
+        await table.put(data);
+    }
+    async safeDeleteRow(tableName, key, incomingTimeStr) {
+        const table = this.db.table(tableName);
+        if (incomingTimeStr) {
+            const existing = await table.get(key);
+            if (existing && existing.updatedAt) {
+                const existingTime = new Date(existing.updatedAt).getTime();
+                const incomingTime = new Date(incomingTimeStr).getTime();
+                if (incomingTime < existingTime) {
+                    // Ignore older delete
+                    return;
+                }
+            }
+        }
+        await table.delete(key);
+    }
+    async handleServerMessage(msg) {
+        switch (msg.type) {
+            case "snapshot": {
+                const tableName = this.findTableByChannel(msg.channel);
+                if (tableName) {
+                    const table = this.db.table(tableName);
+                    if (msg.isDelta) {
+                        // Delta Sync: put changes using Last-Write-Wins
+                        for (const row of msg.data) {
+                            await this.safePutRow(tableName, row);
+                        }
+                    }
+                    else {
+                        // Full Snapshot: clear and replace
+                        await this.db.transaction("rw", table, async () => {
+                            await table.clear();
+                            await table.bulkPut(msg.data);
+                        });
+                    }
+                }
+                break;
+            }
+            case "ack": {
+                const pending = this.pendingMutations.get(msg.id);
+                if (pending) {
+                    // If server returned canonical data, update local Dexie (respecting LWW)
+                    if (msg.data) {
+                        const tableName = this.findTableByChannel(pending.channel);
+                        if (tableName) {
+                            await this.safePutRow(tableName, msg.data);
+                        }
+                    }
+                    pending.resolve(msg.data);
+                    this.pendingMutations.delete(msg.id);
+                }
+                break;
+            }
+            case "reject": {
+                const pending = this.pendingMutations.get(msg.id);
+                if (pending) {
+                    console.warn(`Mutation ${msg.id} rejected by server: ${msg.error}`);
+                    await pending.rollback();
+                    pending.reject(new Error(msg.error));
+                    this.pendingMutations.delete(msg.id);
+                }
+                break;
+            }
+            case "change": {
+                // Prevent sync loops: if we sent this mutation, ignore the echo change
+                if (msg.mutationId && this.pendingMutations.has(msg.mutationId)) {
+                    break;
+                }
+                const tableName = this.findTableByChannel(msg.channel);
+                if (!tableName)
+                    break;
+                if (msg.action === "create" || msg.action === "update") {
+                    await this.safePutRow(tableName, msg.data);
+                }
+                else if (msg.action === "delete" && msg.key) {
+                    const incomingTimeStr = msg.data?.updatedAt;
+                    await this.safeDeleteRow(tableName, msg.key, incomingTimeStr);
+                }
+                break;
+            }
+        }
+    }
+    findTableByChannel(channel) {
+        for (const [tableName, config] of Object.entries(this.tableConfigs)) {
+            if (config.channel === channel)
+                return tableName;
+        }
+        return undefined;
+    }
+    table(tableName) {
+        const dexieTable = this.db.table(tableName);
+        const config = this.tableConfigs[tableName];
+        if (!config) {
+            throw new Error(`Table ${tableName} not defined in SyncClient config.`);
+        }
+        return {
+            liveQuery: (queryFn) => {
+                return useLiveQuery(() => queryFn(dexieTable));
+            },
+            add: async (row) => {
+                const rowData = row;
+                const id = rowData.id || crypto.randomUUID();
+                const fullRow = { ...rowData, id };
+                // Rollback function
+                const rollback = async () => {
+                    await dexieTable.delete(id);
+                };
+                // Apply optimistic update
+                await dexieTable.put(fullRow);
+                return this.enqueueMutation(config.channel, "create", id, fullRow, rollback);
+            },
+            put: async (id, changes) => {
+                const existing = await dexieTable.get(id);
+                if (!existing) {
+                    throw new Error(`Cannot update item ${id}: not found locally.`);
+                }
+                // Rollback function
+                const rollback = async () => {
+                    await dexieTable.put(existing);
+                };
+                const updatedRow = { ...existing, ...changes };
+                // Apply optimistic update
+                await dexieTable.put(updatedRow);
+                return this.enqueueMutation(config.channel, "update", id, changes, rollback);
+            },
+            delete: async (id) => {
+                const existing = await dexieTable.get(id);
+                if (!existing)
+                    return; // Already deleted
+                // Rollback function
+                const rollback = async () => {
+                    await dexieTable.put(existing);
+                };
+                // Apply optimistic update
+                await dexieTable.delete(id);
+                return this.enqueueMutation(config.channel, "delete", id, undefined, rollback);
+            },
+        };
+    }
+    enqueueMutation(channel, action, key, data, rollback) {
+        const mutationId = crypto.randomUUID();
+        return new Promise((resolve, reject) => {
+            this.pendingMutations.set(mutationId, {
+                id: mutationId,
+                channel,
+                action,
+                key,
+                data,
+                rollback,
+                resolve,
+                reject,
+            });
+            const msg = {
+                id: mutationId,
+                channel,
+                action,
+                key,
+                data,
+            };
+            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                this.socket.send(JSON.stringify({ type: "mutate", ...msg }));
+            }
+            else {
+                this.mutationQueue.push(msg);
+            }
+        });
+    }
+    disconnect() {
+        this.closedByClient = true;
+        this.stopHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        if (this.socket) {
+            this.socket.close();
+            this.socket = undefined;
+        }
+    }
+}

package/dist/client/live.svelte.d.ts

@@ -0,0 +1,18 @@
+export type LiveQueryResult<T> = {
+    status: "loading";
+    data: undefined;
+    error: undefined;
+    isLoading: true;
+} | {
+    status: "success";
+    data: T;
+    error: undefined;
+    isLoading: false;
+} | {
+    status: "error";
+    data: undefined;
+    error: any;
+    isLoading: false;
+};
+export declare function useLiveQuery<T>(queryFn: () => Promise<T> | T): LiveQueryResult<T>;
+//# sourceMappingURL=live.svelte.d.ts.map

package/dist/client/live.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.svelte.d.ts","sourceRoot":"","sources":["../../src/client/live.svelte.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,eAAe,CAAC,CAAC,IACzB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,IAAI,CAAA;CAAE,GACzE;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,KAAK,CAAA;CAAE,GAClE;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC;IAAC,SAAS,EAAE,KAAK,CAAA;CAAE,CAAC;AAEvE,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAuCjF"}

package/dist/client/live.svelte.js

@@ -0,0 +1,40 @@
+import { onDestroy } from "svelte";
+import { liveQuery } from "dexie";
+export function useLiveQuery(queryFn) {
+    let data = $state(undefined);
+    let error = $state(undefined);
+    let status = $state("loading");
+    if (typeof window !== "undefined") {
+        const observable = liveQuery(queryFn);
+        const subscription = observable.subscribe({
+            next: (val) => {
+                data = val;
+                error = undefined;
+                status = "success";
+            },
+            error: (err) => {
+                data = undefined;
+                error = err;
+                status = "error";
+                console.error("liveQuery error:", err);
+            },
+        });
+        onDestroy(() => {
+            subscription.unsubscribe();
+        });
+    }
+    return {
+        get data() {
+            return data;
+        },
+        get error() {
+            return error;
+        },
+        get status() {
+            return status;
+        },
+        get isLoading() {
+            return status === "loading";
+        },
+    };
+}

package/dist/global.d.ts

@@ -0,0 +1,25 @@
+namespace App {
+  interface Platform {
+    env: {
+      SYNC_ENGINE: any;
+      [key: string]: any;
+    };
+    context: any;
+    caches: any;
+  }
+}
+
+interface Env {
+  SYNC_ENGINE: any;
+  [key: string]: any;
+}
+
+declare module "$app/environment" {
+  export const dev: boolean;
+  export const browser: boolean;
+  export const building: boolean;
+}
+
+declare module "$app/server" {
+  export function getRequestEvent(): any;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { SyncClient, useLiveQuery } from "./client/index.js";
+export { defineSync } from "./server/index.js";
+export { handleUpgrade, publishEvent } from "./server/handler.js";
+export type { SyncContext, SyncHandler } from "./server/index.js";
+export type { SyncMessage } from "./protocol.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAClE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAClE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { SyncClient, useLiveQuery } from "./client/index.js";
+export { defineSync } from "./server/index.js";
+export { handleUpgrade, publishEvent } from "./server/handler.js";

package/dist/protocol.d.ts

@@ -0,0 +1,41 @@
+export type SyncMessage = {
+    type: "subscribe";
+    channel: string;
+    since?: string;
+} | {
+    type: "unsubscribe";
+    channel: string;
+} | {
+    type: "mutate";
+    id: string;
+    channel: string;
+    action: "create" | "update" | "delete";
+    key?: string;
+    data?: any;
+} | {
+    type: "ping";
+} | {
+    type: "pong";
+} | {
+    type: "snapshot";
+    channel: string;
+    data: any[];
+    isDelta?: boolean;
+} | {
+    type: "ack";
+    id: string;
+    data?: any;
+} | {
+    type: "reject";
+    id: string;
+    error: string;
+} | {
+    type: "change";
+    channel: string;
+    action: "create" | "update" | "delete";
+    key?: string;
+    data?: any;
+    mutationId?: string;
+};
+export declare function parseSyncMessage(data: string): SyncMessage | null;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACxC;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ,GACD;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,GAAG,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC7C;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEN,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAcjE"}

package/dist/protocol.js

@@ -0,0 +1,14 @@
+export function parseSyncMessage(data) {
+    try {
+        const parsed = JSON.parse(data);
+        if (parsed &&
+            typeof parsed === "object" &&
+            typeof parsed.type === "string") {
+            return parsed;
+        }
+    }
+    catch {
+        // Ignore malformed JSON
+    }
+    return null;
+}

package/dist/server/broker.d.ts

@@ -0,0 +1,27 @@
+import type { SyncHandler } from "./index.js";
+export interface ISyncConnection {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    getAuth(): any;
+    setAuth(auth: any): void;
+    getSubscribedChannels(): Set<string>;
+    readonly headers: Headers;
+    readonly url: string;
+}
+export declare class SyncBroker {
+    private handlers;
+    private connections;
+    private authorizeConnection?;
+    constructor(handlers: SyncHandler[], authorizeConnection?: (request: Request, platform: App.Platform | undefined) => Promise<any>);
+    setHandlers(handlers: SyncHandler[]): void;
+    registerConnection(conn: ISyncConnection): void;
+    removeConnection(conn: ISyncConnection): void;
+    /**
+     * Resolves the appropriate handler for a channel name.
+     */
+    private findHandler;
+    handleMessage(conn: ISyncConnection, rawMessage: string, platform: App.Platform | undefined, request: Request): Promise<void>;
+    private broadcastChange;
+    handleExternalChange(channel: string, action: "create" | "update" | "delete", key: string | undefined, data: any): Promise<void>;
+}
+//# sourceMappingURL=broker.d.ts.map

package/dist/server/broker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broker.d.ts","sourceRoot":"","sources":["../../src/server/broker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,YAAY,CAAC;AAG3D,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,OAAO,IAAI,GAAG,CAAC;IACf,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;IACzB,qBAAqB,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,mBAAmB,CAAC,CAGV;gBAGhB,QAAQ,EAAE,WAAW,EAAE,EACvB,mBAAmB,CAAC,EAAE,CACpB,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,GAAG,CAAC,QAAQ,GAAG,SAAS,KAC/B,OAAO,CAAC,GAAG,CAAC;IAOZ,WAAW,CAAC,QAAQ,EAAE,WAAW,EAAE;IAanC,kBAAkB,CAAC,IAAI,EAAE,eAAe;IAIxC,gBAAgB,CAAC,IAAI,EAAE,eAAe;IAI7C;;OAEG;IACH,OAAO,CAAC,WAAW;IAqCN,aAAa,CACxB,IAAI,EAAE,eAAe,EACrB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,GAAG,CAAC,QAAQ,GAAG,SAAS,EAClC,OAAO,EAAE,OAAO;YA0IJ,eAAe;IAoDhB,oBAAoB,CAC/B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,EACtC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,GAAG;CAoBZ"}