eschwartz

// https://gist.github.com/eschwartz/70a15f12e6ef90f377d5d51fba9c86d8
import mapAsync from './mapAsync';

interface Dict<TVal> {
  [key: string]: TVal
}

async function mapValuesAsync<TVal, TRes>(obj:Dict<TVal>, iter:(val:TVal, key:string) => Promise<TRes>):Promise<Dict<TRes>> {
  const keyResPairs:[string, TRes][] = await mapAsync<string, [string, TRes]>(Object.keys(obj),
    async (key:string) => {

eschwartz

import * as _ from 'lodash';
async function mapAsync<TVal, TRes>(items:TVal[], iter:(val:TVal, i:(number | string)) => Promise<TRes>):Promise<TRes[]> {
  return Promise.all(_.map(items, iter));
}
export default mapAsync;

eschwartz

const childProcess = require('child_process');

// otherwise we get a stupid warning.
process.stdout.setMaxListeners(100);
process.stderr.setMaxListeners(100);

/**
 * Promisified child_process.exec
 *
 * @param cmd

eschwartz

const _ = require('lodash');

function flattenObj(obj, prefix) {
	prefix || (prefix = '');

	return Object.keys(obj)
		.reduce((flat, key) => (
			_.isObject(obj[key]) ?
				// Recursively flatten objects
				Object.assign(flat, flattenObj(obj[key], `${prefix}${key}.`)) :

eschwartz

function assertMatch(actual:string, regex: string | RegExp, msg?:string):void {
  const regexNorml:RegExp = _.isString(regex) ? new RegExp(regex as string) : regex;

  const isMatch = regexNorml.test(actual);

  if (!isMatch) {
    assert.fail(actual, regexNorml.toString(), msg, 'matches');
  }
}

eschwartz

import * as stream from 'stream';

function pipe(readStream:stream.Readable, writeStream: NodeJS.WritableStream):Promise<void> {
  return new Promise<void>((onRes, onErr) => {
    readStream
      .on('error', onErr)
      .pipe(writeStream)
      .on('error', onErr)
      .on('finish', () => onRes())
  });

eschwartz

/**
 * eg.
 *
 *  poll(
 *    () => Promise.resolve(Math.random()),
 *    val => val > 0.5
 *  )
 *    .then(val => console.log(`You won, with ${val}!`));
 *
 * @param {():Promise<T>} run

eschwartz

function Deferred() {
  var deferred = {
    resolve: null,
    reject: null
  };
  deferred.promise = new Promise((resolve, reject) => {
    // Save resolve/reject to deferred, for later usage.
    deferred.resolve = resolve;
    deferred.reject = reject;
  });

eschwartz

/**
 * @param {Array<T>} list
 * @param {(T):Promise<Boolean>} filter
 * @returns {Promise<T[]>}
 */
function filterAsync(list, filter) {
  return Promise
    .all(
      list.map(item => filter(item)
        .then(filterRes => ({ filterRes, item }))

eschwartz

// See https://gist.github.com/eschwartz/4f16fcb963954d433753ffe32ce5d5ca
const ReplicationController = require('./ReplicationController');
const fs = require('fs-extra');
// See https://gist.github.com/eschwartz/310a7d9938b60eaf49c8d56c1ccfb759
const loadS3Env = require('./loadS3Env');
const path = require('path');
const Cli = require('admiral-cli');
const co = require('co');

function main() {