jwulf

import { dispatch, spawn, query, Ref, start } from "nact";

type Result = { success: boolean };

type DoLoadMessage = {
  type: "LOAD";
  filename: string;
  sender: Ref<Result>;
};

jwulf

interface QueuedTask<T> {
  task: () => T;
  promise: {
    resolve: (res: any) => void;
    reject: (err: any) => void;
  };
}

interface RateLimitedTask<T> {
  task: () => T;

jwulf

interface QueuedTask<T> {
  task: () => T;
  promise: {
    resolve: (res: any) => void;
    reject: (err: any) => void;
  };
}

interface RateLimitedTask<T> {
  task: () => T;

jwulf

Contributing to this project

We welcome your contributions to this project.

It could be:

• a bug report in a GitHub issue
• a feature request in a GitHub issue
• a fix to documentation
• a code contribution to address an existing bug or feature request

jwulf

• Prerequisites: Node, npm, TypeScript, Zeebe Modeler
• Scaffold new project
• Create new Camunda Cloud account
• Create new Camunda Cloud cluster
• Point them to the Slack channel for support
• Create new worker credentials
• Put worker credentials in .env file
• Create BPMN model: Start event, single service task, end event
• Save model
• Write code to deploy model, log response to console

jwulf

async function executeAsyncTasks(tasks: AsyncTask<any>[]) {
  const success = async res => ({ success: await res }) // Promise<{success: res}>
  const error = async err => ({ error: await err }) // Promise<{error: e}>

  const runWithResult = task => task.run()
    .then(result => {
      success(result)
      task._success(result)
    })
    .catch(e => {

jwulf

class AsyncTask<T> {
  _run: () => Promise<T>;
  _success: (result: T) => void;
  _error: (e: Error) => void;

  constructor({
    error,
    run,
    success
  }: {

jwulf

// Takes an array of async tasks that may throw of shape {run: () => Promise<result>}
// Returns Promise<{error: error[], success: result[]}>

async function executeAsyncTasks(arrayOfAsyncTasks) {
  const success = async res => ({ success: await res }) // Promise<{success: res}>
  const error = async err => ({ error: await err }) // Promise<{error: e}>

  const runWithResult = task => task.run().then(success).catch(error)
  const outcomes = await Promise.all(arrayOfAsyncTasks.map(runWithResult))

jwulf

const { error, success } = outcomes.reduce((acc, o) => o.error ? 
    { error: [...acc.error, o.error], success: acc.success } :
    { error: acc.error, success: [...acc.success, o.success] }, 
    { error: [], success: [] })

jwulf

async function myAsyncFunction(argument) {

  const success = async res => ({ success: await res }) // Promise<{success: res}>
  const error = async err => ({ error: await err }) // Promise<{error: e}>

  const arrayTasks = [
    { 
      run: async () => getDataAsync()
      }
    },