Define and reference workflows and activities using records.

The usage of this module is best explained by example. First, define a record type that contains all of the workflows and activities that you want to define:

data EmailWorkflowsB t f = Workflows
 { emailNewUser :: Wear t f (Int -> Workflow ())
 , sendEmail :: Wear t f (String -> Activity () ())
 , emailPasswordReset :: Wear t f (String -> Workflow ())
 } deriving (Generic)

type EmailWorkflows = EmailWorkflowsB Bare Identity
type EmailWorkflowsH = EmailWorkflowsB Covered

We define all of our fields using the Wear type, which is a type family that lets us convert fields from their direct function definitions into versions that are wrapped in a functor.

Next, we will need some boilerplate instances for this type:

instance FunctorB (EmailWorkflowsB Covered)
instance TraversableB (EmailWorkflowsB Covered)
instance ApplicativeB (EmailWorkflowsB Covered)
instance ConstraintsB (EmailWorkflowsB Covered)
instance BareB EmailWorkflowsB
instance Label (EmailWorkflowsB Covered)

As an alternative to using Generic and deriving these instances, you can use TH to generate them for you. With this style, you don't have to introduce the type parameters manually:

import Temporal.Bundle.TH

passthroughBareB [d|
  data EmailWorkflows = Workflows
    { emailNewUser :: Int -> Workflow ()
    , sendEmail :: String -> Activity () ()
    , emailPasswordReset :: String -> Workflow ()
    }
  |]

This will generate the same instances as the manual version above, with the following type synonyms:

data EmailWorkflowsB = Workflows {..}
type EmailWorkflows = EmailWorkflowsB Bare Identity
type EmailWorkflowsH = EmailWorkflowsB Covered

Now that we have our record type, we can turn it into references and definitions:

Using refs, we can use our record type to provide references to our workflows and activities. References are essentially identifiers that we can use across application / process boundaries to invoke our workflows and activities with Temporal.

wfRefs :: Refs EmailWorkflowsB
wfRefs = refs JSON workflowsImpl

Now, we can implement our workflows and activities:

workflowsImpl :: EmailWorkflows
workflowsImpl = Workflows
  { emailNewUser = userId -> provideCallStack $ do
      h <- startActivity
        wfRefs.sendEmail -- <=== Note how we can reference other workflows and activities using the refs we defined above
        (defaultStartActivityOptions $ ScheduleToClose $ TimeSpec 0 0)
        "foo"
      wait h
  , sendEmail = email -> do
      pure ()
  , emailPasswordReset = email -> do
      pure ()
  }

Lastly, we want a way to register our workflows and activities with the Temporal worker:

workerConfigFromRecord = defsToConfig $ defs JSON workflowsImpl

This will produce a ConfigM that we can use to register our workflows and activities with the Temporal worker as part of a larger ConfigM that we pass to startWorker.