¿Cómo leer correctamente un archivo con async / await?

No puedo entender cómo funciona async/ await. Lo entiendo un poco, pero no puedo hacer que funcione.

function loadMonoCounter() {
    fs.readFileSync("monolitic.txt", "binary", async function(err, data) {
       return await new Buffer( data);
  });
}

module.exports.read = function() {
  console.log(loadMonoCounter());
};

Sé que podría utilizar readFileSync, pero si lo hago, sé que nunca voy a entender async/ awaity voy a enterrar el asunto.

Objetivo: llamar loadMonoCounter()y devolver el contenido de un archivo.

Ese archivo se incrementa cada vez que incrementMonoCounter()se llama (cada carga de página). El archivo contiene el volcado de un búfer en binario y se almacena en un SSD.

No importa lo que haga, aparece un error o undefineden la consola.

Para usar await/ asyncnecesita métodos que devuelvan promesas. Las funciones principales de la API no hacen eso sin envoltorios como promisify:

const fs = require('fs');
const util = require('util');

// Convert fs.readFile into Promise version of same    
const readFile = util.promisify(fs.readFile);

function getStuff() {
  return readFile('test');
}

// Can't use `await` outside of an async function so you need to chain
// with then()
getStuff().then(data => {
  console.log(data);
})

Como nota, readFileSyncno acepta una devolución de llamada, devuelve los datos o lanza una excepción. No obtiene el valor que desea porque la función que proporciona se ignora y no está capturando el valor de retorno real.

Dado que las promesas de Node v11.0.0 fs están disponibles de forma nativa sin promisify:

const fs = require('fs').promises;
async function loadMonoCounter() {
    const data = await fs.readFile("monolitic.txt", "binary");
    return new Buffer(data);
}

Esta es la versión TypeScript de la respuesta de @ Joel. Se puede usar después del Nodo 11.0:

import { promises as fs } from 'fs';

async function loadMonoCounter() {
    const data = await fs.readFile('monolitic.txt', 'binary');
    return Buffer.from(data);
}

Puede envolver fácilmente el comando readFile con una promesa como esta:

async function readFile(path) {
    return new Promise((resolve, reject) => {
      fs.readFile(path, 'utf8', function (err, data) {
        if (err) {
          reject(err);
        }
        resolve(data);
      });
    });
  }

luego usa:

await readFile("path/to/file");

Puede usar fs.promisesdisponible de forma nativa desde Node v11.0.0

import fs from 'fs';

const readFile = async filePath => {
  try {
    const data = await fs.promises.readFile(filePath, 'utf8')
    return data
  }
  catch(err) {
    console.log(err)
  }
}

Hay un fs.readFileSync( path, options )método que es sincrónico.