# Writes \[sync.create / sync.update / sync.delete and touch] `sync.create`, `sync.update`, and `sync.delete` run the SQL write and then publish sync messages. All three accept an optional `{ touch: [...] }` option to mark state channels stale. `server/api.ts` pulls together three things declared elsewhere — the tabs below show each one: * `live` — the `Live` object from [`createSync`](/framework/server/create-server). * `postResource` — a resource from [`defineResource`](/framework/server/define-resource). * `postsState` — a state from [`defineState`](/rxfy/define-state), the **same state you pass to `useStateData`** on the client. It already carries the `{ key, window }` a channel needs, so it doubles as a `StateChannelDescriptor`. :::code-group ```ts [server/api.ts] import { touch } from "rxfy-server"; import { postsState } from "../src/blog/states.js"; import { postResource } from "../src/blog/resources.js"; import { sync } from "./sync.js"; // update — publishes a `patch` on the entity topic automatically await sync.update(postResource, postId, { title, body }); // create — does NOT publish a patch; touch the state channels that list this entity await sync.create(postResource, { id: newId(), userId, title, body }, { touch: [touch(postsState, {})] }); // delete — same: no patch, touch the channels that referenced this entity await sync.delete(postResource, postId, { touch: [touch(postsState, {})] }); ``` ```ts [server/live.ts] import { createInMemoryHub, createSync } from "rxfy-server"; import { drizzleStorage } from "rxfy-server-drizzle"; import { db } from "./db.js"; export const hub = createInMemoryHub(); export const sync = createSync({ storage: drizzleStorage(db), hub }); ``` ```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 [src/blog/states.ts] import { array, defineState } from "rxfy"; import { z } from "zod"; import { postModel, userModel } from "./models.js"; // Declared once, imported by both the client (useStateData) and the server (touch). export const postsState = defineState({ key: "posts", params: z.object({}), model: { posts: array(postModel), authors: array(userModel) }, }); ``` ::: **Publish behaviour:** | Call | SQL | Publishes | | --------------------------------------- | ------------------ | ----------------------------------------------------------------------------- | | `sync.update(resource, id, patch)` | UPDATE … RETURNING | `patch` on the `":"` entity topic, then `stale` on touched channels | | `sync.create(resource, row, { touch })` | INSERT | `stale` on touched channels only (no patch) | | `sync.delete(resource, id, { touch })` | DELETE | `stale` on touched channels only | | `sync.touch(...targets)` | none | `stale` out of band | `create` and `delete` publish no entity patch — there is no row to push for a new entity, and the deleted row is gone. They publish `stale` on every touched channel so clients know to refetch. **Return values:** `create` resolves the inserted row. `update` resolves the updated row, or `undefined` when no row matches the id — a not-found update writes nothing and publishes nothing (no patch, no touch). ## touch `touch(stateDescriptor, params)` builds a `TouchTarget` for a specific state instance. Window dimensions declared in `state.window` (page, cursor, sort) are stripped from the channel key so all windows of the same partition share one invalidation channel — see [Grants](/framework/server/grants) for how channels are derived and signed. You can also call `sync.touch(...targets)` directly without a write to invalidate channels out of band.