# createSync \[Wire a storage adapter, hub, and secret into a Live object] `createSync` wires together a storage adapter, hub, and signing secret into a `Live` object with typed write methods plus the grant calls `serve`, `renew`, and `hydration`. `storage` is a [`SyncStorage` adapter](/framework/server/storage-adapters) — `drizzleStorage(db)` from `rxfy-server-drizzle` for a Drizzle-backed app, or `memoryStorage()` from `rxfy-server-memory` for an in-memory one — and `secret` is the HMAC key used to sign and verify [channel grants](/framework/server/grants) — share it with the WebSocket server. The writers (`create` / `update` / `delete`) delegate to the adapter, so core `rxfy-server` never imports Drizzle. The tabs below show them: :::code-group ```ts [server/live.ts] import { createInMemoryHub, createSync } from "rxfy-server"; import { drizzleStorage } from "rxfy-server-drizzle"; import { db } from "./db.js"; export const sync = createSync({ storage: drizzleStorage(db), // The hub holds sync socket subscriptions, so there must be exactly ONE instance. entry-server // receives `live` as a parameter instead of importing this module, so a separate Vite SSR module // graph never instantiates a second hub. hub: createInMemoryHub(), // Signs/verifies channel grants — shared with the WebSocket server. Override via RXFY_SECRET. secret: process.env.RXFY_SECRET ?? "dev-secret-change-me", }); ``` ```ts [src/blog/resources.ts] import { postModel, userModel } from "./models.js"; import { defineResource } from "rxfy-server-drizzle"; import { posts, users } from "../db/schema.js"; export const userResource = defineResource({ table: users, model: userModel }); export const postResource = defineResource({ table: posts, model: postModel }); ``` ```ts [server/db.ts] import { PGlite } from "@electric-sql/pglite"; import { drizzle } from "drizzle-orm/pglite"; import { posts, users } from "../src/db/schema.js"; // Any Drizzle database works — this example uses in-memory PGlite. export const db = drizzle(new PGlite()); // Re-exported so server routes can import tables and `db` from one place. export { posts, users }; ``` ::: The returned `Live` object exposes: * [`sync.create` / `sync.update` / `sync.delete` / `sync.touch`](/framework/server/writes) — typed writes that publish sync messages. * [`sync.serve(state, params, data)`](/framework/server/grants) — read-endpoint wrapper; parses `data` (the state's input shape — raw DB rows work as-is) through the state's schemas, signs a grant for the state's channel, and returns the parsed shape with the grant attached as `$grant`. Stateless — no `req`, no hub interaction. * [`sync.renew(grant)`](/framework/server/grants) — verify a grant (within a grace window) and reissue it with a fresh expiry, or return `null` when denied. Mount it behind your app's auth. * [`sync.hydration(registry)`](/framework/server/grants) — one-call SSR payload: signs one grant per channel the render logged, embeds them as `grants: string[]`, and returns the `hydrationScript` string. `createSync` also accepts `grantTtlMs` (grant lifetime, default 15 minutes) and `renewGraceMs` (how long past expiry a grant still renews, default 5 minutes). `Live` is generic over the adapter's binding — `Live` for `drizzleStorage`, `Live` for `memoryStorage`. Its collaborators each have their own article: resources come from [`defineResource`](/framework/server/define-resource) (Drizzle) or `defineCollection` (`rxfy-server-memory`), and the hub from [`createInMemoryHub`](/framework/server/hub) — it holds per-socket subscriptions, so there must be exactly one instance per process.