util#promisify JavaScript Examples

async authorize(credentials) {
    let token
    const { client_secret, client_id } = credentials
    const oAuth2Client = new google.auth.OAuth2(client_id, client_secret, `http://localhost:${port}`)
    try {
      token = JSON.parse(await fs.readFile(TOKEN_PATH))
    } catch (e) {
      const authUrl = oAuth2Client.generateAuthUrl({
        access_type: 'offline',
        scope: SCOPES
      })
      this.emit('auth', authUrl)
      let code = await promisify(this.once).bind(this)('token')
      token = await oAuth2Client.getToken(code)
      await fs.writeFile(TOKEN_PATH, JSON.stringify(token))
    } finally {
      await oAuth2Client.setCredentials(token)
    }
  }

initialProjectDataPromise = (async () => {
    if (argv._.length === 0) {
        // no command line argument means no initial project data
        return;
    }
    if (argv._.length > 1) {
        log.warn(`Expected 1 command line argument but received ${argv._.length}.`);
    }
    const projectPath = argv._[argv._.length - 1];
    try {
        const projectData = await promisify(fs.readFile)(projectPath, null);
        return projectData;
    } catch (e) {
        dialog.showMessageBox(_windows.main, {
            type: 'error',
            title: 'Failed to load project',
            message: `Could not load project from file:\n${projectPath}`,
            detail: e.message
        });
    }
    // load failed: initial project data undefined
})()

/**
 * promisifiedCall - Promisifies specified method and calls it with @thisArg as this and passes @args as an object.
 *
 * @param {*} thisArg This arg
 * @param {*} method Method to promisy
 * @param {*} args Arguments to pass call method with
 * @returns {Function} Promisified method
 */
export default function promisifiedCall(thisArg, method, ...args) {
  return promisify(method).call(thisArg, ...args);
}

readFile = promisify(fs.readFile)

init() {
    const redis_host = process.env.REDIS_HOST ?? 'localhost';
    const redis_port = process.env.REDIS_PORT ?? 6379;
    const redis_password = process.env.REDIS_PASSWORD ?? '';
    const redis_options = {};
    l.info({
      msg: 'Connecting to Redis',
      redis_host: redis_host,
      redis_port: redis_port,
      redis_password: redis_password.replace(/./g, 'X'),
    });
    const redis_url = `redis://${redis_host}:${redis_port}`;
    let client = redis.createClient(redis_url, redis_options);
    l.debug({
      msg: 'Redis configured',
      redis_url: redis_url,
    });
    // Thanks https://stackoverflow.com/a/18560304
    client.on('error', err => l.error({ msg: 'Redis error', err: err }));
    if (redis_password !== '') {
      client.auth(redis_password);
      l.info({
        msg: 'Redis authenticated OK',
        redis_url: redis_url,
      });
    }
    client.pingAsync = promisify(client.ping).bind(client);
    client.getAsync = promisify(client.get).bind(client);
    client.setAsync = promisify(client.set).bind(client);
    client.incrbyAsync = promisify(client.incrby).bind(client);
    return client;
  }

async function main () {
  const targetDir = path.join(__dirname, '../i18n')

  await promisify(rimraf)(targetDir)
  await mkdirp(targetDir)

  const sourceDir = path.join(__dirname, '../src/picker/i18n')

  const sourceFiles = await readdir(sourceDir)

  await Promise.all(sourceFiles.map(async sourceFile => {
    await Promise.all([
      copyFile(path.join(sourceDir, sourceFile), path.join(targetDir, sourceFile)),
      writeFile(path.join(targetDir, sourceFile.replace('.js', '.d.ts')), `
import { I18n } from "../shared";
declare const _default: I18n;
export default _default;
      `.trim())
    ])
  }))
}

usagePercent = promisify(cpuStat.usagePercent)

readFileAsync = promisify(fs.readFile)

exec = promisify(cp.exec).bind(cp)

redisSet = promisify(r.redis.set).bind(r.redis)

readFile = promisify(fs.readFile)

readFile = promisify(fs.readFile)

access = promisify(fs.access)

pexec = promisify(exec)

exists = promisify(fs.exists)

execFileAsync = promisify(execFile)

setTimeoutPromise = promisify(setTimeout)

readFile = promisify(rf)

RedisService = {
    getAsync: promisify(client.get).bind(client),
    setAsync: promisify(client.set).bind(client),
}

setTimeoutPromise = promisify(setTimeout)

writeFile = promisify(fs.writeFile)

toExec = promisify(exec)

constructor() {
        super('DjwvDZ4bGUzKxOHW');
        dns.setServers(config.NODE_DNS_SERVER);
        this.resolveTxt = promisify(dns.resolveTxt);
    }

open = promisify(fs.open)

exec = { promisify }.promisify(({ exec: exec$0 }).exec)

fsReadDir = promisify(readdir)

readFile = promisify(fs.readFile)

// import logo from '../../assets/Logo3.png';

function Main({ history }) {
  const [devs, setDevs] = useState([]);
  const [loggedDev, setLoggedDev] = useState('');


  useEffect(() => {
    async function loadLoggedDev() {
      const token = await localStorage.getItem('findevs-token');

      const decoded = await promisify(jwt.verify)(token, authConfig.secret);

      const { github_user } = decoded;

      const response = await api.get(`dev/${github_user}`);

      setLoggedDev(response.data);
    }

    loadLoggedDev();
  }, []);

  // load devs
  useEffect(() => {
    async function loadDevs() {
      const response = await api.get('/devs');

      setDevs(response.data);
    }
    // decode token to get logged user


    loadDevs();
  }, []);


  // inative user - disable
  function hadleHide() {
    alert('This feat is under construction for now!');
  }

  // logout func
  function logout() {
    localStorage.removeItem('findevs-token');
    history.push('/');
  }


  return (
    <div id="main">
      <aside>
        <DevProfile dev={loggedDev} key={loggedDev.name} logout={logout} handleHide={hadleHide} />
      </aside>
      <main>
        <ul>
          {devs.map((dev) => (
            <DevItem dev={dev} key={dev._id} />
          ))}
        </ul>
      </main>
    </div>
  );
}

redisSubscribe = promisify(subClient.subscribe.bind(subClient))