faizahmedfarooqui

// Converts the time string into Date Object
const timestamp = _time => Date.parse(_time) / 1000;

/** 
 * 1. group-by given keys 
 * 2. sort the groups in ascending order for Time key
 * 3. filters duplicate entries with time difference < 60 seconds
 *
 * @param _array    Array     [required]
 * @param _function Function  [required]

Bilguun132

const config = require('config');
const jwt = require('jsonwebtoken');
const Joi = require('joi');
const mongoose = require('mongoose');

//simple schema
const UserSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,

batrudinych

async function take3subtake1part0() {
  const concurrencyLimit = 5;
  const argsCopy = listOfArguments.slice();
  const promises = new Array(concurrencyLimit).fill(Promise.resolve());
  // Recursively chain the next Promise to the currently executed Promise
  function chainNext(p) {
    if (argsCopy.length) {
      const arg = argsCopy.shift();
      return p.then(() => {
        const operationPromise = asyncOperation(arg);

batrudinych

async function take2() {
  // Running Promises in parallel
  const listOfPromises = listOfArguments.map(asyncOperation);
  // Harvesting
  return await Promise.all(listOfPromises);
}

goldbergyoni

it("When getting orders report, get the existing orders", () => {
    //This one hopefully is telling a direct and explicit story
    const orderWeJustAdded = ordersTestHelpers.addRandomNewOrder();
    const queryObject = newQueryObject(config.DBInstanceURL, queryOptions.deep, useCache:false);
    const result = queryObject.query(config.adminUserToken, reports.orders, pageSize:200);
    expect(result).to.be.an('array').that.does.include(orderWeJustAdded);
})

anned20

const crypto = require('crypto');
const algorithm = 'aes-256-ctr';
let key = 'MySuperSecretKey';
key = crypto.createHash('sha256').update(String(key)).digest('base64').substr(0, 32);

const encrypt = (buffer) => {
    // Create an initialization vector
    const iv = crypto.randomBytes(16);
    // Create a new cipher using the algorithm, key, and iv
    const cipher = crypto.createCipheriv(algorithm, key, iv);

giampaolotrapasso

List of links from Designing Event-Driven Systems by Ben Stopford

Designing Event-Driven Systems book by Ben Stopford contains a lot of useful links to papers, books, documentation and definitions related to event driven design and Kafka. I just extracted them as reference for the future and added some groups to show them better.

You can read the book for free

• A Crystal Ball to Prioritise Technical Debt in Monoliths or Microservices: Adam Tornhill's Thoughts
• Brewer's CAP Theorem <= :julianbrowne

FermiDirak

class TicTacToe {
  constructor() {
    this.board = [
      ['-', '-', '-'],
      ['-', '-', '-'],
      ['-', '-', '-'],
    ];

    this.currentPlayer = 'x';

itaditya

async function orderItems() {
  const items = await getCartItems()    // async call
  const noOfItems = items.length
  const promises = []
  for(var i = 0; i < noOfItems; i++) {
    const orderPromise = sendRequest(items[i])    // async call
    promises.push(orderPromise)    // sync call
  }
  await Promise.all(promises)    // async call
}

guyguyon

const fs = require('fs');
const async_hooks = require('async_hooks');
async_hooks.createHook({
   init(asyncId, type, triggerAsyncId) {
      fs.writeSync(1, `Init ${type} resource: asyncId: ${asyncId} trigger: ${triggerAsyncId}\n`);
   },
   destroy(asyncId) {
      const eid = async_hooks.executionAsyncId();
      fs.writeSync(1, `Destroy resource: execution: ${eid} asyncId: ${asyncId}\n`);
  }