Struct Error 

#[non_exhaustive]
pub struct Error { /* private fields */ }

The error type for the TypeScript exporter.

BigInt Forbidden

Specta Typescript intentionally forbids exporting BigInt-style Rust integer types. This includes usize, isize, i64, u64, u128, i128 and f128.

This guard exists because JSON.parse will truncate large integers to fit into a JavaScript number type so we explicitly forbid exporting them.

We take the stance that correctness matters more than developer experience as people using Rust generally strive for correctness.

If you encounter this error, there are a few common migration paths (in order of preference):

1. Use a Specta-based framework which can handle these types

   • None currently exist but it would theoretically be possible refer to #203 for more information.

2. Use a smaller integer types (any of u8/i8/u16/i16/u32/i32/f64).

   • Only possible when the biggest integer you need to represent is small enough to be represented by a number in JS.
   • This approach forces your application code to handle overflow/underflow values explicitly
   • Downside is that it can introduce annoying glue code and doesn’t actually work if your need large values.

3. Serialize the value as a string

   • This can be done using #[specta(type = String)] for the type combined with a Serde #[serde(with = "...")] attribute for runtime.
   • Downside is that it can introduce annoying glue code, both on in Rust and in JS as you will need to turn it back into a new BigInt(myString) in JS but this will support numbers of any size losslessly.

4. UNSAFE: Accept precision loss on per-field basis

   • Accept that large numbers may be deserialized differently than they are in Rust and use #[specta(type = specta_typescript::Number)] to bypass this warning on a per-field basis.
   • Marking each field explicitly encodes the decision similar to an unsafe block, ensuring everyone working on your codebase is aware of the risk and where it exists within the codebase.
   • This doesn’t work for external implementations like serde_json::Value which contain BigInt’s as you don’t control the definition.

5. UNSAFE: Accept precision loss using specta_util::Remapper

   • You can apply a Remapper to your Types collection to override types. This would allow you to remap usize/isize/i64/u64/i128/u128/f128 into number.
   • This is highly not recommended but it might be required if your using serde_json::Value or other built-in impls which contain BigInt’s as you can’t override them.
   • Refer to discussion around this on #481.

Implementations

impl Error

pub fn named_datatype(&self) -> Option<&NamedDataType>

The named Rust type being exported when this error occurred, if known.

pub fn trace(&self) -> &[ErrorTraceFrame]

TypeScript exporter traversal context for this error.

pub fn framework( message: impl Into<Cow<'static, str>>, source: impl Into<Box<dyn Error + Send + Sync>>, ) -> Self

Construct an error for framework-specific logic.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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 Error

fn from(error: Error) -> Self

Converts to this type from the input type.