Content releases

A content release is a named collection of unpublished entity versions. It is useful for work that crosses entity boundaries: launching a brand and its products, preparing a campaign and its pages, or coordinating a taxonomy change with the content that uses it.

A release is an overlay on published content, not an isolated workspace. A release perspective resolves each entity like this:

version in the selected release
            ↓ otherwise
      published version

Ordinary drafts and releases are independent. An ordinary draft never appears in a release accidentally. Copying a draft into a release is an explicit operation, after which each version evolves independently.

Lifecycle

A release has one of four statuses:

Status	Meaning
Draft	Editable and not scheduled.
Scheduled	Editable and queued for a future publication time. The latest saved versions will publish.
Error	A validation, uniqueness, or field-group conflict blocked publication. The release remains editable.
Published	Published successfully and immutable. Its item history and release perspective remain available.

Creating a release materializes its perspective over the current published model. Later published changes are rebased into every active release unless that release changed the same field group. This gives release queries, relations, calculations, context memberships, caches, and search the same semantics as ordinary draft preview.

Creating and editing through .NET

var release = await releases.CreateAsync(
    new VoxCreateContentRelease("Autumn launch", "New brand and products"),
    cancellationToken);

var product = await updater.UpdateAsync(
    "mug",
    new VoxContentVersion(VoxContentMode.Published, published.Version),
    new ProductActions.SetName { Name = "Autumn mug" },
    VoxSaveTarget.Release(release.Id),
    cancellationToken: cancellationToken);

var preview = await products.GetAsync(
    "mug", VoxContentScope.ForRelease(release.Id), cancellationToken);

Saving to a release automatically adds that entity to the release. Continue editing from the release version by using VoxContentMode.Release and its release ID in VoxContentVersion.

IVoxContentReleaseManager lists release items, copies an ordinary draft into a release, removes an item, resolves conflicts, schedules or unschedules the release, and publishes it.

Atomic publishing and conflicts

Before publishing, Vox validates every release version and checks the caller's publish permissions. The storage provider then checks all field-group bases and publishes every item in one transaction. Any conflict, validation failure, uniqueness violation, or concurrency failure rolls back the entire release.

When published content changes a group that a release also changed, the release item reports that group as a conflict. Resolve it explicitly with TakeDraft (keep the release value and rebase it) or TakePublished (discard the release change for that group). Scheduled publication never resolves conflicts automatically; its Nexus queue item enters Error and the release becomes Error.

Atomicity is a storage capability. A release may contain only entities whose authoritative provider can publish the whole release transactionally. The Entity Framework provider supports this. Vox rejects unsupported providers instead of publishing part of a release.

Scheduling

Scheduling creates one delayed Nexus message for the release. Editing a scheduled release preserves its schedule, so the newest versions go live. Publishing manually makes the queued message stale; duplicate and stale messages are safe no-ops. Unscheduling also invalidates the queued message.

Preview clients

Use content=Release&release={releaseId} on reads. An API client can make this its default by setting ContentMode to Release and ContentReleaseId to the release ID. This is suitable for a dedicated preview deployment. Published remains the default perspective for delivery clients.

Permissions

Creating, updating, scheduling, publishing, and deleting releases requires vox:ContentReleases. Saving an entity action into a release requires both that permission and the ordinary entity create/edit/action permission. Publishing additionally requires {EntityType}:Publish for every entity type with an item in the release.