Class ZBClient

Broadcast a Signal

const zbc = new ZBClient()

zbc.broadcastSignal({
  signalName: 'my-signal',
  variables: { reasonCode: 3 }
})

Cancel a process instance by process instance key.

const zbc = new ZBClient()

zbc.cancelProcessInstance(processInstanceId)
    .catch(
        (e: any) => console.log(`Error cancelling instance: ${e.message}`)
)

Gracefully shut down all workers, draining existing tasks, and return when it is safe to exit.

const zbc = new ZBClient()

zbc.createWorker({
  taskType:
})

setTimeout(async () => {
  await zbc.close()
  console.log('All work completed.')
}),
  5 * 60 * 1000 // 5 mins
)

Explicitly complete a job. The method is useful for manually constructing a worker.

const zbc = new ZBClient()
zbc.activateJobs({
  maxJobsToActivate: 5,
  requestTimeout: 6000,
  timeout: 5 * 60 * 1000,
  type: 'process-payment',
  worker: 'my-worker-uuid'
}).then(jobs =>
     jobs.forEach(job =>
    // business logic
    zbc.completeJob({
      jobKey: job.key,
      variables: {}
    ))
  )
})

Deploy a process model.

import { readFileSync } from 'fs'
import { join } from 'path'

const zbc = new ZBClient()
const bpmnFilePath = join(process.cwd(), 'bpmn', 'onboarding.bpmn')

// Loading the process model allows you to perform modifications or analysis
const bpmn = readFileSync(bpmnFilePath, 'utf8')

zbc.deployProcess({
   definition: bpmn,
   name: 'onboarding.bpmn'
})

// If you don't need access to model contents, simply pass a file path
zbc.deployProcess(bpmnFilePath)

Deploys one or more resources (e.g. processes or decision models) to Zeebe. Note that this is an atomic call, i.e. either all resources are deployed, or none of them are.

Errors: PERMISSION_DENIED:

• if a deployment to an unauthorized tenant is performed INVALID_ARGUMENT:
• no resources given.
• if at least one resource is invalid. A resource is considered invalid if:
• the content is not deserializable (e.g. detected as BPMN, but it's broken XML)
• the content is invalid (e.g. an event-based gateway has an outgoing sequence flow to a task)
• if multi-tenancy is enabled, and:
• a tenant id is not provided
• a tenant id with an invalid format is provided
• if multi-tenancy is disabled and a tenant id is provided

import {join} from 'path'
const zbc = new ZBClient()

zbc.deployResource({ processFilename: join(process.cwd(), 'bpmn', 'onboarding.bpmn' })
zbc.deployResource({ decisionFilename: join(process.cwd(), 'dmn', 'approval.dmn')})

Evaluates a decision. The decision to evaluate can be specified either by using its unique key (as returned by DeployResource), or using the decision ID. When using the decision ID, the latest deployed version of the decision is used.

const zbc = new ZBClient()
zbc.evaluateDecision({
  decisionId: 'my-decision',
  variables: { season: "Fall" }
}).then(res => console.log(JSON.stringify(res, null, 2)))

Fail a job. This is useful if you are using the decoupled completion pattern or building your own worker. For the retry count, the current count is available in the job metadata.

const zbc = new ZBClient()
zbc.failJob( {
  jobKey: '345424343451',
  retries: 3,
  errorMessage: 'Could not get a response from the order invoicing API',
  retryBackOff: 30 * 1000 // optional, otherwise available for reactivation immediately
})

Return an array of task types contained in a BPMN file or array of BPMN files. This can be useful, for example, to do

const zbc = new ZBClient()
zbc.getServiceTypesFromBpmn(['bpmn/onboarding.bpmn', 'bpmn/process-sale.bpmn'])
  .then(tasktypes => console.log('The task types are:', tasktypes))

Modify a running process instance. This allows you to move the execution tokens, and change the variables. Added in 8.1. See the gRPC protocol documentation.

zbc.createProcessInstance('SkipFirstTask', {}).then(res =>
     zbc.modifyProcessInstance({
    processInstanceKey: res.processInstanceKey,
    activateInstructions: [{
      elementId: 'second_service_task',
      ancestorElementInstanceKey: "-1",
      variableInstructions: [{
        scopeId: '',
        variables: { second: 1}
      }]
    }]
     })
)

Resolve an incident by incident key.

type JSONObject = {[key: string]: string | number | boolean | JSONObject}

const zbc = new ZBClient()

async updateAndResolveIncident({
  processInstanceId,
  incidentKey,
  variables
} : {
  processInstanceId: string,
  incidentKey: string,
  variables: JSONObject
}) {
  await zbc.setVariables({
    elementInstanceKey: processInstanceId,
    variables
  })
  await zbc.updateRetries()
  zbc.resolveIncident({
    incidentKey
  })
  zbc.resolveIncident(incidentKey)
}

Fail a job by throwing a business error (i.e. non-technical) that occurs while processing a job. The error is handled in the workflow by an error catch event. If there is no error catch event with the specified errorCode then an incident will be raised instead. This method is useful when building a worker, for example for the decoupled completion pattern.

type JSONObject = {[key: string]: string | number | boolean | JSONObject}

interface errorResult {
  resultType: 'ERROR' as 'ERROR'
     errorCode: string
  errorMessage: string
}

interface successResult {
  resultType: 'SUCCESS' as 'SUCCESS'
  variableUpdate: JSONObject
}

type Result = errorResult | successResult

const zbc = new ZBClient()


// This could be a listener on a return queue from an external system
async function handleJob(jobKey: string, result: Result) {
  if (resultType === 'ERROR') {
    const { errorMessage, errorCode } = result
        zbc.throwError({
       jobKey,
       errorCode,
          errorMessage
    })
  } else {
    zbc.completeJob({
      jobKey,
      variables: result.variableUpdate
    })
  }
}

Return the broker cluster topology.

const zbc = new ZBClient()

zbc.topology().then(res => console.res(JSON.stringify(res, null, 2)))

Update the number of retries for a Job. This is useful if a job has zero remaining retries and fails, raising an incident.

type JSONObject = {[key: string]: string | number | boolean | JSONObject}

const zbc = new ZBClient()

async function updateAndResolveIncident({
  incidentKey,
  processInstanceKey,
  jobKey,
  variableUpdate
} : {
  incidentKey: string
  processInstanceKey: string
  jobKey: string
  variableUpdate: JSONObject
}) {
  await zbc.setVariables({
    elementInstanceKey: processInstanceKey,
    variables: variableUpdate
  })
  await zbc.updateJobRetries({
    jobKey,
    retries: 1
  })
  return zbc.resolveIncident({
    incidentKey
  })
}