operation

type Access func(Context) (Decision, error)

type AccessCapabilities struct {
	Operations OperationCapabilities
	// Fields holds field capabilities by runtime path for each located value,
	// and by canonical path for each resource field and each block placement
	// with located values.
	Fields map[string]FieldCapabilities
	// BlockFields holds, by block slug and definition-relative path, the
	// capabilities of a block definition's field at a placement without
	// located values, such as a row the client has yet to add. It is
	// evaluated once per definition field rather than once per placement.
	BlockFields map[string]map[string]FieldCapabilities
}

type CapabilitiesRequest struct {
	Collection      string
	ID              string
	Data            store.Values
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	TrashOnly       bool
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
	AllLocales      bool
}

type Collection struct {
	Key      string
	Schema   schema.Collection
	Access   map[operation.Kind]Access
	Hooks    Hooks
	Bindings []FieldBinding
	// contains filtered or unexported fields
}

type CollectionPageAccess struct {
	Collection AccessCapabilities
	Documents  map[string]AccessCapabilities
}

type Computed func(Context, store.Document) (store.Value, error)

type Config struct {
	Collections               []Collection
	Store                     store.Store
	AllowIDOnCreate           bool
	MaxDepth                  int
	PluginValidators          map[string]PluginValidator
	DispatchAfterCommit       func(Context, Hook) error
	BeginPermanentDeleteFence func(context.Context, []PermanentDelete) func(bool)
	CleanupPermanentDeletes   func(context.Context, []PermanentDelete) error
	ValidateUploadImport      func(context.Context, schema.Collection, store.Values) error
	RootAfterError            []Hook
	Localization              *schema.LocalizationSettings
	// EditorCollection is the auth collection whose members see drafts by
	// default: the admin's user collection. Empty means no actor does.
	EditorCollection schema.StableID
}

type Context struct {
	Context         context.Context
	Operation       operation.Kind
	WritePhase      operation.WritePhase
	Collection      schema.Collection
	ID              string
	Actor           *store.Document
	ActorCollection schema.CollectionSlug

	// System marks trusted server code that skips collection and field access
	// rules. Only the Local API sets it; transports never do.
	System bool
	Data   store.Values
	Value  store.Value
	// Root, Siblings and Prior are a field callback's immutable object views of
	// the document, the enclosing object or row, and that object's previous
	// persisted state. Root is zero outside field callbacks; Prior is zero when
	// no previous object exists. Input is a live validator's submitted object.
	Root     store.Value
	Siblings store.Value
	Prior    store.Value
	Input    store.Value

	// Replacement receives a field hook's new value for its own field. The
	// engine sets it for each field hook; other contexts leave it nil.
	Replacement    *FieldReplacement
	LiveValidation bool

	Document *store.Document
	Original *store.Document

	// OccurrenceID correlates a field callback's value; SchemaOccurrenceID
	// names the configured field at the value's placement.
	OccurrenceID       string
	SchemaOccurrenceID string
	ValuePresent       bool

	RuntimePath string
	Error       error
	Locale      schema.LocaleCode
	AllLocales  bool
	Locales     []schema.LocaleCode
	// contains filtered or unexported fields
}

type Decision struct {
	Kind   DecisionKind
	Access *query.Node
}

type DecisionKind string

type DistinctRequest struct {
	Collection      string
	Field           query.Path
	Filter          query.Expression
	Page            int
	Limit           int
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	// System skips access rules for trusted server code; see Request.System.
	System          bool
	Draft           *bool
	TrashOnly       bool
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
}

type Engine struct {
	// contains filtered or unexported fields
}

type Error struct {
	Code    string
	Status  int
	Message string
	Issues  []schema.Issue
	Cause   error
	// Committed reports that the durable transaction succeeded before a later
	// after-commit effect failed. Callers that stage external resources must not
	// roll those resources back when this is true.
	Committed bool
	// CommitAttempted reports that Commit was sent but its durable outcome could
	// not be proven. External resources must be retained and reconciled instead
	// of rolled back when this is true.
	CommitAttempted bool
	// contains filtered or unexported fields
}

type FieldAccess func(Context) (bool, error)

type FieldBinding struct {
	ID string
	// Block names the block definition that declares Field, whose path and ID
	// are then definition-relative. It is empty for a resource's own field.
	Block          string
	Field          schema.Field
	Hooks          Hooks
	Access         FieldRules
	Validators     []FieldValidator
	LiveValidators []FieldLiveValidator
	Computed       Computed
	Default        FieldDefault
}

type FieldCapabilities struct {
	Read   bool
	Create bool
	Update bool
}

type FieldDefault func(Context) (store.Value, bool, error)

type FieldLiveValidator func(Context) ([]schema.Issue, bool, error)

type FieldReplacement struct {
	Value store.Value
	Set   bool
}

type FieldRules struct {
	Create FieldAccess
	Read   FieldAccess
	Update FieldAccess
}

type FieldValidator func(Context) ([]schema.Issue, error)

type FilteredSelectionItem struct {
	ID           string
	Capabilities AccessCapabilities
}

type FilteredSelectionRequest struct {
	Collection      string
	Filter          query.Expression
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	TrashOnly       bool
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
	AllLocales      bool
}

type FilteredSelectionResult struct {
	Items []FilteredSelectionItem
}

type Hook func(Context) error

type Hooks struct {
	BeforeDuplicate []Hook
	BeforeValidate  []Hook
	BeforeChange    []Hook
	BeforeOperation []Hook
	BeforeRead      []Hook
	BeforeDelete    []Hook
	AfterChange     []Hook
	AfterRead       []Hook
	AfterDelete     []Hook
	AfterOperation  []Hook
	AfterError      []Hook
	AfterCommit     []Hook
}

type JoinMutationRequest struct {
	Collection      string
	ID              string
	Field           string
	Additions       []string
	Removals        []string
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	// System skips access rules for trusted server code; see Request.System.
	System          bool
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
	AllLocales      bool
}

type JoinMutationResult struct {
	Document store.Document
	Added    int
	Removed  int
}

type LiveValidationEmbeddedScope struct {
	Field       string
	TreeKey     string
	CaseTag     string
	VariantSlug string
	Identity    string
	Data        store.Values
}

type LiveValidationEvaluation struct {
	Path   string
	Target string
	Status string
	Issues []schema.Issue
}

type LiveValidationRequest struct {
	Collection      string
	ID              string
	Draft           *bool
	Data            store.Values
	Fields          []string
	Embedded        []LiveValidationEmbeddedScope
	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	Locale          string
}

type LiveValidationResult struct{ Evaluations []LiveValidationEvaluation }

type LocalizationOptions struct {
	Locale          string
	FallbackLocales []schema.LocaleCode
	DisableFallback bool
	AllLocales      bool
	// ActorCollection identifies the exact auth collection that owns Actor on
	// specialized version and locale operations.
	ActorCollection schema.CollectionSlug
	// System skips access rules for trusted server code; see Request.System.
	System bool
}

type OperationCapabilities struct {
	Admin           bool
	Create          bool
	Read            bool
	ReadVersions    bool
	Update          bool
	Delete          bool
	Duplicate       bool
	Publish         bool
	Unpublish       bool
	RestoreDeleted  bool
	DeletePermanent bool
	SelectAll       bool
	Unlock          bool
}

type PermanentDelete struct {
	Collection schema.Collection
	DocumentID string
	Original   store.Document
}

type PluginValidator func(schema.Field, store.Value, string) []schema.Issue

type Rejection struct {
	Message string
	Issues  []schema.Issue
}

type Request struct {
	Operation  operation.Kind
	Collection string
	ID         string
	Data       store.Values
	Filter     query.Expression

	Actor           *store.Document
	ActorCollection schema.CollectionSlug
	// System runs the request as trusted server code: collection, field, draft
	// and reference access rules are skipped, while validation, hooks, versions
	// and reference integrity still apply. Only the Local API sets it.
	System bool
	Page   int
	Limit  int
	// SkipTotal reads a collection list page without counting every match:
	// the page has no Total and an exact HasNextPage. Index windows never count.
	SkipTotal   bool
	IndexWindow *store.IndexWindow
	Sort        []query.Sort
	Select      []query.Path
	Populate    []query.Population
	// IncludeAccess enriches an ordinary collection list with collection and
	// per-document capabilities evaluated in the list's read transaction.
	IncludeAccess bool
	// OutputFields limits computed and inverse-join resolution. Nil preserves
	// the local API's historical behavior of resolving every output field; a
	// non-nil empty slice resolves none. This is deliberately separate from
	// Select because computed resolvers may depend on unprojected stored data.
	OutputFields []query.Path
	// Draft overrides versioned read visibility or selects the status written
	// by create/update. Nil preserves the caller's existing behavior.
	Draft *bool
	// ExpectedRevision, when nonzero, must equal the revision of the document
	// as the operation locks it, before any hook runs; otherwise the operation
	// fails with a conflict. Writes the operation's own hooks make in its
	// transaction do not conflict with it.
	ExpectedRevision int
	Status           *store.Status
	ImportID         string
	ImportCreatedAt  time.Time
	ImportUpdatedAt  time.Time
	TrashOnly        bool
	StoragePrepared  bool
	// ValidateUploadObjects re-adopts existing upload keys. The engine locks and
	// verifies every final key inside the write transaction before committing
	// metadata that can make those objects live again.
	ValidateUploadObjects bool
	LocalizationPrepared  bool

	// SkipFieldAccess is reserved for framework-owned initialization that must
	// author the first administrator before an actor exists. Collection access,
	// validation, hooks, and the transaction remain active.
	SkipFieldAccess     bool
	TransactionMutation TransactionMutation
	// TransactionResource binds one framework-owned external resource to the
	// true outer transaction. Commit retains it, a definite rollback cleans it
	// up, and an unknown commit outcome retains it for reconciliation rather
	// than risking a dangling durable row.
	TransactionResource *TransactionResource
	Locale              string
	FallbackLocales     []schema.LocaleCode
	DisableFallback     bool
	AllLocales          bool
	// contains filtered or unexported fields
}

type Result struct {
	Document   *store.Document
	Page       *store.Page
	PageAccess *CollectionPageAccess
}

type TransactionMutation func(context.Context, store.Transaction, schema.Collection, store.Document) error

type TransactionResource struct {
	Commit   func()
	Rollback func(context.Context) error
	Unknown  func()
	// contains filtered or unexported fields
}