feat: add framework macros and validated type definitions

Introduce the framework module with validated type wrappers that
enforce constraints at parse time rather than at each use site.
Includes attributed_string_type macro for generating validated
newtypes, and typed wrappers for Kubernetes (NamespaceName, Uid)
and operator (ProductName, OperatorName, etc.) concepts.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: adwk67

Cargo.lock

@@ -23,6 +23,7 @@ const_format = "0.2"
 fnv = "1.0"
 futures = { version = "0.3", features = ["compat"] }
 indoc = "2.0"
+regex = "1"
 rstest = "0.26"
 semver = "1.0"
 serde = { version = "1.0", features = ["derive"] }
@@ -32,6 +33,7 @@ snafu = "0.9"
 strum = { version = "0.28", features = ["derive"] }
 tokio = { version = "1.40", features = ["full"] }
 tracing = "0.1"
+uuid = { version = "1.16", features = ["v4"] }
 
 [patch."https://github.com/stackabletech/operator-rs.git"]
 # stackable-operator = { git = "https://github.com/stackabletech//operator-rs.git", branch = "main" }

Cargo.toml

@@ -21,10 +21,12 @@ indoc.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 serde_yaml.workspace = true
+regex.workspace = true
 snafu.workspace = true
 strum.workspace = true
 tokio.workspace = true
 tracing.workspace = true
+uuid.workspace = true
 
 [build-dependencies]
 built.workspace = true

rust/operator-binary/Cargo.toml

@@ -0,0 +1,46 @@
+//! Additions to stackable-operator
+//!
+//! Functions in stackable-operator usually accept generic types like strings and validate the
+//! parameters as late as possible. Therefore, nearly all functions have to return a [`Result`] and
+//! errors are returned along the call chain. That makes error handling complex because every
+//! module re-packages the received error. Also, the validation is repeated if the value is used in
+//! different function calls. Sometimes, validation is not necessary if constant values are used,
+//! e.g. the name of the operator.
+//!
+//! This operator uses a different approach. The incoming values are validated as early as possible
+//! and wrapped in a fail-safe type. This type is then used along the call chain, validation is not
+//! necessary anymore and functions without side effects do not need to return a [`Result`].
+//!
+//! However, this operator uses stackable-operator and at the interface, the fail-safe types must
+//! be unwrapped and the [`Result`] returned by the stackable-operator function must be handled.
+//! This is done by calling [`Result::expect`] which requires thorough testing.
+//!
+//! When the development of this module has progressed and changes become less frequent, then this
+//! module can be incorporated into stackable-operator. The module structure should already
+//! resemble the one of stackable-operator.
+
+use types::kubernetes::Uid;
+
+pub mod macros;
+pub mod types;
+
+/// Has a non-empty name
+///
+/// Useful as an object reference; Should not be used to create an object because the name could
+/// violate the naming constraints (e.g. maximum length) of the object.
+pub trait HasName {
+    #[allow(dead_code)]
+    fn to_name(&self) -> String;
+}
+
+/// Has a Kubernetes UID
+#[allow(dead_code)]
+pub trait HasUid {
+    fn to_uid(&self) -> Uid;
+}
+
+/// The name is a valid label value
+#[allow(dead_code)]
+pub trait NameIsValidLabelValue {
+    fn to_label_value(&self) -> String;
+}