swc for typescript transpiling

Author: mikea

compile_flags.txt

@@ -55,6 +55,7 @@
 -isystembazel-bin/src/rust/dns/_virtual_includes/dns@cxx
 -isystembazel-bin/src/rust/python-parser/_virtual_includes/python-parser@cxx
 -isystembazel-bin/src/rust/net/_virtual_includes/net@cxx
+-isystembazel-bin/src/rust/transpiler/_virtual_includes/transpiler@cxx
 -D_FORTIFY_SOURCE=1
 -D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES
 -D_LIBCPP_NO_ABI_TAG

samples/helloworld-ts/README.md

@@ -0,0 +1,7 @@
+# Hello World Typescript
+
+Workerd experimental feature is to transpile typescript to javascript on load time.
+This examples demonstrates how to use it.
+
+It is important to note that workerd does not validate types, but barely strips them away.
+The code must be syntactically correct, though.

samples/helloworld-ts/config.capnp

@@ -0,0 +1,14 @@
+using Workerd = import "/workerd/workerd.capnp";
+
+const helloWorldExample :Workerd.Config = (
+  services = [ (name = "main", worker = .helloWorld) ],
+  sockets = [ ( name = "http", address = "*:8080", http = (), service = "main" ) ]
+);
+
+const helloWorld :Workerd.Worker = (
+  modules = [
+    (name = "worker", esModule = embed "worker.ts")
+  ],
+  compatibilityDate = "2025-08-01",
+  compatibilityFlags = ["typescript_strip_types"]
+);

samples/helloworld-ts/worker.ts

@@ -0,0 +1,9 @@
+// Copyright (c) 2017-2023 Cloudflare, Inc.
+// Licensed under the Apache 2.0 license found in the LICENSE file or at:
+//     https://opensource.org/licenses/Apache-2.0
+
+export default {
+	async fetch(request, env, ctx): Promise<Response> {
+		return new Response('Hello World from Typescript!');
+	},
+} satisfies ExportedHandler<Env>;

src/rust/transpiler/BUILD

@@ -0,0 +1,13 @@
+load("//:build/wd_rust_crate.bzl", "wd_rust_crate")
+
+wd_rust_crate(
+    name = "transpiler",
+    cxx_bridge_src = "lib.rs",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//src/rust/cxx-integration",
+        "@crates_vendor//:swc_core",
+        "@crates_vendor//:swc_ts_fast_strip",
+        "@crates_vendor//:thiserror",
+    ],
+)

src/rust/transpiler/lib.rs

@@ -0,0 +1,164 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use swc_core::common::SourceMap;
+use swc_core::common::errors::DiagnosticBuilder;
+use swc_core::common::errors::Emitter;
+use swc_core::common::errors::HANDLER;
+use swc_core::common::errors::Handler;
+use swc_core::common::errors::Level;
+
+use crate::ffi::Output;
+
+#[cxx::bridge(namespace = "workerd::rust::transpiler")]
+mod ffi {
+    #[derive(Debug)]
+    struct Output {
+        success: bool,
+        // empty when error
+        code: String,
+        error: String,
+        diagnostics: Vec<Message>,
+    }
+
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    enum Level {
+        Error,
+        Warning,
+    }
+
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    struct Message {
+        level: Level,
+        message: String,
+    }
+    extern "Rust" {
+
+        /// Strip typescript types from the source code.
+        /// Other typescript constructs line enum will result in error `Output`.
+        fn ts_strip(filename: &str, src: &[u8]) -> Output;
+    }
+}
+
+fn ts_strip(filename: &str, src: &[u8]) -> Output {
+    tr_strip_string(filename, String::from_utf8_lossy(src).to_string())
+}
+
+fn tr_strip_string(filename: &str, src: String) -> Output {
+    let cm: Rc<SourceMap> = Rc::default();
+    let errors = Box::new(MessagesCollector::default());
+    let messages = errors.messages.clone();
+    let handler = Handler::with_emitter(false, false, errors);
+
+    let output = HANDLER.set(&handler, || {
+        swc_ts_fast_strip::operate(
+            &cm,
+            &handler,
+            src,
+            swc_ts_fast_strip::Options {
+                filename: Some(filename.to_owned()),
+                mode: swc_ts_fast_strip::Mode::StripOnly,
+                ..Default::default()
+            },
+        )
+    });
+
+    match output {
+        Ok(output) => Output {
+            success: true,
+            code: output.code,
+            error: String::new(),
+            diagnostics: messages.borrow().clone(),
+        },
+        Err(err) => Output {
+            success: false,
+            code: String::new(),
+            error: err.message,
+            diagnostics: messages.borrow().clone(),
+        },
+    }
+}
+
+/// Collects all swc emitted error message.
+#[derive(Default)]
+struct MessagesCollector {
+    messages: Rc<RefCell<Vec<ffi::Message>>>,
+}
+
+impl Emitter for MessagesCollector {
+    fn emit(&mut self, db: &mut DiagnosticBuilder<'_>) {
+        if db.is_error() {
+            self.messages.borrow_mut().push(ffi::Message {
+                level: ffi::Level::Error,
+                message: db.message(),
+            });
+        } else if db.level == Level::Warning {
+            self.messages.borrow_mut().push(ffi::Message {
+                level: ffi::Level::Warning,
+                message: db.message(),
+            });
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ffi::Output;
+    use crate::ffi::{self};
+    use crate::tr_strip_string;
+
+    fn tr(src: &str) -> Output {
+        tr_strip_string("foo.ts", src.to_owned())
+    }
+
+    #[test]
+    fn js() {
+        let out = tr("let x = 42;");
+        assert!(out.success);
+        assert_eq!("let x = 42;", out.code);
+        assert!(out.diagnostics.is_empty());
+    }
+
+    #[test]
+    fn ts() {
+        let out = tr("let x: Number = 42;");
+        assert!(out.success);
+        assert_eq!("let x         = 42;", out.code);
+        assert!(out.diagnostics.is_empty());
+    }
+
+    #[test]
+    fn worker() {
+        assert_eq!(
+            r"
+export default {
+    async fetch(request, env, ctx)                    {
+        return new Response('Hello World from Typescript!');
+    },
+}                               ;",
+            tr(r"
+export default {
+    async fetch(request, env, ctx): Promise<Response> {
+        return new Response('Hello World from Typescript!');
+    },
+} satisfies ExportedHandler<Env>;")
+            .code
+        );
+    }
+
+    #[test]
+    fn erase_enum() {
+        // only types are stripped, unsupported typescript construct are reported as errors
+        let out = tr(r"enum Foo { A,B,C }");
+        assert!(!out.success);
+        assert_eq!("", out.code);
+        assert_eq!("Unsupported syntax", out.error);
+        assert_eq!(
+            vec![ffi::Message {
+                level: ffi::Level::Error,
+                message: "TypeScript enum is not supported in strip-only mode".to_owned()
+            }],
+            out.diagnostics
+        );
+    }
+}

src/workerd/api/worker-loader.c++

@@ -165,6 +165,7 @@ Worker::Script::Source WorkerLoader::extractSource(jsg::Lock& js, WorkerCode& co
 
         return {.name = entry.name, .content = [&]() -> Worker::Script::ModuleContent {
           KJ_IF_SOME(js, module.js) {
+            // TODO: this might need typescript transpilation too.
             return Worker::Script::EsModule{.body = js};
           } else KJ_IF_SOME(cjs, module.cjs) {
             return Worker::Script::CommonJsModule{.body = cjs};

src/workerd/io/BUILD.bazel

@@ -104,6 +104,7 @@ wd_cc_library(
         ":supported-compatibility-date",
         ":trace",
         ":worker-interface",
+        "//src/rust/cxx-integration",
         "//src/workerd/api:analytics-engine_capnp",
         "//src/workerd/api:data-url",
         "//src/workerd/api:deferred-proxy",

src/workerd/io/compatibility-date.capnp

@@ -962,4 +962,11 @@ struct CompatibilityFlags @0x8f8c1b68151b6cef {
   # Enables the generation of dedicated snapshots on Python Worker upload. The snapshot will be
   # stored inside the resulting WorkerBundle of the Worker. The snapshot will be taken after the
   # top-level execution of the Worker.
+
+  typescriptStripTypes @111 :Bool
+    $compatEnableFlag("typescript_strip_types")
+    $experimental;
+  # Strips all Typescript types from loaded files.
+  # If loaded files contain unsupported typescript construct beyond type annotations (e.g. enums),
+  # or is not a syntactically valid Typescript, the worker will fail to load.
 }

src/workerd/io/worker-source.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <rust/cxx.h>
+
 #include <capnp/schema.capnp.h>
 #include <kj/one-of.h>
 #include <kj/refcount.h>
@@ -28,7 +30,9 @@ struct WorkerSource {
   // These structs are the variants of the `ModuleContent` `OneOf`, defining all the different
   // module types.
   struct EsModule {
-    kj::StringPtr body;
+    kj::ArrayPtr<const char> body;
+    // Owns the body text in case it was transpiled during the load.
+    kj::Maybe<::rust::String> ownBody;
   };
   struct CommonJsModule {
     kj::StringPtr body;