[typeshare] Support external tags for enums (1Password#7)

* For complex enums the default serde serialization is externally tagged, to avoid having to re-write our rust logic to use internal tags via `#[serde(tag = "type", content = "content")]` we are going to add manual support for it in `typescript`
* Bumping version to `1.12.1`
* Adding a `--dry-run` flag to allow building locally

```
enum MyEnum {
  blahblah {
    name: String
  }
  blahblah2 {
    age: u64
  }
}
```

```
export type MyEnum =
  { "type": "blahblah", content: { "name": string }}
  | { "type": "blahblah2", content: { "age": number }}
```

```
export type MyEnum =
 { "blahblah": { "name": string }}
| { "blahblah2": { "age": number }}
```

* CI passes

* Revert

Author: naveenOnarayanan

.gitignore

@@ -17,3 +17,4 @@ dist/
 uploads.txt
 dist-manifest.json
 .intentionally-empty-file.o
+.DS_Store

core/src/language/typescript.rs

@@ -291,36 +291,63 @@ impl TypeScript {
                 writeln!(w)?;
                 self.write_comments(w, 1, &v.shared().comments)?;
                 match v {
-                    RustEnumVariant::Unit(shared) => write!(
-                        w,
-                        "\t| {{ {}: {:?}, {}?: undefined }}",
-                        tag_key, shared.id.renamed, content_key
-                    ),
+                    RustEnumVariant::Unit(shared) => {
+                        if !tag_key.is_empty() {
+                            if !content_key.is_empty() {
+                                write!(
+                                    w,
+                                    "\t| {{ {}: {:?}, {}?: undefined }}",
+                                    tag_key, shared.id.renamed, content_key
+                                )
+                            } else {
+                                write!(w, "\t| {{ {}: {:?} }}", tag_key, shared.id.renamed)
+                            }
+                        } else {
+                            write!(w, "\t| {:?}", shared.id.renamed)
+                        }
+                    }
                     RustEnumVariant::Tuple { ty, shared } => {
                         let r#type = self
                             .format_type(ty, e.shared().generic_types.as_slice())
-                            .map_err(io::Error::other)?;
-                        write!(
-                            w,
-                            "\t| {{ {}: {:?}, {}{}: {} }}",
-                            tag_key,
-                            shared.id.renamed,
-                            content_key,
-                            if ty.is_optional() {
-                                "?"
+                            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+                        if !tag_key.is_empty() {
+                            if !content_key.is_empty() {
+                                write!(
+                                    w,
+                                    "\t| {{ {}: {:?}, {}{}: {} }}",
+                                    tag_key,
+                                    shared.id.renamed,
+                                    content_key,
+                                    ty.is_optional().then_some("?").unwrap_or_default(),
+                                    r#type
+                                )
                             } else {
-                                Default::default()
-                            },
-                            r#type
-                        )
+                                panic!("Tuple variants must have a content key if they have a tag key: {:?}", shared.id.original)
+                            }
+                        } else {
+                            write!(
+                                w,
+                                "\t| {{ {:?}{}: {} }}",
+                                shared.id.renamed,
+                                ty.is_optional().then_some("?").unwrap_or_default(),
+                                r#type
+                            )
+                        }
                     }
                     RustEnumVariant::AnonymousStruct { fields, shared } => {
-                        writeln!(
-                            w,
-                            "\t| {{ {}: {:?}, {}: {{",
-                            tag_key, shared.id.renamed, content_key
-                        )?;
-
+                        if !tag_key.is_empty() {
+                            if !content_key.is_empty() {
+                                writeln!(
+                                    w,
+                                    "\t| {{ {}: {:?}, {}: {{",
+                                    tag_key, shared.id.renamed, content_key
+                                )?;
+                            } else {
+                                panic!("Struct variants must have a content key if they have a tag key: {:?}", shared.id.original)
+                            }
+                        } else {
+                            writeln!(w, "\t| {{ {:?}: {{", shared.id.renamed)?;
+                        }
                         fields.iter().try_for_each(|f| {
                             self.write_field(w, f, e.shared().generic_types.as_slice())
                         })?;

core/src/parser.rs

@@ -378,18 +378,8 @@ pub(crate) fn parse_enum(
     } else {
         // At least one enum variant is either a tuple or an anonymous struct
 
-        let tag_key = maybe_tag_key.ok_or_else(|| {
-            ParseError::SerdeTagRequired {
-                enum_ident: original_enum_ident.clone(),
-            }
-            .with_span(e.span())
-        })?;
-        let content_key = maybe_content_key.ok_or_else(|| {
-            ParseError::SerdeContentRequired {
-                enum_ident: original_enum_ident.clone(),
-            }
-            .with_span(e.span())
-        })?;
+        let tag_key = maybe_tag_key.unwrap_or_default();
+        let content_key = maybe_content_key.unwrap_or_default();
 
         Ok(RustItem::Enum(RustEnum::Algebraic {
             tag_key,

scripts/build.sh

@@ -14,6 +14,7 @@ function help() {
     echo "                             * \"aarch64-unknown-linux-gnu\""
     echo "                             * \"x86_64-unknown-linux-gnu\""
     echo "                             * \"x86_64-pc-windows-msvc\""
+    echo "  --dry-run              Run the script without releasing"
     exit 0
 }
 
@@ -26,6 +27,8 @@ function help() {
 TARGET=""
 # --version <version>
 VERSION=""
+# --dry-run
+DRY_RUN=false
 
 # Parse command line arguments
 while [[ $# -gt 0 ]]; do
@@ -41,6 +44,10 @@ while [[ $# -gt 0 ]]; do
             shift
             shift
             ;;
+        --dry-run)
+            DRY_RUN=true
+            shift
+            ;;
         -h|--help)
             help
             ;;
@@ -52,12 +59,12 @@ while [[ $# -gt 0 ]]; do
 done
 
 # Check if required arguments are provided
-if [ -z "${TARGET}" ]; then
+if [[ -z "${TARGET}" ]]; then
     echo "Missing required argument: --target"
     exit 1
 fi
 
-if [ -z "$VERSION" ]; then
+if [[ -z "$VERSION" ]]; then
     echo "Missing required argument: --version"
     exit 1
 fi
@@ -87,9 +94,13 @@ echo "{\"artifacts\": [{\"path\": \"dist/${ZIP_NAME}\"}]}" > dist-manifest.json
 echo "Build complete, contents of dist-manifest.json:"
 cat dist-manifest.json
 
-# Upload to release
-cat dist-manifest.json | jq --raw-output ".artifacts[]?.path | select( . != null )" > uploads.txt
-echo "uploading..."
-cat uploads.txt
-gh release upload ${VERSION} $(cat uploads.txt)
-echo "uploaded!"
+if [[ "$DRY_RUN" == true ]]; then
+    echo "ℹ️ Dry run, skipping release upload"
+else
+    # Upload to release
+    cat dist-manifest.json | jq --raw-output ".artifacts[]?.path | select( . != null )" > uploads.txt
+    echo "uploading..."
+    cat uploads.txt
+    gh release upload ${VERSION} $(cat uploads.txt)
+    echo "uploaded!"
+fi