content

type Collection[F, T any] struct {
	// contains filtered or unexported fields
}

type Draft[F, T any] struct {
	// ID is empty for new content.
	ID string
	// Fields are the language-independent values.
	Fields F
	// Translations are the texts per language; languages left out have no
	// text.
	Translations []Translation[T]
	// Author is the user ID; empty for system changes. Revisions only.
	Author string
	// Note is an optional change note. Revisions only.
	Note string
}

type IDs []string

type Item[F, T any] struct {
	ID           string
	Instance     string
	Fields       F
	Translations []Translation[T]
	CreatedAt    time.Time
	UpdatedAt    time.Time
	// CreatedBy and UpdatedBy are the IDs of the users who made the item and
	// changed it last; empty for visitors and the system (see db.Actor).
	CreatedBy string
	UpdatedBy string
	// DeletedAt is when the item went to the trash, by DeletedBy; nil for
	// live items. Only Trashed returns deleted items.
	DeletedAt *time.Time
	DeletedBy string

	// Published is true when the item is visible. For Revisions this means some
	// revision is published, not necessarily the one in this Item.
	Published bool

	// Collection only.
	Position int

	// Revisions only.
	Revision        Revision
	PublishedID     string
	PublishedNumber int
	// Schedule is the item's planned publication change, if any.
	Schedule Schedule
}

type Mover interface {
	Move(ctx context.Context, id string, position int) error
}

type Planner[F, T any] interface {
	Planned(ctx context.Context) ([]Item[F, T], error)
}

type Publisher struct {
	// Publish publishes revisionID of item id, which must be complete in
	// the required language.
	Publish func(ctx context.Context, id, revisionID, required string) error
	// Unpublish takes item id off the website.
	Unpublish func(ctx context.Context, id string) error
}

type Review struct {
	State       ReviewState
	SubmittedBy string
	SubmittedAt time.Time
	ReviewedBy  string
	ReviewedAt  time.Time
	// Note is the reviewer's comment, required when rejecting.
	Note string
}

type ReviewPolicy func(ctx context.Context, instance string) bool

type ReviewState string

type Reviewing[F, T any] interface {
	// ReviewRequired reports whether publishing needs an approved revision
	// under ctx's policy (see WithReview).
	ReviewRequired(ctx context.Context) bool
	// Submit asks for a review of a revision.
	Submit(ctx context.Context, id, revision string) error
	// Approve and Reject decide on a submitted revision.
	Approve(ctx context.Context, id, revision, note string) error
	Reject(ctx context.Context, id, revision, note string) error
	// InReview lists at most limit revisions waiting for review.
	InReview(ctx context.Context, limit int) ([]Item[F, T], error)
}

type Revision struct {
	ID string
	// Number counts the item's revisions from 1, for people.
	Number int
	// Author is the ID of the user who saved it; empty for system changes.
	Author    string
	CreatedAt time.Time
	// Note is the change note the author gave, if any.
	Note string
	// Review is the revision's state in the optional review workflow (see
	// WithReview).
	Review Review
}

type Revisions[F, T any] struct {
	// contains filtered or unexported fields
}

type Schedule struct {
	// RevisionID is published at PublishAt; both are empty when only
	// unpublishing is planned.
	RevisionID string
	PublishAt  time.Time
	// UnpublishAt takes the item offline; zero when not planned.
	UnpublishAt time.Time
}

type Scheduler interface {
	// RunDue publishes and unpublishes what is due at now and returns how many
	// changes it made. Published revisions must be complete in required.
	RunDue(ctx context.Context, now time.Time, required string) (int, error)
}

type Scheduling interface {
	Scheduler
	// Schedule replaces the plan of an item. required is the locale a
	// published revision must be complete in.
	Schedule(ctx context.Context, id string, schedule Schedule, required string) error
	// Unschedule cancels the plan of an item.
	Unschedule(ctx context.Context, id string) error
}

type Spec[F, T any] struct {
	// Table is the base table name, for example "wt_publishing_post".
	Table string
	// Complete reports whether a translation can be shown publicly.
	Complete func(T) bool
	// SlugColumn names T's slug column. Empty means the content has no detail URLs.
	SlugColumn string
	// Check validates module rules after the kit normalized locales and slugs.
	Check func(fields F, translations []Translation[T]) error
	// Media lists referenced media asset IDs. They cannot be deleted while used.
	Media func(fields F, translations []Translation[T]) []string
	// Deletable refuses moving an item to the trash with an error, for
	// example while live items of another type still refer to it. Nil
	// allows every delete.
	Deletable func(ctx context.Context, id string) error
	// Changed, when set, is called after every committed write that may
	// change what visitors see: publishing, unpublishing, moving to the
	// trash and back and, for a Collection, saving and moving an item.
	// Modules set it to webthings.Env.Changed, so the output cache renders
	// its pages again also after a write made from Go, such as an import,
	// a seed or a background job.
	Changed func()
}

type Store[F, T any] interface {
	// Spec returns the description of the content.
	Spec() Spec[F, T]
	// List returns every item outside the trash, published or not, in the
	// store's order.
	List(ctx context.Context) ([]Item[F, T], error)
	// Load returns the latest state, or a specific revision when revision is set.
	Load(ctx context.Context, id, revision string) (Item[F, T], error)
	// Save stores draft: a new revision, or the new state of the item. It
	// does not publish.
	Save(ctx context.Context, draft Draft[F, T]) (Item[F, T], error)
	// Delete moves the item to the trash.
	Delete(ctx context.Context, id string) error
	// Trashed lists the items in the trash, most recently deleted first.
	Trashed(ctx context.Context) ([]Item[F, T], error)
	// Undelete brings an item back from the trash; ErrDuplicateSlug when
	// another item took its slug meanwhile.
	Undelete(ctx context.Context, id string) error
	// Purge removes an item in the trash for good.
	Purge(ctx context.Context, id string) error
	// Recent returns at most limit items, the most recently changed first.
	Recent(ctx context.Context, limit int) ([]Item[F, T], error)
	// Publish makes the item (or the given revision) public; locale must be complete.
	Publish(ctx context.Context, id, revision, locale string) error
	// Unpublish takes the item off the website; it stays in the admin.
	Unpublish(ctx context.Context, id string) error
	// Revisioned reports whether History and Restore are available.
	Revisioned() bool
	// History lists the item's revisions, newest first; nil when the store
	// keeps none.
	History(ctx context.Context, id string) ([]Revision, error)
	// Restore copies an old revision into a new latest revision by author.
	// It does not publish.
	Restore(ctx context.Context, id, revision, author string) (Item[F, T], error)
}

type Translation[T any] struct {
	// Locale is the language code, such as "nl"; stores normalize it (see
	// locales.Normalize).
	Locale string
	// Text is the translated text, the T of the Spec.
	Text T
}