TypeScript E2E tests

Author: aumetra

Cargo.lock

@@ -17,11 +17,14 @@ frunk = "0.4.3"
 frunk_core = "0.4.3"
 heck = "0.5.0"
 log = "0.4.22"
+mimalloc = "0.1.43"
 serde_json = "1.0.128"
 simple_logger = { version = "5.0.0", features = ["stderr"] }
 
 [dev-dependencies]
+arbitrary = { version = "=1.3.2", features = ["derive"] }
+derive_arbitrary = "=1.3.2"
 insta = "1.40.0"
+rand = { version = "0.8.5", features = ["min_const_gen"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = "1.0.128"
-tempfile = "3.14.0"

packages/cw-schema-codegen/Cargo.toml

@@ -12,6 +12,9 @@ use std::{
     path::PathBuf,
 };
 
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, ValueEnum)]
 pub enum Language {
     #[default]
@@ -54,6 +57,7 @@ fn generate_defs<W>(
     output: &mut W,
     language: Language,
     schema: &cw_schema::Schema,
+    add_imports: bool,
 ) -> anyhow::Result<()>
 where
     W: io::Write,
@@ -68,7 +72,7 @@ where
         match language {
             Language::Rust => cw_schema_codegen::rust::process_node(output, schema, node),
             Language::Typescript => {
-                cw_schema_codegen::typescript::process_node(output, schema, node)
+                cw_schema_codegen::typescript::process_node(output, schema, node, add_imports)
             }
             Language::Go | Language::Python => todo!(),
         }
@@ -105,23 +109,23 @@ fn main() -> anyhow::Result<()> {
     let mut output = opts.output()?;
 
     if let Some(ref instantiate) = schema.instantiate {
-        generate_defs(&mut output, opts.language, instantiate)?;
+        generate_defs(&mut output, opts.language, instantiate, true)?;
     }
 
     if let Some(ref execute) = schema.execute {
-        generate_defs(&mut output, opts.language, execute)?;
+        generate_defs(&mut output, opts.language, execute, false)?;
     }
 
     if let Some(ref query) = schema.query {
-        generate_defs(&mut output, opts.language, query)?;
+        generate_defs(&mut output, opts.language, query, false)?;
     }
 
     if let Some(ref migrate) = schema.migrate {
-        generate_defs(&mut output, opts.language, migrate)?;
+        generate_defs(&mut output, opts.language, migrate, false)?;
     }
 
     if let Some(ref sudo) = schema.sudo {
-        generate_defs(&mut output, opts.language, sudo)?;
+        generate_defs(&mut output, opts.language, sudo, false)?;
     }
 
     if let Some(ref responses) = schema.responses {
@@ -131,7 +135,7 @@ fn main() -> anyhow::Result<()> {
             .collect::<HashSet<_>>();
 
         for response in responses {
-            generate_defs(&mut output, opts.language, response)?;
+            generate_defs(&mut output, opts.language, response, false)?;
         }
     }
 

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

@@ -12,19 +12,20 @@ fn expand_node_name<'a>(
     match node.value {
         cw_schema::NodeType::Array { items } => {
             let items = &schema.definitions[items];
-            format!("{}[]", expand_node_name(schema, items)).into()
+            format!("z.array({})", 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 { .. } => "string".into(),
-        cw_schema::NodeType::Binary => "Uint8Array".into(),
+        cw_schema::NodeType::Float => "z.number()".into(),
+        cw_schema::NodeType::Double => "z.number()".into(),
+        cw_schema::NodeType::Boolean => "z.boolean()".into(),
+        cw_schema::NodeType::String => "z.string()".into(),
+        cw_schema::NodeType::Integer { .. } => "z.string()".into(),
+        cw_schema::NodeType::Binary => "z.instanceof(Uint8Array)".into(),
         cw_schema::NodeType::Optional { inner } => {
             let inner = &schema.definitions[inner];
-            format!("{} | null", expand_node_name(schema, inner)).into()
+            format!("{}.optional()", expand_node_name(schema, inner)).into()
         }
-        cw_schema::NodeType::Struct(..) => node.name.as_ref().into(),
+
+        cw_schema::NodeType::Struct(..) => format!("{}Schema", node.name).into(),
         cw_schema::NodeType::Tuple { ref items } => {
             let items = items
                 .iter()
@@ -34,14 +35,17 @@ fn expand_node_name<'a>(
 
             format!("[{}]", items).into()
         }
-        cw_schema::NodeType::Enum { .. } => node.name.as_ref().into(),
+        cw_schema::NodeType::Enum { .. } => format!("{}Schema", node.name).into(),
 
-        cw_schema::NodeType::Decimal { .. } => "string".into(),
-        cw_schema::NodeType::Address => "string".into(),
+        cw_schema::NodeType::Decimal { .. } => "z.string()".into(),
+        cw_schema::NodeType::Address => "z.string()".into(),
         cw_schema::NodeType::Checksum => todo!(),
         cw_schema::NodeType::HexBinary => todo!(),
-        cw_schema::NodeType::Timestamp => todo!(),
-        cw_schema::NodeType::Unit => Cow::Borrowed("void"),
+        cw_schema::NodeType::Timestamp => {
+            // ToDo: Replace with better type
+            "z.string()".into()
+        }
+        cw_schema::NodeType::Unit => "z.void()".into(),
     }
 }
 
@@ -54,6 +58,7 @@ pub fn process_node<O>(
     output: &mut O,
     schema: &cw_schema::SchemaV1,
     node: &cw_schema::Node,
+    add_imports: bool,
 ) -> io::Result<()>
 where
     O: io::Write,
@@ -82,6 +87,7 @@ where
                             .collect(),
                     ),
                 },
+                add_imports,
             };
 
             writeln!(output, "{structt}")?;
@@ -125,6 +131,7 @@ where
                         },
                     })
                     .collect(),
+                add_imports,
             };
 
             writeln!(output, "{enumm}")?;

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

@@ -14,6 +14,7 @@ pub struct EnumTemplate<'a> {
     pub name: Cow<'a, str>,
     pub docs: Cow<'a, [Cow<'a, str>]>,
     pub variants: Cow<'a, [EnumVariantTemplate<'a>]>,
+    pub add_imports: bool,
 }
 
 #[derive(Clone)]
@@ -38,4 +39,5 @@ pub struct StructTemplate<'a> {
     pub name: Cow<'a, str>,
     pub docs: Cow<'a, [Cow<'a, str>]>,
     pub ty: TypeTemplate<'a>,
+    pub add_imports: bool,
 }

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

@@ -1,15 +1,17 @@
 // This code is @generated by cw-schema-codegen. Do not modify this manually.
 
+{% if add_imports %}
+import { z } from 'zod';
+{% endif %}
+
 /**
 {% for doc in docs %}
     * {{ doc }}
 {% endfor %}
  */
 
-type {{ name }} = 
+const {{ name }}Schema = z.union([
 {% for variant in variants %}
-    | 
-
     /**
     {% for doc in variant.docs %}
         * {{ doc }}
@@ -18,27 +20,29 @@ type {{ name }} =
 
     {% match variant.ty %}
         {% when TypeTemplate::Unit %}
-            { "{{ variant.name }}": {} }
+            z.object({ "{{ variant.name }}": z.void() }),
         {% when TypeTemplate::Tuple with (types) %}
-            { "{{ variant.name }}": [{{ types|join(", ") }}] }
+            z.object({ "{{ variant.name }}": z.tuple([{{ types|join(", ") }}]) }),
         {% when TypeTemplate::Named with { fields } %}
-            { "{{ variant.name }}": {
+            z.object({ "{{ variant.name }}": z.object({
                 {% for field in fields %}
                     /**
                     {% for doc in field.docs %}
                         * {{ doc }}
                     {% endfor %}
                      */
 
-                    {{ field.name }}: {{ field.ty }};
+                    {{ field.name }}: {{ field.ty }},
                 {% endfor %}
-            } }
+            }) }),
     {% endmatch %}
 {% endfor %}
 
 {% if variants.len() == 0 %}
     never;
 {% endif %}
-;
+]);
+
+type {{ name }} = z.infer<typeof {{ name }}Schema>;
 
-export { {{ name }} };
+export { {{ name }}, {{ name }}Schema };

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

@@ -1,30 +1,36 @@
 // This code is @generated by cw-schema-codegen. Do not modify this manually.
 
+{% if add_imports %}
+import { z } from 'zod';
+{% endif %}
+
 /**
 {% for doc in docs %}
     * {{ doc }}
 {% endfor %}
  */
 
-type {{ name }} = 
+const {{ name }}Schema = 
 {% match ty %}
     {% when TypeTemplate::Unit %}
-        void
+        z.void()
     {% when TypeTemplate::Tuple with (types) %}
-        [{{ types|join(", ") }}]
+        z.tuple([{{ types|join(", ") }}])
     {% when TypeTemplate::Named with { fields } %}
-        {
+        z.object({
             {% for field in fields %}
                 /**
                 {% for doc in field.docs %}
                     * {{ doc }}
                 {% endfor %}
                  */
 
-                {{ field.name }}: {{ field.ty }};
+                {{ field.name }}: {{ field.ty }},
             {% endfor %}
-        }
+        })
 {% endmatch %}
 ;
 
-export { {{ name }} };
+type {{ name }} = z.infer<typeof {{ name }}Schema>;
+
+export { {{ name }}, {{ name }}Schema };

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

@@ -4,14 +4,20 @@ expression: output
 ---
 // This code is @generated by cw-schema-codegen. Do not modify this manually.
 
+
+import { z } from 'zod';
+
+
 /**
 
  */
 
-type Uwu = 
+const UwuSchema = 
 
-        [string, string]
+        z.tuple([z.string(), z.string()])
 
 ;
 
-export { Uwu };
+type Uwu = z.infer<typeof UwuSchema>;
+
+export { Uwu, UwuSchema };