Pruebe el siguiente código y asegúrese de que la función contenga una word clave en espera que siempre debe tener una función asíncrona (la word clave asíncrona debe usarse antes del nombre de la función). Pero en su caso, la función de devolución de llamada ya está definida como función asíncrona.

Simplemente cambie la parte de ahorro solo a abajo, está listo para comenzar.

 try {
 const catModel = mongoose.model('testColl', catSchema);
 const cat = new catModel({ name: 'Zildjian' });
 const response = await cat.save(); // if error while saving, catch will get executed
 console.log(response); // saved record
 // return success response 
} catch (err) {
 console.log('err' + err);
 // return error response
}

Primero debe hacer que connectDB sea asíncrono y luego deshacerse de mongoose.connection.once() ya que, de lo contrario, necesitaría que todo su código Mongoose estuviera allí.

 main().catch((err) => console.log(err));

async function main() {
 await connectDb('testDB');

 const catSchema = new mongoose.Schema({ name: String });
 const catDocument = mongoose.model('testColl', catSchema);

 const catObj = new catDocument({ name: 'Zildjian' });
 await catObj.save();
}

conectar DB

 import mongoose from 'mongoose';
import { strict as assert } from 'assert';
import { readToml } from './readToml';

const db = readToml('./config/database.toml');

export async function connectDb(
 database: string = db.database,
 uri: string = db.uri,
 username: string = db.username,
 password: string = db.password,
) {
 assert(typeof uri === 'string');
 assert(typeof database === 'string');
 assert(typeof username === 'string');
 assert(typeof password === 'string');

 const URI = `mongodb+srv://${username}:${password}@${uri}/${database}?retryWrites=true&w=majority`;

 const options = {
 bufferCommands: false,
 autoCreate: false,
 };

 try {
 await mongoose.connect(URI, options);
 } catch (err: any) {
 throw err.message;
 }
}

Para usar await , debe proporcionar una promesa para esperar. cat.save() devuelve una promesa, por lo que debería funcionar. Sin embargo, solo puede usar await en la función asíncrona, por lo que también debe declarar la función de devolución de llamada para el evento abierto como asíncrono:

 (async () => {
 connectDb('testDB');

 mongoose.connection.once('open', async () => {
 console.log('MongoDB is connected');

 mongoose.connection.db.listCollections().toArray(function (err, names) {
 console.log(names);
 });

 const catModel = mongoose.model('testColl', catSchema);

 const cat = new catModel({ name: 'Zildjian' });
 await cat.save();
 console.log('Saved in db');
 });
})();