Crate strong_id

Strongly typed IDs which optionally satisfy the TypeID specification.

A StrongId is any type which implements StrongId<T: Id>.

The Id trait is implemented for u8, u16, u32, u64, u128, usize and when the "uuid" feature is enabled, Uuid.

Examples

Dynamic StrongIds

ID with a prefix

use strong_id::{prefix, DynamicStrongId};

let user_id = DynamicStrongId::<u16>::new(prefix!("user"), 3203).unwrap();
println!("{}", user_id); // user_0343

let user_id = "user_0343".parse::<DynamicStrongId<u16>>().unwrap();
println!("{:#?}", user_id);
// DynamicStrongId {
//     prefix: Some(
//        Prefix {
//           inner: "user",
//        ,
//     ),
//     suffix: 3203,
// }

ID without a prefix

use strong_id::{prefix, DynamicStrongId};

let id = DynamicStrongId::<u16>::new_plain(3203);
println!("{}", id); // 0343

let id = "0343".parse::<DynamicStrongId<u16>>().unwrap();
println!("{:#?}", id);
// DynamicStrongId {
//     prefix: None,
//     suffix: 3203,
// }

TypeId with a prefix

use strong_id::{prefix, DynamicStrongId};
use uuid::Uuid;

let user_id = DynamicStrongId::<Uuid>::now_v7(prefix!("user")).unwrap();
println!("{}", user_id); // user_01h536gfwffx2rm6pa0xg63337

let user_id = "user_01h536gfwffx2rm6pa0xg63337"
    .parse::<DynamicStrongId<Uuid>>()
    .unwrap();
println!("{:#?}", user_id);
// DynamicStrongId {
//     prefix: Some(
//        Prefix {
//            inner: "user",
//        },
//     ),
//     suffix: 01894668-3f8f-7f45-8a1a-ca0760618c67,
// }

TypeId without a prefix

use strong_id::{prefix, DynamicStrongId};
use uuid::Uuid;

let id = DynamicStrongId::<Uuid>::now_v7_plain();
println!("{}", id); // 01h536gfwffx2rm6pa0xg63337

let id = "01h536gfwffx2rm6pa0xg63337"
    .parse::<DynamicStrongId<Uuid>>()
    .unwrap();
println!("{:#?}", id);
// DynamicStrongId {
//     prefix: None,
//     suffix: 01894668-3f8f-7f45-8a1a-ca0760618c67,
// }

Generated StrongIds

ID with a prefix

use strong_id::strong_id;

strong_id!(pub struct UserId(u16 => "user"));

let user_id = UserId::from(3203);
println!("{}", user_id); // user_0343

let user_id = "user_0343".parse::<UserId>().unwrap();
println!("{:#?}", user_id);
// UserId {
//     suffix: 3203,
// }

ID without a prefix

use strong_id::strong_id;

strong_id!(pub struct Id(u16));

let id = Id::from(3203);
println!("{}", id); // user_0343

let id = "0343".parse::<Id>().unwrap();
println!("{:#?}", id);
// Id {
//     suffix: 3203,
// }

Generated TypeId with a prefix

use strong_id::{strong_uuid, StrongUuid};

strong_uuid!(pub struct UserId(pub Uuid => "user"));

let user_id = UserId::now_v7();
println!("{}", user_id); // user_01h536z8abez196j2nzz06y8c8

let user_id = "user_01h536z8abez196j2nzz06y8c8".parse::<UserId>().unwrap();
println!("{:#?}", user_id);
// UserId {
//     suffix: 0189466f-a14b-77c2-9348-55ffc06f2188,
// }

Alternatively, derive StrongUuid yourself:

use strong_id::{strong_id, StrongUuid};
use uuid::Uuid;

strong_id! {
    #[derive(StrongUuid)]
    pub struct UserId(pub Uuid => "user")
}

If you don’t need the utility functions, then just create a Uuid-backed ID:

use strong_id::strong_id;
use uuid::Uuid;

strong_id!(pub struct UserId(pub Uuid));

Note that this would still require the “uuid” feature so that the Id trait can be implemented for Uuid.

Generated TypeId without a prefix

use strong_id::{strong_uuid, StrongUuid};

strong_uuid!(pub struct Id(pub Uuid);

let id = Id::now_v7();
println!("{}", id); // 01h5372sq2egxb6ps3taq7p6np

let id = "01h5372sq2egxb6ps3taq7p6np".parse::<Id>().unwrap();
println!("{:#?}", id);
// UserId {
//     suffix: 01894671-66e2-743a-b35b-23d2ae7b1ab6,
// }

Re-exports

pub use uuid;

pub use serde;

Macros

prefix

Validate &'static str prefixes at compile-time

strong_id

Generate a StrongId

strong_uuiduuid

Generate a StrongId backed by a Uuid.

Structs

DynamicStrongId

A StrongId with runtime validation

Enums

Base32Error

Errors which might occur when encoding or decoding bytes into base32

Error

Errors which may occur when creating or parsing StrongIds

Traits

Id

Represents a type which can be encoded and decoded

StrongId

Represents a type which can be used as a StrongId

StrongUuiduuid

Utility trait to allow StrongId’s backed by a Uuid to wrap calls to Uuid new_ and now_ functions.

Derive Macros

StrongId

StrongUuid