pub struct IndexModel {Show 22 fields
pub prefix: EmissionPrefix,
pub index: Ident,
pub kind: NodeKind,
pub vis: Visibility,
pub krate: Path,
pub source: Upstream,
pub dedup: Dedup,
pub embeddings: Vec<Elected>,
pub labelled: Vec<Labelled>,
pub searchable: Vec<Ident>,
pub engines: Vec<FieldEngines>,
pub stores: Vec<Engine>,
pub extension: Option<Extension>,
pub data: bool,
pub keys: bool,
pub subscribe: bool,
pub graphql: Option<IndexGraphql>,
pub numbers: Numbers,
pub field_numbers: Vec<FieldNumbers>,
pub rename: Option<IndexRename>,
pub slot: Option<LitStr>,
pub fields: Vec<Column>,
}Expand description
A validated derived index: which storage it is, what it draws from, and the fields it declares.
PLAIN, for RecordModel’s reason — public fields, no constructor,
nothing that parses — so the derive today and a manifest front end later build the same one.
Fields§
§prefix: EmissionPrefixThe EMISSION NAMESPACE this declaration’s minted names wear.
EmissionPrefix::INGRAPH for everything ingraph’s own front ends build, and a domain
framework’s own mark for a model mediagraph-codegen or its successors build — see
crate::prefix for what the seat covers and why it is a field rather than a constant.
index: IdentThe index’s own name — the declaration this model came from.
kind: NodeKindWHICH of the three storages this is.
Spent on the sentences a front end writes, on which SEAM the emitted doors name — a full-text
engine or a vector one — and on nothing else this emission does: all three mint the one-storage
marker and all three carry the upstream’s key. WHICH engines hold the documents is no longer
read off the kind at all: it is engines, declared per field.
vis: VisibilityHow visible the index is, and therefore how visible each emitted method is.
Mirrored rather than fixed at pub, exactly as a record’s: no one can widen a type they did
not declare.
krate: PathThe path to the ingraph crate itself — ::ingraph unless crate = "…" named another.
source: UpstreamThe ONE upstream this index draws from, and what it takes from it.
One rather than a list: several upstreams key a derived index by an ENUM over their keys, and the field that carries it is a different field of a different type. The model holds what this emission spends.
dedup: DedupThe dedup MECHANISM a retrieve over this index runs — the dedup(…) word, or its default.
Spent by the two emitted retrieve methods and by nothing else, which is also why it is on the
model rather than on Upstream: it is a property of how this node ANSWERS, not of where its
documents came from.
embeddings: Vec<Elected>WHICH fields a knn over this index may run over — every knn-marked field, on the one kind
that has any.
NON-EMPTY on every VECTOR declaration and EMPTY on the other two, and the asymmetry is the marker’s own: it is mandatory where it applies and refused by name where it does not, so a front end that produced an empty list for a vector has already refused the declaration. In DECLARED order, which is the order the emitted columns and the record face are written in.
A LIST rather than one, because a declaration may elect several and each is queryable — see
Elected for the geometry that carries them and for why the role is declared rather than
read off the type.
labelled: Vec<Labelled>Every LABELLED field NO election names — the forward declarations, in declared order.
§A label on payload is ACCEPTED, and that is a ruling rather than an oversight
The label states a STRUCTURAL fact about a field — one embedding, or a set of them — and the party that will spend it is not only the query side. A storage layer that lays a set out differently from a single vector, or that carries a weight per member, reads the same fact about a field nothing queries. So a labelled field with no election is a declaration made EARLY rather than a word nobody reads, and this crate’s usual refusal — a word parsed into a model nothing spends is a promise rather than a rule — does not reach it.
What the acceptance does NOT buy is a face: no column, no door, no projection. The election marker is still what grows those, and a labelled payload field is hydrated by its own accessor exactly as an unlabelled one is.
ACCEPTED IS NOT UNEXAMINED. The label’s claim is audited here as it is on an election, so a
payload field labelled list(embedding) over a single embedding is E0277 at its own type.
searchable: Vec<Ident>WHICH fields a search over this index runs over — every searchable-marked field, on the one
kind that has any.
embeddings’ mirror one kind over, and the same law: NON-EMPTY on every
FULL-TEXT declaration, EMPTY on the other two, in DECLARED order.
§Idents rather than an Elected, and the asymmetry is the ENGINE’s rather than this model’s
An election carries what the EMISSION has to read off it, and the two kinds hand over different
amounts. A knn’s column is opened at an element and a width, so Elected carries E, N and
the space it lives in — every one read off the field’s own type, all three spent on the query
type the emitted pair takes. A search takes a STRING, and what a searched field must BE is not
this crate’s to say: FulltextRecord::Document is deliberately
bound by nothing, what a document must be is the searching engine’s question. So the name is
the whole of what a full-text election has to carry, and inventing a shape for it here would
answer that question for engines that have not arrived.
What it is SPENT on is BOTH halves of the read face. The whole-subject pair’s doc line names
the fields it searches — the sentence that used to say every projection — and each name in
this list also mints its own retrieve_keys_by_<field> / retrieve_by_<field> pair, at vector
parity, narrowing to a one-column FulltextSubset. The selector the per-field doors waited on
is the seam’s now: FulltextRead::search takes the subset beside the query.
engines: Vec<FieldEngines>WHERE each elected field is written — one entry per election, in declared order, carrying the engine blocks that field wore and whether all of them are live at once.
ONE list over BOTH kinds, kept in step with the elections above by construction: the engine
grammar is one grammar, and a knn’s field and a search’s field name their engines alike. An
election that named NO engine has an entry with an empty list — declaring none is legal, and
means the deployment says instead, which is what a record with no persist(…) means one family
over.
See engine for the semantics this carries: several blocks are declared
PORTABILITY, the default is SINGLE-WRITE, and fanout is the one
departure.
stores: Vec<Engine>WHERE an ARTIFACT FAMILY’s objects are written — the engine blocks a blob declaration wrote
at its HEAD, beside upstream(…).
NON-EMPTY only on a blob, and the reason it is a second list rather than an entry in
engines is that the GRAIN differs. A slot on the other two kinds is
(field × engine), because a declaration elects several fields and each is searched
independently; an artifact family elects nothing and holds ONE object per message, so its slot
is (declaration × engine) and the head is the only position coarse enough to name it. Writing
blob engines on a field would have asked which of a payload’s fields the object is — a question
with no answer.
The SEMANTICS are the field grammar’s, unchanged: several blocks are declared PORTABILITY, the
deployment selects, and the default is SINGLE-WRITE. fanout is NOT among them — see the
fanout refusal on this kind, which names the deferral rather than pretending the word is
unknown.
EMPTY is legal and means the deployment says instead, exactly as a record with no persist(…)
does one family over.
extension: Option<Extension>HOW this family’s addresses END — the extension word, in whichever of its forms was written.
None is the OMITTED form and a real one: extensionless storage, which a heterogeneous
family takes at zero tax, its per-entry type travelling as metadata or as the host channel’s
Content-Type. It is not unset — there is nothing to set it to.
NON-None only on a blob; extension on the other two kinds is refused by name.
data: boolWHETHER this family’s BYTES may travel beside its address — the bare data word at the head.
An artifact family answers an ADDRESS, and the whole kind is built around that posture: what a caller is handed is where the object lives, and going to get it is a second hop against the store. On a family of large objects that is the only sane answer — nothing wants a video inlined into a response. On a family of small ones the hop costs more than the bytes it fetches, and a thumbnail served as an address alone is a round trip bought for nothing.
data is where a declaration says which of the two it is. WRITTEN, this family’s object may be
served inline — base64, BESIDE the address rather than instead of it, so nothing a caller could
already reach stops being reachable. OMITTED, the address is the whole of what is served, and
that is a real form rather than an unset field: it is the default because it is the one that
cannot hand anybody a payload they did not ask for.
A BOOL because the word carries nothing — no value and no block, since these bytes may be served has no knob inside it. MAY rather than WILL is the deliberate half: what a DECLARATION can settle is whether inline bytes are on the table for this family at all.
false on the other two kinds ALWAYS — data there is refused by name, for
data_wrong_kind’s reason.
keys: boolWhether this declaration’s upstream is an ENTITY, so its dressed answer family mounts the KEYS
TIER ALONE — the keys word.
§The word declares a TIER FACT, and the two clocks are why one exists at all
A dressed election answers each road twice: the KEYS tier hands back addresses and touches no
store, the HYDRATED tier hands back the upstream’s whole entities and reads them out of one.
The hydrated pair projects <Upstream as Hydrates>::Db, whose impl only a record with a
queryable row emits — so which tiers this declaration can mount is decided by which RUNG of the
record ladder its upstream sits on, and the two derives cannot see each other.
false — a RECORD upstream — mounts BOTH, unconditionally and with no word to write: rows are
a record’s essence now, so storage is guaranteed and hydration can never miss. true — an
ENTITY upstream — mounts the keys tier, which is the pure-engine deployment’s honest home: a
search surface over a node whose messages land in no database anywhere.
A declaration that has an entity upstream and writes NO word is not silently narrowed. The
hydrated demand is emitted, the compiler cannot satisfy it, and the E0277 lands at
upstream(node = "…") carrying Hydrates’ own sentence — which names both exits, persist the
upstream or wear the word. Guessing here would be this crate deciding a deployment’s storage
posture from what happens to compile.
false on blob ALWAYS: an artifact family answers an address rather than a ranking, so it
mounts no tier pair for the word to narrow, and the word is refused there by name.
subscribe: boolWHETHER THIS DECLARATION LAUNCHES — the bare subscribe word at the head.
false is the HAND ROAD and it is the shipped one: the declaration mints its corpora, its
slot markers and its search doors, and a deployment fills those corpora through the branded
handle itself. Every expansion this crate wrote before the word existed is that road, and none
of them moves — subscription is purely additive, so the emission below is the only thing the
word adds and nothing it touches is rewritten.
true mints a NODE beside the declaration — see
subscriber — which the deployment mounts like any other, and which
receives the upstream’s messages, projects them per this declaration’s own upstream(…)
entries, and lands them in the corpora this declaration already names.
false on every kind but fulltext, where the word is refused by name: the write lane is a
per-family seam and the full-text one is the family with a live engine behind it.
graphql: Option<IndexGraphql>WHICH GRAPHQL BACKENDS this declaration is dressed for — see IndexGraphql for the law the
word states.
None is no wire face, and it is a real form rather than an unset field: a declaration
with no block emits every Rust type and every door it would otherwise emit, and emits no wire
impl for any of them. Nothing is missing programmatically — what is missing is a schema, which
is what a backend-only search pipeline wants.
numbers: NumbersTHE CONTAINER TIER’s numbers — limit, depth and ceiling written at the head.
Empty is the ordinary state and means the framework’s own answers stand; see Numbers for
the trichotomy the three words divide into, and wire_first /
pool_depth / declared_ceiling for the three
chains that read them.
field_numbers: Vec<FieldNumbers>THE ELECTION TIER’s numbers, one entry per field that wrote one — in the order the declaration wrote the fields.
A field with nothing written on it has NO entry rather than an empty one, so the list is exactly what a declaration said and a chain that finds nothing falls to the container.
rename: Option<IndexRename>WHAT THIS DECLARATION’S MINTED RUST TYPES ARE CALLED — see IndexRename.
None is the declaration’s own ident is the base, which is where this family started and
is what every declaration written before the word arrived means.
slot: Option<LitStr>WHAT THIS FAMILY’S CORPUS IS CALLED WHERE IT IS STORED — the slot = "…" word, blob only.
§A DURABLE name, which is the whole reason it is not the Rust rename
The slot is the directory an artifact family’s objects live under, and it survives every
rebuild: two deployments of one declaration address the same objects because they agree on
this string. So it is deliberately NOT moved by rename — a Rust word
repointing a live store would be a rename that loses data — and it is deliberately additive:
the DEFAULT stays snake_case(<declaration name>), which is what every family written before
the word arrived is stored under.
None is that default rather than an unset field. Non-None only on a blob: the other two
kinds’ slots are (field × engine) pairings and a declaration-level word is the wrong grain
for one, which the front end says by name.
fields: Vec<Column>EVERY field the index declares, in declared order — the injected key field is NOT among them, being the emitter’s rather than the declaration’s.
A Column rather than a Field, for
FieldsModel’s reason: a Field carries identity and a
reference, and every field here is on the same side of an identity it does not hold.
Implementations§
Source§impl IndexModel
impl IndexModel
Source§impl IndexModel
impl IndexModel
Sourcepub fn base(&self) -> &Ident
pub fn base(&self) -> &Ident
THE BASE EVERY MINTED NAME IS BUILT ON — the top-level rename’s word, or the declaration’s
own ident.
The one place the two are chosen between, so that a name minted anywhere in this crate cannot
be built on the wrong one. NOT the same question as what is this type called: the
declaration’s own ident is what an impl … for writes and what a doc link points at, and it
never moves.
Sourcepub fn emit(&self) -> TokenStream
pub fn emit(&self) -> TokenStream
The whole expansion: the one-storage marker at module scope, and everything else inside the
anonymous const this crate puts every impl in.
The marker CANNOT move inside that const — see
one_storage_marker; two of them in two anonymous consts
are two items in two scopes and collide with nothing at all.
Sourcepub fn mounts(&self) -> bool
pub fn mounts(&self) -> bool
WHETHER THIS DECLARATION MOUNTS AT ALL — a retrieving kind wearing a backend word.
The presence law at the tier that mints the unit: a declaration with no graphql(…) block
emits every Rust door and package it would otherwise emit, and mints no citizenship — which is
exactly what a backend-only search pipeline wants.
Sourcepub fn queries_name(&self) -> Ident
pub fn queries_name(&self) -> Ident
<Decl>Queries — this declaration’s query unit, re-based by the BONES rename like every other
name it mints.
No piece word of its own, on the record unit’s precedent: the unit is a Rust type a root spells once and a schema never sees, so a name for it is the base’s business. The base moves it because the base moves the whole family — a rename that reached the packages and left this one behind would put two stems in one declaring scope.
Sourcepub fn unmounted(&self, field: &Ident, which: Field) -> Option<&'static str>
pub fn unmounted(&self, field: &Ident, which: Field) -> Option<&'static str>
WHY THIS ELECTION PUBLISHES NO which QUERY FIELD, or None where it publishes one.
§The law: seats may sit EMPTY, and a written word must point at something MINTED
An unwritten seat is a capability nobody has asked for yet and costs a declaration nothing. A
WRITTEN one that reaches no emitted name is a swallowed authoring error — the class this house
already refuses at lineage(rename) on a lineage-less record — because the author believes they
renamed a field and the schema still publishes the derived name, or publishes nothing at all.
§What it reads is the DECLARATION’S OWN SHAPE, and that is the whole of its scope
Two facts decide which roads an election mounts, and both are the declaration’s:
- a FANNED election publishes the fused field alone. Its four sibling roads are not emitted,
because
vector_fuse_by_<field>is the one door a multi-store election has. - the head’s
keysword says the upstream is an ENTITY, so the answer family mounts the KEYS tier alone and the two hydrated roads have no store to read rows out of.
§Three cases it deliberately does NOT answer, each measured
Field::Fused always answers None here. It is unmounted on a plain election exactly as
its siblings are on a fanned one, and auditing it is a one-line change to the match below — but
the round that wrote this law enumerated four roads, so the fifth is left for a ruling rather
than taken by symmetry.
A FULL-TEXT election mounts no query field at all: answer_roads returns
nothing for that kind, so every seat on one is currently unspent. That is the ANSWER FACE not
having arrived for the kind rather than a shape the author chose, so a refusal there would be
this crate claiming the face is never coming.
An election naming its engines BY WORD ALONE publishes no field either — the portable case, which is legal and means the deployment picks the engine — and the same reasoning holds: the surface is absent for a reason outside the seat’s own axis.
Both are recorded here rather than fixed, so the next reader inherits the measurement.
Sourcepub fn unminted_engines(&self, field: &Ident) -> Option<&'static str>
pub fn unminted_engines(&self, field: &Ident) -> Option<&'static str>
WHY THIS ELECTION MINTS NO <Index><Field>Engines, or None where it mints one.
unmounted’s law at a TYPE seat rather than a field seat. The per-leg
product is minted by the fused answer and by nothing else — a fused read states one floor per
leg, and an election answered by one store has one leg and names it through the @oneOf
selector at the head instead.
Its sister seat question(rename = "…") has no such clause, and that is a MEASUREMENT rather
than an omission: question_input runs for every election that mounts a road at all, on every
road, so the question type is minted wherever the seat is reachable. The seat is audited and
found always-spent, which is a different answer from unaudited.
Sourcepub fn field_name(&self, elected: &Elected, which: Field) -> String
pub fn field_name(&self, elected: &Elected, which: Field) -> String
WHAT ONE ELECTION’S QUERY FIELD IS CALLED — the declared word verbatim, or the derived name.
#[ingraph(embedding, knn, lance(resource = "…"),
graphql(async_graphql(keys(rename = "clipNeighbours"))))]
└── replaces the whole nameVERBATIM, and that is the choice worth stating: the derived name is composed from three parts — the declaration, the election and the road — so a word that re-cased or re-composed what an author wrote would be a rename they could not predict from what they typed. The front end holds it to GraphQL’s own Name grammar at the literal, which is where a caret can land.
§The resolution is MEMBER, then BASE-DERIVED, then DEFAULT
The road’s own word answers first. Where it wrote none, the DERIVED half reads the rename-aware
base, so rename = "…" moves the field with the rest of the family; and where the declaration
wrote no base either, the derived name is built on its own ident. The declared half never moves
with a base, being a name in the SCHEMA’s namespace rather than Rust’s.
§FIVE seats for five roads, which is what closed the composition question
A declared word is VERBATIM, so it cannot be composed: a seat for the keys road says nothing
about what its hydrated twin should be called, and deriving clipNeighboursHydrated from
clipNeighbours would be the composition the verbatim law refuses. Two more seats was
therefore the only shape a word for the hydrated roads could take, and the 2026-08-16 rename
ruling minted them — so the seat set and Field are now one closed five, matched by
ElectionBackend::road where a missing arm is a compile error rather than a silent fallback.
Sourcepub fn road_name(&self, field: &Ident, which: Field) -> String
pub fn road_name(&self, field: &Ident, which: Field) -> String
field_name over a bare ident — the shape the FULL-TEXT kind has, whose
elections carry a name and nothing else.
One body for both, so the rename seat a vector election reads and the one a searchable field reads cannot come to disagree about which word wins.
Sourcepub fn slots(&self) -> Vec<Slot>
pub fn slots(&self) -> Vec<Slot>
EVERY slot this declaration names — one per (elected field × declared engine), in declared
order.
The set the storage plumbing is keyed by, and the answer to how many corpora does this declaration own. It is EMPTY for a declaration whose elections named no engine, which is the portable case: the slots exist, and which engines they are opened on is the deployment’s.
Sourcepub fn carried_key(&self) -> Field
pub fn carried_key(&self) -> Field
γ′ — the ONE field this expansion adds to the item its author wrote.
Minted here rather than at the front end that injects it, so that the name, the type and the
visibility are decided by the code that also reads them back: new takes it, key_ref borrows
it, the entity binding answers through it, and all four are above.
pub(crate), which is the stamp every other field of the declaration wears — see
ingraph-derive’s host module — and no exception is carved for this one. The visibility
convention is about a declaration’s fields being read by the code emitted around them, and this
field is the case that statement was written for.
§Panics
Never in practice: the tokens are this function’s own, and the only way they fail to parse as a named field is a change to this line.
Sourcepub fn emitted_methods(&self) -> Vec<Emitted>
pub fn emitted_methods(&self) -> Vec<Emitted>
Every method this emission declares, in EMISSION ORDER, for the front end that has to refuse a collision before an expansion lands two of one name in a scope its author cannot edit.
The FIXED names are here for the reason a declaration’s derived ones are: a field called key
reaches key_ref, and a copy field called new reaches new. Neither is a near miss — both
are the emitted name exactly — so both are refused at the declaration rather than left to be a
duplicate definition inside the expansion.
§EVERY name, and the ones this used to miss are the reason it says so
The list once held the constructor, the borrowed key and the accessor families, and the whole
read-and-write surface below them was absent. Each absence was the same defect: a copy field
called fan_title beside a fanout-marked title gives the index two fan_title, a field
called retrieve_keys gives it two of those, and E0592 reports each of them at
#[ingraph::fulltext(…)] — a span the author cannot edit, in a message that never names the
field. A table that knows about the accessors alone refuses the collisions it happens to have
heard of and is silent about the rest, which reads as a rule that has been applied.
§ONE OWNER, and an impl written inside the anonymous const is not a smaller scope
Every method here lands on the DECLARATION’s own type, which is why they all carry
Owner::Record. The retrieve face is emitted inside the expansion’s anonymous const and the
fan door at module scope, and that difference buys nothing: an inherent impl is global whatever
block it was written in, so the two impls’ names share one namespace and collide with each other
exactly as they collide with the carrier’s.
The order is the EMITTER’s own walk — see emit — so a front end reporting a
collision can name the earlier of the two as the one already there. It is pinned against the
emission itself by tests::the_enumeration_names_exactly_the_methods_the_emission_declares,
rather than maintained by hand.
Sourcepub fn emitted_types(&self) -> Vec<Declared>
pub fn emitted_types(&self) -> Vec<Declared>
Every TYPE this emission declares into the DECLARING SCOPE, in EMISSION ORDER — the markers, which are the whole of what a derived index puts in the type namespace beside the item its author wrote.
RecordModel::emitted_types’ argument, one family
over: the front end refuses a declaration whose emitted types collide, and it asks HERE which
those are rather than keeping a list of its own.
§WHY a derived index needs this at all, when its markers are minted rather than named
No word renames either of these, so the collisions are not a rename landing on a neighbour —
they are the JOIN. A marker is <Index><Field><Engine> in upper camel case, and camel case has
no separator: field a × engine b_c and field a_b × engine c both mint <Index>ABC.
The election markers are <Index>By<Field> and stand in the same scope, so field by × engine
image mints exactly the marker of an election on image.
The durable slot NAME has the same three parts and does NOT have the problem — see
Slot::name, which joins with __ for precisely this reason and
is test-pinned.
§The boundary-preserving JOIN was measured against the refusal, and lost on two counts
A TYPE cannot take that separator. <Index>__a__b_c is not upper camel case, so every
marker would arrive under non_camel_case_types in a crate that never wrote it — the cost
one_storage_marker already spends allows on, paid here
on names the WIRING spells rather than on a hidden one. And spell them it does:
SlotHandle<E, SearchDocumentTitleTantivy> and the lanes over it are some eighty sites across
this workspace, several of them compile_fail goldens whose text IS the assertion.
And it would not close the class. The election markers camel-join too, so elections on
image_1 and image1 mint one <Index>ByImage1 whatever the slot markers do. A respelling
buys one of the three collisions and leaves the other two live — under an error code that would
then look handled, which is the failure the whole-fix constraint was written against.
So the name stays and the collision is REFUSED at the declaration, which is the road that leaves the author’s own tokens the thing that moves.
§The INDEX’s own name is not here, and cannot collide with one of these
A record adds its own name to this list because a rename can land on it. Nothing here can:
every marker is the index’s name followed by at least one more camel-case segment, so
<Index> itself is not in the set — and a name this enumeration invented would refuse a
declaration for a clash that could not happen.
The order is the emitter’s own walk — elections, then slots — and it is pinned against the
emission by tests::the_enumeration_names_exactly_the_types_the_emission_declares.
Sourcepub fn numbers_of(&self, field: &Ident) -> Option<&FieldNumbers>
pub fn numbers_of(&self, field: &Ident) -> Option<&FieldNumbers>
What the field wrote, or None where it wrote nothing — the ELECTION tier’s lookup.
Sourcepub fn declared_ceiling(&self, field: Option<&Ident>) -> Option<NonZeroU32>
pub fn declared_ceiling(&self, field: Option<&Ident>) -> Option<NonZeroU32>
THE WALL FOR ONE ROUTE — the declared ceiling route_depth caps every fetch against.
Two tiers and no third: the ELECTION’s word where it wrote one, else the CONTAINER’s. There is no framework default and there never will be one — an absent wall is the AUTHOR’S INFORMED OPENNESS (#293-B), and a number invented on their behalf would be the framework deciding what a deployment may afford.
field is None at the grains that are not one election’s — the full-text tier’s unsuffixed
subject — where the container’s word is the whole chain.
Sourcepub fn declared_streams(&self, field: Option<&Ident>) -> Option<NonZeroU32>
pub fn declared_streams(&self, field: Option<&Ident>) -> Option<NonZeroU32>
THE STREAM GUARD FOR ONE ELECTION — how many query vectors one request may ask its _with
road with, or None where no tier wrote a guard.
declared_ceiling’s twin on the other protective axis, resolved the
same way and for the same reason: the ELECTION’s word where it wrote one, else the CONTAINER’s,
and no third step — a word written closer to the door is the more specific statement of the same
rule, and an unwritten guard is NO guard rather than a number this crate invented.
It is spent in points_binding and nowhere else, which is the ruled
scope: the guard is over an m a REQUEST states, and the only road asked with one is the
_with question road.
Sourcepub fn wall(&self, field: Option<&Ident>) -> TokenStream
pub fn wall(&self, field: Option<&Ident>) -> TokenStream
THE WALL, AS AN EMITTED route_depth READS IT — the token that fills the second argument
every fetch resolves through.
Option::as_ref over a fresh Option<NonZeroU32> rather than a hoisted const, and the shape
is the borrow’s: the callee takes Option<&NonZeroU32>, the temporary lives to the end of the
let statement the call sits in, and route_depth hands back an owned number — so nothing
outlives the statement and no item has to be minted in the emitted body’s scope.
None where no tier declared one, which is the ::core::option::Option::None every site
spelled while the word did not exist — so a declaration that writes nothing expands to exactly
the tokens it expanded to before, and the word is purely additive.
Sourcepub fn wire_first(&self, kind: GraphqlKind, field: Option<&Ident>) -> NonZeroU32
pub fn wire_first(&self, kind: GraphqlKind, field: Option<&Ident>) -> NonZeroU32
THE WIRE DEFAULT — the literal one election’s first: argument publishes, resolved through
the ruled chain and capped by the wall.
field-skin `first` → field `limit` → container-skin `first` → container `limit` → 20The order is Q6a’s verbatim, and each step is the more specific statement of the same number:
a skin’s word beats the bones at its own tier because it is written closer to the schema, and a
field’s tier beats the container’s because it is written closer to the door. FRAMEWORK_LIMIT
is the floor of the chain rather than a default anybody writes.
The WALL caps the answer, and that is not decoration: a default published above the ceiling would be a schema promising a page size the fetch silently cuts, which is the one thing an SDL literal must not be able to do.
Sourcepub fn pool_depth(&self, kind: GraphqlKind, field: Option<&Ident>) -> NonZeroU32
pub fn pool_depth(&self, kind: GraphqlKind, field: Option<&Ident>) -> NonZeroU32
THE POOL DEPTH a fold’s streams are fetched at when a request names none — the declared half of Q6b’s chain.
(request depth) → field `depth` → container `depth` → the whole limit chainThe first step is the REQUEST’s and is therefore the resolver’s, not a declaration’s: what this
answers is everything below it, which is what a resolver falls to when the request deferred.
Falling to the limit chain rather than to a depth of its own is the same statement
Route::depth’s None makes one grain up — as deep as the answer is wide — and it keeps an
undepthed world byte-identical to the one before the knob existed.