schema

type Dataset ¶

type Dataset struct {
	Fields  []Field
	Dynamic bool

	// DeleteBy: record-delete gate. Zero = anyone.
	DeleteBy DeletePolicy
	// IdRule: how record ids are produced. Zero = auto (derived).
	IdRule IdRule
	// IdPattern is an RE2 pattern user-supplied ids must match in full
	// (IdUser only). Empty = DefaultIdPattern.
	IdPattern string
	// IdMaxLen caps user-supplied id length (IdUser only). 0 =
	// DefaultIdMaxLen.
	IdMaxLen int
	// Search is the optional search-extraction annotation.
	Search *SearchFields
}

Dataset is a dataset's required, JSON-Schema-compatible declaration. Dynamic datasets (shortIds, the per-type `objects` namespace) carry a free-form key space: undeclared fields are allowed and default to ScopeSynced; declared fields (e.g. derived auto-fields) are still enforced.

func (d Dataset) MarshalJSON() ([]byte, error)

{"type":"object","properties":{<id>:{<value schema>,"title":..,"x-scope":..}},
 "required":[..],"additionalProperties":<Dynamic>}

func (d Dataset) Normalized() Dataset

func (d Dataset) ScopeOf(id string) (Scope, bool)

type DeletePolicy ¶

type DeletePolicy uint8

DeletePolicy is the dataset-level record-delete gate.

const (
	// DeleteByAnyone (zero): any writer may delete a record.
	DeleteByAnyone DeletePolicy = iota
	// DeleteByAuthor: only the record's creator (StampCreator field)
	// may delete it.
	DeleteByAuthor
)

func ParseDeletePolicy(label string) (DeletePolicy, bool)

func (p DeletePolicy) String() string

type Field ¶

type Field struct {
	Id     string
	Name   string
	Schema *Schema // value shape; nil means unconstrained
	Scope  Scope

	// Required: the field must be present in the create payload.
	// Enforced by the generic schema handler; mutually exclusive with
	// Stamp.
	Required bool
	// MutableBy: post-create write rule. Zero = write-once.
	MutableBy Mutability
	// Stamp: apply-time derived value. Non-zero forces ScopeDerived.
	Stamp Stamp

	// Description and XFormat are the field's descriptive slice: a
	// display description and the opaque descriptor bag (semantic slug,
	// icon, options, …). Neither is enforced by any handler and neither
	// enters the schema revision — editing them never re-registers a
	// dataset. Rendered by discovery as `description` / `x-format`.
	Description string
	XFormat     map[string]any
}

Field is one declared dataset field: a JSON-Schema value shape plus its class. Modeled like a type property (Id/Name + recursive Schema) so the two share one representation.

type IdRule ¶

type IdRule uint8

IdRule declares how the dataset's record ids are produced.

const (
	// IdAuto (zero): records are created with an empty id and the id is
	// derived from the change (the existing empty-id upsert sugar);
	// explicit caller ids are rejected at create.
	IdAuto IdRule = iota
	// IdUser: the caller supplies the id, constrained by
	// IdPattern/IdMaxLen. The id doubles as the upsert idempotency
	// key. Contract: one writer per id — concurrent creates of the
	// same id by different members take arrival-order-dependent
	// creation verdicts (required checks, creator stamp) and are
	// outside the convergence guarantee.
	IdUser
)

func ParseIdRule(label string) (IdRule, bool)

func (r IdRule) String() string

type Kind ¶

type Kind uint8

Kind is the declared type of a value.

const (
	KindUnknown Kind = iota
	KindString
	KindNumber
	KindBoolean
	KindNull
	KindArray
	KindObject
	// KindDatetime is an instant, stored as any-store's native
	// TypeDateTime (unix millis, memcmp-orderable, index-keyable,
	// `{"$date": …}` in JSON). Appended last: the numeric values are
	// mirrored by the public handler.PropertyKind enum, so the existing
	// ones must not move.
	KindDatetime
)

func KindOf(v *anyenc.Value) Kind

func ParseKind(s string) (Kind, bool)

func (k Kind) String() string

type Mutability ¶

type Mutability uint8

Mutability is a declared field's post-create write rule, enforced by the generic schema handler. The zero value is write-once: the field is writable ONLY in the record's creating change — there is no late fill (a presence-based rule would diverge under concurrent fills). Declare MutableBy for fields that must stay settable later.

const (
	// MutableNever: writable only in the record's creating change.
	MutableNever Mutability = iota
	// MutableByAuthor: only the record's creator (the StampCreator
	// field) may rewrite; accepted writes bump the modifyTime stamp.
	MutableByAuthor
	// MutableByAnyone: any writer may rewrite; accepted writes bump the
	// modifyTime stamp.
	MutableByAnyone
)

func ParseMutability(label string) (Mutability, bool)

func (m Mutability) String() string

type Schema ¶

type Schema struct {
	Kind       Kind
	Items      *Schema
	Properties map[string]*Schema
}

Schema is a recursive schema node. Items is populated only for KindArray (nil means "any element"); Properties only for KindObject (nil means "any shape").

func CompileShape(v *anyenc.Value) (*Schema, error)

func Leaf(k Kind) *Schema

func (s *Schema) MarshalJSON() ([]byte, error)

type Scope ¶

type Scope uint8

Scope is the single write/sync taxonomy shared by dataset fields AND property definitions: how a value is written, which version domain stamps its `_ver` entries, and how far it syncs. One vocabulary everywhere — dataset schema fields, property defs, and the x-scope discovery keyword all use these labels.

Each scope is a disjoint write route. A given field/property lives in exactly ONE scope for its whole life (scope is pinned at declaration, like a property's kind) — there is no per-value override stack. That disjointness is what lets versions from different domains coexist in one `_ver` tree: no two routes ever gate on the same path.

const (
	// ScopeSynced: user/DAG-written through the object's own tree,
	// change-versioned, normal LWW, synced to everyone with access.
	// (Docs historically called this "base".)
	ScopeSynced Scope = iota + 1
	// ScopeDerived: handler-computed from the change, change-versioned,
	// converges across peers; never writable by an input op. (Was
	// ScopeAuto.) e.g. author(creator)/createdAt/_ver.id.
	ScopeDerived
	// ScopeLocal: materialised on-device via Object.LocalSet,
	// lexid.Next-versioned, never synced. e.g. localStatus.
	// (Docs historically called this "device".)
	ScopeLocal
	// ScopeAccount: synced across the SAME account's devices only, via a
	// carrier record in the private tech space; a per-device watcher
	// mirrors converged values into the target record, stamping the
	// tech tree's versionIds. Invisible to other space members.
	ScopeAccount
)

func ParseScope(label string) (Scope, bool)

func (s Scope) String() string

type SearchFields ¶

type SearchFields struct {
	Title string
	Text  []string
	Scope string
}

SearchFields is the dataset's search-extraction annotation: which field feeds the document title and which fields the body text, plus the index scope the entries land under. Opaque to the SDK — surfaced through discovery (`x-search`) for external indexers; Scope is a free-form slug the indexer interprets (empty = the indexer's default).

Text holds one or more field keys; the indexer joins the mapped values into one body. On the wire (`x-search` and the head record's `search.text` leaf) a single key rides as a bare string and multiple keys as an array — MarshalJSON canonicalizes, so single-field declarations look exactly as they did before.

type Stamp ¶

type Stamp uint8

Stamp marks a field whose value the generic schema handler derives from the change at apply time. A stamped field is ScopeDerived, so client writes to it are rejected by the controller's scope enforcement; the handler is its only writer.

const (
	StampNone Stamp = iota
	// StampCreator: the creating change's signer identity, set once at
	// create. The authorship fact author-gated rules check against.
	StampCreator
	// StampCreateTime: the creating change's timestamp, set once.
	StampCreateTime
	// StampModifyTime: the change timestamp, set at create and bumped
	// on every accepted mutable write.
	StampModifyTime
)

func ParseStamp(label string) (Stamp, bool)

func (s Stamp) String() string

type Validator ¶

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

Validator is a compiled schema. Built once via Compile; used read-only on many change-apply paths. Safe for concurrent use after Compile returns.

func Compile(records []*anyenc.Value) (*Validator, error)

func (v *Validator) Kind(name string) (Kind, bool)

func (v *Validator) Validate(name string, value *anyenc.Value) error