contracts

type Content struct {
	crud.Base

	// Slug is the name this content is reached by, unique within the tenant. It
	// is normalised on every write, so two callers cannot disagree about
	// whether "About Us" and "about-us" are the same page.
	Slug string `` /* 155-byte string literal not displayed */
	// Title is what a list and a heading show.
	Title string `` /* 130-byte string literal not displayed */
	// Body is Markdown. It is stored as it was written and rendered on read, so
	// a change to what the renderer allows applies to everything ever written
	// rather than to whatever happens to be saved next.
	Body string `` /* 146-byte string literal not displayed */

	// Kind and Status are closed sets; the enum tag is what a form renders as a
	// select and what Validate refuses a value outside.
	Kind   string `` /* 146-byte string literal not displayed */
	Status string `` /* 168-byte string literal not displayed */

	// PublishedAt is when it was published, and nil whenever it is not
	// published: the two are one fact, and Validate keeps them together.
	PublishedAt *time.Time `json:"publishedAt,omitempty" gorm:"type:timestamptz" ui:"widget:datetime" doc:"When this was published" readOnly:"true"`

	// AuthorID is whoever created it. Validate stamps it from the caller on the
	// context, so it is the actor of the request that wrote the row and not
	// something a body can claim; the Spec names it Immutable, so no patch
	// rewrites a byline.
	AuthorID uuid.UUID `` /* 134-byte string literal not displayed */
}

type Moved struct {
	ContentID uuid.UUID `json:"contentId"`
	Slug      string    `json:"slug"`
	Kind      string    `json:"kind"`
	Status    string    `json:"status"`
	At        time.Time `json:"at"`
}

type Service interface {
	// Publish serves it to anybody, and records when. Publishing what is
	// already published changes nothing — the publication time does not move,
	// because a page has one — and archived content is refused: it is taken out
	// of the archive first, which is what Unpublish does.
	Publish(ctx context.Context, tx db.Tx[db.Tenant], id uuid.UUID) (*Content, error)

	// Unpublish takes it back to a draft, from published or from archived, and
	// clears the publication time with it. A draft again changes nothing.
	Unpublish(ctx context.Context, tx db.Tx[db.Tenant], id uuid.UUID) (*Content, error)

	// Archive keeps it and serves it to nobody. Archiving twice changes
	// nothing.
	Archive(ctx context.Context, tx db.Tx[db.Tenant], id uuid.UUID) (*Content, error)

	// Public is the published content at this slug, which is what the public
	// site serves. Anything else — a draft, an archived page, a slug nobody has
	// used — is ErrNotFound, because from outside, content that is not served
	// and content that does not exist are the same fact.
	Public(ctx context.Context, tx db.Tx[db.Tenant], slug string) (*Content, error)
}