myjson

type Action string

type AggregateFunction string

type Authz struct {
	Rules []AuthzRule `json:"rules" validate:"min=1,required"`
}

type AuthzEffect string

type AuthzRule struct {
	Effect AuthzEffect `json:"effect" validate:"required"`
	Action []Action    `json:"action" validate:"min=1,required"`
	Match  string      `json:"match" validate:"required"`
}

type CDC struct {
	// ID is the unique id of the cdc
	ID string `json:"_id" validate:"required"`
	// Collection is the collection the change was applied to
	Collection string `json:"collection" validate:"required"`
	// Action is the action applied to the document
	Action Action `json:"action" validate:"required,oneof='create' 'update' 'delete' 'set'"`
	// DocumentID is the ID of the document that was changed
	DocumentID string `json:"documentID" validate:"required"`
	// Diff is the difference between the previous and new version of the document
	Diff []JSONFieldOp `json:"diff,omitempty"`
	// Timestamp is the nanosecond timestamp the cdc was created at
	Timestamp int64 `json:"timestamp" validate:"required"`
	// Metadata is the context metadata when the change was made
	Metadata *Document `json:"metadata" validate:"required"`
}

type CollectionSchema interface {
	// Collection is the collection name
	Collection() string
	// ValidateDocument validates the input document against the collection's JSON schema
	ValidateDocument(ctx context.Context, doc *Document) error
	// Indexing returns a copy the schemas indexing
	Indexing() map[string]Index
	// PrimaryIndex returns the collection's primary index
	PrimaryIndex() Index
	// PrimaryKey returns the collection's primary key
	PrimaryKey() string
	// GetPrimaryKey gets the document's primary key
	GetPrimaryKey(doc *Document) string
	// SetPrimaryKey sets the document's primary key
	SetPrimaryKey(doc *Document, id string) error
	// RequireQueryIndex returns whether the collection requires that queries are appropriately indexed
	RequireQueryIndex() bool
	// Properties returns a map of the schema's properties
	Properties() map[string]SchemaProperty
	// PropertyPaths returns a flattened map of the schema's properties - nested properties will be keyed in dot notation
	PropertyPaths() map[string]SchemaProperty
	// Triggers returns a map of triggers keyed by name that are assigned to the collection
	Triggers() []Trigger
	// IsReadOnly returns whether the collection is read only
	IsReadOnly() bool
	// Authz returns the collection's authz if it exists
	Authz() Authz
	// MarshalYAML returns the collection schema as yaml bytes
	MarshalYAML() ([]byte, error)
	// UnmarshalYAML refreshes the collection schema with the given json bytes
	UnmarshalYAML(bytes []byte) error
	json.Marshaler
	json.Unmarshaler
}

type CommitCmd struct{}

type CreateCmd struct {
	// Collection is the collection the document belongs to
	Collection string `json:"collection" validate:"required"`
	// Document is the document to set
	Document *Document `json:"document" validate:"required"`
}

type DBOpt func(d *defaultDB)

type Database interface {
	// Collections returns a list of collection names that are registered in the collection
	Collections(ctx context.Context) []string
	// Configure overwrites a single database collection configuration. It will create the collection if it does not exist
	// and will update the collection if it does exist. The collection will be created/updated with the given schema and indexing.
	Configure(ctx context.Context, collectionSchemaBytes []byte) error
	// GetSchema gets a collection schema by name (if it exists)
	GetSchema(ctx context.Context, collection string) CollectionSchema
	// HasCollection reports whether a collection exists in the database
	HasCollection(ctx context.Context, collection string) bool
	// Tx executes the given function against a new transaction.
	// if the function returns an error, all changes will be rolled back.
	// otherwise, the changes will be commited to the database
	Tx(ctx context.Context, opts kv.TxOpts, fn TxFunc) error
	// NewTx returns a new transaction. a transaction must call Commit method in order to persist changes
	NewTx(opts kv.TxOpts) (Txn, error)
	// ChangeStream streams changes to documents in the given collection. CDC Persistence must be enabled to use this method.
	ChangeStream(ctx context.Context, collection string, fn func(cdc CDC) (bool, error)) error
	// Get gets a single document by id
	Get(ctx context.Context, collection, id string) (*Document, error)
	// ForEach scans the optimal index for a collection's documents passing its filters.
	// results will not be ordered unless an index supporting the order by(s) was found by the optimizer
	// Query should be used when order is more important than performance/resource-usage
	ForEach(ctx context.Context, collection string, opts ForEachOpts, fn ForEachFunc) (Explain, error)
	// Query queries a list of documents
	Query(ctx context.Context, collection string, query Query) (Page, error)
	// Get gets 1-many document by id(s)
	BatchGet(ctx context.Context, collection string, ids []string) (Documents, error)
	// RunScript executes a javascript function within the script
	// The following global variables will be injected: 'db' - a database instance, 'ctx' - the context passed to RunScript, and 'params' - the params passed to RunScript
	RunScript(ctx context.Context, function string, script string, params map[string]any) (any, error)
	// RawKV returns the database key value provider - it should be used with caution and only when standard database functionality is insufficient.
	RawKV() kv.DB
	// Serve serves the database over the given transport
	Serve(ctx context.Context, t Transport) error
	// NewDoc creates a new document builder instance
	NewDoc() *DocBuilder
	// Close closes the database
	Close(ctx context.Context) error
}

type DeleteCmd struct {
	// Collection is the collection the document belongs to
	Collection string `json:"collection" validate:"required"`
	// ID is the unique id of the document
	ID string `json:"id" validate:"required"`
}

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

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

type Documents []*Document

type EventType string

type Explain struct {
	// Collection
	Collection string `json:"collection"`
	// Index is the index the query optimizer chose
	Index Index `json:"index"`
	// MatchedFields are the fields that matched the index
	MatchedFields []string `json:"matched_fields"`
	// MatchedValues are the values that were matched to the index
	MatchedValues map[string]any `json:"matched_values,omitempty"`
	// SeekFields indicates that the given fields will be seeked
	SeekFields []string `json:"seek,omitempty"`
	// SeekValues are the values to seek
	SeekValues map[string]any `json:"seek_values,omitempty"`
	// Reverse indicates that the index should be scanned in reverse
	Reverse bool `json:"reverse,omitempty"`
}

type ForEachFunc func(d *Document) (bool, error)

type ForEachOpts struct {
	Where []Where `json:"where,omitempty"`
	Join  []Join  `json:"join,omitempty"`
}

type ForeignKey struct {
	// Collection is the foreign collection
	Collection string `json:"collection"`
	// Cascade indicates that the document should be deleted when the foreign key is deleted
	Cascade bool `json:"cascade"`
}

type GetCmd struct {
	// Collection is the collection the document belongs to
	Collection string `json:"collection" validate:"required"`
	// ID is the unique id of the document
	ID string `json:"id" validate:"required"`
}

type Index struct {
	// Name is the indexes unique name in the collection
	Name string `json:"name" validate:"required,min=1"`
	// Fields to index - order matters
	Fields []string `json:"fields" validate:"required,min=1"`
	// Unique indicates that it's a unique index which will enforce uniqueness
	Unique bool `json:"unique"`
	// Unique indicates that it's a primary index
	Primary bool `json:"primary"`
	// ForeignKey indecates that it's an index for a foreign key
	ForeignKey *ForeignKey `json:"foreign_key,omitempty"`
}

type JSONFieldOp struct {
	// Path is the path to the field within the document
	Path string `json:"path"`
	// Op is the operation applied
	Op JSONOp `json:"op"`
	// Value is the value applied with the operation
	Value any `json:"value,omitempty"`
	// BeforeValue is the value before the operation was applied
	BeforeValue any `json:"beforeValue,omitempty"`
}

type JSONOp string

type Join struct {
	Collection string  `json:"collection" validate:"required"`
	On         []Where `json:"on" validate:"required,min=1"`
	As         string  `json:"as,omitempty"`
}

type Optimizer interface {
	// Optimize selects the optimal index to use based on the given where clauses
	Optimize(c CollectionSchema, where []Where) (Explain, error)
}

type OrderBy struct {
	Direction OrderByDirection `json:"direction" validate:"oneof='desc' 'asc'"`
	Field     string           `json:"field"`
}

type OrderByDirection string

type Page struct {
	// Documents are the documents that make up the page
	Documents Documents `json:"documents"`
	// Next page
	NextPage int `json:"next_page"`
	// Document count
	Count int `json:"count"`
	// Stats are statistics collected from a document aggregation query
	Stats PageStats `json:"stats,omitempty"`
}

type PageStats struct {
	// ExecutionTime is the execution time to get the page
	ExecutionTime time.Duration `json:"execution_time,omitempty"`
	// Explain is the optimizer's output for the query that returned a page
	Explain *Explain `json:"explain,omitempty"`
}

type PropertyIndex struct {
	AdditionalFields []string `json:"additional_fields,omitempty"`
}

type Query struct {
	// Select selects fields - at least 1 select is required.
	// 1 select with Field: * gets all fields
	Select []Select `json:"select" validate:"min=1,required"`
	// Join joins the results to another collection
	Join []Join `json:"join,omitempty" validate:"dive"`
	// Where filters results. The optimizer will select the appropriate index based on where clauses
	Where []Where `json:"where,omitempty" validate:"dive"`
	// GroupBy groups results by a given list of fields
	GroupBy []string `json:"groupBy,omitempty"`
	// Page is the page of results - it is used with Limit for pagination
	Page int `json:"page" validate:"min=0"`
	// Limit is used to limit the number of results returned
	Limit int `json:"limit,omitempty" validate:"min=0"`
	// OrderBy orders results
	OrderBy []OrderBy `json:"orderBy,omitempty" validate:"dive"`
	// Having applies a final filter after any aggregations have occured
	Having []Where `json:"having,omitempty" validate:"dive"`
}

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

type QueryCmd struct {
	// Collection is the collection the document belongs to
	Collection string `json:"collection" validate:"required"`
	// Query is the query to execute
	Query Query `json:"query,omitempty"`
}

type RollbackCmd struct{}

type SchemaProperty struct {
	// Primary indicates the property is the primary key
	Primary bool `json:"x-primary,omitempty"`
	// Name is the name of the property
	Name string `json:"name" validate:"required"`
	// Description is the description of the property
	Description string `json:"description,omitempty"`
	// Type is the type of the property
	Type string `json:"type" validate:"required"`
	// Path is a dot notation path to the property
	Path string `json:"path" validate:"required"`
	// Unique indicates the field value is unique
	Unique bool `json:"x-unique,omitempty"`
	// ForeignKey is a relationship to another collection
	ForeignKey *ForeignKey `json:"x-foreign,omitempty"`
	// Index is a secondary index mapped by index name
	Index map[string]PropertyIndex `json:"x-index,omitempty"`
	// Properties are object properties
	Properties map[string]SchemaProperty `json:"properties,omitempty"`
}

type Select struct {
	Aggregate AggregateFunction `json:"aggregate,omitempty" validate:"oneof='count' 'max' 'min' 'sum'"`
	As        string            `json:"as,omitempty"`
	Field     string            `json:"field"`
}

type SetCmd struct {
	// Collection is the collection the document belongs to
	Collection string `json:"collection" validate:"required"`
	// Document is the document to set
	Document *Document `json:"document" validate:"required"`
}

type Transport interface {
	Serve(ctx context.Context, db Database) error
}

type Trigger struct {
	// Name is the unique name of the trigger
	Name string `json:"name" validate:"required"`
	// Order is used to sort triggers into an array where the lower order #s are executed before larger order #s
	Order int `json:"order"`
	// Events is an array of events that the trigger executes on
	Events []EventType `json:"events" validate:"min=1,required"`
	// Script is the javascript script to execute
	Script string `json:"script" validate:"required"`
}

type Tx interface {
	// Cmd is a generic command that can be used to execute any command against the database
	Cmd(ctx context.Context, cmd TxCmd) TxResponse
	// Query executes a query against the database
	Query(ctx context.Context, collection string, query Query) (Page, error)
	// Get returns a document by id
	Get(ctx context.Context, collection string, id string) (*Document, error)
	// Create creates a new document - if the documents primary key is unset, it will be set as a sortable unique id
	Create(ctx context.Context, collection string, document *Document) (string, error)
	// Update updates a value in the database
	Update(ctx context.Context, collection, id string, document map[string]any) error
	// Set sets the specified key/value in the database
	Set(ctx context.Context, collection string, document *Document) error
	// Delete deletes the specified key from the database
	Delete(ctx context.Context, collection string, id string) error
	// ForEach scans the optimal index for a collection's documents passing its filters.
	// results will not be ordered unless an index supporting the order by(s) was found by the optimizer
	// Query should be used when order is more important than performance/resource-usage
	ForEach(ctx context.Context, collection string, opts ForEachOpts, fn ForEachFunc) (Explain, error)
	// DB returns the transactions underlying database
	DB() Database
}

type TxCmd struct {
	// Create is a create command
	Create *CreateCmd `json:"create,omitempty"`
	// Get is a get command
	Get *GetCmd `json:"get,omitempty"`
	// Set is a set command
	Set *SetCmd `json:"set,omitempty"`
	// Update is an update command
	Update *UpdateCmd `json:"update,omitempty"`
	// Delete is a delete command
	Delete *DeleteCmd `json:"delete,omitempty"`
	// Query is a query command
	Query *QueryCmd `json:"query,omitempty"`
	// Commit is a commit command - it ends the transaction
	Commit *CommitCmd `json:"commit,omitempty"`
	// Rollback is a rollback command - it ends the transaction
	Rollback *RollbackCmd `json:"rollback,omitempty"`
}

type TxFunc func(ctx context.Context, tx Tx) error

type TxResponse struct {
	// Create is a create response - it returns the created document
	Create *Document `json:"create,omitempty"`
	// Get is a get response - it returns the document from the get request (if it exists)
	Get *Document `json:"get,omitempty"`
	// Set is a set response - it returns the document after the set was applied
	Set *Document `json:"set,omitempty"`
	// Update is an update response - it contains the document after the update was applied
	Update *Document `json:"update,omitempty"`
	// Delete is an empty delete response
	Delete *struct{} `json:"delete,omitempty"`
	// Query is a query response - it contains the documents returned from the query
	Query *Page `json:"page,omitempty"`
	// Commit is an empty commit response
	Commit *struct{} `json:"commit,omitempty"`
	// Rollback is an empty rollback response
	Rollback *struct{} `json:"rollback,omitempty"`
	// Error is an error response if an error was encountered
	Error *errors.Error `json:"error,omitempty"`
}

type Txn interface {
	// Commit commits the transaction to the database
	Commit(ctx context.Context) error
	// Rollback rollsback all changes made to the datbase
	Rollback(ctx context.Context) error
	// Close closes the transaction - it should be deferred after
	Close(ctx context.Context)
	Tx
}

type UpdateCmd struct {
	// Collection is the collection the document belongs to
	Collection string `json:"collection" validate:"required"`
	// ID is the unique id of the document
	ID string `json:"id" validate:"required"`
	// Update is the set of fields to set
	Update map[string]any `json:"update,omitempty"`
}

type Where struct {
	Field string      `json:"field" validate:"required"`
	Op    WhereOp     `json:"op" validate:"oneof='eq' 'neq' 'gt' 'gte' 'lt' 'lte' 'contains' 'containsAny' 'containsAll' 'in'"`
	Value interface{} `json:"value" validate:"required"`
}

type WhereOp string