How to use the mongodb-memory-server function in mongodb-memory-server

async startMongo() {
    this.mongoServer = new MongoDBMemoryServer();
    const mongoUri = await this.mongoServer.getConnectionString();
    this.connection = await MongoClient.connect(mongoUri);
    this.db = this.connection.db(await this.mongoServer.getDbName());

    defineCollections(this.db, this.collections);

    const { Media } = setUpFileCollections({
      absoluteUrlPrefix: "http://fake.com",
      db: this.db,
      Logger: { info: console.info.bind(console) }, // eslint-disable-line no-console
      MediaRecords: this.collections.MediaRecords,
      mongodb
    });

    this.collections.Media = Media;
  }

console.log('started dev_mongo_server')

import MongodbMemoryServer from 'mongodb-memory-server';
// import { MongoClient } from 'mongodb'
import restore from 'mongodb-restore'

console.log('imported monogodb memory server && mongodb restore')

import DB from './flux/db'

let port = 53799

console.log("creating mongo memory server")
const mongod = new MongodbMemoryServer({instance: {port, dbName: "flux"}, debug: true});
console.log('created monogo memory server')

async function main() {
    const uri = await mongod.getConnectionString()
    console.log("DB URI:", uri)
    const db = await DB.init({}, uri)
    const {client, rawDb} = db.dbv1
    // always refresh for the moment
    if ((await rawDb.collections()).length < 5 || true) {
        // then we need to populate it
        console.log("loading saved db")
        await new Promise((res, rej) => restore({uri, drop: true, root: __dirname + "/dev-mongo-data/flux", callback: (e,v) => e ? rej(e) : res(v)}));
    }
    console.log("Mongo server ready!")
}

mongoose.connect = (async () => {
  const mongoServer = new MongodbMemoryServer();

  const mongoUri = await mongoServer.getConnectionString(true);

  // originalConnect.bind(mongoose)(mongoUri, { useMongoClient: true }); // mongoose 4
  originalConnect.bind(mongoose)(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true }); // mongoose 5

  mongoose.connection.on('error', e => {
    if (e.message.code === 'ETIMEDOUT') {
      console.error(e);
    } else {
      throw e;
    }
  });

  mongoose.connection.once('open', () => {
    // console.log(`MongoDB successfully connected to ${mongoUri}`);

import { ApolloServer } from 'apollo-server';
import AMM from '../src';
import QueryExecutor from '@apollo-model/mongodb-executor';
import { MongoClient, ObjectID } from 'mongodb';
import typeDefs from './model';
import MongoMemoryServer from 'mongodb-memory-server';
import * as DirectiveImplements from '@apollo-model/directive-implements';
const util = require('util');

export const mongod = new MongoMemoryServer();
const uri = mongod.getConnectionString();
const dbName = mongod.getDbName();

let DB = null;

export const connectToDatabase = () => {
  if (DB && DB.serverConfig.isConnected()) {
    return Promise.resolve(DB);
  }
  return Promise.all([uri, dbName]).then(([uri, dbName]) =>
    MongoClient.connect(uri, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    }).then(client => {
      DB = client.db(dbName);
      return DB;

const initMongoServer = () => {
  mongod = new MongodbMemoryServer();
  return mongod.getConnectionString()
  .then((uri) => {
    connected = true;
    db = pow.connect(uri);
    testingDB.clear = db.clear.bind(db);
    return mongoose.connect(uri, { useMongoClient: true });
  });
};