@farm.js/sync 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Farm.js Team
+
+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, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/dist/client.d.ts

@@ -0,0 +1,80 @@
+import { SyncModelStore, type SyncRow, type SyncRuntimeConfig } from "./store.js";
+export type SyncMutationState = "pending" | "paused" | "completed" | "failed";
+/**
+ * The result of a mutation, usable three ways:
+ *
+ * ```ts
+ * tasks.update({ id, status: "done" });          // fire and forget
+ * await tasks.update({ id, status: "done" });    // awaited directly
+ * await tasks.update({ id, status: "done" }).persisted;  // explicit
+ * ```
+ *
+ * It is a thenable rather than a promise so that ignoring it is safe: the
+ * rejection is only materialized when a caller actually asks for it, and a
+ * write the UI already rolled back does not surface as an unhandled rejection.
+ */
+export type SyncMutationHandle<TRow = SyncRow> = PromiseLike<TRow> & {
+    readonly key: unknown;
+    readonly state: SyncMutationState;
+    /** Resolves once the server has stored the write; rejects if it never lands. */
+    readonly persisted: Promise<TRow>;
+    catch<TResult = never>(onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<TRow | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<TRow>;
+};
+export type SyncClientOptions = {
+    /** Pause writes while offline and resume them on reconnect. Default true. */
+    networkMode?: "always" | "online";
+    /** Retry transient failures. Default 2 retries with linear backoff. */
+    retry?: {
+        count?: number;
+        delay?: number | ((attempt: number) => number);
+    };
+};
+/** @internal Called by the plugin's client hook once the descriptor is available. */
+export declare function startSyncRuntime(config: SyncRuntimeConfig, options?: SyncClientOptions): void;
+export declare function getSyncStore(model: string): SyncModelStore;
+/** Fetch rows for a model, incrementally when the schema supports a cursor. */
+export declare function loadModel(model: string): Promise<void>;
+export type SyncModelClient = {
+    insert(input: SyncRow): SyncMutationHandle;
+    update(input: SyncRow): SyncMutationHandle;
+    delete(input: SyncRow): SyncMutationHandle;
+    get(key: unknown): SyncRow | undefined;
+    refresh(): Promise<void>;
+    readonly rows: SyncRow[];
+    readonly status: string;
+    readonly pending: number;
+    readonly paused: number;
+    /** @internal */
+    readonly __farmSyncModel: string;
+};
+/** Typed per-model client accessor, resolved lazily so imports stay cheap. */
+export declare const db: Record<string, SyncModelClient>;
+/**
+ * Rows are written to the browser directly rather than through the shared
+ * query cache: they are feature-owned data with their own lifetime, and this
+ * keeps the plugin working whether or not the app configures
+ * `cache.client.adapter`.
+ *
+ * `localStorage` is the default because it is synchronous on read, which is
+ * what makes a warm start paint before the first network round trip. Apps that
+ * outgrow it can pass their own store.
+ */
+type SyncPersistence = {
+    read(model: string): {
+        rows: SyncRow[];
+        cursor: string | null;
+    } | null;
+    write(model: string, value: {
+        rows: SyncRow[];
+        cursor: string | null;
+    }): void;
+    clear(): void;
+};
+/** Replace the default browser store, for example with an IndexedDB one. */
+export declare function setSyncPersistence(store: SyncPersistence | null): void;
+/** Remove every persisted row. Call on logout so a shared device stays clean. */
+export declare function clearSyncedRows(): void;
+export declare function hydrateModel(model: string): void;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/client.js

@@ -0,0 +1,326 @@
+import { SyncModelStore, } from "./store.js";
+let runtime;
+/** @internal Called by the plugin's client hook once the descriptor is available. */
+export function startSyncRuntime(config, options = {}) {
+    if (runtime)
+        return;
+    runtime = { config, stores: new Map(), options };
+}
+const isBrowser = () => typeof window !== "undefined";
+/** Placeholder used while server rendering, before the browser runtime starts. */
+const SSR_DESCRIPTOR = {
+    key: "id",
+    access: "read",
+    persist: false,
+    cursor: null,
+};
+function requireRuntime() {
+    if (runtime)
+        return runtime;
+    const pending = globalThis.__FARM_SYNC_CONFIG__;
+    if (pending) {
+        startSyncRuntime(pending);
+        return runtime;
+    }
+    // Server rendering runs before the plugin's client hook, and the rows live in
+    // the browser anyway. Render an empty store rather than failing the request;
+    // hydration starts the real runtime and fills it in.
+    if (!isBrowser()) {
+        return { config: { path: "", models: {} }, stores: new Map(), options: {} };
+    }
+    throw new Error("The sync runtime is not started. Add `sync({ ... })` to the plugins in farm.config.ts.");
+}
+export function getSyncStore(model) {
+    const state = requireRuntime();
+    let store = state.stores.get(model);
+    if (store)
+        return store;
+    const descriptor = state.config.models[model];
+    if (!descriptor) {
+        if (!isBrowser())
+            return new SyncModelStore(model, SSR_DESCRIPTOR);
+        throw new Error(`Model "${model}" is not exposed to the browser. Add it to \`models\` in sync().`);
+    }
+    store = new SyncModelStore(model, descriptor);
+    state.stores.set(model, store);
+    if (isBrowser())
+        void loadModel(model);
+    return store;
+}
+async function request(body) {
+    const state = requireRuntime();
+    const response = await fetch(state.config.path, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        credentials: "same-origin",
+    });
+    const payload = await response.json().catch(() => undefined);
+    if (!response.ok) {
+        const message = payload?.error?.message ?? `Sync request failed with ${response.status}`;
+        const error = new Error(message);
+        error.code = payload?.error?.code;
+        error.status = response.status;
+        throw error;
+    }
+    return payload;
+}
+/** Fetch rows for a model, incrementally when the schema supports a cursor. */
+export async function loadModel(model) {
+    const store = getSyncStore(model);
+    if (store.status === "idle")
+        store.setStatus("loading");
+    try {
+        const result = await request({ model, operation: "list", since: store.cursor });
+        store.applyServerRows(result.rows ?? [], {
+            full: result.full !== false,
+            cursor: result.cursor ?? null,
+        });
+        // Keep the warm-start copy current even when the session performs no writes.
+        persistModel(model);
+    }
+    catch (cause) {
+        store.setStatus("error", cause instanceof Error ? cause : new Error(String(cause)));
+    }
+}
+function isOnline() {
+    return typeof navigator === "undefined" || typeof navigator.onLine !== "boolean"
+        ? true
+        : navigator.onLine;
+}
+function waitForOnline() {
+    if (typeof window === "undefined")
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const onOnline = () => {
+            window.removeEventListener("online", onOnline);
+            resolve();
+        };
+        window.addEventListener("online", onOnline);
+    });
+}
+/**
+ * Send a write, pausing while offline and retrying transient failures. The
+ * caller has already applied an optimistic layer, so the row stays on screen
+ * for the whole wait.
+ */
+async function dispatchWrite(store, body, options) {
+    const mode = options.networkMode ?? "online";
+    const maxRetries = options.retry?.count ?? 2;
+    let attempt = 0;
+    while (true) {
+        if (mode === "online" && !isOnline()) {
+            store.trackPaused(1);
+            try {
+                await waitForOnline();
+            }
+            finally {
+                store.trackPaused(-1);
+            }
+        }
+        try {
+            return await request(body);
+        }
+        catch (error) {
+            const status = error.status ?? 0;
+            // A rejection the server reasoned about is final; only transport and
+            // server faults are worth retrying.
+            const retriable = status === 0 || status >= 500;
+            if (mode === "online" && !isOnline())
+                continue;
+            if (!retriable || attempt >= maxRetries)
+                throw error;
+            attempt += 1;
+            const delay = typeof options.retry?.delay === "function"
+                ? options.retry.delay(attempt)
+                : (options.retry?.delay ?? attempt * 300);
+            if (delay > 0)
+                await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+}
+function runMutation(model, operation, input, optimistic) {
+    const state = requireRuntime();
+    const store = getSyncStore(model);
+    const layer = optimistic.row === null
+        ? { type: "delete", key: optimistic.key }
+        : { type: "upsert", key: optimistic.key, row: optimistic.row };
+    store.addLayer(layer);
+    store.trackPending(1);
+    let handleState = "pending";
+    const isPersisted = (async () => {
+        try {
+            const result = await dispatchWrite(store, { model, operation, input }, state.options);
+            store.commitLayer(layer, operation === "delete" ? null : result);
+            handleState = "completed";
+            persistModel(model);
+            return result;
+        }
+        catch (error) {
+            store.removeLayer(layer);
+            handleState = "failed";
+            throw error;
+        }
+        finally {
+            store.trackPending(-1);
+        }
+    })();
+    // Keep the promise owned so a fire-and-forget failure never becomes an
+    // unhandled rejection. Callers that await get a fresh chain below.
+    void isPersisted.catch(() => undefined);
+    return {
+        key: optimistic.key,
+        get state() {
+            return handleState;
+        },
+        get persisted() {
+            return isPersisted;
+        },
+        then: (onFulfilled, onRejected) => isPersisted.then(onFulfilled, onRejected),
+        catch: (onRejected) => isPersisted.catch(onRejected),
+        finally: (onFinally) => isPersisted.finally(onFinally),
+    };
+}
+const clientCache = new Map();
+function createModelClient(model) {
+    const client = {
+        insert(input) {
+            const store = getSyncStore(model);
+            const key = input[store.descriptor.key] ?? generateKey();
+            const row = { ...input, [store.descriptor.key]: key };
+            return runMutation(model, "insert", row, { key, row });
+        },
+        update(input) {
+            const store = getSyncStore(model);
+            const key = input[store.descriptor.key];
+            if (key === undefined) {
+                throw new Error(`${model}.update() requires "${store.descriptor.key}" in its input.`);
+            }
+            return runMutation(model, "update", input, { key, row: store.mergeRow(key, input) });
+        },
+        delete(input) {
+            const store = getSyncStore(model);
+            const key = input[store.descriptor.key];
+            if (key === undefined) {
+                throw new Error(`${model}.delete() requires "${store.descriptor.key}" in its input.`);
+            }
+            return runMutation(model, "delete", { [store.descriptor.key]: key }, { key, row: null });
+        },
+        get(key) {
+            return getSyncStore(model).get(key);
+        },
+        refresh() {
+            return loadModel(model);
+        },
+        get rows() {
+            return getSyncStore(model).getRows();
+        },
+        get status() {
+            return getSyncStore(model).status;
+        },
+        get pending() {
+            return getSyncStore(model).pending;
+        },
+        get paused() {
+            return getSyncStore(model).paused;
+        },
+        __farmSyncModel: model,
+    };
+    // Bind so `useMutation(db.tasks.update)` keeps working when detached.
+    client.insert = client.insert.bind(client);
+    client.update = client.update.bind(client);
+    client.delete = client.delete.bind(client);
+    return client;
+}
+function generateKey() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/** Typed per-model client accessor, resolved lazily so imports stay cheap. */
+export const db = new Proxy({}, {
+    get(_target, property) {
+        if (typeof property !== "string")
+            return undefined;
+        let client = clientCache.get(property);
+        if (!client) {
+            client = createModelClient(property);
+            clientCache.set(property, client);
+        }
+        return client;
+    },
+});
+// ── persistence ────────────────────────────────────────────────────────────
+// Rows ride the client cache adapter configured through cache.client.adapter,
+// so warm starts render from disk before the first network round trip.
+const PERSIST_PREFIX = "farm-sync:";
+const PERSIST_VERSION = "1";
+function createLocalStoragePersistence() {
+    if (typeof localStorage === "undefined")
+        return null;
+    const keyFor = (model) => `${PERSIST_PREFIX}${PERSIST_VERSION}:${model}`;
+    return {
+        read(model) {
+            try {
+                const raw = localStorage.getItem(keyFor(model));
+                return raw ? JSON.parse(raw) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        write(model, value) {
+            try {
+                localStorage.setItem(keyFor(model), JSON.stringify(value));
+            }
+            catch {
+                // Quota or private browsing: rows stay in memory for this session.
+            }
+        },
+        clear() {
+            try {
+                for (const key of Object.keys(localStorage)) {
+                    if (key.startsWith(PERSIST_PREFIX))
+                        localStorage.removeItem(key);
+                }
+            }
+            catch {
+                // Nothing to clean up if storage is unavailable.
+            }
+        },
+    };
+}
+let persistence;
+function getPersistence() {
+    persistence ??= createLocalStoragePersistence();
+    return persistence;
+}
+/** Replace the default browser store, for example with an IndexedDB one. */
+export function setSyncPersistence(store) {
+    persistence = store;
+}
+/** Remove every persisted row. Call on logout so a shared device stays clean. */
+export function clearSyncedRows() {
+    getPersistence()?.clear();
+}
+function persistModel(model) {
+    const store = runtime?.stores.get(model);
+    if (!store?.descriptor.persist)
+        return;
+    getPersistence()?.write(model, { rows: store.confirmedRows(), cursor: store.cursor });
+}
+export function hydrateModel(model) {
+    const store = getSyncStore(model);
+    if (!store.descriptor.persist)
+        return;
+    const saved = getPersistence()?.read(model);
+    if (saved?.rows?.length)
+        store.hydrate(saved.rows, saved.cursor ?? null);
+}
+// Register for the plugin handshake: the client hook may run before or after
+// this module is evaluated, so both directions are covered.
+const scope = globalThis;
+scope.__FARM_SYNC__ = { start: (config) => startSyncRuntime(config) };
+if (scope.__FARM_SYNC_CONFIG__)
+    startSyncRuntime(scope.__FARM_SYNC_CONFIG__);

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+import type { FarmSchema, FarmSqlDialect } from "@farm.js/core";
+import { executeSyncOperation, SyncOperationError } from "./server.js";
+import { resolveSyncModels, type ResolvedSyncModel, type SyncModelSetting, type SyncWhere } from "./types.js";
+export type SyncPluginOptions = {
+    /** Declarative data schema; see `defineSchema` from `@farm.js/core`. */
+    schema: FarmSchema;
+    /**
+     * Name of a mount from `storage.mounts` in `farm.config.ts`. Models are read
+     * and written through it, so an app with storage configured needs no
+     * separate data-layer module.
+     */
+    storage?: string;
+    /**
+     * Your database, instead of `storage`. Pass a raw connection — a `pg` Pool, a
+     * Drizzle or Prisma client, a D1 binding, a Mongo client, an unstorage
+     * instance — and the orm runtime detects the driver and builds the model
+     * client from the schema. An already-built orm client is used as-is.
+     */
+    client?: unknown | (() => unknown | Promise<unknown>);
+    /** Row filter applied to every read and write, server side. */
+    where?: SyncWhere | false;
+    /** Which models the browser may read or write. Unlisted models are not exposed. */
+    models: Record<string, SyncModelSetting>;
+    /** Request middleware producing the context passed to `where`. */
+    middleware?: readonly SyncMiddleware[];
+    /** Endpoint the browser calls. */
+    path?: string;
+    /** Persist rows through the configured client cache adapter. */
+    persist?: boolean;
+    /**
+     * Sql dialect for `farm sync migrate`. Only needed when the client's dialect
+     * cannot be detected from its shape.
+     */
+    dialect?: FarmSqlDialect;
+};
+export type SyncMiddlewareContext = {
+    request: Request;
+    context: Record<string, unknown>;
+};
+export type SyncMiddleware = (ctx: SyncMiddlewareContext) => Record<string, unknown> | void | Promise<Record<string, unknown> | void>;
+export type { SyncOrmClient } from "./server.js";
+export type { SyncAccess, SyncModelConfig, SyncModelSetting, SyncOperation, SyncWhere, SyncWhereContext, } from "./types.js";
+export declare function sync(options: SyncPluginOptions): import("@farm.js/core").FarmPlugin<undefined, Record<string, never>, void, {
+    path: string;
+    models: {
+        [k: string]: {
+            key: string;
+            access: import("./types.js").SyncAccess;
+            persist: boolean;
+            cursor: string | null;
+        };
+    };
+}, unknown, false, import("@farm.js/core").PluginRoutes>;
+/** @internal Exposed for tests. */
+export { resolveSyncModels, executeSyncOperation, SyncOperationError };
+export type { ResolvedSyncModel };
+//# 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":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAsB,MAAM,aAAa,CAAC;AAC3F,OAAO,EACL,iBAAiB,EACjB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAErB,KAAK,SAAS,EACf,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,wEAAwE;IACxE,MAAM,EAAE,UAAU,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IACtD,+DAA+D;IAC/D,KAAK,CAAC,EAAE,SAAS,GAAG,KAAK,CAAC;IAC1B,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACzC,kEAAkE;IAClE,UAAU,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IACvC,kCAAkC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAC3B,GAAG,EAAE,qBAAqB,KACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;AAE9E,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EACV,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAIpB,wBAAgB,IAAI,CAAC,OAAO,EAAE,iBAAiB;;;;;;;;;;yDAuH9C;AAiHD,mCAAmC;AACnC,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,CAAC;AACvE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}