sdk

type Edge ¶

type Edge struct {
	Type string
	From string
	To   string
}

Edge is a single typed edge between two notes (by id).

type FiredPredicate ¶

type FiredPredicate struct {
	Predicate string
	Args      map[string]any
}

FiredPredicate records a declare_predicate_fired call (§8.4.1).

type Grant ¶

type Grant struct {
	Namespace string
	Mode      Mode
}

Grant is one (namespace, mode) pair in a token's authorized set (§8.2).

type MemStore ¶

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

MemStore is an in-memory Store for tests and the dogfood hard test. It enforces the §8.2 namespace-token contract: every operation's namespace and mode must be authorized by the supplied token, else the operation is rejected before touching storage. The zero value is not usable; use NewMemStore.

func NewMemStore() *MemStore

func (m *MemStore) Edges(token Token, ns string) ([]Edge, error)

func (m *MemStore) Namespaces() []string

func (m *MemStore) Notes(token Token, ns string) ([]Note, error)

func (m *MemStore) WriteEdges(token Token, ns string, edges []Edge) error

func (m *MemStore) WriteNotes(token Token, ns string, notes []Note) error

type Mode ¶

type Mode string

Mode is a namespace access mode (§8.2): read or write.

const (
	// ModeRead authorizes reads against a namespace.
	ModeRead Mode = "read"
	// ModeWrite authorizes writes against a namespace.
	ModeWrite Mode = "write"
)

type NamespaceView ¶

type NamespaceView struct {
	Notes []Note
	Edges []Edge
}

NamespaceView is the read-only data a QueryRunner sees.

func (v NamespaceView) EdgesByType(t string) []Edge

func (v NamespaceView) NotesByType(t string) []Note

type Note ¶

type Note struct {
	ID     string
	Type   string
	Fields map[string]any
}

Note is a single note written to a namespace. The SDK is schema-agnostic at this layer: schema validation (§4) is the registry's job and runs before a bootstrap calls WriteNotes. ID and Type are required; Fields carries the declared note-type fields.

type QueryRunner ¶

type QueryRunner func(NamespaceView) []Row

QueryRunner runs a named query over a single namespace's data and returns rows. It is the in-process stand-in for a compiled DSL query.

type Row ¶

type Row map[string]any

Row is a single named-query result row: an ordered set of column values keyed by the RETURN column name.

type SDK ¶

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

SDK is the `da-adapter-sdk` surface (§8.4.1). A bootstrap skill is constructed with For(adapter, store) and calls only these methods; it never sees a Store, a Token, or a namespace string it did not declare. The SDK derives the token for each operation from the adapter's identity and the operation kind — the bootstrap cannot widen its own authority.

func For(adapter string, store Store) *SDK

func (s *SDK) Adapter() string

func (s *SDK) DeclarePredicateFired(predicate string, args map[string]any)

func (s *SDK) FiredPredicates() []FiredPredicate

func (s *SDK) MaterializeView(name string, readsFrom []string, runner ViewRunner) error

func (s *SDK) Query(runner QueryRunner) ([]Row, error)

func (s *SDK) WriteEdges(edges []Edge) error

func (s *SDK) WriteNotes(notes []Note) error

type Store ¶

type Store interface {
	// WriteNotes bulk-writes notes to ns. token must grant {ns, write}.
	WriteNotes(token Token, ns string, notes []Note) error
	// WriteEdges bulk-writes edges to ns. token must grant {ns, write}.
	WriteEdges(token Token, ns string, edges []Edge) error
	// Notes returns all notes in ns. token must grant {ns, read}.
	Notes(token Token, ns string) ([]Note, error)
	// Edges returns all edges in ns. token must grant {ns, read}.
	Edges(token Token, ns string) ([]Edge, error)
}

Store is the storage substrate the SDK writes into. It is the only thing the SDK touches; a production SDK injects a gcc-backed Store (§2.7) and the SDK surface is unchanged. Every method takes the operation token and rejects out-of-namespace access (§8.2 storage-layer enforcement).

type Token ¶

type Token struct {
	PrimaryAdapter string
	Authorized     []Grant
	IssuedFor      string
}

Token is the namespace token of §8.2: a set of authorized (namespace, mode) pairs derived from the executing adapter's own namespace plus any cross-namespace dependencies declared in the operation being authorized.

In a production backend the token is signed and validated at the storage layer (§8.2.1 N13). Here the SDK constructs and checks it in-process; the authorization model — every referenced namespace must be in the authorized set — is identical, which is what the dogfood needs to exercise.

func BootstrapToken(adapter string) Token

func OwnReadToken(adapter, operation string) Token

func ViewToken(adapter, view string, readsFrom []string) Token

type ViewRunner ¶

type ViewRunner func(read func(ns string) ([]Note, error)) ([]Note, error)

ViewRunner computes a materialized view's notes, pulling dependency notes via read (which is token-checked at the storage layer).