lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

package_matrix.rs (6291B)


      1 use std::collections::BTreeSet;
      2 
      3 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
      4 pub struct PackageSpec {
      5     pub key: &'static str,
      6     pub crate_name: &'static str,
      7     pub crate_dir: &'static str,
      8     pub package_name: &'static str,
      9     pub package_dir: &'static str,
     10 }
     11 
     12 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     13 pub struct WasmPackageSpec {
     14     pub key: &'static str,
     15     pub crate_name: &'static str,
     16     pub crate_dir: &'static str,
     17     pub package_name: &'static str,
     18     pub package_dir: &'static str,
     19     pub out_name: &'static str,
     20     pub out_dir: &'static str,
     21 }
     22 
     23 pub const PACKAGE_SPECS: [PackageSpec; 5] = [
     24     PackageSpec {
     25         key: "core",
     26         crate_name: "radroots_core_bindings",
     27         crate_dir: "crates/core_bindings",
     28         package_name: "@radroots/core-bindings",
     29         package_dir: "packages/core-bindings",
     30     },
     31     PackageSpec {
     32         key: "event",
     33         crate_name: "radroots_event_bindings",
     34         crate_dir: "crates/event_bindings",
     35         package_name: "@radroots/event-bindings",
     36         package_dir: "packages/event-bindings",
     37     },
     38     PackageSpec {
     39         key: "identity",
     40         crate_name: "radroots_identity_bindings",
     41         crate_dir: "crates/identity_bindings",
     42         package_name: "@radroots/identity-bindings",
     43         package_dir: "packages/identity-bindings",
     44     },
     45     PackageSpec {
     46         key: "replica_schema",
     47         crate_name: "radroots_replica_schema_bindings",
     48         crate_dir: "crates/replica_schema_bindings",
     49         package_name: "@radroots/replica-schema-bindings",
     50         package_dir: "packages/replica-schema-bindings",
     51     },
     52     PackageSpec {
     53         key: "trade",
     54         crate_name: "radroots_trade_bindings",
     55         crate_dir: "crates/trade_bindings",
     56         package_name: "@radroots/trade-bindings",
     57         package_dir: "packages/trade-bindings",
     58     },
     59 ];
     60 
     61 pub const WASM_PACKAGE_SPECS: [WasmPackageSpec; 3] = [
     62     WasmPackageSpec {
     63         key: "event_codec",
     64         crate_name: "radroots_event_codec_wasm",
     65         crate_dir: "crates/event_codec_wasm",
     66         package_name: "@radroots/event-codec-wasm",
     67         package_dir: "packages/event-codec-wasm",
     68         out_name: "radroots_event_codec_wasm",
     69         out_dir: "../../packages/event-codec-wasm/dist",
     70     },
     71     WasmPackageSpec {
     72         key: "replica_store",
     73         crate_name: "radroots_replica_store_wasm",
     74         crate_dir: "crates/replica_store_wasm",
     75         package_name: "@radroots/replica-store-wasm",
     76         package_dir: "packages/replica-store-wasm",
     77         out_name: "radroots_replica_store_wasm",
     78         out_dir: "../../packages/replica-store-wasm/dist",
     79     },
     80     WasmPackageSpec {
     81         key: "replica_sync",
     82         crate_name: "radroots_replica_sync_wasm",
     83         crate_dir: "crates/replica_sync_wasm",
     84         package_name: "@radroots/replica-sync-wasm",
     85         package_dir: "packages/replica-sync-wasm",
     86         out_name: "radroots_replica_sync_wasm",
     87         out_dir: "../../packages/replica-sync-wasm/dist",
     88     },
     89 ];
     90 
     91 pub const FORBIDDEN_PACKAGE_NAMES: [&str; 2] =
     92     ["@radroots/tangle-db-schema-bindings", "@radroots/contracts"];
     93 
     94 pub fn package_specs() -> &'static [PackageSpec] {
     95     &PACKAGE_SPECS
     96 }
     97 
     98 pub fn wasm_package_specs() -> &'static [WasmPackageSpec] {
     99     &WASM_PACKAGE_SPECS
    100 }
    101 
    102 pub fn validate_package_matrix() -> Result<(), String> {
    103     let mut crate_names = BTreeSet::new();
    104     let mut package_names = BTreeSet::new();
    105     let mut package_dirs = BTreeSet::new();
    106     for spec in package_specs() {
    107         if FORBIDDEN_PACKAGE_NAMES.contains(&spec.package_name) {
    108             return Err(format!(
    109                 "forbidden package in matrix: {}",
    110                 spec.package_name
    111             ));
    112         }
    113         if !crate_names.insert(spec.crate_name) {
    114             return Err(format!("duplicate crate in matrix: {}", spec.crate_name));
    115         }
    116         if !package_names.insert(spec.package_name) {
    117             return Err(format!(
    118                 "duplicate package in matrix: {}",
    119                 spec.package_name
    120             ));
    121         }
    122         if !package_dirs.insert(spec.package_dir) {
    123             return Err(format!(
    124                 "duplicate package directory in matrix: {}",
    125                 spec.package_dir
    126             ));
    127         }
    128     }
    129     for spec in wasm_package_specs() {
    130         if FORBIDDEN_PACKAGE_NAMES.contains(&spec.package_name) {
    131             return Err(format!(
    132                 "forbidden package in matrix: {}",
    133                 spec.package_name
    134             ));
    135         }
    136         if !crate_names.insert(spec.crate_name) {
    137             return Err(format!("duplicate crate in matrix: {}", spec.crate_name));
    138         }
    139         if !package_names.insert(spec.package_name) {
    140             return Err(format!(
    141                 "duplicate package in matrix: {}",
    142                 spec.package_name
    143             ));
    144         }
    145         if !package_dirs.insert(spec.package_dir) {
    146             return Err(format!(
    147                 "duplicate package directory in matrix: {}",
    148                 spec.package_dir
    149             ));
    150         }
    151     }
    152     Ok(())
    153 }
    154 
    155 #[cfg(test)]
    156 mod tests {
    157     use super::{
    158         FORBIDDEN_PACKAGE_NAMES, package_specs, validate_package_matrix, wasm_package_specs,
    159     };
    160 
    161     #[test]
    162     fn package_matrix_is_valid() {
    163         validate_package_matrix().expect("package matrix is valid");
    164     }
    165 
    166     #[test]
    167     fn approved_package_count_is_stable() {
    168         assert_eq!(package_specs().len(), 5);
    169         assert_eq!(wasm_package_specs().len(), 3);
    170     }
    171 
    172     #[test]
    173     fn forbidden_names_are_absent() {
    174         for spec in package_specs() {
    175             assert!(!FORBIDDEN_PACKAGE_NAMES.contains(&spec.package_name));
    176         }
    177         for spec in wasm_package_specs() {
    178             assert!(!FORBIDDEN_PACKAGE_NAMES.contains(&spec.package_name));
    179         }
    180     }
    181 
    182     #[test]
    183     fn replica_schema_package_uses_current_name() {
    184         assert!(
    185             package_specs()
    186                 .iter()
    187                 .any(|spec| spec.package_name == "@radroots/replica-schema-bindings")
    188         );
    189     }
    190 
    191     #[test]
    192     fn wasm_packages_use_sdk_package_names() {
    193         assert!(
    194             wasm_package_specs()
    195                 .iter()
    196                 .any(|spec| spec.package_name == "@radroots/replica-store-wasm")
    197         );
    198     }
    199 }