Files
xarmian 04514817ae feat(store): add Yjs op-log table + store methods (TASK-1252) (#450)
* feat(store): add Yjs op-log table + store methods (TASK-1252)

Persistence groundwork for the dumb-relay WebSocket server in PLAN-1248.
The item_yjs_updates table records every Yjs binary update (browser
edits, future designated-applier conversions of CLI/API content
changes) so reconnecting peers can replay updates since their last
known cursor and cold rooms can rebuild their in-memory Y.Doc.

Schema (mirrored across SQLite + Postgres):
- id              monotonic — INTEGER PRIMARY KEY AUTOINCREMENT (SQLite)
                   / BIGSERIAL (Postgres). Never reused, even after
                   deletes; serves as the cursor every reconnecting
                   client compares against.
- item_id         FK with ON DELETE CASCADE so item deletion reclaims
                   op-log space automatically.
- update_data     raw Yjs binary update — BLOB / BYTEA. Opaque to the
                   server.
- schema_version  stamped per row. Mismatch on connect drives
                   TASK-1268's snapshot-and-rebuild flow.
- created_at      ISO8601 UTC TEXT, matching pad's cross-dialect
                   timestamp convention (see migrations/047_attachments).
                   Drives PruneYjsUpdatesBefore.

Store API (internal/store/yjs_updates.go):
- AppendYjsUpdate — validates non-empty itemID/data/schemaVersion,
   inserts and returns the new monotonic id (RETURNING on Postgres,
   LastInsertId on SQLite). Empty-zero-byte updates are rejected at
   the Go layer rather than relying on NOT NULL — they're a no-op
   that would only pollute the log.
- LoadYjsUpdatesSince — strict id > sinceID filter, ordered by id
   ascending. sinceID=0 returns everything (cold-room rebuild path).
   Tolerates either RFC3339 or "YYYY-MM-DD HH:MM:SS" timestamp formats
   on read so any future operator-written / CURRENT_TIMESTAMP-style row
   doesn't blow up the load path.
- PruneYjsUpdatesBefore — created_at < cutoff, scoped to itemID.
   Returns rows-affected count. Used by the eventual GC sweeper
   (out of scope for this task).

Tests cover: append + monotonic ids, load-since-cursor filtering,
input validation, prune scoped to itemID, and ON DELETE CASCADE on
parent item removal. Pass on SQLite locally; Postgres mirror migration
+ store methods are dialect-agnostic.

Parent: PLAN-1248. First task of Phase 1 — Backend foundation.

* docs(store): document AppendYjsUpdate per-item serialization contract per Codex review (round 1)

P1: Postgres BIGSERIAL ids are allocation-ordered, not commit-order.
Concurrent appends to the same item could in theory produce a cursor
gap — a slower transaction can hold a smaller id while a faster one
commits a larger id first, and a reader that advances past the visible
larger id would later miss the smaller id when it commits.

The dumb-relay room manager (TASK-1255) is the sole writer per item by
design — there's exactly one goroutine appending per Y.Doc — so the
hazard does not manifest in practice. The fix is at the API contract
level: the doc comment now spells out the serialization requirement,
why the room manager satisfies it, and the multi-replica re-enforcement
note for the future Redis-fanout IDEA. We do not take an internal
advisory lock because that would be paid by every append even though
the caller already holds the per-room mutex.

No code change — contract is at the doc comment.
2026-05-08 13:28:55 -04:00

22 lines
880 B
Go

package models
import "time"
// YjsUpdate is a single appended Yjs binary update for an item.
//
// Rows live in the `item_yjs_updates` op-log added in PLAN-1248. The
// dumb-relay WebSocket server (TASK-1254) appends one row per peer
// update; on reconnect, clients replay rows since their last known ID
// and resume seamlessly. UpdateData is the raw output of Yjs's
// encodeStateAsUpdate / mergeUpdates — opaque to the server. SchemaVersion
// is stamped from the client at append time and drives TASK-1268's
// snapshot-and-rebuild flow when a Tiptap minor bump changes the
// underlying ProseMirror schema between releases.
type YjsUpdate struct {
ID int64 `json:"id"`
ItemID string `json:"item_id"`
UpdateData []byte `json:"update_data"`
SchemaVersion string `json:"schema_version"`
CreatedAt time.Time `json:"created_at"`
}