Struct PipelineId 

pub struct PipelineId(/* private fields */);

Pipeline entity identifier value object for type-safe pipeline management

This value object provides type-safe pipeline identification with temporal ordering, pipeline lifecycle management, and comprehensive validation capabilities. It implements Domain-Driven Design (DDD) value object patterns with immutable semantics.

Key Features

• Type Safety: Strongly-typed pipeline identifiers that cannot be confused with other IDs
• Temporal Ordering: ULID-based time-ordered creation sequence for pipeline management
• Pipeline Lifecycle: Natural chronological ordering for audit trails and processing
• Cross-Platform: Consistent representation across languages and storage systems
• Validation: Comprehensive pipeline-specific validation and business rules
• Serialization: Full serialization support for storage and API integration

Benefits Over Raw ULIDs

• Type Safety: PipelineId cannot be confused with StageId or other entity IDs
• Domain Semantics: Clear intent in function signatures and business logic
• Validation: Pipeline-specific validation rules and constraints
• Future Evolution: Extensible for pipeline-specific methods and features

Usage Examples

Cross-Language Mapping

• Rust: PipelineId newtype wrapper with full validation
• Go: PipelineID struct with equivalent interface
• JSON: String representation of ULID for API compatibility
• Database: TEXT column with ULID string storage

Implementations

impl PipelineId

pub fn new() -> Self

Creates a new pipeline ID with current timestamp

Purpose

Generates a unique, time-ordered pipeline identifier using ULID. Each ID captures the exact moment of pipeline creation.

Why

Time-ordered pipeline IDs provide:

• Natural chronological sorting for audit trails
• Efficient range queries by creation time
• Guaranteed uniqueness with 128-bit randomness
• No coordination needed across distributed systems

Time Ordering

Pipeline IDs are naturally sorted by creation time, making them perfect for chronological pipeline processing and audit trails.

Returns

New PipelineId with current millisecond timestamp

Examples

pub fn from_ulid(ulid: Ulid) -> Result<Self, PipelineError>

Creates a pipeline ID from an existing ULID

Use Cases

• Deserializing from database
• Converting from external systems
• Testing with known IDs

pub fn from_string(s: &str) -> Result<Self, PipelineError>

Creates a pipeline ID from a string representation

Purpose

Parses and validates a pipeline ID from its ULID string representation. Used for deserialization, API input, and database retrieval.

Why

String parsing enables:

• RESTful API integration
• Database round-trip serialization
• Configuration file support
• Cross-language interoperability

Format

Accepts standard ULID string format (26 characters, base32 encoded) Example: “01ARZ3NDEKTSV4RRFFQ69G5FAV”

Arguments

• s - ULID string (26 characters, Crockford Base32)

Returns

• Ok(PipelineId) - Valid pipeline ID
• Err(PipelineError::InvalidConfiguration) - Invalid ULID format

Errors

Returns PipelineError::InvalidConfiguration when:

• String is not 26 characters
• Contains invalid Base32 characters
• Validation rules fail

Examples

pub fn from_timestamp_ms(timestamp_ms: u64) -> Self

Creates a pipeline ID from a timestamp (useful for range queries)

Purpose

Generates a pipeline ID with a specific timestamp. Primary use case is creating boundary IDs for time-range queries.

Why

Timestamp-based IDs enable:

• Efficient time-range queries (“created after midnight”)
• Time-based pagination in databases
• Migration from timestamp-based systems
• Reproducible IDs for testing

Arguments

• timestamp_ms - Milliseconds since Unix epoch

Returns

PipelineId with specified timestamp (random component generated)

Use Cases

• Creating boundary IDs for time-range queries
• “Find all pipelines created after midnight”
• Time-based pagination
• Migration from timestamp-based systems

Examples

pub fn as_ulid(&self) -> Ulid

Gets the underlying ULID value

Use Cases

• Database storage
• External API integration
• Logging and debugging

pub fn timestamp_ms(&self) -> u64

Gets the timestamp component of the pipeline ID

Returns

Milliseconds since Unix epoch when this pipeline ID was created

Use Cases

• Time-range queries
• Debugging pipeline creation times
• Audit trails and compliance

pub fn datetime(&self) -> DateTime<Utc>

Gets the creation time as a DateTime

Use Cases

• Human-readable timestamps in logs
• Time-based filtering in UI
• Audit reports

pub fn to_lowercase(&self) -> String

Converts to lowercase string representation

Use Cases

• Case-insensitive systems
• URL paths
• Database systems that prefer lowercase

pub fn validate(&self) -> Result<(), PipelineError>

Validates the pipeline ID

Pipeline-Specific Validation

• Must be a valid ULID
• Must not be nil (all zeros)
• Timestamp must be reasonable (not too far in future)
• Additional pipeline-specific rules can be added here

pub fn is_nil(&self) -> bool

Checks if this is a nil (zero) pipeline ID

Use Cases

• Validation in constructors
• Default value checking
• Debugging empty states

Trait Implementations

impl AsRef<Ulid> for PipelineId

fn as_ref(&self) -> &Ulid

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for PipelineId

fn clone(&self) -> PipelineId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PipelineId

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

Formats the value using the given formatter.

impl Default for PipelineId

fn default() -> Self

Creates a new random pipeline ID as the default

Design Decision

We use a random ID rather than nil to prevent accidental use of uninitialized IDs in production code.

impl<'de> Deserialize<'de> for PipelineId

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PipelineId

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

Formats the value using the given formatter.

impl From<PipelineId> for Ulid

fn from(id: PipelineId) -> Self

Converts to this type from the input type.

impl From<Ulid> for PipelineId

fn from(ulid: Ulid) -> Self

Converts to this type from the input type.

impl FromStr for PipelineId

type Err = PipelineError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for PipelineId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for PipelineId

fn cmp(&self, other: &PipelineId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PipelineId

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

fn partial_cmp(&self, other: &PipelineId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for PipelineId

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 PipelineId

impl StructuralPartialEq for PipelineId