ingraph 0.1.0

A declaration-driven indexing framework: records and nodes are written as Rust types, and the storage rows, the dataflow between them and the GraphQL query surface are emitted from the declaration.
Documentation
//! THE POLICIES BLOCK: the rack's SECOND framework row, and what it can and cannot say yet.
//!
//! `[node.policies]` mounts beside `[node.channels]` under [`NodeSection`], each typed, each
//! refusing its own unknown keys. That the rack takes a second row without being rebuilt for one is
//! the claim the channels round made when it wrote `NodeSection<O, C = Unchanneled>` — one type
//! parameter per block, defaulted, so every site naming one spelling keeps spelling it exactly as
//! it did. This is that claim being cashed.
//!
//! # What a document can write today, and why it is nothing
//!
//! A policy is a TYPE — that is the framework-open ruling, and it is what lets a deployment supply
//! its own rather than picking from a list somebody else closed. A document cannot name a type, so
//! selecting one from a file is a thing that needs a mechanism (a registry the launch layer
//! resolves through) and that mechanism is the launch round's, not this one's. Until it exists the
//! honest content of this block is empty: the row is REAL — it parses, it is typed, it refuses
//! unknown keys by name — and what it holds is nothing.
//!
//! That is deliberately not a placeholder. A block that accepted a knob now would be a knob whose
//! meaning the selection mechanism would then have to preserve; an empty block that refuses
//! everything is a seat with no debt on it.
//!
//! # Where a policy IS stated today
//!
//! In code, once, for the deployment: [`Policies`](crate::Policies) handed to
//! [`Plan::with_policies`](super::Plan::with_policies). The shipped set reproduces today's
//! behaviour exactly, so a deployment that states nothing changes nothing.

/// WHAT A PER-NODE POLICIES BLOCK IS, whoever emitted it.
///
/// A marker, and the emptiness is the point rather than an unfinished edge: the block's readable
/// content is the launch round's to mint (see the module note), and a method invented before there
/// is something to read would be a method the mechanism then has to be shaped around.
///
/// What the trait DOES carry is the constraint that matters now — a shelf is a type the rack can
/// hold, so a node's block is checked and named at the place a deployment writes it.
pub trait PolicyShelf {}

/// The shelf of a node that selects NO policy — the rack's default, and every node today.
///
/// [`Unchanneled`](super::Unchanneled)'s twin, for its reason: [`NodeSection`](super::NodeSection)'s
/// third parameter needs an answer for every node, and a document writing `policies` for a node
/// with nothing to select is refused by name at deserialization rather than accepted and ignored.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
pub struct Unpoliced {}

impl PolicyShelf for Unpoliced {}