Struct EntityView 

pub struct EntityView {

    pub uri: String,
    pub id: String,
    pub kind: String,
    pub identity: String,
    pub slug: String,
    pub route: String,
    pub kind_route: String,
    pub title: Option<String>,
    pub description: Option<String>,
    pub provenance: Provenance,
    pub metadata: Value,
    pub media_type: String,
    pub content: String,
    pub relations: Vec<Edge>,
    pub surfaces: Vec<Surface>,
    pub evidence: Evidence,
    pub documentation: Option<Documentation>,
}

One object of the layer as an addressable node: what it is, where it is served, what it is joined to, and what can be said about its enforcement.

The whole answer in one value, because it is one question: every surface that shows an entity — the Cockpit page, GET /api/v1/entity, majordomus_entity, majordomus entity show — renders this and composes nothing of its own. A field a reader sees on one surface and not another would be a surface holding an opinion, which is what ADR 0004 forecloses.

use majordomus_cli::capability::builtin::entity::EntityView;

// it round-trips through the wire shape every projection reads it as
let view: EntityView = serde_json::from_value(serde_json::json!({
    "uri": "majordomus://adr/adr-0056",
    "id": "adr.adr-0056",
    "kind": "adr",
    "identity": "adr-0056",
    "slug": "adr-0056",
    "route": "/cockpit/objects/adr/adr-0056",
    "kind_route": "/cockpit/objects/adr",
    "title": "Every object of the layer has a derived address",
    "provenance": { "path": "x.md", "directory": "x", "source_class": "adr", "bytes": 0 },
    "metadata": {},
    "media_type": "text/markdown",
    "content": "",
    "relations": [],
    "surfaces": [],
    "evidence": { "state": "unclaimed", "meaning": "nothing named" },
    "documentation": {
        "projection": "entity",
        "route": "/adrs/adr-0056/",
        "url": "https://majordomus.dev/adrs/adr-0056/",
        "declared_in": "site/data/publication.toml",
    },
}))
.unwrap();

assert_eq!(view.route, "/cockpit/objects/adr/adr-0056");
// the Cockpit route is the object's; the public page is the site's, and both are named
let public = view.documentation.as_ref().and_then(|d| d.url.as_deref());
assert_eq!(public, Some("https://majordomus.dev/adrs/adr-0056/"));
// the kind's index is the entity's route with the last segment removed
assert!(view.route.starts_with(&view.kind_route));

Fields

uri: String

majordomus://<kind>/<identity>.

id: String

The capability id, <kind>.<identity>.

kind: String

The kind.

identity: String

The identity within the kind.

slug: String

The last segment of its route, derived from the identity.

route: String

Its route in the Cockpit.

kind_route: String

The route of its kind’s index.

title: Option<String>

The title, when the kind’s title rule found one.

description: Option<String>

The one-line description, when the kind holds one.

provenance: Provenance

Where it came from.

metadata: Value

The parsed front matter or YAML, keys in the file’s order.

media_type: String

IANA media type of content.

content: String

The file as read.

relations: Vec<Edge>

The references it declares, and the references that resolve to it.

surfaces: Vec<Surface>

Every surface that answers for it.

evidence: Evidence

What can be said about its enforcement without running anything.

documentation: Option<Documentation>

Its public documentation page, derived from the repository’s publication declaration (site/data/publication.toml) and the site’s base_url by the same function the site generator writes the page with. Null when the repository declares no publication or does not declare this kind; a kind declared as not published carries the reason.

Trait Implementations

impl Clone for EntityView

fn clone(&self) -> EntityView

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EntityView

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EntityView

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for EntityView

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for EntityView

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.