Type collections

examples/type_collection.rs

@@ -0,0 +1,23 @@
+use specta::{ts::ExportConfig, Type, TypeCollection};
+
+#[derive(Type)]
+pub struct Hello {
+    pub a: i32,
+    pub b: bool,
+}
+
+#[derive(Type)]
+pub struct Test(Hello);
+
+fn main() {
+    let code = TypeCollection::default()
+        .register::<Hello>()
+        .register::<Test>()
+        .export_ts(&ExportConfig::default())
+        .unwrap();
+
+    assert_eq!(
+        code,
+        "export type Hello = { a: number; b: boolean }\nexport type Test = Hello\n"
+    )
+}

src/lang/ts/mod.rs

@@ -46,6 +46,30 @@ pub fn export<T: NamedType>(conf: &ExportConfig) -> Output {
     result
 }
 
+impl TypeCollection {
+    /// Export a collection into a Typescript string.
+    pub fn export_ts(&mut self, conf: &ExportConfig) -> Output {
+        let mut type_map = TypeMap::default();
+        self.export(&mut type_map);
+
+        let mut result = String::new();
+        for (_, typ) in type_map.iter() {
+            is_valid_ty(&typ.inner, &type_map)?;
+
+            let ty = export_named_datatype(conf, typ, &type_map)?;
+            if let Some((ty_name, l0, l1)) =
+                detect_duplicate_type_names(&type_map).into_iter().next()
+            {
+                return Err(ExportError::DuplicateTypeName(ty_name, l0, l1));
+            }
+            result.push_str(&ty);
+            result.push('\n');
+        }
+
+        Ok(result)
+    }
+}
+
 /// Convert a type which implements [`Type`](crate::Type) to a TypeScript string.
 ///
 /// Eg. `{ demo: string; };`

src/lib.rs

@@ -27,6 +27,7 @@ mod serde;
 mod static_types;
 /// Contains [`Type`] and everything related to it, including implementations and helper macros
 pub mod r#type;
+mod type_collection;
 
 pub use crate::serde::*;
 #[doc(hidden)] // TODO: Should we actually do this? I think not
@@ -35,6 +36,7 @@ pub use lang::*;
 pub use r#type::*;
 pub use selection::*;
 pub use static_types::*;
+pub use type_collection::TypeCollection;
 
 /// Implements [`Type`] for a given struct or enum.
 ///

src/type_collection.rs

@@ -0,0 +1,40 @@
+use std::collections::HashMap;
+
+use crate::{NamedDataType, NamedType, SpectaID, TypeMap};
+
+/// Define a set of types which can be exported together
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TypeCollection {
+    types: HashMap<SpectaID, fn(&mut TypeMap) -> NamedDataType>,
+}
+
+impl Default for TypeCollection {
+    fn default() -> Self {
+        Self {
+            types: HashMap::new(),
+        }
+    }
+}
+
+impl TypeCollection {
+    /// Join another type collection into this one.
+    pub fn join(&mut self, collection: TypeCollection) -> &mut Self {
+        self.types.extend(collection.types);
+        self
+    }
+
+    /// Register a type with the collection.
+    pub fn register<T: NamedType>(&mut self) -> &mut Self {
+        self.types
+            .insert(T::sid(), |type_map| T::definition_named_data_type(type_map));
+        self
+    }
+
+    /// Export all the types in the collection.
+    pub fn export(&mut self, mut type_map: &mut crate::TypeMap) {
+        for (sid, export) in self.types.iter() {
+            let dt = export(&mut type_map);
+            type_map.insert(*sid, dt);
+        }
+    }
+}

tests/lib.rs

@@ -25,6 +25,7 @@ mod transparent;
 pub mod ts;
 mod ts_rs;
 mod ty_override;
+mod type_collection;
 mod type_map;
 mod typescript;
 #[cfg(all(feature = "ulid", feature = "typescript"))]

tests/macro/compile_error.stderr

@@ -60,6 +60,16 @@ error: specta: You must apply the #[specta] macro before the #[wasm_bindgen] mac
     |
     = note: this error originates in the attribute macro `wasm_bindgen` (in Nightly builds, run with -Z macro-backtrace for more info)
 
+error[E0255]: the name `__specta__fn__testing` is defined multiple times
+   --> tests/macro/compile_error.rs:110:8
+    |
+109 | #[specta]
+    | --------- previous definition of the macro `__specta__fn__testing` here
+110 | pub fn testing() {}
+    |        ^^^^^^^ `__specta__fn__testing` reimported here
+    |
+    = note: `__specta__fn__testing` must be defined only once in the macro namespace of this module
+
 error[E0601]: `main` function not found in crate `$CRATE`
    --> tests/macro/compile_error.rs:110:20
     |

tests/type_collection.rs

@@ -0,0 +1,67 @@
+use specta::{Type, TypeCollection, TypeMap};
+
+#[derive(Type)]
+struct A2(String);
+
+#[derive(Type)]
+struct A {
+    a: A2,
+}
+
+#[derive(Type)]
+struct C {
+    d: String,
+}
+
+#[derive(Type)]
+struct D(String);
+
+#[test]
+fn type_collection_export() {
+    let mut type_map = TypeMap::default();
+    TypeCollection::default()
+        .register::<A>()
+        .export(&mut type_map);
+    assert_eq!(type_map.len(), 2);
+}
+
+#[test]
+fn type_collection_merge() {
+    let mut a = TypeCollection::default();
+    a.register::<A>();
+    let mut b = TypeCollection::default();
+    b.register::<C>();
+
+    let mut type_map = TypeMap::default();
+    TypeCollection::default()
+        .register::<D>()
+        .join(a)
+        .join(b)
+        .export(&mut type_map);
+    assert_eq!(type_map.len(), 4);
+}
+
+#[test]
+fn type_collection_duplicate_register_ty() {
+    let mut type_map = TypeMap::default();
+    TypeCollection::default()
+        .register::<C>()
+        .register::<C>()
+        .export(&mut type_map);
+    assert_eq!(type_map.len(), 1);
+}
+
+#[test]
+#[cfg(feature = "typescript")]
+fn type_collection_ts() {
+    let result = TypeCollection::default()
+        .register::<A>()
+        .register::<C>()
+        .register::<D>()
+        .export_ts(&Default::default())
+        .unwrap();
+    assert_eq!(
+        result,
+        "export type A = { a: A2 }\nexport type A2 = string\nexport type C = { d: string }\nexport type D = string\n"
+    );
+}