AWS Lambda Database connection issue [updated issue]

I would start using the promises/async/await instead of callback pattern. Something like

const request = require("request");
const tickerController = require("./controllers/ticker");

const mongoose = require("mongoose");

let conn = null;

const uri = `mongodb+srv://${process.env.dbUser}:${process.env.dbPassword}@cluster0-oj6p1.mongodb.net/test?retryWrites=true&w=majority`;

exports.handler = async event => {
  // Make sure to add this so you can re-use `conn` between function calls.
  // See https://www.mongodb.com/blog/post/serverless-development-with-nodejs-aws-lambda-mongodb-atlas
  context.callbackWaitsForEmptyEventLoop = false;

  // Because `conn` is in the global scope, Lambda may retain it between
  // function calls thanks to `callbackWaitsForEmptyEventLoop`.
  // This means your Lambda function doesn't have to go through the
  // potentially expensive process of connecting to MongoDB every time.
  if (conn == null) {
    conn = await mongoose.createConnection(uri, {
      // Buffering means mongoose will queue up operations if it gets
      // disconnected from MongoDB and send them when it reconnects.
      // With serverless, better to fail fast if not connected.
      bufferCommands: false, // Disable mongoose buffering
      bufferMaxEntries: 0, // and MongoDB driver buffering
      useUnifiedTopology: true,
      useNewUrlParser: true
    });
    // conn.model('Test', new mongoose.Schema({ name: String }));
    // console.log(conn);
    console.log(conn.readyState);

    const body = await runRequest();
    return body;
    // })
  }
};

function runRequest() {
  return new Promise((resolve, reject) => {
    request(
      "https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol=BKUH&apikey=" +
        process.env.apiKey,
      (err, response, body) => {
        console.log("Request ran");
        if (err) {
          console.error(err);
          reject(err);
        }
        resolve(body);
      }
    );
  });
}

So the answer with the database connection issue was to refactor my code to one file, and use the 'conn' variable as a global object to create my model, like so..

let conn = null;
let Ticker = null;

const uri = `mongodb+srv://${process.env.dbUser}:${process.env.dbPassword}@cluster0-oj6p1.mongodb.net/bakhu?retryWrites=true&w=majority`;

exports.handler = async function main(event, context, lambdaCallback) {
  // Make sure to add this so you can re-use `conn` between function calls.
  // See https://www.mongodb.com/blog/post/serverless-development-with-nodejs-aws-lambda-mongodb-atlas
    context.callbackWaitsForEmptyEventLoop = false;

    // Because `conn` is in the global scope, Lambda may retain it between
    // function calls thanks to `callbackWaitsForEmptyEventLoop`.
    // This means your Lambda function doesn't have to go through the
    // potentially expensive process of connecting to MongoDB every time.
    if (conn == null) {
      conn = await mongoose.createConnection(uri, {
        // Buffering means mongoose will queue up operations if it gets
        // disconnected from MongoDB and send them when it reconnects.
        // With serverless, better to fail fast if not connected.
        bufferCommands: false, // Disable mongoose buffering
        bufferMaxEntries: 0, // and MongoDB driver buffering
        useUnifiedTopology: true,
        useNewUrlParser: true
      });
      // conn.model('Test', new mongoose.Schema({ name: String }));
      // console.log(conn);
      console.log(conn.readyState);

      const Schema = mongoose.Schema;
      const moment = require('moment');

      const tickerSchema = new Schema({
        createdAt: { type: Date },
        updatedAt: { type: Date },
        symbol: { type: String },
        latestPrice: { type: String }
      });

      tickerSchema.pre('save', function (next) {
        let ticker = this;

        this.createdAt = ticker.createdAt ? ticker.createdAt : moment().local();
        this.updatedAt = moment().local();

        next();
      })

      Ticker = conn.model('Ticker', tickerSchema);

When I called my schema methods in a separate file, it never shared the connection.