Merge pull request #221 from stepchowfun/typescript-codegen

Add a placeholder TypeScript code generator

Author: stepchowfun

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
         password: ${{ secrets.DOCKER_PASSWORD }}
     - uses: stepchowfun/toast/.github/actions/toast@main
       with:
-        tasks: build test_units test_rust_integration lint release run
+        tasks: build test_units test_rust_integration test_typescript_integration lint release run
         docker_repo: stephanmisc/toast
         write_remote_cache: ${{ github.event_name == 'push' }}
     - run: |

.gitignore

@@ -4,4 +4,5 @@
 /example/target/
 /integration_tests/rust/src/types.rs
 /integration_tests/rust/target/
+/integration_tests/typescript/node_modules/
 /target/

CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.2] - 2021-10-09
+
+### Changed
+- Renamed `--rust-out-file` to `--rust-out`.
+
 ## [0.0.1] - 2021-10-08
 
 ### Added

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "typical"
-version = "0.0.1"
+version = "0.0.2"
 authors = ["Stephan Boyer <[email protected]>"]
 edition = "2018"
 description = "Algebraic data types for data interchange."

Cargo.toml

@@ -43,7 +43,7 @@ Each field also has a type, either explicitly or implicitly. If the type is miss
 Now that we've defined some types, we can use Typical to generate the code for serialization and deserialization. For example, you can generate Rust code with the following:
 
 ```sh
-$ typical generate email_api.t --rust-out-file email_api.rs
+$ typical generate email_api.t --rust-out email_api.rs
 ```
 
 The client and server can then use the generated code to serialize and deserialize messages for mutual communication. If the client and server are written in different languages, you can generate code for each language.
@@ -468,10 +468,10 @@ For a simple enumerated type (such as `Weekday` above), the encoding of a field
 Once Typical is [installed](#installation-instructions), you can use it to generate code for a schema called `main.t` with the following:
 
 ```sh
-$ typical generate main.t --rust-out-file main.rs
+$ typical generate main.t --rust-out types.rs --typescript-out types.ts
 ```
 
-You can change the `--rust-out-file` flag as appropriate to select the programming language.
+You can change the `--rust-out flag as appropriate to select the programming language.
 
 Here are the supported command-line options:
 
@@ -505,7 +505,8 @@ FLAGS:
     -h, --help    Prints help information
 
 OPTIONS:
-        --rust-out-file <PATH>    Sets the path of the Rust file to emit
+        --rust-out <PATH>          Sets the path of the Rust file to emit
+        --typescript-out <PATH>    Sets the path of the TypeScript file to emit
 
 ARGS:
     <SCHEMA_PATH>    Sets the path of the schema

README.md

@@ -3,6 +3,6 @@
 To run this demonstration, first [install Typical](https://github.com/stepchowfun/typical#installation-instructions) if you haven't already. Then issue the following commands in this directory:
 
 ```sh
-$ typical generate types.t --rust-out-file src/types.rs
+$ typical generate types.t --rust-out src/types.rs
 $ cargo run
 ```

example/README.md

@@ -4,5 +4,8 @@
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "typescript": "^4.4.3"
   }
 }

integration_tests/typescript/package-lock.json

@@ -54,7 +54,7 @@ use Direction::{In, Out};
 #[allow(clippy::too_many_lines)]
 pub fn generate(
     typical_version: &str,
-    schemas: BTreeMap<schema::Namespace, (schema::Schema, PathBuf, String)>,
+    schemas: &BTreeMap<schema::Namespace, (schema::Schema, PathBuf, String)>,
 ) -> String {
     // Construct a tree of modules and schemas. We start with an empty tree.
     let mut tree = Module {
@@ -67,7 +67,7 @@ pub fn generate(
 
     // Populate the tree with all the schemas.
     for (namespace, (schema, _, _)) in schemas {
-        insert_schema(&mut tree, &namespace, schema);
+        insert_schema(&mut tree, namespace, schema);
     }
 
     // Write the code.
@@ -288,7 +288,7 @@ pub trait Deserialize {{
 }
 
 // Insert a schema into a module.
-fn insert_schema(module: &mut Module, namespace: &schema::Namespace, schema: schema::Schema) {
+fn insert_schema(module: &mut Module, namespace: &schema::Namespace, schema: &schema::Schema) {
     let mut iter = namespace.components.iter();
 
     if let Some(head) = iter.next() {
@@ -320,7 +320,7 @@ fn insert_schema(module: &mut Module, namespace: &schema::Namespace, schema: sch
             module.children.insert(head.clone(), child);
         }
     } else {
-        module.schema = schema;
+        module.schema = schema.clone();
     }
 }
 
@@ -1626,7 +1626,7 @@ mod tests {
         validate(&schemas).unwrap();
 
         assert_eq!(
-            generate("0.0.0", schemas),
+            generate("0.0.0", &schemas),
             "\
 // This file was automatically generated by Typical 0.0.0.
 // Visit https://github.com/stepchowfun/typical for more information.