Struct OrganizationContext 

pub struct OrganizationContext {
    pub org_id: OrgId,
    pub principal: Principal,
    pub request_id: RequestId,
    pub roles: Vec<RoleBinding>,
    pub org_path: Vec<OrgId>,
    pub attestation: Option<Attestation>,
}

Platform context bundle — org, principal, request-id, roles, org-path, attestation.

Carries the cross-cutting request context (tenant ID, actor identity, request tracing ID, authorization roles, org-path, and optional credential) in a single, cheap-to-clone value. Avoids threading (org_id, principal) pairs separately through every function and middleware layer.

Examples

use api_bones::{OrganizationContext, OrgId, Principal, RequestId, Role, RoleBinding, RoleScope, Attestation, AttestationKind};
use uuid::Uuid;

let org_id = OrgId::generate();
let principal = Principal::human(Uuid::new_v4());
let request_id = RequestId::new();

let ctx = OrganizationContext::new(org_id, principal, request_id)
    .with_roles(vec![RoleBinding { role: Role::from("admin"), scope: RoleScope::Self_ }])
    .with_attestation(Attestation {
        kind: AttestationKind::Jwt,
        raw: vec![1, 2, 3],
    });

assert_eq!(ctx.roles.len(), 1);
assert!(ctx.attestation.is_some());

Fields

org_id: OrgId

Tenant ID

principal: Principal

Actor identity

request_id: RequestId

Request tracing ID

roles: Vec<RoleBinding>

Authorization roles

org_path: Vec<OrgId>

Org path from root to the acting org (inclusive). Empty = platform scope.

attestation: Option<Attestation>

Optional credential/attestation

Implementations

impl OrganizationContext

pub fn new(org_id: OrgId, principal: Principal, request_id: RequestId) -> Self

Construct a new context with org, principal, and request-id.

Roles default to an empty vec, org_path to empty, attestation to None.

Examples

use api_bones::{OrganizationContext, OrgId, Principal, RequestId};
use uuid::Uuid;

let ctx = OrganizationContext::new(
    OrgId::generate(),
    Principal::human(Uuid::new_v4()),
    RequestId::new(),
);

assert!(ctx.roles.is_empty());
assert!(ctx.org_path.is_empty());
assert!(ctx.attestation.is_none());

pub fn with_roles(self, roles: Vec<RoleBinding>) -> Self

Set the roles on this context (builder-style).

Examples

use api_bones::{OrganizationContext, OrgId, Principal, RequestId, Role, RoleBinding, RoleScope};
use uuid::Uuid;

let ctx = OrganizationContext::new(
    OrgId::generate(),
    Principal::human(Uuid::new_v4()),
    RequestId::new(),
).with_roles(vec![RoleBinding { role: Role::from("editor"), scope: RoleScope::Self_ }]);

assert_eq!(ctx.roles.len(), 1);

pub fn with_org_path(self, org_path: Vec<OrgId>) -> Self

Set the org path on this context (builder-style).

Examples

use api_bones::{OrganizationContext, OrgId, Principal, RequestId};
use uuid::Uuid;

let org_id = OrgId::generate();
let ctx = OrganizationContext::new(
    org_id,
    Principal::human(Uuid::new_v4()),
    RequestId::new(),
).with_org_path(vec![org_id]);

assert!(!ctx.org_path.is_empty());

pub fn with_attestation(self, attestation: Attestation) -> Self

Set the attestation on this context (builder-style).

Examples

use api_bones::{OrganizationContext, OrgId, Principal, RequestId, Attestation, AttestationKind};
use uuid::Uuid;

let ctx = OrganizationContext::new(
    OrgId::generate(),
    Principal::human(Uuid::new_v4()),
    RequestId::new(),
).with_attestation(Attestation {
    kind: AttestationKind::ApiKey,
    raw: vec![42],
});

assert!(ctx.attestation.is_some());

Trait Implementations

impl Clone for OrganizationContext

fn clone(&self) -> OrganizationContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrganizationContext

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OrganizationContext

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OrganizationContext

fn eq(&self, other: &OrganizationContext) -> 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 Serialize for OrganizationContext

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for OrganizationContext

impl StructuralPartialEq for OrganizationContext