vkarpov15

There is no time limit on Temporal Workflow Executions. You can write a Workflow that runs forever, storing some state and responding to Signals and Queries that come in, as long as you remember to Continue As New. One neat use case for long-lived Workflows is caching API requests.

For example, suppose you want to display prices in different currencies based on cached exchange rates. Exchange rate APIs are often expensive for high volumes of requests, so caching can be worthwhile as long as stale data isn't a problem for your use case. You can create a single Temporal Workflow that makes 1 API request per day to get the latest exchange rates for a set of currencies, and stores the most recent result, with no explicit database calls or cron jobs. In this blog post, I'll describe how you can write an API caching Workflow for the [moneyconvert.net API](https://moneyconvert.net

vkarpov15

const WebSocket = require('ws');

// Core solver logic, stubbed out for example
async function* slow() {
  yield 'starting...';
  await new Promise(resolve => setTimeout(resolve, 10 * 1000));

  // Use `yield` to report on progress
  yield 'loading data...';
  await new Promise(resolve => setTimeout(resolve, 10 * 1000));

vkarpov15

const mongodb = require('mongodb')

run().catch(error => console.log(error));

async function run() {
  const db = await mongodb.MongoClient.
    connect('mongodb://localhost:27017/test', {
      useNewUrlParser: true,
      poolSize: 1 // Only 1 operation can run at a time
    }).

vkarpov15

import test from './test.js';

test();

vkarpov15

[document.querySelector('#intercom-frame'), document.querySelector('#intercom-container')].forEach(el => { el.parentNode.removeChild(el); });

vkarpov15

db.test.drop();
db.test.insertOne({
  name: 'Denver',
  location: {
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {},
      "geometry": {

vkarpov15

let i = 0;

run();

setInterval(() => console.log(i), 10);

async function run() {
  ++i;
  await new Promise(resolve => setTimeout(resolve, 15));
  ++i;

vkarpov15

const assert = (v, err) => {
  if (!v) {
    throw err;
  }
};

let counter = 0;

class Promise {
  constructor(executor) {

vkarpov15

class MyPromise {
  constructor(executor) {
    if (typeof executor !== 'function') {
      throw new Error('Executor must be a function');
    }

    // Internal state. `$state` is the state of the promise, and `$chained` is
    // an array of the functions we need to call once this promise is settled.
    this.$state = 'PENDING';
    this.$chained = [];

vkarpov15

class MyPromise {
  constructor(executor) {
    if (typeof executor !== 'function') {
      throw new Error('Executor must be a function');
    }

    // Internal state. `$state` is the state of the promise, and `$chained` is
    // an array of the functions we need to call once this promise is settled.
    this.$state = 'PENDING';
    this.$chained = [];