@temporalio/core-bridge 1.13.2 → 1.14.0

package/Cargo.lock

@@ -159,6 +159,31 @@ version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 
+[[package]]
+name = "bon"
+version = "3.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebeb9aaf9329dff6ceb65c689ca3db33dbf15f324909c60e4e5eef5701ce31b1"
+dependencies = [
+ "bon-macros",
+ "rustversion",
+]
+
+[[package]]
+name = "bon-macros"
+version = "3.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77e9d642a7e3a318e37c2c9427b5a6a48aa1ad55dcd986f3034ab2239045a645"
+dependencies = [
+ "darling 0.21.3",
+ "ident_case",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
 [[package]]
 name = "bridge-macros"
 version = "0.1.0"
@@ -287,8 +312,18 @@ version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
 dependencies = [
- "darling_core",
- "darling_macro",
+ "darling_core 0.20.11",
+ "darling_macro 0.20.11",
+]
+
+[[package]]
+name = "darling"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+dependencies = [
+ "darling_core 0.21.3",
+ "darling_macro 0.21.3",
 ]
 
 [[package]]
@@ -305,13 +340,38 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "darling_core"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn",
+]
+
 [[package]]
 name = "darling_macro"
 version = "0.20.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
- "darling_core",
+ "darling_core 0.20.11",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
+dependencies = [
+ "darling_core 0.21.3",
  "quote",
  "syn",
 ]
@@ -356,7 +416,7 @@ version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
 dependencies = [
- "darling",
+ "darling 0.20.11",
  "proc-macro2",
  "quote",
  "syn",
@@ -2048,29 +2108,6 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
-[[package]]
-name = "rustfsm"
-version = "0.1.0"
-dependencies = [
- "rustfsm_procmacro",
- "rustfsm_trait",
-]
-
-[[package]]
-name = "rustfsm_procmacro"
-version = "0.1.0"
-dependencies = [
- "derive_more",
- "proc-macro2",
- "quote",
- "rustfsm_trait",
- "syn",
-]
-
-[[package]]
-name = "rustfsm_trait"
-version = "0.1.0"
-
 [[package]]
 name = "rustix"
 version = "1.0.8"
@@ -2412,15 +2449,42 @@ dependencies = [
 ]
 
 [[package]]
-name = "temporal-client"
+name = "temporal-sdk-typescript-bridge"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "bridge-macros",
+ "futures",
+ "neon",
+ "opentelemetry",
+ "os_pipe",
+ "parking_lot",
+ "prost",
+ "prost-types",
+ "serde",
+ "serde_json",
+ "temporalio-client",
+ "temporalio-common",
+ "temporalio-sdk-core",
+ "thiserror 2.0.14",
+ "tokio",
+ "tokio-stream",
+ "tonic",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "temporalio-client"
 version = "0.1.0"
 dependencies = [
  "anyhow",
  "async-trait",
  "backoff",
  "base64",
+ "bon",
  "bytes",
- "derive_builder",
  "derive_more",
  "dyn-clone",
  "futures-retry",
@@ -2430,9 +2494,9 @@ dependencies = [
  "hyper",
  "hyper-util",
  "parking_lot",
+ "rand 0.9.2",
  "slotmap",
- "temporal-sdk-core-api",
- "temporal-sdk-core-protos",
+ "temporalio-common",
  "thiserror 2.0.14",
  "tokio",
  "tonic",
@@ -2443,7 +2507,43 @@ dependencies = [
 ]
 
 [[package]]
-name = "temporal-sdk-core"
+name = "temporalio-common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "base64",
+ "derive_builder",
+ "derive_more",
+ "opentelemetry",
+ "prost",
+ "prost-wkt",
+ "prost-wkt-types",
+ "rand 0.9.2",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.14",
+ "tonic",
+ "tonic-prost",
+ "tonic-prost-build",
+ "tracing",
+ "tracing-core",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "temporalio-macros"
+version = "0.1.0"
+dependencies = [
+ "derive_more",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "temporalio-sdk-core"
 version = "0.1.0"
 dependencies = [
  "anyhow",
@@ -2479,16 +2579,15 @@ dependencies = [
  "rand 0.9.2",
  "reqwest",
  "ringbuf",
- "rustfsm",
  "serde",
  "serde_json",
  "siphasher",
  "slotmap",
  "sysinfo",
  "tar",
- "temporal-client",
- "temporal-sdk-core-api",
- "temporal-sdk-core-protos",
+ "temporalio-client",
+ "temporalio-common",
+ "temporalio-macros",
  "thiserror 2.0.14",
  "tokio",
  "tokio-stream",
@@ -2501,70 +2600,6 @@ dependencies = [
  "zip",
 ]
 
-[[package]]
-name = "temporal-sdk-core-api"
-version = "0.1.0"
-dependencies = [
- "async-trait",
- "derive_builder",
- "derive_more",
- "opentelemetry",
- "prost",
- "serde_json",
- "temporal-sdk-core-protos",
- "thiserror 2.0.14",
- "tonic",
- "tracing",
- "tracing-core",
- "url",
-]
-
-[[package]]
-name = "temporal-sdk-core-protos"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "base64",
- "derive_more",
- "prost",
- "prost-wkt",
- "prost-wkt-types",
- "rand 0.9.2",
- "serde",
- "serde_json",
- "thiserror 2.0.14",
- "tonic",
- "tonic-prost",
- "tonic-prost-build",
- "uuid",
-]
-
-[[package]]
-name = "temporal-sdk-typescript-bridge"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "async-trait",
- "bridge-macros",
- "futures",
- "neon",
- "opentelemetry",
- "os_pipe",
- "parking_lot",
- "prost",
- "prost-types",
- "serde",
- "serde_json",
- "temporal-client",
- "temporal-sdk-core",
- "thiserror 2.0.14",
- "tokio",
- "tokio-stream",
- "tonic",
- "tracing",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "termtree"
 version = "0.5.1"

package/Cargo.toml

@@ -35,10 +35,11 @@ prost = "0.14"
 prost-types = "0.14"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-temporal-sdk-core = { version = "*", path = "./sdk-core/core", features = [
+temporalio-sdk-core = { version = "*", path = "./sdk-core/crates/sdk-core", features = [
   "ephemeral-server",
 ] }
-temporal-client = { version = "*", path = "./sdk-core/client" }
+temporalio-client = { version = "*", path = "./sdk-core/crates/client" }
+temporalio-common = { version = "*", path = "./sdk-core/crates/common" }
 thiserror = "2"
 tokio = "1.13"
 tokio-stream = "0.1"

package/{sdk-core/fsm/rustfsm_trait/LICENSE.txt → LICENSE}

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2021 Temporal Technologies, Inc. All Rights Reserved
+Copyright (c) 2021-2025 Temporal Technologies Inc. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -2,7 +2,6 @@
 
 [![NPM](https://img.shields.io/npm/v/@temporalio/core-bridge?style=for-the-badge)](https://www.npmjs.com/package/@temporalio/core-bridge)
 
-
 Part of [Temporal](https://temporal.io)'s [TypeScript SDK](https://docs.temporal.io/typescript/introduction/).
 
 > [!CAUTION]

package/bridge-macros/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "bridge-macros"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2.0", features = ["full", "extra-traits"] }
+quote = "1.0"
+proc-macro2 = "1.0"
+convert_case = "0.6"
+
+[dev-dependencies]
+temporal-sdk-typescript-bridge = { path = ".." }

package/bridge-macros/src/derive_js_function.rs

@@ -0,0 +1,126 @@
+use quote::format_ident;
+use quote::quote;
+use syn::GenericArgument;
+use syn::Pat;
+use syn::PathArguments;
+use syn::Type;
+use syn::{FnArg, ItemFn, PatType, ReturnType, parse_macro_input};
+
+pub fn js_function_impl(
+    _attr: proc_macro::TokenStream,
+    item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(item as ItemFn);
+
+    let vis = &input.vis;
+    let fn_name = &input.sig.ident;
+    let generics = &input.sig.generics; // Is this still pertinent?
+    let args = &input.sig.inputs;
+    let return_type = &input.sig.output; // Can we avoid in some cases?
+    let fn_block = &input.block;
+    let attrs = &input.attrs;
+
+    let fn_impl_name = format_ident!("{}_impl", fn_name);
+
+    // Extract function arguments
+    let args = args
+        .iter()
+        .filter_map(|arg| {
+            if let FnArg::Typed(PatType { pat, ty, .. }) = arg {
+                if let Pat::Ident(pat_ident) = &**pat {
+                    Some((pat_ident.ident.clone(), (*ty).clone()))
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+
+    // Extract return type
+    let (result_return_type, inner_return_type) = match return_type {
+        ReturnType::Type(_, ty) => match extract_bridge_result_type(ty) {
+            Some(inner_type) => (ty, inner_type),
+            None => panic!("Return type must be a BridgeResult"),
+        },
+        ReturnType::Default => panic!("Return type must be a BridgeResult"),
+    };
+
+    // Generate argument conversions
+    let arg_conversions = args.iter().enumerate().map(|(i, (name, ty))| {
+        quote! {
+            use crate::helpers::*;
+            let #name = cx.argument_into::<#ty>(#i).field(format!("fn {}", stringify!(#fn_name)).as_str()).into_throw(&mut cx)?;
+        }
+    });
+
+    // Generate implementation function arguments
+    let impl_args = args.iter().map(|(name, ty)| {
+        quote! { #name: #ty }
+    });
+
+    // Generate argument names for impl function call
+    let arg_names = args.iter().map(|(name, _)| quote! { #name });
+
+    let expanded = if args.is_empty() {
+        // No arguments case
+        quote! {
+            // Bridge function
+            #[allow(clippy::significant_drop_tightening, clippy::unnecessary_wraps)]
+            #vis fn #fn_name #generics(
+                mut cx: FunctionContext #generics
+            ) -> JsResult<<#inner_return_type as crate::helpers::TryIntoJs>::Output> {
+                let result = #fn_impl_name().into_throw(&mut cx)?;
+                result.try_into_js(&mut cx)
+            }
+
+            // Implementation function
+            #(#attrs)*
+            #[allow(clippy::unnecessary_wraps)]
+            #vis fn #fn_impl_name #generics() -> #result_return_type {
+                #fn_block
+            }
+        }
+    } else {
+        // With arguments case
+        quote! {
+            // Bridge function
+            #[allow(clippy::significant_drop_tightening, clippy::unnecessary_wraps)]
+            #vis fn #fn_name #generics(
+                mut cx: FunctionContext #generics
+            ) -> JsResult<<#inner_return_type as crate::helpers::TryIntoJs>::Output> {
+                #(#arg_conversions)*
+
+                let result = #fn_impl_name(#(#arg_names),*).into_throw(&mut cx)?;
+                result.try_into_js(&mut cx)
+            }
+
+            // Implementation function
+            #(#attrs)*
+            #[allow(clippy::unnecessary_wraps)]
+            #vis fn #fn_impl_name #generics(#(#impl_args),*) -> #result_return_type {
+                #fn_block
+            }
+        }
+    };
+
+    proc_macro::TokenStream::from(expanded)
+}
+
+fn extract_bridge_result_type(ty: &Type) -> Option<&Type> {
+    if let Type::Path(type_path) = ty {
+        if let Some(last_segment) = type_path.path.segments.last() {
+            // Check if it's BridgeResult
+            if last_segment.ident == "BridgeResult" {
+                // Extract the type parameter T from BridgeResult<T>
+                if let PathArguments::AngleBracketed(generic_args) = &last_segment.arguments {
+                    if let Some(GenericArgument::Type(inner_type)) = generic_args.args.first() {
+                        return Some(inner_type);
+                    }
+                }
+            }
+        }
+    }
+    None
+}

package/bridge-macros/src/derive_tryfromjs.rs

@@ -0,0 +1,138 @@
+use convert_case::{Case, Casing};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DeriveInput, FieldsNamed, FieldsUnnamed};
+
+pub fn derive_tryfromjs_struct(input: &DeriveInput, data: &syn::DataStruct) -> TokenStream {
+    let struct_ident = &input.ident;
+    let generics = &input.generics;
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    let field_conversions = if let syn::Fields::Named(ref fields) = data.fields {
+        field_conversions_for_named_fields(fields)
+    } else {
+        panic!("Only named fields are supported")
+    };
+
+    let expanded = quote! {
+        impl #impl_generics crate::helpers::TryFromJs for #struct_ident #ty_generics #where_clause {
+            fn try_from_js<'cx, 'b>(cx: &mut impl neon::prelude::Context<'cx>, js_value: neon::prelude::Handle<'b, neon::prelude::JsValue>) -> crate::helpers::BridgeResult<Self> {
+                use crate::helpers::*;
+
+                let obj = js_value.downcast::<neon::prelude::JsObject, _>(cx)?;
+                Ok(Self {
+                    #(#field_conversions),*
+                })
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+pub fn derive_tryfromjs_enum(input: &DeriveInput, data: &syn::DataEnum) -> TokenStream {
+    let enum_ident = &input.ident;
+    let enum_name = enum_ident.to_string();
+    let variants = &data.variants;
+    let generics = &input.generics;
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    let variant_conversions = variants.iter().map(|v| {
+        let variant_ident = &v.ident;
+        let discriminant = variant_ident.to_string().to_case(Case::Kebab);
+        let js_discriminant = variant_ident.to_string().to_case(Case::Camel);
+
+        match &v.fields {
+            syn::Fields::Unit => {
+                // e.g. "otel" => Ok(MetricsExporter::Otel)
+                quote! {
+                    #discriminant => Ok(#enum_ident::#variant_ident),
+                }
+            }
+            syn::Fields::Unnamed(FieldsUnnamed { unnamed, .. }) => {
+                if unnamed.len() != 1 {
+                    panic!("Enum variant must have a single unnamed field that implements the TryFromJs trait");
+                }
+                let ty = unnamed.first().map(|f| f.ty.clone()).unwrap();
+                match ty {
+                    syn::Type::Path(path) => {
+                        // Example output:
+                        //
+                        // "otel" => {
+                        //    <OtelConfig>::try_from_js(cx, js_value).field("otel").map(MetricsExporter::Otel)
+                        // }
+                        quote! {
+                            #discriminant => {
+                                <#path>::try_from_js(cx, js_value).field(&#js_discriminant).map(#enum_ident::#variant_ident)
+                            },
+                        }
+                    },
+                    _ => panic!("Enum variant must have a single unnamed field that implements the TryFromJs trait"),
+                }
+            }
+            syn::Fields::Named(fields) => {
+                // Example output:
+                //
+                //   "console" => Ok((|| {
+                //       Ok::<LogExporter, BridgeError>(LogExporter::Console {
+                //           filter: { obj.get_property_into(cx, "filter")? },
+                //       })
+                //   })()
+                //   .field(format!("type={}", type_str).as_str())?),
+                //
+                // The inner closure is required so that we can use the `field` method on the result.
+                // An alternative would be to do that at the field level, but then that concern would
+                // spill into the field_conversions_for_named_fields function, which is used in
+                // other places.
+                let field_conversions = field_conversions_for_named_fields(fields);
+                quote! {
+                    #discriminant => Ok(( || {
+                        Ok::<#enum_ident #ty_generics, crate::helpers::BridgeError>(#enum_ident::#variant_ident {
+                            #(#field_conversions),*
+                        })
+                    })()
+                    .field(&#js_discriminant)?),
+                }
+            }
+        }
+    });
+
+    let expanded = quote! {
+        impl #impl_generics crate::helpers::TryFromJs for #enum_ident #ty_generics #where_clause {
+            fn try_from_js<'cx, 'b>(cx: &mut impl neon::prelude::Context<'cx>, js_value: neon::prelude::Handle<'b, neon::prelude::JsValue>) -> crate::helpers::BridgeResult<Self> {
+                use crate::helpers::*;
+
+                let obj = js_value.downcast::<neon::prelude::JsObject, _>(cx)?;
+                let type_str: String = obj.get_property_into(cx, "type")?;
+
+                match type_str.as_str() {
+                    #(#variant_conversions)*
+                    _ => Err(crate::helpers::BridgeError::InvalidVariant {
+                        enum_name: #enum_name.to_string(),
+                        variant: type_str,
+                    }),
+                }
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+fn field_conversions_for_named_fields(
+    fields: &FieldsNamed,
+) -> impl Iterator<Item = TokenStream> + '_ {
+    fields.named.iter().map(|f| {
+        let field_ident = f
+            .ident
+            .as_ref()
+            .expect("FieldsNamed.named must have an identifier");
+        let js_name = field_ident.to_string().to_case(Case::Camel);
+
+        quote! {
+            #field_ident: {
+                obj.get_property_into(cx, #js_name)?
+            }
+        }
+    })
+}