feat(stackable-versioned): Add conversion tracking

[Techassi]

Part of stackabletech/issues#642

Note

This PR description will be adjusted.

Tracking changes across sub structs

This is a rough sketch of what enabling this will look like. Support for this is essential so effectively track all changes values. Fields will be targeted by JSONPath like selectors.

use kube::CustomResource;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use stackable_versioned::{ChangedValues, versioned};

// A from trait which allows turning one type into another while also being able to track changes
// across upgrades and downgrades. This allows nested sub structs to bubble up their tracked changes.
pub trait TrackingFrom<T, S>
where
    Self: Sized,
    S: TrackingStatus,
{
    fn tracking_from(value: T, status: S) -> Self;
}

// This Into trait mirrors the standard Into trait, just with the ability to track changes. This
// trait is auto-implemented by all U: TrackingFrom.
pub trait TrackingInto<T, S>
where
    Self: Sized,
    S: TrackingStatus,
{
    fn tracking_into(self, status: S) -> T;
}

impl<T, U, S> TrackingInto<U, S> for T
where
    S: TrackingStatus,
    U: TrackingFrom<T, S>,
{
    fn tracking_into(self, status: S) -> U {
        U::tracking_from(self, status)
    }
}

// Generically access tracked changes in any status which implements this. The generated status
// struct will automatically implement this.
pub trait TrackingStatus {
    fn changes(&mut self) -> &mut ChangedValues;
}

#[versioned(
    version(name = "v1alpha1"),
    version(name = "v1beta1"),
    options(skip(from))
)]
mod versioned {
    #[versioned(
        k8s(
        group = "test.stackable.tech",
        status = FooStatus,
        // options(experimental_conversion_tracking)
    )
    )]
    #[derive(Clone, Debug, CustomResource, Serialize, Deserialize, JsonSchema)]
    pub struct FooSpec {
        // #[versioned(k8s(nested))]
        bar: Bar,
    }

    // #[versioned(k8s(nested))]
    #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
    pub struct Bar {
        baz: usize,

        #[versioned(added(since = "v1beta1"))]
        quox: u16,
    }
}

#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
pub struct FooStatus {
    changes: ChangedValues,
}

// Those two impls are generated by default because FooSpec describes the root struct.
impl From<v1alpha1::Foo> for v1beta1::Foo {
    fn from(value: v1alpha1::Foo) -> Self {
        // Call spec.tracking_into(status), because at least one field was marked with k8s(nested)
        todo!()
    }
}

impl From<v1beta1::Foo> for v1alpha1::Foo {
    fn from(value: v1beta1::Foo) -> Self {
        todo!()
    }
}

// If k8s(nested) is applied to a field, we know that we instead need to generate the TrackingFrom
// impl instead of the standard From impl.
impl<S> TrackingFrom<v1alpha1::FooSpec, S> for v1beta1::FooSpec
where
    S: TrackingStatus,
{
    fn tracking_from(value: v1alpha1::FooSpec, status: S) -> Self {
        Self {
            // The following generation is already in place, just needs to be adjusted to be able
            // to generate tracking_into for fields which need it. Currently in always emits .into()
            bar: value.bar.tracking_into(status),
        }
    }
}

impl<S> TrackingFrom<v1beta1::FooSpec, S> for v1alpha1::FooSpec
where
    S: TrackingStatus,
{
    fn tracking_from(value: v1beta1::FooSpec, status: S) -> Self {
        Self {
            bar: value.bar.tracking_into(status),
        }
    }
}

// The following two impls are generated if k8s(nested) is set on a sub struct
impl<S> TrackingFrom<v1alpha1::Bar, S> for v1beta1::Bar
where
    S: TrackingStatus,
{
    fn tracking_from(value: v1alpha1::Bar, status: S) -> Self {
        // This is a nested sub struct and thus knows which fields change in what way. As such,
        // it can insert into and read from the provided status (which has access to a mutable
        // changes tracking section).

        Self {
            baz: value.baz,
            quox: Default::default(),
        }
    }
}

impl<S> TrackingFrom<v1beta1::Bar, S> for v1alpha1::Bar
where
    S: TrackingStatus,
{
    fn tracking_from(value: v1beta1::Bar, status: S) -> Self {
        Self { baz: value.baz }
    }
}

// This is to be generated automatically when conversion_tracking is enabled
impl TrackingStatus for FooStatus {
    fn changes(&mut self) -> &mut ChangedValues {
        &mut self.changes
    }
}

[NickLarsenNZ]

This could be hidden behind the experimental_conversion_tracking feature flag.

Or, as you mentioned, we could throw an error when it is used without the feature enabled (I actually like this idea better as it helps with discovering features).

[sbernauer]

nit: Ideally we sort them alphabetical

[sbernauer]

nit: Please use a match here, so that we can add a TODO for type changes. Also, the compiler will force us to think about new added actions