Struct OpAdmission 

#[non_exhaustive]
pub struct OpAdmission {
    pub diagnostic_op_id: &'static str,
    pub idempotent_by_default: bool,
    pub rate_limited_by_default: bool,
}

The participation facts a schema declares about one op, lifted off whichever descriptor the schema’s transport emitted.

REST schemas emit RouteTransportDescriptor and RPC schemas emit OpDescriptor; never both. Both From impls exist so admission logic is written once against this type rather than twice against two descriptor shapes — the transport-parity rule in CLAUDE.md, and the concrete lesson of cratestack#474, where a fix landed on one transport and silently no-oped on the other.

#[non_exhaustive]

Slices 2 and 3 add fields here — rate-limit tunables and whatever policy evaluation needs — and this crate is unreleased, so the marker costs nothing now and saves a second breaking release later. Consumers build one with OpAdmission::new, OpAdmission::unresolved or the two From impls below rather than a struct literal; reading the public fields is unaffected. Same reasoning ConflictTarget (cratestack-sql) and CratestackError already use.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

diagnostic_op_id: &'static str

Identifier for diagnostics only — nothing here dispatches on it. The name carries the constraint so a call site cannot forget it (this is pub in a published crate, where a bare op_id would read as a dispatch key).

RPC descriptors carry a real dotted op id (procedure.transfer). REST descriptors carry no such thing, so the From impl below uses RouteTransportDescriptor::name, which is not unique across a model’s five verbs. That is acceptable precisely because no decision reads this field; if one ever does, REST needs a genuine op id first.

idempotent_by_default: bool

true when the op does not participate in idempotency reservation — see the field of the same name on OpDescriptor for the full statement of what the flag means.

rate_limited_by_default: bool

true when the op participates in rate limiting. Carried but unread in slice 1 (rate limiting is still an L4 tower::Layer); it is here so a later slice does not have to change this type.

Implementations

impl OpAdmission

pub const fn new( diagnostic_op_id: &'static str, idempotent_by_default: bool, rate_limited_by_default: bool, ) -> OpAdmission

Build the admission facts for an op a caller has identified.

The two From impls below cover every in-tree caller; this exists for a consumer whose descriptors do not come from a generated OPS/ROUTE_TRANSPORTS slice, and as the supported alternative to the struct literal #[non_exhaustive] now blocks.

pub const fn unresolved() -> OpAdmission

The facts to assume when a caller could not identify the op at all — no descriptor matched the request, or the caller has no descriptor table wired up.

Fails closed toward reserving, which is the opposite direction from cratestack-axum’s rate-limit filters, and deliberately so: for rate limiting the conservative answer is “throttle it”, while for idempotency the conservative answer is “take the reservation”, because skipping a reservation is what would let a duplicate execute twice. Both mean “when in doubt, apply the protection”.

Trait Implementations

impl Clone for OpAdmission

fn clone(&self) -> OpAdmission

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for OpAdmission

impl Debug for OpAdmission

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

Formats the value using the given formatter.

impl Eq for OpAdmission

impl From<&'static OpDescriptor> for OpAdmission

fn from(descriptor: &'static OpDescriptor) -> OpAdmission

Converts to this type from the input type.

impl From<&'static RouteTransportDescriptor> for OpAdmission

fn from(descriptor: &'static RouteTransportDescriptor) -> OpAdmission

Converts to this type from the input type.

impl PartialEq for OpAdmission

fn eq(&self, other: &OpAdmission) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for OpAdmission