feat: add framework macros and validated type definitions

Introduce the framework module with compile-time validated string wrapper
types (attributed_string_type macro) and typed Kubernetes/operator name
types. Ported from the opensearch-operator reference implementation.

All code is currently unused and will be wired into the controller in
subsequent commits.

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

Author: adwk67

Cargo.lock

@@ -20,6 +20,7 @@ const_format = "0.2"
 fnv = "1.0"
 futures = { version = "0.3", features = ["compat"] }
 indoc = "2.0"
+regex = "1.11"
 pin-project = "1.1"
 rstest = "0.26"
 semver = "1.0"
@@ -30,6 +31,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 = { path = "../operator-rs/crates/stackable-operator" }

Cargo.toml

@@ -18,6 +18,7 @@ const_format.workspace = true
 fnv.workspace = true
 futures.workspace = true
 indoc.workspace = true
+regex.workspace = true
 pin-project.workspace = true
 semver.workspace = true
 serde.workspace = true
@@ -26,6 +27,7 @@ snafu.workspace = true
 strum.workspace = true
 tokio.workspace = true
 tracing.workspace = true
+uuid.workspace = true
 
 [dev-dependencies]
 rstest.workspace = true

rust/operator-binary/Cargo.toml

@@ -0,0 +1,44 @@
+//! 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
+pub trait HasUid {
+    fn to_uid(&self) -> Uid;
+}
+
+/// The name is a valid label value
+pub trait NameIsValidLabelValue {
+    fn to_label_value(&self) -> String;
+}