NODEJS + EXPRESS - Al usar REQUIRE siempre obtengo "undefined"

PROBLEMA

El problema que tienes es el manejo de los procesos asíncronos en tu código. Nada de eso tiene que ver con la forma en que trabaja el método require().

Actualmente, en tu código del módulo getToken.js, tienes una llamada a un proceso asíncrono:

await instance.post()

Y aunque la función getToken la declaras con la sentencia async, no estás tratando el resultado de dicha función como lo que es: una Promesa.

SOLUCIÓN

La solución pasa primero por entender el proceso asíncrono del método de instancia post() de axios, el cual devuelve una Promesa.

Una Promesa en esencia lo que su palabra significa: la promesa de obtener un resultado a futuro. Y es debido a esta naturaleza (y a la naturaleza del lenguaje javascript) que nunca podremos garantizar cuándo un resultado devuelto por una Promesa esté disponible para ser usado (en una secuencia lineal o síncrona) en nuestro programa.

Hemos de tomar en cuenta que toda función tipo async devuelve una Promesa (realmente devuelve una instancia de una AsyncFunction).

Por otro lado, al método then() le estás pasando una segunda función, cosa que no es correcto, ya que then sólo espera 1 función callback. Lo que haces con la segunda función deberías pasarlo al método catch():

let token = await instancia.post()
            .then(callback_1)
            .catch(callback_2);

Para entender el funcionamiento de un método asíncrono, veamos el siguiente ejemplo:

const saludar = async someone => {
  if(!someone) {
    someone = '';
  }
  return `¡Hola ${someone}!`
}

const miSaludo = async () => {
  saludo = await saludar('Mauricio').then(resultado => {
    console.log(`Obtuve este resultado: ${resultado}`);
  });
  console.log(`miSaludo(): ${saludo}`);
}

const miSaludoReturn = async () => {
  saludo = await saludar('MANZARBEITIA').then(resultado => {
    return resultado;
  });
  console.log(`miSaludoReturn(): ${saludo}`);
}

const miSaludoSinThen = async () => {
  saludo = await saludar();
  console.log(`miSaludoSinThen: ${saludo}`);
}


miSaludo();

miSaludoReturn();

miSaludoSinThen();

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

En el código anterior se tienen 3 casos de llamadas a funciones asíncronas.

En el primer caso, se hace una llamada a la función saludar usando la sentencia await, y el resultado se asigna a la variable saludo. Además, se utiliza el método then(), sin embargo dentro del mismo no se devuelve el resultado, solo se muestra por consola. Podemos observar que el resultado asignado a la variable saludo es undefined.

En el segundo caso, se hace la misma rutina que en el primer caso, pero introducimos una sentencia return dentro del método then, por lo cual, se devuelve una Promesa. Ya que hemos usado una sentencia await, el resultado de esta Promesa (la variable result pasada como argumento al callback en then) se asigna a la variable saludo.

En el tercer caso, no usamos el método then. Simplemente se recibe el resultado de la función saludar en la variable saludo. De esta forma el código es incluso más legible, y sería la forma preferida de usar resultados de una Promesa directamente, a menos que queramos manipular el mismo antes de asignarlo a la variable donde será recibido.

Aclarados estos puntos, podemos ajustar tu función getToken para que la misma utilice correctamente then y catch. Además, ajustaremos el código de tu aplicación para que puedas usar correctamente el valor devuelto por esta función.

// ARCHIVO GETTOKEN JS --> routes/pre/getToken.js
const axios = require('axios');

// función tipo async: devuelve una Promesa
const getToken = async() => {
  const instance = axios.create({
    baseURL: 'https://auth.es-pre.baikalplatform.com/token?client_id=baikal-api-read&client_secret=B6Dk9CBsfouihKIo8WNh&grant_type=client_credentials'
  });

  let token = await instance.post()
    .then(r => {
      return r.data.access_token;
    })
    .catch(e => {
      // debemos decidir qué hacer con el posible error, lo usual es hacer un throw
      throw e;
    });
  // ahora podemos devolver el token
  return token;
}

// ahora podemos exportar nuestra función (recordar que es una Promesa)
module.exports = getToken;

Ahora que ya sabemos que nuestro módulo getToken devuelve una Promesa, debemos usarlo como tal al momento de hacer el require.

Por ejemplo:

// ARCHIVO APIS JS --> Routes/pre/apis.js**
const axios = require('axios');
const { Router } = require('express');

// getToken devuelve una Promesa, recordar eso.
const { getToken } = require('./getToken');

const router = Router();

// getToken es una Promesa, para usar su resultado debo usar then y catch
getToken
.then(token => {
  console.log(token);
})
.catch(error => {
  console.log(`Ocurrió un error al obtener el token: ${error.message}`);
});

module.exports = router;

De esta forma al momento de hacer el require de nuestro módulo apis.js se ejecutará la llamada al método getToken y una vez obtenido el resultado se mostrará en pantalla. Si la llamada de axios arrojara algún error, el mismo será capturado por el método catch() de nuestro módulo getToken y como en el mismo estamos simplemente lanzando dicho error, el mismo será capturado por nuestro método catch en apis.js donde nos mostrará el mensaje de error.

Para usar el valor del token siempre debemos recordar que el mismo es el resultado de un proceso asíncrono (el método post de axios es asíncrono), por lo cual, la única forma de tener acceso a dicho resultado será dentro de una función callback pasada como argumento al método then o usando la sentencia await (dentro de una función o entorno async) para esperar directamente por dicho resultado.

Espero que esto te ayude a resolver el problema y aclare un poco más el uso de procesos asíncronos.