Enum cedar_policy_core::entities::JsonDeserializationError

pub enum JsonDeserializationError {
    Serde(Error),
    ParseEscape {
        kind: EscapeKind,
        value: String,
        errs: ParseErrors,
    },
    RestrictedExpressionError(RestrictedExpressionError),
    ExtensionsError(ExtensionsError),
    ExpectedLiteralEntityRef {
        ctx: Box<JsonDeserializationErrorContext>,
        got: Box<Expr>,
    },
    ExpectedExtnValue {
        ctx: Box<JsonDeserializationErrorContext>,
        got: Box<Expr>,
    },
    ExpectedContextToBeRecord {
        got: Box<RestrictedExpr>,
    },
    ActionParentIsNotAction {
        uid: EntityUID,
        parent: EntityUID,
    },
    MissingImpliedConstructor {
        ctx: Box<JsonDeserializationErrorContext>,
        return_type: Box<SchemaType>,
        arg_type: Box<SchemaType>,
    },
    UnexpectedEntityType {
        uid: EntityUID,
        suggested_types: Vec<EntityType>,
    },
    UndeclaredAction {
        uid: EntityUID,
    },
    ActionDeclarationMismatch {
        uid: EntityUID,
    },
    UnexpectedEntityAttr {
        uid: EntityUID,
        attr: SmolStr,
    },
    UnexpectedRecordAttr {
        ctx: Box<JsonDeserializationErrorContext>,
        record_attr: SmolStr,
    },
    MissingRequiredEntityAttr {
        uid: EntityUID,
        attr: SmolStr,
    },
    MissingRequiredRecordAttr {
        ctx: Box<JsonDeserializationErrorContext>,
        record_attr: SmolStr,
    },
    TypeMismatch {
        ctx: Box<JsonDeserializationErrorContext>,
        expected: Box<SchemaType>,
        actual: Box<SchemaType>,
    },
    HeterogeneousSet {
        ctx: Box<JsonDeserializationErrorContext>,
        ty1: Box<SchemaType>,
        ty2: Box<SchemaType>,
    },
    InvalidParentType {
        ctx: Box<JsonDeserializationErrorContext>,
        uid: EntityUID,
        parent_ty: Box<EntityType>,
    },
}

Errors thrown during deserialization from JSON

Variants

Serde(Error)

Error thrown by the serde_json crate

ParseEscape

Contents of an escape failed to parse. Note that escape __expr is deprecated and once it is removed, EscapeKind::Expr will also be removed

Fields

kind: EscapeKind

Escape kind

value: String

Escape value at fault

errs: ParseErrors

Parse errors

RestrictedExpressionError(RestrictedExpressionError)

Restricted expression error

ExtensionsError(ExtensionsError)

Error thrown by an operation on Extensions

ExpectedLiteralEntityRef

A field that needs to be a literal entity reference, was some other JSON value

Fields

ctx: Box<JsonDeserializationErrorContext>

Context of this error

got: Box<Expr>

the expression we got instead

ExpectedExtnValue

A field that needs to be an extension value, was some other JSON value

Fields

ctx: Box<JsonDeserializationErrorContext>

Context of this error

got: Box<Expr>

the expression we got instead

ExpectedContextToBeRecord

Contexts need to be records, but we got some other JSON value

Fields

got: Box<RestrictedExpr>

Expression we got instead

ActionParentIsNotAction

Parents of actions should be actions, but this action has a non-action parent

Fields

uid: EntityUID

Action entity that had the invalid parent

parent: EntityUID

Parent that is invalid

MissingImpliedConstructor

Schema-based parsing needed an implicit extension constructor, but no suitable constructor was found

Fields

ctx: Box<JsonDeserializationErrorContext>

Context of this error

return_type: Box<SchemaType>

return type of the constructor we were looking for

arg_type: Box<SchemaType>

argument type of the constructor we were looking for

UnexpectedEntityType

During schema-based parsing, encountered an entity of a type which is not declared in the schema. Note that this error is only used for non-Action entity types.

Fields

uid: EntityUID

Entity that had the unexpected type

suggested_types: Vec<EntityType>

Suggested similar entity types that actually are declared in the schema (if any)

UndeclaredAction

During schema-based parsing, encountered an action which was not declared in the schema

Fields

uid: EntityUID

Action which was not declared in the schema

ActionDeclarationMismatch

During schema-based parsing, encountered an action whose definition doesn’t precisely match the schema’s declaration of that action

Fields

uid: EntityUID

Action whose definition mismatched between entity data and schema

UnexpectedEntityAttr

During schema-based parsing, encountered this attribute on this entity, but that attribute shouldn’t exist on entities of this type

Fields

uid: EntityUID

Entity that had the unexpected attribute

attr: SmolStr

Name of the attribute that was unexpected

UnexpectedRecordAttr

During schema-based parsing, encountered this attribute on a record, but that attribute shouldn’t exist on that record

Fields

ctx: Box<JsonDeserializationErrorContext>

Context of this error

record_attr: SmolStr

Name of the (Record) attribute which was unexpected

MissingRequiredEntityAttr

During schema-based parsing, didn’t encounter this attribute of an entity, but that attribute should have existed

Fields

uid: EntityUID

Entity that is missing a required attribute

attr: SmolStr

Name of the attribute which was expected

MissingRequiredRecordAttr

During schema-based parsing, didn’t encounter this attribute of a record, but that attribute should have existed

Fields

ctx: Box<JsonDeserializationErrorContext>

Context of this error

record_attr: SmolStr

Name of the (Record) attribute which was expected

TypeMismatch

During schema-based parsing, the given attribute on the given entity had a different type than the schema indicated to expect

Fields

ctx: Box<JsonDeserializationErrorContext>

Context of this error

expected: Box<SchemaType>

Type which was expected

actual: Box<SchemaType>

Type which was encountered instead

HeterogeneousSet

During schema-based parsing, found a set whose elements don’t all have the same type. This doesn’t match any possible schema.

Fields

ctx: Box<JsonDeserializationErrorContext>

Context of this error

ty1: Box<SchemaType>

First element type which was found

ty2: Box<SchemaType>

Second element type which was found

InvalidParentType

During schema-based parsing, found a parent of a type that’s not allowed for that entity

Fields

ctx: Box<JsonDeserializationErrorContext>

Context of this error

uid: EntityUID

Entity that has an invalid parent type

parent_ty: Box<EntityType>

Parent type which was invalid

Trait Implementations

impl Debug for JsonDeserializationError

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

Formats the value using the given formatter.

impl Display for JsonDeserializationError

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

Formats the value using the given formatter.

impl Error for JsonDeserializationError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for JsonDeserializationError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ExtensionsError> for JsonDeserializationError

fn from(source: ExtensionsError) -> Self

Converts to this type from the input type.

impl From<JsonDeserializationError> for EntitiesError

fn from(source: JsonDeserializationError) -> Self

Converts to this type from the input type.

impl From<JsonDeserializationError> for EstToAstError

fn from(source: JsonDeserializationError) -> Self

Converts to this type from the input type.

impl From<RestrictedExpressionError> for JsonDeserializationError

fn from(source: RestrictedExpressionError) -> Self

Converts to this type from the input type.