WIP TypeScript codegen

packages/cw-schema-codegen/Cargo.toml

@@ -12,6 +12,7 @@ clap = { version = "4.5.18", features = ["derive"] }
 cw-schema = { version = "=2.2.0-rc.1", path = "../cw-schema" }
 either = "1.13.0"
 frunk = "0.4.3"
+frunk_core = "0.4.3"
 heck = "0.5.0"
 log = "0.4.22"
 serde_json = "1.0.128"

packages/cw-schema-codegen/src/main.rs

@@ -79,7 +79,14 @@ fn main() -> anyhow::Result<()> {
 
     schema.definitions.iter().try_for_each(|node| {
         debug!("Processing node: {node:?}");
-        cw_schema_codegen::rust::process_node(&mut output, &schema, node)
+
+        match opts.language {
+            Language::Rust => cw_schema_codegen::rust::process_node(&mut output, &schema, node),
+            Language::Typescript => {
+                cw_schema_codegen::typescript::process_node(&mut output, &schema, node)
+            }
+            Language::Go | Language::Python => todo!(),
+        }
     })?;
 
     Ok(())

packages/cw-schema-codegen/src/typescript/mod.rs

@@ -1 +1,145 @@
+use self::template::{
+    EnumTemplate, EnumVariantTemplate, FieldTemplate, StructTemplate, TypeTemplate,
+};
+use heck::ToPascalCase;
+use std::{borrow::Cow, io};
+
 pub mod template;
+
+fn expand_node_name<'a>(
+    schema: &'a cw_schema::SchemaV1,
+    node: &'a cw_schema::Node,
+) -> Cow<'a, str> {
+    match node.value {
+        cw_schema::NodeType::Array { items } => {
+            let items = &schema.definitions[items];
+            format!("{}[]", expand_node_name(schema, items)).into()
+        }
+        cw_schema::NodeType::Float => "number".into(),
+        cw_schema::NodeType::Double => "number".into(),
+        cw_schema::NodeType::Boolean => "boolean".into(),
+        cw_schema::NodeType::String => "string".into(),
+        cw_schema::NodeType::Integer { signed, precision } => {
+            "string".into()
+            /*let ty = if signed { "i" } else { "u" };
+            format!("{ty}{precision}").into()*/
+        }
+        cw_schema::NodeType::Binary => "Uint8Array".into(),
+        cw_schema::NodeType::Optional { inner } => {
+            let inner = &schema.definitions[inner];
+            format!("{} | null", expand_node_name(schema, inner)).into()
+        }
+        cw_schema::NodeType::Struct(..) => node.name.as_ref().into(),
+        cw_schema::NodeType::Tuple { ref items } => {
+            let items = items
+                .iter()
+                .map(|item| expand_node_name(schema, &schema.definitions[*item]))
+                .collect::<Vec<_>>()
+                .join(", ");
+
+            format!("[{}]", items).into()
+        }
+        cw_schema::NodeType::Enum { .. } => node.name.as_ref().into(),
+
+        cw_schema::NodeType::Decimal { precision, signed } => todo!(),
+        cw_schema::NodeType::Address => todo!(),
+        cw_schema::NodeType::Checksum => todo!(),
+        cw_schema::NodeType::HexBinary => todo!(),
+        cw_schema::NodeType::Timestamp => todo!(),
+        cw_schema::NodeType::Unit => Cow::Borrowed("void"),
+    }
+}
+
+fn prepare_docs(desc: Option<&str>) -> Cow<'_, [Cow<'_, str>]> {
+    desc.map(|desc| {
+        desc.lines()
+            .map(|line| line.replace('"', "\\\"").into())
+            .collect()
+    })
+    .unwrap_or(Cow::Borrowed(&[]))
+}
+
+pub fn process_node<O>(
+    output: &mut O,
+    schema: &cw_schema::SchemaV1,
+    node: &cw_schema::Node,
+) -> io::Result<()>
+where
+    O: io::Write,
+{
+    match node.value {
+        cw_schema::NodeType::Struct(ref sty) => {
+            let structt = StructTemplate {
+                name: node.name.clone(),
+                docs: prepare_docs(node.description.as_deref()),
+                ty: match sty {
+                    cw_schema::StructType::Unit => TypeTemplate::Unit,
+                    cw_schema::StructType::Named { ref properties } => TypeTemplate::Named {
+                        fields: properties
+                            .iter()
+                            .map(|(name, prop)| FieldTemplate {
+                                name: Cow::Borrowed(name),
+                                docs: prepare_docs(prop.description.as_deref()),
+                                ty: expand_node_name(schema, &schema.definitions[prop.value]),
+                            })
+                            .collect(),
+                    },
+                    cw_schema::StructType::Tuple { ref items } => TypeTemplate::Tuple(
+                        items
+                            .iter()
+                            .map(|item| expand_node_name(schema, &schema.definitions[*item]))
+                            .collect(),
+                    ),
+                },
+            };
+
+            writeln!(output, "{structt}")?;
+        }
+        cw_schema::NodeType::Enum { ref cases, .. } => {
+            let enumm = EnumTemplate {
+                name: node.name.clone(),
+                docs: prepare_docs(node.description.as_deref()),
+                variants: cases
+                    .iter()
+                    .map(|(name, case)| EnumVariantTemplate {
+                        name: name.clone(),
+                        docs: prepare_docs(case.description.as_deref()),
+                        ty: match case.value {
+                            cw_schema::EnumValue::Unit => TypeTemplate::Unit,
+                            cw_schema::EnumValue::Tuple { ref items } => {
+                                let items = items
+                                    .iter()
+                                    .map(|item| {
+                                        expand_node_name(schema, &schema.definitions[*item])
+                                    })
+                                    .collect();
+
+                                TypeTemplate::Tuple(items)
+                            }
+                            cw_schema::EnumValue::Named { ref properties, .. } => {
+                                TypeTemplate::Named {
+                                    fields: properties
+                                        .iter()
+                                        .map(|(name, prop)| FieldTemplate {
+                                            name: Cow::Borrowed(name),
+                                            docs: prepare_docs(prop.description.as_deref()),
+                                            ty: expand_node_name(
+                                                schema,
+                                                &schema.definitions[prop.value],
+                                            ),
+                                        })
+                                        .collect(),
+                                }
+                            }
+                        },
+                    })
+                    .collect(),
+            };
+
+            writeln!(output, "{enumm}")?;
+        }
+        _ => (),
+    }
+
+    Ok(())
+}

packages/cw-schema-codegen/src/typescript/template.rs

@@ -1,9 +1,41 @@
 use askama::Template;
+use std::borrow::Cow;
+
+#[derive(Clone)]
+pub struct EnumVariantTemplate<'a> {
+    pub name: Cow<'a, str>,
+    pub docs: Cow<'a, [Cow<'a, str>]>,
+    pub ty: TypeTemplate<'a>,
+}
 
 #[derive(Template)]
 #[template(escape = "none", path = "typescript/enum.tpl.ts")]
-pub struct EnumTemplate {}
+pub struct EnumTemplate<'a> {
+    pub name: Cow<'a, str>,
+    pub docs: Cow<'a, [Cow<'a, str>]>,
+    pub variants: Cow<'a, [EnumVariantTemplate<'a>]>,
+}
+
+#[derive(Clone)]
+pub struct FieldTemplate<'a> {
+    pub name: Cow<'a, str>,
+    pub docs: Cow<'a, [Cow<'a, str>]>,
+    pub ty: Cow<'a, str>,
+}
+
+#[derive(Clone)]
+pub enum TypeTemplate<'a> {
+    Unit,
+    Tuple(Cow<'a, [Cow<'a, str>]>),
+    Named {
+        fields: Cow<'a, [FieldTemplate<'a>]>,
+    },
+}
 
 #[derive(Template)]
 #[template(escape = "none", path = "typescript/struct.tpl.ts")]
-pub struct StructTemplate {}
+pub struct StructTemplate<'a> {
+    pub name: Cow<'a, str>,
+    pub docs: Cow<'a, [Cow<'a, str>]>,
+    pub ty: TypeTemplate<'a>,
+}

packages/cw-schema-codegen/templates/rust/enum.tpl.rs

@@ -1,3 +1,5 @@
+// This code is @generated by cw-schema-codegen. Do not modify this manually.
+
 {% for doc in docs %}
     #[doc = "{{ doc }}"]
 {% endfor %}
@@ -20,9 +22,7 @@ pub enum {{ name }} {
             {% when TypeTemplate::Unit %}
             {% when TypeTemplate::Tuple with (types) %}
                 (
-                    {% for ty in types %}
-                        {{ ty }},
-                    {% endfor %}
+                    {{ types|join(", ") }}
                 )
             {% when TypeTemplate::Named with { fields } %}
                 {

packages/cw-schema-codegen/templates/rust/struct.tpl.rs

@@ -1,3 +1,5 @@
+// This code is @generated by cw-schema-codegen. Do not modify this manually.
+
 {% for doc in docs %}
     #[doc = "{{ doc }}"]
 {% endfor %}
@@ -10,9 +12,7 @@ pub struct {{ name }}
         ;
     {% when TypeTemplate::Tuple with (types) %}
         (
-            {% for ty in types %}
-                {{ ty }},
-            {% endfor %}
+            {{ types|join(", ") }}
         );
     {% when TypeTemplate::Named with { fields } %}
         {

packages/cw-schema-codegen/templates/typescript/enum.tpl.ts

@@ -0,0 +1,38 @@
+// This code is @generated by cw-schema-codegen. Do not modify this manually.
+
+/**
+{% for doc in docs %}
+    * {{ doc }}
+{% endfor %}
+ */
+
+type {{ name }} = 
+{% for variant in variants %}
+    | 
+
+    /**
+    {% for doc in variant.docs %}
+        * {{ doc }}
+    {% endfor %}
+     */
+
+    {% match variant.ty %}
+        {% when TypeTemplate::Unit %}
+            { "{{ variant.name }}": {} }
+        {% when TypeTemplate::Tuple with (types) %}
+            { "{{ variant.name }}": [{{ types|join(", ") }}] }
+        {% when TypeTemplate::Named with { fields } %}
+            { "{{ variant.name }}": {
+                {% for field in fields %}
+                    /**
+                    {% for doc in field.docs %}
+                        * {{ doc }}
+                    {% endfor %}
+                     */
+
+                    {{ field.name }}: {{ field.ty }};
+                {% endfor %}
+            } }
+    {% endmatch %}
+{% endfor %}
+;

packages/cw-schema-codegen/templates/typescript/struct.tpl.ts

@@ -0,0 +1,30 @@
+// This code is @generated by cw-schema-codegen. Do not modify this manually.
+
+/**
+{% for doc in docs %}
+    * {{ doc }}
+{% endfor %}
+ */
+
+type {{ name }} = 
+{% match ty %}
+    {% when TypeTemplate::Unit %}
+        void
+    {% when TypeTemplate::Tuple with (types) %}
+        [{{ types|join(", ") }}]
+    {% when TypeTemplate::Named with { fields } %}
+        {
+            {% for field in fields %}
+                /**
+                {% for doc in field.docs %}
+                    * {{ doc }}
+                {% endfor %}
+                 */
+
+                {{ field.name }}: {{ field.ty }};
+            {% endfor %}
+        }
+{% endmatch %}
+;
+
+export { {{ name }} };