infomodel

type AccessResolver func(r *http.Request, applicationID string) (ApplicationAccess, error)

type ApplicationAccess struct {
	Exists    bool
	CanView   bool
	CanEdit   bool
	Protected bool
}

type Association struct {
	ID   string `json:"id"`
	Name string `json:"name,omitempty"`
	Kind string `json:"kind"`
	// From is the source end. For a generalization it is the *specific* class ("an
	// ExpressOrder is an Order"); for a composition or aggregation it is the whole.
	From End `json:"from"`
	To   End `json:"to"`
}

type AssociationKind struct {
	Kind  string `json:"kind"`
	Label string `json:"label"`
	// Rule is the sentence this implements, in plain words, so a refusal can say
	// *why* rather than only that it was refused.
	Rule string `json:"rule"`
	// Directed reports whether the two ends mean different things, so the canvas
	// knows whether reversing the arrow changes the statement.
	Directed bool `json:"directed"`
}

type Attribute struct {
	Name string `json:"name"`
	// Type is a primitive (see PrimitiveTypes) or the name of another class in the
	// same model — including an «enumeration», which is how a closed set of values
	// is declared.
	Type          string `json:"type"`
	Multiplicity  string `json:"multiplicity"`
	Documentation string `json:"documentation,omitempty"`
}

type CatalogEntry struct {
	ModelID       string `json:"modelId"`
	ModelName     string `json:"modelName"`
	ApplicationID string `json:"applicationId"`
	ClassID       string `json:"classId"`
	Name          string `json:"name"`
	Stereotype    string `json:"stereotype"`
	Documentation string `json:"documentation,omitempty"`
	// Members is the count of whichever members this kind of class has: attributes,
	// or an «enumeration»'s literals. One column, honestly filled, rather than two of
	// which one is always empty.
	Members   int          `json:"members"`
	Identity  []string     `json:"identity,omitempty"`
	States    int          `json:"states"`
	Usage     UsageSummary `json:"usage"`
	UpdatedAt int64        `json:"updatedAt"`
}

type Class struct {
	// ID is stable across renames, so an association survives its class being
	// renamed; Name is what a model and a diagram refer to, and what
	// `itemSubjectRef` matches.
	ID            string `json:"id"`
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	// Stereotype says what kind of type this is, and it is what most of the
	// relationship rules in subset.go are actually about — see the constants there.
	Stereotype string      `json:"stereotype"`
	Attributes []Attribute `json:"attributes"`
	// Literals are the members of an «enumeration», which has literals where every
	// other stereotype has attributes. Empty otherwise.
	Literals []string `json:"literals,omitempty"`
	// Identity names the attributes that together form the business key: the fact
	// that makes Order#ORD-1 the same order in three processes and in a data store.
	// It is the part BPMN has no equivalent for, and every cross-process capability
	// rests on it. Empty for a class whose instances have no identity of their own.
	Identity []string `json:"identity,omitempty"`
	// Lifecycle is the states this class's instances move through, and what a BPMN
	// data state resolves against (ADR-0259). It sits here beside the business key
	// because both are facts about a business object that BPMN has no field for, and
	// because a lifecycle scoped to one process would reproduce the very problem the
	// information model exists to solve.
	//
	// nil is the normal case and means silence everywhere: a class without one is
	// exactly as it was before this existed.
	Lifecycle *Lifecycle `json:"lifecycle,omitempty"`
	// X and Y place the class on the canvas. Layout is part of the document because
	// a diagram a person arranged is a diagram they can read again.
	X float64 `json:"x"`
	Y float64 `json:"y"`
}

type Clock func() time.Time

type DataStore struct {
	ID            string `json:"id"`
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	// Class is the class whose instances this store holds. It must be a business
	// object with a business key: a store you cannot address something in by its
	// identity is not a store a process can read from.
	Class string `json:"class"`
	// Worker is the configured Worker that backs it (ADR-0036/0203) — a clio event
	// store, a database, a SharePoint list. Empty while the store is modeled but not
	// yet wired to anything, which is a normal state and not an error: a store is
	// routinely drawn before somebody configures the worker behind it.
	Worker string `json:"worker,omitempty"`
	// Mode is what a process may do with it. Read-only today; writing through a store
	// is a decision of its own (transactionality against something outside the engine)
	// and gets its own record.
	Mode string  `json:"mode"`
	X    float64 `json:"x"`
	Y    float64 `json:"y"`
}

type Derivation struct {
	Model Model `json:"model"`
	Gaps  []Gap `json:"gaps"`
}

type Diff struct {
	Planned []DiffFinding `json:"planned"`
	Built   []DiffFinding `json:"built"`
	// Excluded is what the comparison did not look at, said where it lists rather than
	// in a footnote: a reader who does not know what was excluded cannot tell a short
	// list from a clean bill.
	Excluded []string `json:"excluded"`
	// Modeled reports whether anything is authored at all. An application that models
	// nothing produces no findings — nothing has been planned, so nothing is missing
	// from the plan.
	Modeled bool `json:"modeled"`
}

type DiffFinding struct {
	Side  string `json:"side"`
	Kind  string `json:"kind"`
	Class string `json:"class"`
	// Name is the member or the state; From and To are a transition's ends. A finding
	// about the class as a whole carries none of them.
	Name string `json:"name,omitempty"`
	From string `json:"from,omitempty"`
	To   string `json:"to,omitempty"`
	Note string `json:"note"`
}

type End struct {
	ClassID      string `json:"classId"`
	Role         string `json:"role,omitempty"`
	Multiplicity string `json:"multiplicity,omitempty"`
}

type Finding struct {
	Code    string `json:"code"`
	Reason  string `json:"reason"`
	Message string `json:"message"`
	// Exactly one of ClassID / AssociationID / StoreID identifies where the finding
	// is; Attribute names the member within a class when the finding is about one.
	ClassID       string `json:"classId,omitempty"`
	AssociationID string `json:"associationId,omitempty"`
	StoreID       string `json:"storeId,omitempty"`
	Attribute     string `json:"attribute,omitempty"`
	// State and Transition locate a finding inside a class's lifecycle, the way
	// Attribute locates one inside its members — so the state canvas can mark the
	// state or the arrow that is wrong instead of colouring the whole class.
	State      string `json:"state,omitempty"`
	Transition string `json:"transition,omitempty"`
}

type Gap struct {
	Class string `json:"class,omitempty"`
	Kind  string `json:"kind"`
	Note  string `json:"note"`
}

type Graph struct {
	Nodes      []ObjectNode    `json:"nodes"`
	Links      []ObjectLink    `json:"links"`
	Unresolved []UnresolvedRef `json:"unresolved"`
	// Degraded says the application models nothing, so this is the instance's data
	// without the structure a model would give it.
	Degraded bool `json:"degraded"`
	// Truncated says a guard stopped the walk, so the picture is a part of one.
	Truncated bool `json:"truncated"`
}

type IDGenerator func() (string, error)

type ImportNote struct {
	Level string `json:"level"`
	// Element names the thing in the source document — a class, an attribute, an id
	// — so a reader can find it in the tool the document came from.
	Element string `json:"element,omitempty"`
	Message string `json:"message"`
}

type ImportResponse struct {
	Format     string           `json:"format"`
	Notes      []ImportNote     `json:"notes"`
	Validation ValidationResult `json:"validation"`
	// Preview is the model the document would become, present on a dry run only.
	Preview *Model `json:"preview,omitempty"`
	// Model is the stored model, present when one was created.
	Model *Summary `json:"model,omitempty"`
}

type ImportResult struct {
	Format string       `json:"format"`
	Model  Model        `json:"model"`
	Notes  []ImportNote `json:"notes"`
}

type Lifecycle struct {
	// StatesFrom names an «enumeration» in the same model whose literals are this
	// lifecycle's states, or is empty — which is the normal case and means the states
	// below are declared here and nowhere else
	// (ADR-0306).
	//
	// It is a *reference*, not a merge. The enumeration answers which values there
	// are; this answers in what order, which is the half no closed set of values can
	// hold. What it buys is that the strings are written once: the model that prompted
	// the record had five state names written twice, as literals a person maintained
	// and as states a deploy resolved, with nothing noticing when they drifted.
	//
	// A name rather than an id, for the reason Class.Identity names attributes and
	// DataStore.Class names a class: a state's identity is already its name, and a
	// literal's rename *is* a state's rename.
	StatesFrom  string                `json:"statesFrom,omitempty"`
	States      []LifecycleState      `json:"states"`
	Transitions []LifecycleTransition `json:"transitions"`
}

type LifecycleRules struct {
	// Stereotypes that may carry one. Only a business object has an identity that
	// persists through states; a value type is equal to any other with the same
	// contents, and an enumeration is a set of values rather than a thing that moves
	// through them.
	Stereotypes []string `json:"stereotypes"`
	// Exactly one state is where an instance is created, and any number are where
	// instances end. Served rather than assumed, because "one start" is a rule the
	// canvas has to enforce while drawing and not only report afterwards.
	InitialStates int `json:"initialStates"`
	// SelfTransitions says a state may transition to itself: a record can be revised
	// without leaving the stage it is in.
	SelfTransitions bool `json:"selfTransitions"`
	// LeavesFinal says whether a transition may start at a final state. It may not —
	// "final" and "leaves" are the two saying opposite things.
	LeavesFinal bool `json:"leavesFinal"`
	// Guards says whether a transition may carry a condition. It may not, and the
	// reason travels with the answer: what causes a transition is the BPMN element
	// that writes the state, and a condition here would be a second place deciding
	// what happens.
	Guards  bool   `json:"guards"`
	Meaning string `json:"meaning"`
}

type LifecycleState struct {
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	// Initial marks where an instance starts. Exactly one state carries it: a machine
	// with no start says nothing about what an object is when it is created, and one
	// with two says two contradictory things.
	Initial bool `json:"initial,omitempty"`
	// Final marks a state nothing leaves. Any number of them, including none — an
	// order ends either shipped or cancelled, and a long-lived record may end nowhere.
	Final bool `json:"final,omitempty"`
	// X and Y place the state on the canvas, for the reason a class carries them: a
	// diagram somebody arranged is a diagram they can read again.
	X float64 `json:"x"`
	Y float64 `json:"y"`
}

type LifecycleTransition struct {
	ID   string `json:"id"`
	Name string `json:"name,omitempty"`
	// From and To are state names within this lifecycle. A transition to the state it
	// starts from is a self-loop and is allowed: a record can be revised without
	// leaving the stage it is in.
	From string `json:"from"`
	To   string `json:"to"`
}

type LossNote struct {
	Area   string `json:"area"`
	Reason string `json:"reason"`
}

type Model struct {
	ID            string `json:"id"`
	ApplicationID string `json:"applicationId"`
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	// Revision guards a concurrent overwrite: a write states the revision it read,
	// and a write against a stale one is refused rather than silently winning.
	Revision     int64         `json:"revision"`
	Classes      []Class       `json:"classes"`
	Associations []Association `json:"associations"`
	// Stores are where instances of a class live beyond one process instance — the
	// cross-process channel BPMN gestures at with <dataStoreReference> and then says
	// nothing about. They live in this document because a store is per application,
	// declared once and named by every process that reaches it; and beside the
	// classes rather than inside one, because a class stays storage-agnostic. Only
	// the store says where its instances are kept.
	Stores    []DataStore `json:"stores"`
	CreatedAt int64       `json:"createdAt"`
	CreatedBy string      `json:"createdBy,omitempty"`
	UpdatedAt int64       `json:"updatedAt"`
	UpdatedBy string      `json:"updatedBy,omitempty"`
}

type ModelUse struct {
	ModelID   string `json:"modelId"`
	ModelName string `json:"modelName"`
	Kind      string `json:"kind"`
	// Class is the class making the use: the one carrying the attribute or the
	// lifecycle, or the one at the other end of the association. Empty for a store,
	// which belongs to no class.
	Class string `json:"class,omitempty"`
	// Name is the attribute's name or the association's, where it has one.
	Name string `json:"name,omitempty"`
	// Detail is the reading a person wants beside it — a multiplicity, an
	// association's kind and its ends, a store's mode and Worker.
	Detail string `json:"detail,omitempty"`
}

type MultiplicityOption struct {
	Multiplicity string `json:"multiplicity"`
	Label        string `json:"label"`
	// Required and Collection are what the JSON Schema projection and the canvas
	// both need, derived here once rather than by parsing the string in two places.
	Required   bool `json:"required"`
	Collection bool `json:"collection"`
}

type ObjectAttribute struct {
	Name  string `json:"name"`
	Value string `json:"value"`
	Key   bool   `json:"key,omitempty"`
	// Absent distinguishes "this object does not carry that member" from "it carries
	// it, empty" — different facts about a datum, and the first is usually the one
	// worth noticing.
	Absent bool `json:"absent,omitempty"`
}

type ObjectLink struct {
	From  string `json:"from"`
	To    string `json:"to"`
	Kind  string `json:"kind"`
	Label string `json:"label,omitempty"`
	Via   string `json:"via"`
}

type ObjectNode struct {
	ID    string `json:"id"`
	Label string `json:"label"`
	Name  string `json:"name"`
	Class string `json:"class,omitempty"`
	State string `json:"state,omitempty"`
	// Key is the object's business key, rendered — what makes this object *this*
	// one, and what another object's reference has to match to become a line.
	Key        string            `json:"key,omitempty"`
	Attributes []ObjectAttribute `json:"attributes"`
	// Value is what the object holds, rendered as an attribute's value is (a scalar
	// as itself, a structure as its JSON). Carried for an object whose class is
	// unknown or whose value is not a structure — there is no attribute list to show
	// instead, and an object with neither would be an empty box.
	Value string `json:"value,omitempty"`
	// Nested marks a node that came out of a whole's value rather than being a data
	// object of the instance in its own right.
	Nested bool `json:"nested,omitempty"`
	Unset  bool `json:"unset,omitempty"`
}

type ObjectValue struct {
	Name string
	// Class is the resolved declared type, "" when the object is untyped or its
	// itemSubjectRef resolves to nothing.
	Class string
	State string
	// Value is the object's value as canonical JSON, nil when it is unset.
	Value json.RawMessage
}

type PrimitiveType struct {
	Type  string `json:"type"`
	Label string `json:"label"`
	// JSONType and JSONFormat are the projection: the draft 2020-12 type and the
	// format keyword this primitive becomes. A primitive with no format projects to
	// its bare type.
	JSONType   string `json:"jsonType"`
	JSONFormat string `json:"jsonFormat,omitempty"`
}

type Process struct {
	Compiled *compiler.CompiledProcess
	Name     string
	Version  int32
}

type ProcessUse struct {
	ProcessDefinitionKey uint64 `json:"processDefinitionKey"`
	ProcessID            string `json:"processId"`
	ProcessName          string `json:"processName,omitempty"`
	Version              int32  `json:"version,omitempty"`
	Kind                 string `json:"kind"`
	// Object is the data object's name in that process — the local string BPMN scopes
	// to one definition, and the reason this whole area exists.
	Object string `json:"object,omitempty"`
	// ElementID is the BPMN id of the element making the use. Empty for a declaration,
	// which is a property of the process rather than of any element in it.
	ElementID string `json:"elementId,omitempty"`
	// Attribute is the member a write targets (ADR-0060); empty for a write of the
	// whole value.
	Attribute string `json:"attribute,omitempty"`
	// State is the state a write moves the object into, or — on a declaration — the
	// state instances of it are created in.
	State string `json:"state,omitempty"`
	// Variable is the process variable a read lands in (ADR-0059).
	Variable string `json:"variable,omitempty"`
	// WritesValue reports whether a write carries a value at all. A write without one
	// is a state-only transition, which is a different act and reads as one.
	WritesValue bool `json:"writesValue,omitempty"`
	// Collection marks a data object declared as a collection.
	Collection bool `json:"collection,omitempty"`
	// Store is the data store a ProcessUseStore names.
	Store string `json:"store,omitempty"`
}

type Projection struct {
	Class  string         `json:"class"`
	Schema map[string]any `json:"schema"`
	Loss   []LossNote     `json:"loss"`
}

type Refusal struct {
	Reason  string `json:"reason"`
	Message string `json:"message"`
}

type Service struct {

	// Limits are the installation's resource budgets. New sets them to
	// [limits.Default]; the server overwrites them with its own once it has read the
	// environment, so every ceiling in this service is the one operators configured
	// (ADR-0291).
	Limits limits.Limits
	// contains filtered or unexported fields
}

type Step struct {
	From string `json:"from"`
	To   string `json:"to"`
	At   int64  `json:"at"`
	By   string `json:"by,omitempty"`
}

type StereotypeKind struct {
	Stereotype string `json:"stereotype"`
	Label      string `json:"label"`
	// Meaning is the sentence a modeler needs to choose correctly. It travels to the
	// browser because the difference between a business object and a value type is
	// the single most consequential choice in this metamodel, and a palette that only
	// lists three words makes it by accident.
	Meaning string `json:"meaning"`
	// HasIdentity reports whether this kind may declare a business key. Only a
	// business object may: identity is what makes Order#ORD-1 the same order in three
	// processes, and a value with no independent existence has none to declare.
	HasIdentity bool `json:"hasIdentity"`
	// HasAttributes is false for an enumeration, which carries literals instead.
	HasAttributes bool `json:"hasAttributes"`
}

type Store struct {
	*sidecar.Store[Model]
}

type StoreMode struct {
	Mode    string `json:"mode"`
	Label   string `json:"label"`
	Meaning string `json:"meaning"`
}

type Subset struct {
	Version          int                  `json:"version"`
	Notation         string               `json:"notation"`
	Stereotypes      []StereotypeKind     `json:"stereotypes"`
	AssociationKinds []AssociationKind    `json:"associationKinds"`
	Primitives       []PrimitiveType      `json:"primitives"`
	Multiplicities   []MultiplicityOption `json:"multiplicities"`
	StoreModes       []StoreMode          `json:"storeModes"`
	// Lifecycles is the state machine a class may carry (ADR-0259).
	Lifecycles LifecycleRules `json:"lifecycles"`
	// Matrix is AllowAssociation precomputed for every stereotype pair, so the canvas
	// can grey out a connection while it is being dragged without a round trip. Keyed
	// "from>to".
	Matrix map[string][]string `json:"matrix"`
	Limits []SubsetLimit       `json:"limits"`
}

type SubsetLimit struct {
	Area   string `json:"area"`
	Reason string `json:"reason"`
}

type Summary struct {
	ID            string `json:"id"`
	ApplicationID string `json:"applicationId"`
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	Revision      int64  `json:"revision"`
	Classes       int    `json:"classes"`
	Associations  int    `json:"associations"`
	Stores        int    `json:"stores"`
	CreatedAt     int64  `json:"createdAt"`
	CreatedBy     string `json:"createdBy,omitempty"`
	UpdatedAt     int64  `json:"updatedAt"`
	UpdatedBy     string `json:"updatedBy,omitempty"`
}

type Trace struct {
	States      []TracedState      `json:"states"`
	Transitions []TracedTransition `json:"transitions"`
	// Current is the state the last write left the object in — the state it is in
	// now, which is not necessarily one the machine declares.
	Current string `json:"current,omitempty"`
	// Undeclared are the moves this instance made that no transition joins. It is the
	// run-time twin of the `data.illegal-transition` deploy check, and it catches what
	// that check cannot see: an instance started before the lifecycle was declared, and
	// a write by a process the check never ran against.
	Undeclared []Step `json:"undeclared,omitempty"`
	// Unknown names the states the object was written into that the machine does not
	// declare — `[aproved]` typed once, which is the failure this whole record exists
	// to make impossible. Each is named once however often it was written: it is one
	// fact about the model, not one per write.
	Unknown []string `json:"unknown,omitempty"`
}

type TracedState struct {
	LifecycleState
	// Visited is whether the object was ever written into this state, Current whether
	// it is the state the last write left it in.
	Visited bool `json:"visited"`
	Current bool `json:"current"`
	// Entered counts the times the object arrived here — twice for a state it went
	// round to a second time. FirstAt and LastAt answer different questions and
	// neither substitutes for the other: when it first got here, and when it last did.
	Entered int   `json:"entered,omitempty"`
	FirstAt int64 `json:"firstAt,omitempty"`
	LastAt  int64 `json:"lastAt,omitempty"`
}

type TracedTransition struct {
	LifecycleTransition
	// Taken counts the moves this instance made that this transition accounts for.
	Taken int `json:"taken"`
	// LastAt and LastBy are the most recent of those moves — the element that made it
	// being the answer no class diagram can give, and the reason to draw this at all.
	LastAt int64  `json:"lastAt,omitempty"`
	LastBy string `json:"lastBy,omitempty"`
	// Ambiguous marks a transition that shares both its ends with another. The trail
	// records states, not transition ids, so where a model declares two ways from one
	// state to the same other, nothing in the record says which was taken. Both are
	// marked and both say so, rather than one being picked and quietly believed.
	Ambiguous bool `json:"ambiguous,omitempty"`
}

type TrailEntry struct {
	State string
	At    int64
	By    string
}

type UnresolvedRef struct {
	From  string `json:"from"`
	Role  string `json:"role"`
	Class string `json:"class"`
	Value string `json:"value"`
}

type Usage struct {
	Class         Class  `json:"class"`
	ModelID       string `json:"modelId"`
	ModelName     string `json:"modelName"`
	ApplicationID string `json:"applicationId"`

	Processes []ProcessUse `json:"processes"`
	Model     []ModelUse   `json:"model"`
	Summary   UsageSummary `json:"summary"`
}

type UsageSummary struct {
	Processes int `json:"processes"`
	Uses      int `json:"uses"`
	Reads     int `json:"reads"`
	Writes    int `json:"writes"`
	// Attributes and States are what processes *actually* touch, which is rarely all
	// of what the class declares — the gap between the two is the interesting part,
	// and it is the same gap the difference reading reports per application.
	Attributes []string `json:"attributes,omitempty"`
	States     []string `json:"states,omitempty"`
	Stores     []string `json:"stores,omitempty"`
	ModelUses  int      `json:"modelUses"`
}

type ValidationResult struct {
	Valid    bool      `json:"valid"`
	Findings []Finding `json:"findings"`
}

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