stashgen

type Declaration struct {
	// Type is the Go type the declaration is for, as the generator prints it
	// in an error: "User" or "crm.Contact".
	Type string
	// Context is the context of every field, from the `context=` tag; ""
	// when ContextField is set.
	Context string
	// ContextField is the declaration name of the field whose value is the
	// context of every other field, from the `context_field` tag; "" when
	// the context comes from Context. The field is a string, stored as it
	// is, in the clear and unauthenticated like a passthrough.
	ContextField string
	// Opaque seals the whole struct as one value. The fields then carry no
	// tags and no indexes.
	Opaque bool
	// Fields are the struct's fields in declared order, omitted ones included.
	Fields []Field
}

type EQLType struct {
	// Name is the Go type name in encrypt/eql, and the value of encrypt_into.
	Name string
	// Plaintext is the kind of Go value the type seals.
	Plaintext Kind
	// Indexes are the terms the type carries.
	Indexes []IndexName
	// Query is the Go type name of the type's query value, such as
	// TextEqQuery, or "" for a type with no terms.
	Query string
	// Producible says whether this build of the engine produces the type;
	// Reason says why not when it does not.
	Producible bool
	Reason     string
	// contains filtered or unexported fields
}

type Engine interface {
	// EQLTypes lists the EQL types the engine can produce: each name, its
	// plaintext kind, its indexes and its query type.
	EQLTypes(ctx context.Context) ([]EQLType, error)
	// Check refuses a declaration the engine cannot run: an index or an EQL
	// type that does not apply to a field's Go type, a field type it cannot
	// seal, an EQL type it cannot produce, or an index option it cannot
	// carry. The error names the field. For a declaration it accepts, it
	// lists the operators the engine answers on each sealed field, by the
	// field's declared name, in the engine's order: the generator writes one
	// query method for each.
	Check(ctx context.Context, d Declaration) (map[string][]Operator, error)
}

type Field struct {
	// Name is the field's name in the declaration, which is its column name.
	// An omitted field's Name is its Go name in snake case.
	Name string
	// GoName is the field's name in the Go struct.
	GoName string
	// GoType is the field's Go type, for the engine's checks.
	GoType GoType
	// Verb says what happens to the field.
	Verb Verb
	// Indexes are the indexes the tag names, for EncryptIndex and Index.
	Indexes []Index
	// EQLType is the EQL type an EncryptInto field seals into.
	EQLType string
	// TargetOptions are the EQL type's options, for a type that takes them
	// (JsonSearch); nil for its defaults.
	TargetOptions *record.TargetOptions
	// Identity is the field's part of its context when it differs from Name:
	// a column that was renamed keeps the identity it was first written
	// under. "" means Name. Only a policy sets it.
	Identity string
	// Null is how a sealed field declared over a pointer stores nil; NotNull
	// for every other field. GoType is then the type the pointer points to.
	Null Null
}

type FieldError struct {
	// Type is the Go type the field belongs to: "User" or "crm.Contact".
	Type string
	// Field is the Go name of the field, or "" for a mistake about the type.
	Field string
	// Reason says what is wrong, without the type and field.
	Reason string
}

type File struct {
	// Path is where the file goes.
	Path string
	// Content is the formatted Go source.
	Content []byte
	// Notices are what the generator prints to stderr: the unexported fields
	// it ignored, and a type that prints its sealed fields.
	Notices []string
}

type GenerateOption func(*generateConfig)

type GoType struct {
	// Name is the type as Go source in the field's package: "string",
	// "int64", "[]string", "time.Time", "crm.Address".
	Name string
	// Kind is the type's underlying kind.
	Kind Kind
	// Basic is the underlying basic type's name for a scalar kind — "uint8",
	// "int", "string" — which decides the wire type the field seals as. It is
	// "" for a value type the generator knows by name (time.Time,
	// encrypt.Date, encrypt.Int128, encrypt.Uint128, encrypt.Decimal), whose
	// kind says all there is.
	Basic string
	// Elem is the element type of a slice, map or pointer, and nil otherwise.
	Elem *GoType
	// Fields are the fields of a struct kind, in declared order.
	Fields []GoType
}

type Index struct {
	Name    IndexName
	Options []Option
}

type IndexName string

type Kind uint8

type ModelRequest struct {
	// Name is the suffix of the generated functions: EncryptName, DecryptName.
	Name string
	// Type is the model struct, in this package or as P.T.
	Type string
	// Declares is a struct in this package that carries the tags for a Type
	// that cannot, or "".
	Declares string
}

type Null string

type Operator struct {
	// Name is the operator's name, as a query names it: eq, lt, lte, gt,
	// gte, between or matches.
	Name string
	// Probabilistic says the server's answer can hold false positives, so
	// the query's type carries Verify and TargetLimit; an exact answer's
	// carries neither.
	Probabilistic bool
	// Pair says the operator takes two values, low then high, as between
	// does.
	Pair bool
	// Index is the index that answers it: the field's own, or its EQL
	// type's.
	Index IndexName
}

type Option struct {
	Key   string
	Value string
}

type Request struct {
	// Dir is the directory of the package. "" is the working directory.
	Dir string
	// Type is the struct that carries the stash tags.
	Type string
	// Name, when set, writes EncryptName, DecryptName and NameFields.
	Name string
	// For, as P.F, is the type in another package that Type declares for.
	For string
	// Models are the -model flags.
	Models []ModelRequest
	// Redact writes String and LogValue methods on Type.
	Redact bool
	// Output is the file to write, relative to Dir. "" is the type's name in
	// lower case with _stash.go.
	Output string
}

type Verb uint8