@temporalio/core-bridge 1.13.2 → 1.14.0

package/bridge-macros/src/derive_tryintojs.rs

@@ -0,0 +1,151 @@
+use convert_case::{Case, Casing};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DeriveInput, FieldsNamed};
+
+pub fn derive_tryintojs_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::TryIntoJs for #struct_ident #ty_generics #where_clause {
+            type Output = neon::types::JsObject;
+
+            fn try_into_js<'a>(self, cx: &mut impl neon::prelude::Context<'a>) -> neon::result::JsResult<'a, Self::Output> {
+                let obj = cx.empty_object();
+                #(#field_conversions)*
+                Ok(obj)
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+pub fn derive_tryintojs_enum(input: &DeriveInput, data: &syn::DataEnum) -> TokenStream {
+    let enum_ident = &input.ident;
+    let generics = &input.generics;
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    let variant_conversions = data.variants.iter().map(|v| {
+        let variant_ident = &v.ident;
+        let js_discriminant = variant_ident.to_string().to_case(Case::Camel);
+
+        match &v.fields {
+            syn::Fields::Unit => {
+                quote! {
+                    #enum_ident::#variant_ident => {
+                        let obj = cx.empty_object();
+                        let type_str = cx.string(#js_discriminant);
+                        obj.set(cx, "type", type_str)?;
+                        obj
+                    }
+                }
+            }
+            syn::Fields::Unnamed(fields) => {
+                if fields.unnamed.len() != 1 {
+                    panic!("Enum variants with unnamed fields must have exactly one field");
+                }
+
+                quote! {
+                    #enum_ident::#variant_ident(inner) => {
+                        let obj = cx.empty_object();
+                        let type_str = cx.string(#js_discriminant);
+                        obj.set(cx, "type", type_str)?;
+
+                        let inner_js = inner.try_into_js(cx)?;
+                        if inner_js.is_a::<neon::types::JsObject, _>(cx) {
+                            // If inner is a JsObject, copy its properties to our object
+                            let inner_obj = inner_js.downcast::<neon::types::JsObject, _>(cx).unwrap();
+                            let prop_names = inner_obj.get_own_property_names(cx)?.to_vec(cx)?;
+
+                            for key_handle in prop_names {
+                                let value = inner_obj.get_value(cx, key_handle)?;
+                                obj.set(cx, key_handle, value)?;
+                            }
+                        }
+
+                        obj
+                    }
+                }
+            }
+            syn::Fields::Named(fields) => {
+                let field_names = fields.named.iter().map(|f| {
+                    let field_ident = &f.ident;
+                    let js_name = field_ident.as_ref().unwrap().to_string().to_case(Case::Camel);
+                    (field_ident, js_name)
+                });
+
+                let pattern_fields = field_names.clone().map(|(field_ident, _)| {
+                    quote! { #field_ident }
+                });
+
+                let field_sets = field_names.map(|(field_ident, js_name)| {
+                    quote! {
+                        let js_value = #field_ident.try_into_js(cx)?;
+                        obj.set(cx, #js_name, js_value)?;
+                    }
+                });
+
+                quote! {
+                    #enum_ident::#variant_ident { #(#pattern_fields),* } => {
+                        let obj = cx.empty_object();
+                        let type_str = cx.string(#js_discriminant);
+                        obj.set(cx, "type", type_str)?;
+
+                        #(#field_sets)*
+
+                        obj
+                    }
+                }
+            }
+        }
+    });
+
+    let expanded = quote! {
+        impl #impl_generics crate::helpers::TryIntoJs for #enum_ident #ty_generics #where_clause {
+            type Output = neon::types::JsObject;
+
+            fn try_into_js<'a>(self, cx: &mut impl neon::prelude::Context<'a>) -> neon::result::JsResult<'a, Self::Output> {
+                Ok(match self {
+                    #(#variant_conversions),*
+                })
+            }
+        }
+    };
+
+    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);
+
+        // Ignore PhantomData fields
+        if let syn::Type::Path(path) = &f.ty {
+            if let Some(segment) = path.path.segments.last() {
+                if segment.ident == "PhantomData" {
+                    return quote! {};
+                }
+            }
+        }
+
+        quote! {
+            let js_value = self.#field_ident.try_into_js(cx)?;
+            obj.set(cx, #js_name, js_value)?;
+        }
+    })
+}

package/bridge-macros/src/lib.rs

@@ -0,0 +1,42 @@
+mod derive_js_function;
+mod derive_tryfromjs;
+mod derive_tryintojs;
+
+use derive_js_function::js_function_impl;
+use derive_tryfromjs::{derive_tryfromjs_enum, derive_tryfromjs_struct};
+use derive_tryintojs::{derive_tryintojs_enum, derive_tryintojs_struct};
+use proc_macro::TokenStream;
+use syn::{DeriveInput, parse_macro_input};
+
+/// Procedural macro for defining bridge types with compile-time field name conversion
+///
+/// Note that enum types must all be defined on the JS side as objects with a `type` field which
+/// is the kebab-case representation of the enum variant.
+#[proc_macro_derive(TryFromJs)]
+pub fn try_from_js(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    match &input.data {
+        syn::Data::Struct(data) => derive_tryfromjs_struct(&input, data).into(),
+        syn::Data::Enum(data) => derive_tryfromjs_enum(&input, data).into(),
+        syn::Data::Union(_) => panic!("Unions are not supported"),
+    }
+}
+
+/// Procedural macro for defining bridge types with compile-time field name conversion
+#[proc_macro_derive(TryIntoJs)]
+pub fn try_into_js(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    match &input.data {
+        syn::Data::Struct(data) => derive_tryintojs_struct(&input, data).into(),
+        syn::Data::Enum(data) => derive_tryintojs_enum(&input, data).into(),
+        syn::Data::Union(_) => panic!("Unions are not supported"),
+    }
+}
+
+/// Generates a function that can be called from JavaScript with the given name
+#[proc_macro_attribute]
+pub fn js_function(attr: TokenStream, input: TokenStream) -> TokenStream {
+    js_function_impl(attr, input)
+}

package/lib/native.d.ts

@@ -34,7 +34,7 @@ type Option<T> = T | null;
  * Marker for values that are transferred as JSON strings.
  */
 export type JsonString<_T> = string;
-export declare function newRuntime(telemOptions: RuntimeOptions): Runtime;
+export declare function newRuntime(runtimeOptions: RuntimeOptions): Runtime;
 export declare function runtimeShutdown(runtime: Runtime): void;
 export interface Runtime {
     type: 'runtime';
@@ -43,6 +43,7 @@ export type RuntimeOptions = {
     logExporter: LogExporterOptions;
     telemetry: TelemetryOptions;
     metricsExporter: MetricExporterOptions;
+    workerHeartbeatIntervalMillis: Option<number>;
 };
 export type TelemetryOptions = {
     attachServiceName: boolean;
@@ -92,18 +93,18 @@ export interface ClientOptions {
     targetUrl: string;
     clientName: string;
     clientVersion: string;
-    tls: Option<TLSConfig>;
+    tls: Option<TlsOptions>;
     httpConnectProxy: Option<HttpConnectProxy>;
     headers: Option<Record<string, MetadataValue>>;
     apiKey: Option<string>;
     disableErrorCodeMetricTags: boolean;
 }
-export interface TLSConfig {
+export interface TlsOptions {
     domain: Option<string>;
     serverRootCaCert: Option<Buffer>;
-    clientTlsConfig: Option<TlsConfigClientCertPair>;
+    clientTlsOptions: Option<TlsOptionsClientCertPair>;
 }
-export interface TlsConfigClientCertPair {
+export interface TlsOptionsClientCertPair {
     clientCert: Buffer;
     clientPrivateKey: Buffer;
 }
@@ -158,7 +159,12 @@ export interface WorkerOptions {
     workflowTaskPollerBehavior: PollerBehavior;
     activityTaskPollerBehavior: PollerBehavior;
     nexusTaskPollerBehavior: PollerBehavior;
-    enableNonLocalActivities: boolean;
+    taskTypes: {
+        enableWorkflows: boolean;
+        enableLocalActivities: boolean;
+        enableRemoteActivities: boolean;
+        enableNexus: boolean;
+    };
     stickyQueueScheduleToStartTimeout: number;
     maxCachedWorkflows: number;
     maxHeartbeatThrottleInterval: number;
@@ -166,6 +172,7 @@ export interface WorkerOptions {
     maxTaskQueueActivitiesPerSecond: Option<number>;
     maxActivitiesPerSecond: Option<number>;
     shutdownGraceTime: number;
+    plugins: string[];
 }
 export type PollerBehavior = {
     type: 'simple-maximum';

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.13.2",
+  "version": "1.14.0",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "lib/index.d.ts",
   "scripts": {
     "build-rust": "node ./scripts/build.js --force",
-    "build": "npm run build-rust",
-    "build-rust-release": "npm run build-rust -- --release",
+    "build": "pnpm run build-rust",
+    "build-rust-release": "pnpm run build-rust --release",
     "install": "node ./scripts/build.js",
     "format": "cargo fmt",
     "lint": "cargo clippy --fix --allow-staged",
@@ -23,7 +23,7 @@
   "license": "MIT",
   "dependencies": {
     "@grpc/grpc-js": "^1.12.4",
-    "@temporalio/common": "1.13.2",
+    "@temporalio/common": "1.14.0",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.8",
     "which": "^4.0.0"
@@ -41,6 +41,7 @@
     "node": ">= 18.0.0"
   },
   "files": [
+    "bridge-macros",
     "scripts",
     "src",
     "releases",
@@ -56,5 +57,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cccc54c72f85377ac520b5d6cdd9a9a847027c27"
+  "gitHead": "eb428ac36568b48be67fdba662c38631867b932d"
 }

package/sdk-core/.cargo/config.toml

@@ -1,19 +1,19 @@
 [env]
 # This temporarily overrides the version of the CLI used for integration tests, locally and in CI
-CLI_VERSION_OVERRIDE = "v1.4.1-cloud-v1-29-0-139-2.0"
+#CLI_VERSION_OVERRIDE = "v1.4.1-cloud-v1-29-0-139-2.0"
 
 [alias]
 # Not sure why --all-features doesn't work
 integ-test = [
     "test",
     "--features",
-    "temporal-sdk-core-protos/serde_serialize",
+    "temporalio-common/serde_serialize",
     "--features",
     "test-utilities",
     "--features",
     "ephemeral-server",
     "--package",
-    "temporal-sdk-core",
+    "temporalio-sdk-core",
     "--test",
     "integ_runner",
     "--",
@@ -50,6 +50,12 @@ lint-fix = [
     "heavy_tests",
     "--test",
     "manual_tests",
+    "--test",
+    "cloud_tests",
+    "--test",
+    "integ_runner",
+    "--test",
+    "global_metric_tests",
     "--fix",
     "--allow-dirty",
 ]

package/sdk-core/.github/workflows/per-pr.yml

@@ -6,6 +6,10 @@ on: # rebuild any PRs and main branch changes
     branches:
       - master
 
+permissions:
+  contents: read
+  actions: write
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
@@ -32,6 +36,8 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - run: cargo fmt --all --check
       - run: cargo doc --workspace --all-features --no-deps
+        env:
+          RUSTDOCFLAGS: "-D warnings"
       - run: cargo lint
       - run: cargo test-lint
       - run: cargo check
@@ -39,7 +45,7 @@ jobs:
 
   test:
     name: Unit Tests
-    timeout-minutes: 10
+    timeout-minutes: 15
     strategy:
       fail-fast: false
       matrix:
@@ -76,6 +82,18 @@ jobs:
             core.exportVariable('RUSTFLAGS', '-Csymbol-mangling-version=v0');
       - uses: Swatinem/rust-cache@v2
       - run: cargo test -- --include-ignored --nocapture
+      - name: Find test executable for cgroup tests
+        id: find-cgroup-test
+        if: runner.os == 'Linux' && runner.arch == 'X64'
+        run: |
+          test_executable=$(cargo build --tests --message-format json | jq -r 'select(.profile?.test == true and .target?.name == "temporalio_sdk_core" and .executable) | .executable')
+          cp $test_executable ./core-tests
+      - name: Upload cgroup test executable
+        uses: actions/upload-artifact@v4
+        if: runner.os == 'Linux' && runner.arch == 'X64'
+        with:
+          name: cgroup-tests-linux-x86_64
+          path: ./core-tests
       - uses: actions/upload-artifact@v4
         with:
           name: coverage-report
@@ -85,9 +103,28 @@ jobs:
           name: state-machine-coverage
           path: machine_coverage/
 
+  cgroup-tests:
+    name: cgroup tests
+    needs: test
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu
+      options: --cpus=1 --memory=512m
+    env:
+      CGROUP_TESTS_ENABLED: true
+    steps:
+      - name: Download cgroup test executable
+        uses: actions/download-artifact@v5
+        with:
+          name: cgroup-tests-linux-x86_64
+      - name: Run tests
+        run: |
+          chmod +x ./core-tests
+          ./core-tests cgroup_ --nocapture
+
   integ-tests:
     name: Integ tests
-    timeout-minutes: 20
+    timeout-minutes: 25
     strategy:
       fail-fast: false
       matrix:
@@ -174,7 +211,7 @@ jobs:
       - name: Start container for otel-collector and prometheus
         uses: hoverkraft-tech/compose-action@v2.0.1
         with:
-          compose-file: ./docker/docker-compose-ci.yaml
+          compose-file: ./etc/docker/docker-compose-ci.yaml
       - uses: Swatinem/rust-cache@v2
       - run: cargo integ-test docker_
 
@@ -194,10 +231,10 @@ jobs:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build crate as static library
-        run: cargo rustc --package temporal-sdk-core-c-bridge --features xz2-static -- --crate-type=staticlib
+        run: cargo rustc --package temporalio-sdk-core-c-bridge --features xz2-static -- --crate-type=staticlib
 
       - name: Build C test program
-        run: gcc -I./core-c-bridge/include tests/c_bridge_smoke_test.c target/debug/deps/libtemporal_sdk_core_c_bridge.a -lpthread -ldl -lm -o test
+        run: gcc -I./crates/sdk-core-c-bridge/include crates/sdk-core/tests/c_bridge_smoke_test.c target/debug/deps/libtemporalio_sdk_core_c_bridge.a -lpthread -ldl -lm -o test
 
       - name: Run C test program
         run: ./test

package/sdk-core/AGENTS.md

@@ -5,15 +5,15 @@ document as your quick reference when submitting pull requests.
 
 ## Where Things Are
 
-- `core/` – implementation of the core SDK
-- `client/` – clients for communicating with Temporal clusters
-- `core-api/` – API definitions exposed by core
-- `core-c-bridge/` – C interface for core
-- `sdk/` – pre-alpha Rust SDK built on top of core (used mainly for tests)
-- `sdk-core-protos/` – protobuf definitions shared across crates
-- `fsm/` – state machine implementation and macros
-- `test-utils/` – helpers and binaries for tests
-- `tests/` – integration, heavy, and manual tests
+- `crates` - All crates in the workspace.
+  - `crates/core/` – implementation of the core SDK
+  - `crates/client/` – clients for communicating with Temporal clusters
+  - `crates/core-api/` – API definitions exposed by core
+  - `crates/core-c-bridge/` – C interface for core
+  - `crates/sdk/` – pre-alpha Rust SDK built on top of core (used mainly for tests)
+  - `crates/sdk-core-protos/` – protobuf definitions shared across crates
+  - `crates/fsm/` – state machine implementation and macros
+  - `crates/core/tests/` – integration, heavy, and manual tests
 - `arch_docs/` – architectural design documents
 - Contributor guide: `README.md`
 - `target/` - This contains compiled files. You never need to look in here.
@@ -21,13 +21,11 @@ document as your quick reference when submitting pull requests.
 ## Repo Specific Utilities
 
 - `.cargo/config.toml` defines useful cargo aliases:
-    - `cargo lint` – run clippy on workspace crates
-    - `cargo test-lint` – run clippy on tests
-    - `cargo integ-test` – run the integration test runner
-- `cargo-tokio-console.sh` – run any cargo command with the `tokio-console` feature
-- `integ-with-otel.sh` – run integration tests with OpenTelemetry enabled
-- `.cargo/multi-worker-manual-test` – helper script for spawning multiple workers during manual
-  testing
+  - `cargo lint` – run clippy on workspace crates
+  - `cargo test-lint` – run clippy on tests
+  - `cargo integ-test` – run the integration test runner
+- `etc` - Various helper scripts and configuration
+  - `etc/docker` - Docker compose files to help with CI or more complex local testing
 
 ## Building and Testing
 
@@ -75,6 +73,6 @@ Reviewers will look for:
 ## Notes
 
 - Fetch workflow histories with `cargo run --bin histfetch <workflow_id> [run_id]` (binary lives in
-  `test-utils`).
-- Protobuf files under `sdk-core-protos/protos/api_upstream` are a git subtree; see `README.md` for
-  update instructions.
+  `crates/core/src/histfetch.rs`).
+- Protobuf files under `crates/sdk-core-protos/protos/api_upstream` are a git subtree; see
+  `README.md` for update instructions.

package/sdk-core/Cargo.toml

@@ -1,12 +1,11 @@
 [workspace]
 members = [
-    "core",
-    "client",
-    "core-api",
-    "fsm",
-    "sdk-core-protos",
-    "sdk",
-    "core-c-bridge",
+    "crates/sdk-core",
+    "crates/client",
+    "crates/common",
+    "crates/macros",
+    "crates/sdk",
+    "crates/sdk-core-c-bridge",
 ]
 resolver = "2"
 

package/sdk-core/README.md

@@ -26,18 +26,16 @@ installed to build Core.
 
 This repo is composed of multiple crates:
 
-- temporal-sdk-core-protos `./sdk-core-protos` - Holds the generated proto code and extensions.
-- temporal-client `./client` - Defines client(s) for interacting with the Temporal gRPC service.
-- temporal-sdk-core-api `./core-api` - Defines the API surface exposed by Core.
-- temporal-sdk-core `./core` - The Core implementation.
-- temporal-sdk-core-c-bridge `./core-c-bridge` - Provides C bindings for Core.
-- temporal-sdk `./sdk` - A (currently prototype) Rust SDK built on top of Core. Used for testing.
-- rustfsm `./fsm` - Implements a procedural macro used by core for defining state machines
-  (contains subcrates). It is Temporal-agnostic.
+- temporalio-client `./crates/client` - Defines client(s) for interacting with the Temporal gRPC service.
+- temporalio-common `./crates/common` - Common code & protobuf definitions
+- temporalio-sdk-core `./crates/core` - The Core implementation.
+- temporalio-sdk-core-c-bridge `./crates/core-c-bridge` - Provides C bindings for Core.
+- temporalio-macros `./crates/macros` - Implements procedural macros used by core and the SDK.
+- temporalio-sdk `./crates/sdk` - A (currently prototype) Rust SDK built on top of Core. Used for testing.
 
 Visualized (dev dependencies are in blue):
 
-![Crate dependency graph](./etc/deps.svg)
+![Crate dependency graph](./arch_docs/diagrams/deps.svg)
 
 All the following commands are enforced for each pull request:
 
@@ -64,8 +62,8 @@ To format all code run:
 ## Linting
 
 We are using [clippy](https://github.com/rust-lang/rust-clippy) for linting.
-You can run it using:
-`cargo clippy --all -- -D warnings`
+We have a couple aliases for linting that make sure various targets are hit:
+`cargo lint` and `cargo test-lint`.
 
 ## Debugging
 
@@ -79,10 +77,10 @@ crate::telemetry::telemetry_init_fallback();
 
 The passed in options to initialization can be customized to export to an OTel collector, etc.
 
-To run integ tests with OTel collection on, you can use `integ-with-otel.sh`. You will want to make
-sure you are running the collector via docker, which can be done like so:
+To run integ tests with OTel collection on, you can use `etc/integ-with-otel.sh`. You will want to
+make sure you are running the collector via docker, which can be done like so:
 
-`docker-compose -f docker/docker-compose.yaml -f docker/docker-compose-telem.yaml up`
+`docker-compose -f etc/docker/docker-compose.yaml -f etc/docker/docker-compose-telem.yaml up`
 
 If you are working on a language SDK, you are expected to initialize tracing early in your `main`
 equivalent.
@@ -137,4 +135,3 @@ pre-alpha in terms of its API surface. Since it's still using Core underneath, i
 functional. We do not currently have any firm plans to productionize this SDK. If you want to write
 workflows and activities in Rust, feel free to use it - but be aware that the API may change at any
 time without warning and we do not provide any support guarantees.
-