How to use fluture - 10 common examples

  const mockNoResponse = middleware (function mock() { return resolve (null); });
  /* eslint-enable prefer-arrow-callback */

const resolveMiddlewareToFuture = async (ctx, next) => {
  try {
    return Future.resolve(await next())
  } catch (error) {
    if (error instanceof CustomError) {
      return Future.reject(error)
    }
    // eslint-disable-next-line no-console
    // console.error('error', error)
    // ctx.app.emit('error', error, ctx)
    return Future.reject(new InternalServerError(error))
  }
}

neutrino.register('publish', () => {
        const isNextRelease = neutrino.options.args.next
        const packageJson = neutrino.options.packageJson
        const mainFile = path.resolve(path.join(neutrino.options.output, packageJson.main))
        const readme = path.join(__dirname, 'README.md')

        return Future.node(done => fs.access(mainFile, done))
          .mapRej(() => {
            console.log()
            console.error('No main file in output directory. Please run npm build')
          })

          // Create package.json for publishing
          .chain(() => {
            const trimPackageJson = R.omit([ 'devDependencies', 'scripts' ])()(packageJson)
            return Future.encase3(JSON.stringify, trimPackageJson, null, ' ')
          })
          .chain(packageJsonString => {
            const publishablePackageJsonPath = path.resolve(path.join(neutrino.options.output, 'package.json'))
            return Future
              .node(done => fs.writeFile(publishablePackageJsonPath, packageJsonString, done))
          })

if (!bytesCmp(newNonceHash1, response.new_nonce_hash1)) {
    const err = reject(ERR.dh.nonce.hash1())/*::.mapRej(dhAnswerFail)*/
    return err
  }

  const serverSalt = bytesXor(newNonce.slice(0, 8), serverNonce.slice(0, 8))
  // console.log('Auth successfull!', authKeyID, authKey, serverSalt)
  const authBlock = {
    authKeyID : /*:: toCryptoKey(*/ id /*::)*/,
    authKey   : /*:: toCryptoKey(*/ key /*::)*/,
    //eslint-disable-next-line
    serverSalt: /*:: toCryptoKey(*/ serverSalt /*::)*/,
  }

  const result: Fluture = of(authBlock)
  return result
}

const middleware = (ctx, next) => {
    if (!isValid(ctx.request.body)) {
      // eslint-disable-next-line no-console
      console.error(ctx.request.body, isValid.errors)
      return Future.reject(new ValidationError(isValid.errors))
    }
    return next()
  }

// Fluture: https://github.com/fluture-js/Fluture

const { Client } = require('tdl')
const Future = require('fluture')

const client = new Client({
  apiId: 2222, // Your api_id
  apiHash: 'YOUR_API_HASH'
})

const searchChat = username =>
  client.invokeFuture({ _: 'searchPublicChat', username })
    .map(chat => `Chat: ${chat.title}, id: ${chat.id}`)
    .mapRej(err => `Error: ${err.message}`)

const login = Future.encaseP(client.login)

Future
  .tryP(client.connect)
  .chain(() => login(() => ({
    phoneNumber: 'YOUR_PHONE_NUMBER'
  })))
  .chain(() => searchChat('username'))
  .fork(console.error, console.log)

const { Client } = require('tdl')
const Future = require('fluture')

const client = new Client({
  apiId: 2222, // Your api_id
  apiHash: 'YOUR_API_HASH'
})

const searchChat = username =>
  client.invokeFuture({ _: 'searchPublicChat', username })
    .map(chat => `Chat: ${chat.title}, id: ${chat.id}`)
    .mapRej(err => `Error: ${err.message}`)

const login = Future.encaseP(client.login)

Future
  .tryP(client.connect)
  .chain(() => login(() => ({
    phoneNumber: 'YOUR_PHONE_NUMBER'
  })))
  .chain(() => searchChat('username'))
  .fork(console.error, console.log)

const insert = (values: Payload) => {
    const query = generatePgInsert({ payload: values, table: tableName })

    return (
      Future.tryP(() => client.query(query.text, query.values))
        .map(debug ? R.tap(console.log) : R.identity)
        // @ts-ignore
        .map(value => new entityMapperClass(value.rows[0]))
    )
  }

function fileMigrateHandler(uid, data, code, message, req, newDc) {
  req.dc = Just(newDc)

  // const futureAuth = Config.authRequest.get(uid, newDc)
  if (!alreadyMoved) {
    // Config.halt.set(uid, newDc, true)
    const auth = cache(
      moveAuthProgression(uid, newDc)
      //   .map(tapLog`after auth`)
      // .map(resp => (Config.halt.set(uid, newDc, false), resp))
      // .map(e => (log`auth`(e), e))
    )
    // const authReq = invoke(uid, 'auth.exportAuthorization', { dc_id: newDc })
    //   .map(resp => (console.log(resp), resp))
    //   // .map(({ id, bytes }) => ({ id, bytes }))
    //   // .map(tapLog`before auth`)
    //   .chain(resp => {
    //     const { id, bytes } = exportAuthRefine(resp)
    //     const refined = { id, bytes: [...bytes] }
    //     const futureAuth = Config.authRequest.get(uid, newDc)
    //     if (futureAuth) return futureAuth
    //     // const auth = cache(Auth(uid, newDc)
    //     //   .map(tapLog`after auth`)

const Future = require('fluture');
const { isEmpty, pathOr, pipe } = require('ramda');
const webpack = require('webpack');
const DevServer = require('webpack-dev-server');
const { toArray } = require('./utils');

// errors :: (Error|Array Error err -> Object stats) -> Array Error
const getErrors = (err, stats) => (err ? toArray(err) : stats.toJson().errors);

// compiler :: Object config -> Future Error Object
const compiler = pipe(Future.of, Future.ap(Future.of(webpack)));

// compile :: Object config -> Future Error Object
const compile = pipe(
  compiler,
  Future.chain(compiler => Future((reject, resolve) => {
    compiler.run((err, stats) => {
      const errors = getErrors(err, stats);

      isEmpty(errors) ? resolve(stats) : reject(errors);
    });
  }))
);

// devServer :: Object config -> Future Error Object
const devServer = pipe(
  compiler,