Modelling references without modelling yourself into a corner

Copying an author's name into every post they wrote is the fastest thing to build and the slowest thing to fix. A reference writes that information once and points at it, and the cost is one extra step on every read — a trade that is obviously right at the tenth post and obviously wrong to argue about at the first.

References are pointers, not joins

A reference is an id in a wrapper: `{ _ref: "author-maya-chen", _type: "reference" }`. It carries no target type, deliberately. A type inside the reference would mean renaming a type is a migration of every document that mentions it, and what a reference may point at is the schema's business anyway. A query's `->` is what turns the pointer into the document.

The uncomfortable part is deletion. Nothing stops a reference from pointing at a document that is gone, and nothing should: a strict foreign key over content makes one editor's save wait on another editor's write. Instead the read is written to survive a missing target, and a sweep finds the orphans on a schedule.

A reference that cannot dangle is a reference that blocks somebody else's save.

Two habits that keep it healthy

• Project the fields you need across the reference, and nothing else.
• Write the renderer so a missing target draws nothing rather than throwing.
• Reach outwards with `^` when a nested projection needs a field from outside it.
• Sweep for orphans on a schedule rather than on every write.

Done that way, a rename is one document, a deletion is a decision somebody makes on purpose, and the content stays readable while both happen.

*[_type == "post"]{ title, "author": author->{ name, role }, "categoryCount": count(categories) }

Counting a list of references without dereferencing any of them is worth noticing: `count(categories)` answers from the document in hand, and a page that only needed the number never reads the categories at all.