@temporalio/core-bridge 1.5.2 → 1.7.0

package/sdk-core/fsm/rustfsm_procmacro/src/lib.rs

@@ -64,21 +64,21 @@ use syn::{
 /// }
 ///
 /// impl Locked {
-///     fn on_card_readable(&self, shared_dat: SharedState, data: CardData)
+///     fn on_card_readable(&self, shared_dat: &mut SharedState, data: CardData)
 ///       -> CardReaderTransition<ReadingCardOrLocked> {
-///         match shared_dat.last_id {
+///         match &shared_dat.last_id {
 ///             // Arbitrarily deny the same person entering twice in a row
-///             Some(d) if d == data => TransitionResult::ok(vec![], Locked {}.into()),
+///             Some(d) if d == &data => TransitionResult::ok(vec![], Locked {}.into()),
 ///             _ => {
 ///                 // Otherwise issue a processing command. This illustrates using the same handler
 ///                 // for different destinations
-///                 TransitionResult::ok_shared(
+///                 shared_dat.last_id = Some(data.clone());
+///                 TransitionResult::ok(
 ///                     vec![
 ///                         Commands::ProcessData(data.clone()),
 ///                         Commands::StartBlinkingLight,
 ///                     ],
-///                     ReadingCard { card_data: data.clone() }.into(),
-///                     SharedState { last_id: Some(data) }
+///                     ReadingCard { card_data: data }.into(),
 ///                 )
 ///             }
 ///         }
@@ -96,19 +96,19 @@ use syn::{
 ///
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// let crs = CardReaderState::Locked(Locked {});
-/// let mut cr = CardReader { state: crs, shared_state: SharedState { last_id: None } };
-/// let cmds = cr.on_event_mut(CardReaderEvents::CardReadable("badguy".to_string()))?;
+/// let mut cr = CardReader::from_parts(crs, SharedState { last_id: None });
+/// let cmds = cr.on_event(CardReaderEvents::CardReadable("badguy".to_string()))?;
 /// assert_eq!(cmds[0], Commands::ProcessData("badguy".to_string()));
 /// assert_eq!(cmds[1], Commands::StartBlinkingLight);
 ///
-/// let cmds = cr.on_event_mut(CardReaderEvents::CardRejected)?;
+/// let cmds = cr.on_event(CardReaderEvents::CardRejected)?;
 /// assert_eq!(cmds[0], Commands::StopBlinkingLight);
 ///
-/// let cmds = cr.on_event_mut(CardReaderEvents::CardReadable("goodguy".to_string()))?;
+/// let cmds = cr.on_event(CardReaderEvents::CardReadable("goodguy".to_string()))?;
 /// assert_eq!(cmds[0], Commands::ProcessData("goodguy".to_string()));
 /// assert_eq!(cmds[1], Commands::StartBlinkingLight);
 ///
-/// let cmds = cr.on_event_mut(CardReaderEvents::CardAccepted)?;
+/// let cmds = cr.on_event(CardReaderEvents::CardAccepted)?;
 /// assert_eq!(cmds[0], Commands::StopBlinkingLight);
 /// # Ok(())
 /// # }
@@ -132,17 +132,17 @@ use syn::{
 /// The macro will generate a few things:
 /// * A struct for the overall state machine, named with the provided name. Here:
 ///   ```text
-///   struct CardMachine {
-///       state: CardMachineState,
-///       shared_state: CardId,
+///   struct CardReader {
+///       state: CardReaderState,
+///       shared_state: SharedState,
 ///   }
 ///   ```
 /// * An enum with a variant for each state, named with the provided name + "State".
 ///   ```text
-///   enum CardMachineState {
+///   enum CardReaderState {
 ///       Locked(Locked),
 ///       ReadingCard(ReadingCard),
-///       Unlocked(Unlocked),
+///       DoorOpen(DoorOpen),
 ///   }
 ///   ```
 ///
@@ -154,15 +154,18 @@ use syn::{
 /// * An enum with a variant for each event. You are expected to define the type (if any) contained
 ///   in the event variant.
 ///   ```text
-///   enum CardMachineEvents {
-///     CardReadable(CardData)
+///   enum CardReaderEvents {
+///     DoorClosed,
+///     CardAccepted,
+///     CardRejected,
+///     CardReadable(CardData),
 ///   }
 ///   ```
 /// * An implementation of the [StateMachine](trait.StateMachine.html) trait for the generated state
-///   machine enum (in this case, `CardMachine`)
+///   machine enum (in this case, `CardReader`)
 /// * A type alias for a [TransitionResult](enum.TransitionResult.html) with the appropriate generic
 ///   parameters set for your machine. It is named as your machine with `Transition` appended. In
-///   this case, `CardMachineTransition`.
+///   this case, `CardReaderTransition`.
 #[proc_macro]
 pub fn fsm(input: TokenStream) -> TokenStream {
     let def: StateMachineDefinition = parse_macro_input!(input as StateMachineDefinition);
@@ -217,7 +220,7 @@ impl Parse for StateMachineDefinition {
         // not ideal.
         let trans_set: HashSet<_> = transitions.iter().collect();
         if trans_set.len() != transitions.len() {
-            return Err(syn::Error::new(
+            return Err(Error::new(
                 input.span(),
                 "Duplicate transitions are not allowed!",
             ));
@@ -346,12 +349,12 @@ impl StateMachineDefinition {
         let name = &self.name;
         let name_str = &self.name.to_string();
 
-        let transition_result_name = Ident::new(&format!("{}Transition", name), name.span());
+        let transition_result_name = Ident::new(&format!("{name}Transition"), name.span());
         let transition_type_alias = quote! {
             type #transition_result_name<Ds, Sm = #name> = TransitionResult<Sm, Ds>;
         };
 
-        let state_enum_name = Ident::new(&format!("{}State", name), name.span());
+        let state_enum_name = Ident::new(&format!("{name}State"), name.span());
         // If user has not defined any shared state, use the unit type.
         let shared_state_type = self
             .shared_state_type
@@ -360,7 +363,7 @@ impl StateMachineDefinition {
         let machine_struct = quote! {
             #[derive(Clone)]
             #visibility struct #name {
-                state: #state_enum_name,
+                state: ::core::option::Option<#state_enum_name>,
                 shared_state: #shared_state_type
             }
         };
@@ -390,7 +393,7 @@ impl StateMachineDefinition {
 
         // Build the events enum
         let events: HashSet<Variant> = self.transitions.iter().map(|t| t.event.clone()).collect();
-        let events_enum_name = Ident::new(&format!("{}Events", name), name.span());
+        let events_enum_name = Ident::new(&format!("{name}Events"), name.span());
         let events: Vec<_> = events
             .into_iter()
             .map(|v| {
@@ -424,8 +427,18 @@ impl StateMachineDefinition {
                 statemap.insert(s.clone(), vec![]);
             }
         }
+        let transition_result_transform = quote! {
+            match res.into_cmd_result() {
+                Ok((cmds, state)) => {
+                    self.state = Some(state);
+                    Ok(cmds)
+                }
+                Err(e) => Err(e)
+            }
+        };
         let mut multi_dest_enums = vec![];
         let state_branches: Vec<_> = statemap.into_iter().map(|(from, transitions)| {
+            let occupied_current_state = quote! { Some(#state_enum_name::#from(state_data)) };
             // Merge transition dest states with the same handler
             let transitions = merge_transition_dests(transitions);
             let event_branches = transitions
@@ -467,27 +480,27 @@ impl StateMachineDefinition {
                         match ts.event.fields {
                             Fields::Unnamed(_) => {
                                 let arglist = if ts.mutates_shared {
-                                    quote! {self.shared_state, val}
+                                    quote! {&mut self.shared_state, val}
                                 } else {
                                     quote! {val}
                                 };
-                                quote_spanned! {span=>
+                                quote_spanned! { span =>
                                     #events_enum_name::#ev_variant(val) => {
                                         let res: #trans_type = state_data.#ts_fn(#arglist);
-                                        res.into_general()
+                                        #transition_result_transform
                                     }
                                 }
                             }
                             Fields::Unit => {
                                 let arglist = if ts.mutates_shared {
-                                    quote! {self.shared_state}
+                                    quote! {&mut self.shared_state}
                                 } else {
                                     quote! {}
                                 };
-                                quote_spanned! {span=>
+                                quote_spanned! { span =>
                                     #events_enum_name::#ev_variant => {
                                         let res: #trans_type = state_data.#ts_fn(#arglist);
-                                        res.into_general()
+                                        #transition_result_transform
                                     }
                                 }
                             }
@@ -498,39 +511,49 @@ impl StateMachineDefinition {
                         // using `Default`.
                         if let [new_state] = ts.to.as_slice() {
                             let span = new_state.span();
-                            let default_trans = quote_spanned! {span=>
-                            TransitionResult::<_, #new_state>::from::<#from>(state_data).into_general()
-                        };
+                            let default_trans = quote_spanned! { span =>
+                            let res = TransitionResult::<Self, #new_state>::from::<#from>(state_data);
+                                #transition_result_transform
+                            };
                             let span = ts.event.span();
                             match ts.event.fields {
-                                Fields::Unnamed(_) => quote_spanned! {span=>
-                                #events_enum_name::#ev_variant(_val) => {
-                                    #default_trans
-                                }
-                            },
-                                Fields::Unit => quote_spanned! {span=>
-                                #events_enum_name::#ev_variant => {
-                                    #default_trans
-                                }
-                            },
+                                Fields::Unnamed(_) => quote_spanned! { span =>
+                                    #events_enum_name::#ev_variant(_val) => {
+                                        #default_trans
+                                    }
+                                },
+                                Fields::Unit => quote_spanned! { span =>
+                                    #events_enum_name::#ev_variant => {
+                                        #default_trans
+                                    }
+                                },
                                 Fields::Named(_) => unreachable!(),
                             }
-
                         } else {
-                            unreachable!("It should be impossible to have more than one dest state in no-handler transitions")
+                            unreachable!("It should be impossible to have more than one dest state \
+                                          in no-handler transitions")
                         }
                     }
                 })
-                // Since most states won't handle every possible event, return an error to that effect
+                // Since most states won't handle every possible event, return an error to that
+                // effect
                 .chain(std::iter::once(
-                    quote! { _ => { return TransitionResult::InvalidTransition } },
+                    quote! { _ => {
+                        // Restore state in event the transition doesn't match
+                        self.state = #occupied_current_state;
+                        return Err(::rustfsm::MachineError::InvalidTransition)
+                    } },
                 ));
             quote! {
-                #state_enum_name::#from(state_data) => match event {
+                #occupied_current_state => match event {
                     #(#event_branches),*
                 }
             }
-        }).collect();
+        }).chain(std::iter::once(
+            quote! {
+                None => Err(::rustfsm::MachineError::InvalidTransition)
+            }
+        )).collect();
 
         let viz_str = self.visualize();
 
@@ -546,19 +569,21 @@ impl StateMachineDefinition {
                   #name_str
                 }
 
-                fn on_event(self, event: #events_enum_name)
-                  -> ::rustfsm::TransitionResult<Self, Self::State> {
-                    match self.state {
+                fn on_event(&mut self, event: #events_enum_name)
+                  -> ::core::result::Result<::std::vec::Vec<Self::Command>,
+                                            ::rustfsm::MachineError<Self::Error>> {
+                    let taken_state = self.state.take();
+                    match taken_state {
                         #(#state_branches),*
                     }
                 }
 
                 fn state(&self) -> &Self::State {
-                    &self.state
+                    self.state.as_ref().unwrap()
                 }
 
                 fn set_state(&mut self, new: Self::State) {
-                    self.state = new
+                    self.state = Some(new)
                 }
 
                 fn shared_state(&self) -> &Self::SharedState{
@@ -566,11 +591,11 @@ impl StateMachineDefinition {
                 }
 
                 fn has_reached_final_state(&self) -> bool {
-                    self.state.is_final()
+                    self.state.as_ref().unwrap().is_final()
                 }
 
-                fn from_parts(shared: Self::SharedState, state: Self::State) -> Self {
-                    Self { shared_state: shared, state }
+                fn from_parts(state: Self::State, shared: Self::SharedState) -> Self {
+                    Self { shared_state: shared, state: Some(state) }
                 }
 
                 fn visualizer() -> &'static str {
@@ -616,11 +641,11 @@ impl StateMachineDefinition {
                 self.all_states()
                     .iter()
                     .filter(|s| self.is_final_state(s))
-                    .map(|s| format!("{} --> [*]", s)),
+                    .map(|s| format!("{s} --> [*]")),
             )
             .collect();
         let transitions = transitions.join("\n");
-        format!("@startuml\n{}\n@enduml", transitions)
+        format!("@startuml\n{transitions}\n@enduml")
     }
 }
 
@@ -643,5 +668,5 @@ fn merge_transition_dests(transitions: Vec<Transition>) -> Vec<Transition> {
             }
         }
     }
-    map.into_iter().map(|(_, v)| v).collect()
+    map.into_values().collect()
 }

package/sdk-core/fsm/rustfsm_trait/src/lib.rs

@@ -19,44 +19,12 @@ pub trait StateMachine: Sized {
     /// The type used to represent commands the machine issues upon transitions.
     type Command;
 
-    /// Handle an incoming event, returning a transition result which represents updates to apply
-    /// to the state machine.
-    fn on_event(self, event: Self::Event) -> TransitionResult<Self, Self::State>;
-
-    /// Handle an incoming event and mutate the state machine to update to the new state and apply
-    /// any changes to shared state.
-    ///
-    /// Returns the commands issued by the transition on success, otherwise a [MachineError]
-    fn on_event_mut(
+    /// Handle an incoming event, returning any new commands or an error. Implementations may
+    /// mutate current state, possibly moving to a new state.
+    fn on_event(
         &mut self,
         event: Self::Event,
-    ) -> Result<Vec<Self::Command>, MachineError<Self::Error>>
-    where
-        Self: Clone,
-    {
-        // NOTE: This clone is actually nice in some sense, giving us a kind of transactionality.
-        //   However if there are really big things in state it could be an issue.
-        let res = self.clone().on_event(event);
-        match res {
-            TransitionResult::Ok {
-                commands,
-                new_state,
-                shared_state,
-            } => {
-                *self = Self::from_parts(shared_state, new_state);
-                Ok(commands)
-            }
-            TransitionResult::OkNoShare {
-                commands,
-                new_state,
-            } => {
-                self.set_state(new_state);
-                Ok(commands)
-            }
-            TransitionResult::InvalidTransition => Err(MachineError::InvalidTransition),
-            TransitionResult::Err(e) => Err(MachineError::Underlying(e)),
-        }
-    }
+    ) -> Result<Vec<Self::Command>, MachineError<Self::Error>>;
 
     fn name(&self) -> &str;
 
@@ -71,7 +39,7 @@ pub trait StateMachine: Sized {
     fn has_reached_final_state(&self) -> bool;
 
     /// Given the shared data and new state, create a new instance.
-    fn from_parts(shared: Self::SharedState, state: Self::State) -> Self;
+    fn from_parts(state: Self::State, shared: Self::SharedState) -> Self;
 
     /// Return a PlantUML definition of the fsm that can be used to visualize it
     fn visualizer() -> &'static str;
@@ -136,12 +104,6 @@ where
     Ok {
         commands: Vec<Machine::Command>,
         new_state: DestinationState,
-        shared_state: Machine::SharedState,
-    },
-    /// The transition was successful with no shared state change
-    OkNoShare {
-        commands: Vec<Machine::Command>,
-        new_state: DestinationState,
     },
     /// There was some error performing the transition
     Err(Machine::Error),
@@ -157,24 +119,10 @@ where
     pub fn ok<CI>(commands: CI, new_state: Ds) -> Self
     where
         CI: IntoIterator<Item = Sm::Command>,
-    {
-        Self::OkNoShare {
-            commands: commands.into_iter().collect(),
-            new_state,
-        }
-    }
-
-    /// Produce a transition with the provided commands to the provided state with shared state
-    /// changes
-    pub fn ok_shared<CI, SS>(commands: CI, new_state: Ds, new_shared: SS) -> Self
-    where
-        CI: IntoIterator<Item = Sm::Command>,
-        SS: Into<Sm::SharedState>,
     {
         Self::Ok {
             commands: commands.into_iter().collect(),
             new_state,
-            shared_state: new_shared.into(),
         }
     }
 
@@ -185,7 +133,7 @@ where
         CurrentState: Into<Ds>,
     {
         let as_dest: Ds = current_state.into();
-        Self::OkNoShare {
+        Self::Ok {
             commands: vec![],
             new_state: as_dest,
         }
@@ -202,16 +150,20 @@ where
     where
         CI: IntoIterator<Item = Sm::Command>,
     {
-        Self::OkNoShare {
+        Self::Ok {
             commands: commands.into_iter().collect(),
             new_state: Ds::default(),
         }
     }
+}
 
-    /// Produce a transition with no commands relying on [Default] for the destination state's
-    /// value
-    pub fn default() -> Self {
-        Self::OkNoShare {
+impl<Sm, Ds> Default for TransitionResult<Sm, Ds>
+where
+    Sm: StateMachine,
+    Ds: Into<Sm::State> + Default,
+{
+    fn default() -> Self {
+        Self::Ok {
             commands: vec![],
             new_state: Ds::default(),
         }
@@ -230,20 +182,26 @@ where
             TransitionResult::Ok {
                 commands,
                 new_state,
-                shared_state,
             } => TransitionResult::Ok {
                 commands,
                 new_state: new_state.into(),
-                shared_state,
             },
-            TransitionResult::OkNoShare {
-                commands,
+            TransitionResult::Err(e) => TransitionResult::Err(e),
+        }
+    }
+
+    /// Transforms the transition result into a machine-ready outcome with commands and new state,
+    /// or a [MachineError]
+    #[allow(clippy::type_complexity)]
+    pub fn into_cmd_result(self) -> Result<(Vec<Sm::Command>, Sm::State), MachineError<Sm::Error>> {
+        let general = self.into_general();
+        match general {
+            TransitionResult::Ok {
                 new_state,
-            } => TransitionResult::OkNoShare {
                 commands,
-                new_state: new_state.into(),
-            },
-            TransitionResult::Err(e) => TransitionResult::Err(e),
+            } => Ok((commands, new_state)),
+            TransitionResult::InvalidTransition => Err(MachineError::InvalidTransition),
+            TransitionResult::Err(e) => Err(MachineError::Underlying(e)),
         }
     }
 }

package/sdk-core/protos/api_upstream/.github/CODEOWNERS

@@ -1,4 +1,5 @@
 # Syntax is here:
 # https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners#codeowners-syntax
 
-* @temporalio/server @temporalio/sdk
+*                       @temporalio/server @temporalio/sdk
+api/temporal/api/sdk/*  @temporalio/sdk

package/sdk-core/protos/api_upstream/Makefile

@@ -23,7 +23,7 @@ PROTO_ROOT := .
 PROTO_FILES = $(shell find $(PROTO_ROOT) -name "*.proto")
 PROTO_DIRS = $(sort $(dir $(PROTO_FILES)))
 PROTO_OUT := .gen
-PROTO_IMPORTS := -I=$(PROTO_ROOT) -I=$(GOPATH)/src/github.com/temporalio/gogo-protobuf/protobuf
+PROTO_IMPORTS = -I=$(PROTO_ROOT) -I=$(shell go list -modfile build/go.mod -m -f '{{.Dir}}' github.com/temporalio/gogo-protobuf)/protobuf
 
 $(PROTO_OUT):
 	mkdir $(PROTO_OUT)
@@ -37,7 +37,7 @@ go-grpc: clean $(PROTO_OUT)
 
 gogo-grpc: clean $(PROTO_OUT)
 	printf $(COLOR) "Compile for gogo-gRPC..."
-	$(foreach PROTO_DIR,$(PROTO_DIRS),protoc --fatal_warnings $(PROTO_IMPORTS) --gogoslick_out=Mgoogle/protobuf/wrappers.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor,Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto;)
+	$(foreach PROTO_DIR,$(PROTO_DIRS),protoc --fatal_warnings $(PROTO_IMPORTS) --gogoslick_out=Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/wrappers.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor,Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,plugins=grpc,paths=source_relative:$(PROTO_OUT) $(PROTO_DIR)*.proto;)
 
 fix-path:
 	mv -f $(PROTO_OUT)/temporal/api/* $(PROTO_OUT) && rm -rf $(PROTO_OUT)/temporal
@@ -45,21 +45,21 @@ fix-path:
 ##### Plugins & tools #####
 grpc-install: gogo-protobuf-install
 	printf $(COLOR) "Install/update gRPC plugins..."
-	go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.2.0
+	go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
 
 gogo-protobuf-install: go-protobuf-install
-	GO111MODULE=off go get github.com/temporalio/gogo-protobuf/protoc-gen-gogoslick
+	go install -modfile build/go.mod github.com/temporalio/gogo-protobuf/protoc-gen-gogoslick
 
 go-protobuf-install:
 	go install github.com/golang/protobuf/protoc-gen-go@v1.5.2
 
 api-linter-install:
 	printf $(COLOR) "Install/update api-linter..."
-	go install github.com/googleapis/api-linter/cmd/api-linter@v1.31.0
+	go install github.com/googleapis/api-linter/cmd/api-linter@v1.32.3
 
 buf-install:
 	printf $(COLOR) "Install/update buf..."
-	go install github.com/bufbuild/buf/cmd/buf@v1.4.0
+	go install github.com/bufbuild/buf/cmd/buf@v1.6.0
 
 ##### Linters #####
 api-linter:

package/sdk-core/protos/api_upstream/build/go.mod

@@ -0,0 +1,7 @@
+module build
+
+go 1.18
+
+require (
+ 	github.com/temporalio/gogo-protobuf v1.22.1
+)

package/sdk-core/protos/api_upstream/build/go.sum

@@ -0,0 +1,5 @@
+github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/temporalio/gogo-protobuf v1.22.1 h1:K5ja5MqmCQKo4tlX7u3g+ZJqbvRr0589ss2cZQx2dSM=
+github.com/temporalio/gogo-protobuf v1.22.1/go.mod h1:tCaEv+fB8tsyLgoaqKr78K/JOhdRe684yyo0z30SHyA=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

package/sdk-core/protos/api_upstream/build/tools.go

@@ -0,0 +1,29 @@
+// The MIT License
+//
+// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
+//
+// Copyright (c) 2020 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// 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 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.
+
+package build
+
+import (
+	_ "github.com/temporalio/gogo-protobuf/gogoproto" // gogoproto is just a random package name for module.
+)

package/sdk-core/protos/api_upstream/go.mod

@@ -0,0 +1,6 @@
+// There is special go module in `build` directory that is used to control tools versions.
+// This file exists because go 1.18 doesn't allow go sub modules if root dirrectory is not a go module.
+
+module api
+
+go 1.18

package/sdk-core/protos/api_upstream/temporal/api/batch/v1/message.proto

@@ -28,8 +28,8 @@ option go_package = "go.temporal.io/api/batch/v1;batch";
 option java_package = "io.temporal.api.batch.v1";
 option java_multiple_files = true;
 option java_outer_classname = "MessageProto";
-option ruby_package = "Temporal::Api::Batch::V1";
-option csharp_namespace = "Temporal.Api.Batch.V1";
+option ruby_package = "Temporalio::Api::Batch::V1";
+option csharp_namespace = "Temporalio.Api.Batch.V1";
 
 import "dependencies/gogoproto/gogo.proto";
 import "google/protobuf/timestamp.proto";
@@ -79,4 +79,11 @@ message BatchOperationSignal {
 message BatchOperationCancellation {
   // The identity of the worker/client
   string identity = 1;
+}
+
+// BatchOperationDeletion sends deletion requests to batch workflows.
+// Keep the parameter in sync with temporal.api.workflowservice.v1.DeleteWorkflowExecutionRequest.
+message BatchOperationDeletion {
+  // The identity of the worker/client
+  string identity = 1;
 }