siderust-js 0.1.0

package/qtty-js/qtty/qtty-core/src/feature_diesel.rs

@@ -0,0 +1,318 @@
+//! Diesel ORM support for `Quantity` types (feature-gated).
+//!
+//! This module is enabled by the `diesel` feature. It provides serialization, deserialization,
+//! and query support for `Quantity<U, S>` types when used with Diesel ORM.
+//!
+//! # Supported Scalar Types
+//!
+//! - `f64` - maps to SQL DOUBLE PRECISION
+//! - `f32` - maps to SQL REAL (FLOAT)
+//!
+//! Note: Decimal and Rational scalar types are not supported for Diesel integration as they
+//! don't have direct SQL type representations. Use f64 or f32 for database storage.
+//!
+//! # Supported Operations
+//!
+//! - **Serialization/Deserialization**: `Quantity<U, S>` maps to SQL DOUBLE PRECISION or REAL
+//! - **Nullable columns**: `Option<Quantity<U, S>>` automatically supported
+//! - **Query parameters**: Use in WHERE clauses and INSERT statements
+//! - **Result loading**: Use in SELECT queries with `Queryable` structs
+//! - **Backend-agnostic**: Works with PostgreSQL, SQLite, MySQL, and other Diesel backends
+//!
+//! # Examples
+//!
+//! ```rust,ignore
+//! use qtty::Degrees;
+//! use diesel::prelude::*;
+//!
+//! #[derive(Queryable, Selectable)]
+//! #[diesel(table_name = observations)]
+//! pub struct Observation {
+//!     pub id: i32,
+//!     pub altitude: Degrees,        // Direct use of Quantity type
+//!     pub azimuth: Degrees,
+//!     pub min_altitude: Option<Degrees>,  // Optional fields work too
+//! }
+//!
+//! #[derive(Insertable)]
+//! #[diesel(table_name = observations)]
+//! pub struct NewObservation {
+//!     pub altitude: Degrees,
+//!     pub azimuth: Degrees,
+//!     pub min_altitude: Option<Degrees>,
+//! }
+//! ```
+
+use crate::scalar::Real;
+use crate::{Quantity, Unit};
+use diesel::{
+    backend::Backend,
+    deserialize::{self, FromSql as DieselFromSql},
+    expression::AsExpression,
+    query_builder::QueryId,
+    serialize::{self, Output, ToSql as DieselToSql},
+    sql_types::{Double, Float, Nullable},
+    Queryable,
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Core FromSql/ToSql implementations for f64 (Double)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Deserialize `Quantity<U, f64>` from SQL DOUBLE PRECISION (f64) for any Diesel backend.
+impl<U, DB> DieselFromSql<Double, DB> for Quantity<U, f64>
+where
+    U: Unit,
+    DB: Backend,
+    f64: DieselFromSql<Double, DB>,
+{
+    fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
+        let value = f64::from_sql(bytes)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+/// Serialize `Quantity<U, f64>` to SQL DOUBLE PRECISION (f64) for any Diesel backend.
+impl<U, DB> DieselToSql<Double, DB> for Quantity<U, f64>
+where
+    U: Unit,
+    DB: Backend,
+    f64: DieselToSql<Double, DB>,
+{
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> serialize::Result {
+        <f64 as DieselToSql<Double, DB>>::to_sql(self.value_ref(), out)
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Core FromSql/ToSql implementations for f32 (Float)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Deserialize `Quantity<U, f32>` from SQL REAL (f32) for any Diesel backend.
+impl<U, DB> DieselFromSql<Float, DB> for Quantity<U, f32>
+where
+    U: Unit,
+    DB: Backend,
+    f32: DieselFromSql<Float, DB>,
+{
+    fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
+        let value = f32::from_sql(bytes)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+/// Serialize `Quantity<U, f32>` to SQL REAL (f32) for any Diesel backend.
+impl<U, DB> DieselToSql<Float, DB> for Quantity<U, f32>
+where
+    U: Unit,
+    DB: Backend,
+    f32: DieselToSql<Float, DB>,
+{
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> serialize::Result {
+        <f32 as DieselToSql<Float, DB>>::to_sql(self.value_ref(), out)
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Nullable column support for f64
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Support for nullable columns: `Option<Quantity<U, f64>>` maps to SQL DOUBLE PRECISION NULL.
+impl<U, DB> DieselFromSql<Nullable<Double>, DB> for Quantity<U, f64>
+where
+    U: Unit,
+    DB: Backend,
+    f64: DieselFromSql<Double, DB>,
+{
+    fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
+        let value = f64::from_sql(bytes)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+impl<U, DB> DieselToSql<Nullable<Double>, DB> for Quantity<U, f64>
+where
+    U: Unit,
+    DB: Backend,
+    f64: DieselToSql<Double, DB>,
+{
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> serialize::Result {
+        <f64 as DieselToSql<Double, DB>>::to_sql(self.value_ref(), out)
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Nullable column support for f32
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Support for nullable columns: `Option<Quantity<U, f32>>` maps to SQL REAL NULL.
+impl<U, DB> DieselFromSql<Nullable<Float>, DB> for Quantity<U, f32>
+where
+    U: Unit,
+    DB: Backend,
+    f32: DieselFromSql<Float, DB>,
+{
+    fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
+        let value = f32::from_sql(bytes)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+impl<U, DB> DieselToSql<Nullable<Float>, DB> for Quantity<U, f32>
+where
+    U: Unit,
+    DB: Backend,
+    f32: DieselToSql<Float, DB>,
+{
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> serialize::Result {
+        <f32 as DieselToSql<Float, DB>>::to_sql(self.value_ref(), out)
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// AsExpression implementations for f64
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Enable `Quantity<U, f64>` in WHERE clauses and INSERT statements.
+impl<U: Unit> AsExpression<Double> for Quantity<U, f64> {
+    type Expression = <f64 as AsExpression<Double>>::Expression;
+
+    fn as_expression(self) -> Self::Expression {
+        AsExpression::<Double>::as_expression(self.value())
+    }
+}
+
+impl<U: Unit> AsExpression<Double> for &Quantity<U, f64> {
+    type Expression = <f64 as AsExpression<Double>>::Expression;
+
+    fn as_expression(self) -> Self::Expression {
+        AsExpression::<Double>::as_expression(self.value())
+    }
+}
+
+/// Enable `Quantity<U, f64>` in nullable (Option) columns.
+impl<U: Unit> AsExpression<Nullable<Double>> for Quantity<U, f64> {
+    type Expression = <f64 as AsExpression<Nullable<Double>>>::Expression;
+
+    fn as_expression(self) -> Self::Expression {
+        AsExpression::<Nullable<Double>>::as_expression(self.value())
+    }
+}
+
+impl<U: Unit> AsExpression<Nullable<Double>> for &Quantity<U, f64> {
+    type Expression = <f64 as AsExpression<Nullable<Double>>>::Expression;
+
+    fn as_expression(self) -> Self::Expression {
+        AsExpression::<Nullable<Double>>::as_expression(self.value())
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// AsExpression implementations for f32
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Enable `Quantity<U, f32>` in WHERE clauses and INSERT statements.
+impl<U: Unit> AsExpression<Float> for Quantity<U, f32> {
+    type Expression = <f32 as AsExpression<Float>>::Expression;
+
+    fn as_expression(self) -> Self::Expression {
+        AsExpression::<Float>::as_expression(self.value())
+    }
+}
+
+impl<U: Unit> AsExpression<Float> for &Quantity<U, f32> {
+    type Expression = <f32 as AsExpression<Float>>::Expression;
+
+    fn as_expression(self) -> Self::Expression {
+        AsExpression::<Float>::as_expression(self.value())
+    }
+}
+
+/// Enable `Quantity<U, f32>` in nullable (Option) columns.
+impl<U: Unit> AsExpression<Nullable<Float>> for Quantity<U, f32> {
+    type Expression = <f32 as AsExpression<Nullable<Float>>>::Expression;
+
+    fn as_expression(self) -> Self::Expression {
+        AsExpression::<Nullable<Float>>::as_expression(self.value())
+    }
+}
+
+impl<U: Unit> AsExpression<Nullable<Float>> for &Quantity<U, f32> {
+    type Expression = <f32 as AsExpression<Nullable<Float>>>::Expression;
+
+    fn as_expression(self) -> Self::Expression {
+        AsExpression::<Nullable<Float>>::as_expression(self.value())
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Queryable implementations for f64
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Enable `Quantity<U, f64>` to be used in Diesel's `Queryable` derive.
+impl<U, DB> Queryable<Double, DB> for Quantity<U, f64>
+where
+    U: Unit,
+    DB: Backend,
+    f64: Queryable<Double, DB>,
+{
+    type Row = <f64 as Queryable<Double, DB>>::Row;
+
+    fn build(row: Self::Row) -> deserialize::Result<Self> {
+        let value = <f64 as Queryable<Double, DB>>::build(row)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+impl<U, DB> Queryable<Nullable<Double>, DB> for Quantity<U, f64>
+where
+    U: Unit,
+    DB: Backend,
+    f64: Queryable<Nullable<Double>, DB>,
+{
+    type Row = <f64 as Queryable<Nullable<Double>, DB>>::Row;
+
+    fn build(row: Self::Row) -> deserialize::Result<Self> {
+        let value = <f64 as Queryable<Nullable<Double>, DB>>::build(row)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Queryable implementations for f32
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Enable `Quantity<U, f32>` to be used in Diesel's `Queryable` derive.
+impl<U, DB> Queryable<Float, DB> for Quantity<U, f32>
+where
+    U: Unit,
+    DB: Backend,
+    f32: Queryable<Float, DB>,
+{
+    type Row = <f32 as Queryable<Float, DB>>::Row;
+
+    fn build(row: Self::Row) -> deserialize::Result<Self> {
+        let value = <f32 as Queryable<Float, DB>>::build(row)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+impl<U, DB> Queryable<Nullable<Float>, DB> for Quantity<U, f32>
+where
+    U: Unit,
+    DB: Backend,
+    f32: Queryable<Nullable<Float>, DB>,
+{
+    type Row = <f32 as Queryable<Nullable<Float>, DB>>::Row;
+
+    fn build(row: Self::Row) -> deserialize::Result<Self> {
+        let value = <f32 as Queryable<Nullable<Float>, DB>>::build(row)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+/// QueryId implementation for query caching support.
+impl<U: Unit, S: Real> QueryId for Quantity<U, S> {
+    type QueryId = Self;
+    const HAS_STATIC_QUERY_ID: bool = false;
+}

package/qtty-js/qtty/qtty-core/src/feature_pyo3.rs

@@ -0,0 +1,27 @@
+//! PyO3 trait implementations for `Quantity` types (feature-gated).
+//!
+//! This module is enabled by the `pyo3` feature. It provides `IntoPyObject` and `FromPyObject`
+//! implementations that convert `Quantity<U, S>` to/from Python floats.
+
+use crate::scalar::Real;
+use crate::{Quantity, Unit};
+use pyo3::prelude::*;
+
+impl<'py, U: Unit, S: Real> pyo3::conversion::IntoPyObject<'py> for Quantity<U, S> {
+    type Target = pyo3::types::PyFloat;
+    type Output = pyo3::Bound<'py, pyo3::types::PyFloat>;
+    type Error = core::convert::Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(pyo3::types::PyFloat::new(py, self.value().to_f64()))
+    }
+}
+
+impl<'a, 'py, U: Unit, S: Real> pyo3::conversion::FromPyObject<'a, 'py> for Quantity<U, S> {
+    type Error = pyo3::PyErr;
+
+    fn extract(obj: pyo3::Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let value = <f64 as pyo3::conversion::FromPyObject<'a, 'py>>::extract(obj)?;
+        Ok(Quantity::new(S::from_f64(value)))
+    }
+}

package/qtty-js/qtty/qtty-core/src/feature_serde.rs

@@ -0,0 +1,203 @@
+//! Serde support for `Quantity` types (feature-gated).
+//!
+//! This module is enabled by the `serde` feature. It provides serialization and deserialization
+//! for `Quantity<U, S>` types, including helper modules for different serialization formats.
+
+use crate::scalar::{Real, Scalar};
+use crate::{Quantity, Unit};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+// Default serde: serialize as f64 (backward compatible)
+impl<U: Unit, S: Real> Serialize for Quantity<U, S> {
+    fn serialize<Ser>(&self, serializer: Ser) -> core::result::Result<Ser::Ok, Ser::Error>
+    where
+        Ser: Serializer,
+    {
+        // Strategy A: Always serialize as f64 for backward compatibility
+        self.value().to_f64().serialize(serializer)
+    }
+}
+
+impl<'de, U: Unit, S: Real> Deserialize<'de> for Quantity<U, S> {
+    fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // Strategy A: Deserialize from f64 and convert
+        let value = f64::deserialize(deserializer)?;
+        Ok(Quantity::new(S::from_f64(value)))
+    }
+}
+
+/// Serde helper module for serializing the raw scalar value.
+///
+/// This module serializes the scalar type directly instead of converting to f64.
+/// Use this when you need to preserve the exact scalar representation.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use qtty_core::length::Meters;
+/// use serde::{Serialize, Deserialize};
+///
+/// #[derive(Serialize, Deserialize)]
+/// struct Config {
+///     #[serde(with = "qtty_core::serde_scalar")]
+///     distance: Meters,  // Serializes the scalar directly
+/// }
+/// ```
+pub mod serde_scalar {
+    use super::*;
+
+    /// Serializes the quantity's scalar value directly.
+    #[allow(dead_code)]
+    pub fn serialize<U, S, Ser>(
+        quantity: &Quantity<U, S>,
+        serializer: Ser,
+    ) -> Result<Ser::Ok, Ser::Error>
+    where
+        U: Unit,
+        S: Scalar + Serialize,
+        Ser: Serializer,
+    {
+        quantity.value_ref().serialize(serializer)
+    }
+
+    /// Deserializes the quantity from a scalar value directly.
+    #[allow(dead_code)]
+    pub fn deserialize<'de, U, S, D>(deserializer: D) -> Result<Quantity<U, S>, D::Error>
+    where
+        U: Unit,
+        S: Scalar + Deserialize<'de>,
+        D: Deserializer<'de>,
+    {
+        let value = S::deserialize(deserializer)?;
+        Ok(Quantity::new(value))
+    }
+}
+
+/// Serde helper module for serializing quantities with unit information.
+///
+/// Use this with the `#[serde(with = "...")]` attribute to preserve unit symbols
+/// in serialized data. This is useful for external APIs, configuration files, or
+/// self-documenting data formats.
+///
+/// # Examples
+///
+/// ```rust
+/// use qtty_core::length::Meters;
+/// use serde::{Serialize, Deserialize};
+///
+/// #[derive(Serialize, Deserialize)]
+/// struct Config {
+///     #[serde(with = "qtty_core::serde_with_unit")]
+///     max_distance: Meters,  // Serializes as {"value": 100.0, "unit": "m"}
+///     
+///     min_distance: Meters,  // Serializes as 50.0 (default, compact)
+/// }
+/// ```
+#[cfg(feature = "std")]
+pub mod serde_with_unit {
+    extern crate alloc;
+    use alloc::format;
+    use alloc::string::String;
+
+    use super::*;
+    use serde::de::{self, Deserializer, MapAccess, Visitor};
+    use serde::ser::{SerializeStruct, Serializer};
+
+    /// Serializes a `Quantity<U, S>` as a struct with `value` and `unit` fields.
+    ///
+    /// # Example JSON Output
+    /// ```json
+    /// {"value": 42.5, "unit": "m"}
+    /// ```
+    pub fn serialize<U, S, Ser>(
+        quantity: &Quantity<U, S>,
+        serializer: Ser,
+    ) -> Result<Ser::Ok, Ser::Error>
+    where
+        U: Unit,
+        S: Real,
+        Ser: Serializer,
+    {
+        let mut state = serializer.serialize_struct("Quantity", 2)?;
+        state.serialize_field("value", &quantity.value().to_f64())?;
+        state.serialize_field("unit", U::SYMBOL)?;
+        state.end()
+    }
+
+    /// Deserializes a `Quantity<U, S>` from a struct with `value` and optionally `unit` fields.
+    ///
+    /// The `unit` field is validated if present but not required for backwards compatibility.
+    /// If provided and doesn't match `U::SYMBOL`, an error is returned.
+    pub fn deserialize<'de, U, S, D>(deserializer: D) -> Result<Quantity<U, S>, D::Error>
+    where
+        U: Unit,
+        S: Real,
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(field_identifier, rename_all = "lowercase")]
+        enum Field {
+            Value,
+            Unit,
+        }
+
+        struct QuantityVisitor<U, S>(core::marker::PhantomData<(U, S)>);
+
+        impl<'de, U: Unit, S: Real> Visitor<'de> for QuantityVisitor<U, S> {
+            type Value = Quantity<U, S>;
+
+            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
+                formatter.write_str("struct Quantity with value and unit fields")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> Result<Quantity<U, S>, V::Error>
+            where
+                V: MapAccess<'de>,
+            {
+                let mut value: Option<f64> = None;
+                let mut unit: Option<String> = None;
+
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Value => {
+                            if value.is_some() {
+                                return Err(de::Error::duplicate_field("value"));
+                            }
+                            value = Some(map.next_value()?);
+                        }
+                        Field::Unit => {
+                            if unit.is_some() {
+                                return Err(de::Error::duplicate_field("unit"));
+                            }
+                            unit = Some(map.next_value()?);
+                        }
+                    }
+                }
+
+                let value = value.ok_or_else(|| de::Error::missing_field("value"))?;
+
+                // Validate unit if provided (optional for backwards compatibility)
+                if let Some(ref unit_str) = unit {
+                    if unit_str != U::SYMBOL {
+                        return Err(de::Error::custom(format!(
+                            "unit mismatch: expected '{}', found '{}'",
+                            U::SYMBOL,
+                            unit_str
+                        )));
+                    }
+                }
+
+                Ok(Quantity::new(S::from_f64(value)))
+            }
+        }
+
+        deserializer.deserialize_struct(
+            "Quantity",
+            &["value", "unit"],
+            QuantityVisitor(core::marker::PhantomData),
+        )
+    }
+}

package/qtty-js/qtty/qtty-core/src/feature_tiberius.rs

@@ -0,0 +1,28 @@
+//! Tiberius SQL Server support for `Quantity` types (feature-gated).
+//!
+//! This module is enabled by the `tiberius` feature. It provides SQL Server database
+//! integration for `Quantity<U, S>` types through the Tiberius driver.
+
+use crate::scalar::Real;
+use crate::{Quantity, Unit};
+use tiberius::{ColumnData, FromSql, ToSql};
+
+impl<U: Unit + Send + Sync, S: Real + Send + Sync> ToSql for Quantity<U, S> {
+    fn to_sql(&self) -> ColumnData<'_> {
+        ColumnData::F64(Some(self.value().to_f64()))
+    }
+}
+
+impl<U: Unit, S: Real> FromSql<'_> for Quantity<U, S> {
+    fn from_sql(value: &ColumnData<'_>) -> tiberius::Result<Option<Self>> {
+        match value {
+            ColumnData::F64(Some(val)) => Ok(Some(Quantity::new(S::from_f64(*val)))),
+            ColumnData::F32(Some(val)) => Ok(Some(Quantity::new(S::from_f64(*val as f64)))),
+            ColumnData::I16(Some(val)) => Ok(Some(Quantity::new(S::from_f64(*val as f64)))),
+            ColumnData::I32(Some(val)) => Ok(Some(Quantity::new(S::from_f64(*val as f64)))),
+            ColumnData::I64(Some(val)) => Ok(Some(Quantity::new(S::from_f64(*val as f64)))),
+            ColumnData::U8(Some(val)) => Ok(Some(Quantity::new(S::from_f64(*val as f64)))),
+            _ => Ok(None),
+        }
+    }
+}