Error: missing db argument when i make Grid(db, mongo)

Question

i use gridfs to store the files in monogodb when i retrive files to database i make the Grid type object but here the error which is missing db argument how to solve this

import mongoose from "mongoose";
import Folders from "../models/Folder.js";
import path from "path";
import Grid from "gridfs-stream";
import fs from "fs";

const connection = mongoose.connection;
// Grid.mongo = mongoose.mongo;
// const gfs = Grid(mongoose.connection.db, mongoose.mongo);
// Grid.mongo = mongoose.mongo;
const db = mongoose.connection.db;
const mongo = mongoose.mongo;
var gfs = Grid(db,mongo);

here the output：

Answer 1

From the Connection.prototype.db documentation:

The mongodb.Db instance, set when the connection is opened

This means the mongoose.connection.db will be set when the connection is opened. Before the connection is opened, the value is undefined. That's why you got the error, gridfs-stream library will validate the parameters here 1.1.1/lib/index.js#L25

Connect the database server first using mongoose.connect() method.

import Grid from 'gridfs-stream';
import mongoose from 'mongoose';
import { config } from '../../config';

(async function main() {
    try {
        console.log('Before DB connected: ', mongoose.connection.db);
        await mongoose.connect(config.MONGODB_URI);
        const { db } = mongoose.connection;
        console.log('DB connected: ', db);
        const mongo = mongoose.mongo;

        const gfs = Grid(db, mongo);
        console.log(gfs);
    } catch (error) {
        console.error(error);
    } finally {
        await mongoose.connection.close();
    }
})();

Logs:

Before DB connected:  undefined
DB connected:  Db {
  s: {
    options: {
      enableUtf8Validation: true,
      forceServerObjectId: false,
      pkFactory: [Object],
      raw: false,
      readPreference: [ReadPreference],
      retryWrites: true
    },
    readPreference: ReadPreference {
      mode: 'primary',
      tags: undefined,
      hedge: undefined,
      maxStalenessSeconds: undefined,
      minWireVersion: undefined
    },
    bsonOptions: {
      raw: false,
      useBigInt64: false,
      promoteLongs: true,
      promoteValues: true,
      promoteBuffers: false,
      ignoreUndefined: false,
      bsonRegExp: false,
      serializeFunctions: false,
      fieldsAsRaw: {},
      enableUtf8Validation: true
    },
    pkFactory: { createPk: [Function: createPk] },
    readConcern: undefined,
    writeConcern: undefined,
    namespace: MongoDBNamespace { db: 'test', collection: undefined }
  },
  client: <ref *1> MongoClient {
    _events: [Object: null prototype] {
      topologyDescriptionChanged: [Function (anonymous)]
    },
    _eventsCount: 1,
    _maxListeners: 0,
    mongoLogger: MongoLogger {
      error: [Function: bound log],
      warn: [Function: bound log],
      info: [Function: bound log],
      debug: [Function: bound log],
      trace: [Function: bound log],
      componentSeverities: [Object],
      maxDocumentLength: 1000,
      logDestination: [Object]
    },
    s: {
      url: 'mongodb+srv://slideshowp2:[email protected]',
      bsonOptions: [Object],
      namespace: [MongoDBNamespace],
      hasBeenClosed: false,
      sessionPool: [ServerSessionPool],
      activeSessions: Set(0) {},
      options: [Getter],
      readConcern: [Getter],
      writeConcern: [Getter],
      readPreference: [Getter],
      isMongoClient: [Getter]
    },
    connectionLock: undefined,
    topology: Topology {
      _events: [Object: null prototype],
      _eventsCount: 26,
      _maxListeners: undefined,
      client: [Circular *1],
      selectServerAsync: [Function (anonymous)],
      s: [Object],
      [Symbol(kCapture)]: false,
      [Symbol(waitQueue)]: [List]
    },
    [Symbol(kCapture)]: false,
    [Symbol(options)]: [Object: null prototype] {
      hosts: [Array],
      credentials: [MongoCredentials],
      compressors: [Array],
      connectTimeoutMS: 30000,
      directConnection: false,
      driverInfo: [Object],
      enableUtf8Validation: true,
      forceServerObjectId: false,
      heartbeatFrequencyMS: 10000,
      keepAlive: true,
      keepAliveInitialDelay: 120000,
      loadBalanced: false,
      localThresholdMS: 15,
      maxConnecting: 2,
      maxIdleTimeMS: 0,
      maxPoolSize: 100,
      minPoolSize: 0,
      minHeartbeatFrequencyMS: 500,
      monitorCommands: false,
      noDelay: true,
      pkFactory: [Object],
      raw: false,
      readPreference: [ReadPreference],
      retryReads: true,
      retryWrites: true,
      serverSelectionTimeoutMS: 30000,
      socketTimeoutMS: 0,
      srvMaxHosts: 0,
      srvServiceName: 'mongodb',
      waitQueueTimeoutMS: 0,
      zlibCompressionLevel: 0,
      dbName: 'test',
      userSpecifiedAuthSource: false,
      userSpecifiedReplicaSet: false,
      srvHost: 'cluster0.d1avjia.mongodb.net',
      tls: true,
      mongoLoggerOptions: [Object],
      metadata: [Object],
      replicaSet: 'atlas-zy5qpa-shard-0',
      [Symbol(@@mdb.enableMongoLogger)]: false
    }
  }
}
Grid {
  db: Db {
    s: {
      options: [Object],
      readPreference: [ReadPreference],
      bsonOptions: [Object],
      pkFactory: [Object],
      readConcern: undefined,
      writeConcern: undefined,
      namespace: [MongoDBNamespace]
    },
    client: MongoClient {
      _events: [Object: null prototype],
      _eventsCount: 1,
      _maxListeners: 0,
      mongoLogger: [MongoLogger],
      s: [Object],
      connectionLock: undefined,
      topology: [Topology],
      [Symbol(kCapture)]: false,
      [Symbol(options)]: [Object: null prototype]
    }
  },
  mongo: {
    BSON: [Getter],
    Binary: [Getter],
    BSONRegExp: [Getter],
    BSONSymbol: [Getter],
    BSONType: [Getter],
    Code: [Getter],
    DBRef: [Getter],
    Decimal128: [Getter],
    Double: [Getter],
    Int32: [Getter],
    Long: [Getter],
    MaxKey: [Getter],
    MinKey: [Getter],
    ObjectId: [Getter],
    Timestamp: [Getter],
    MongoBulkWriteError: [Getter],
    ChangeStreamCursor: [Getter],
    MongoAPIError: [Getter],
    MongoAWSError: [Getter],
    MongoBatchReExecutionError: [Getter],
    MongoChangeStreamError: [Getter],
    MongoCompatibilityError: [Getter],
    MongoCursorExhaustedError: [Getter],
    MongoCursorInUseError: [Getter],
    MongoDecompressionError: [Getter],
    MongoDriverError: [Getter],
    MongoError: [Getter],
    MongoExpiredSessionError: [Getter],
    MongoGridFSChunkError: [Getter],
    MongoGridFSStreamError: [Getter],
    MongoInvalidArgumentError: [Getter],
    MongoKerberosError: [Getter],
    MongoMissingCredentialsError: [Getter],
    MongoMissingDependencyError: [Getter],
    MongoNetworkError: [Getter],
    MongoNetworkTimeoutError: [Getter],
    MongoNotConnectedError: [Getter],
    MongoParseError: [Getter],
    MongoRuntimeError: [Getter],
    MongoServerClosedError: [Getter],
    MongoServerError: [Getter],
    MongoServerSelectionError: [Getter],
    MongoSystemError: [Getter],
    MongoTailableCursorError: [Getter],
    MongoTopologyClosedError: [Getter],
    MongoTransactionError: [Getter],
    MongoUnexpectedServerResponseError: [Getter],
    MongoWriteConcernError: [Getter],
    AbstractCursor: [Getter],
    Admin: [Getter],
    AggregationCursor: [Getter],
    CancellationToken: [Getter],
    ChangeStream: [Getter],
    ClientSession: [Getter],
    Collection: [Getter],
    Db: [Getter],
    FindCursor: [Getter],
    GridFSBucket: [Getter],
    GridFSBucketReadStream: [Getter],
    GridFSBucketWriteStream: [Getter],
    ListCollectionsCursor: [Getter],
    ListIndexesCursor: [Getter],
    MongoClient: [Getter],
    OrderedBulkOperation: [Getter],
    UnorderedBulkOperation: [Getter],
    BatchType: [Getter],
    GSSAPICanonicalizationValue: [Getter],
    AuthMechanism: [Getter],
    Compressor: [Getter],
    CURSOR_FLAGS: [Getter],
    AutoEncryptionLoggerLevel: [Getter],
    MongoErrorLabel: [Getter],
    ExplainVerbosity: [Getter],
    ServerApiVersion: [Getter],
    ReturnDocument: [Getter],
    ProfilingLevel: [Getter],
    ReadConcernLevel: [Getter],
    ReadPreferenceMode: [Getter],
    ServerType: [Getter],
    TopologyType: [Getter],
    ReadConcern: [Getter],
    ReadPreference: [Getter],
    WriteConcern: [Getter],
    CommandFailedEvent: [Getter],
    CommandStartedEvent: [Getter],
    CommandSucceededEvent: [Getter],
    ConnectionCheckedInEvent: [Getter],
    ConnectionCheckedOutEvent: [Getter],
    ConnectionCheckOutFailedEvent: [Getter],
    ConnectionCheckOutStartedEvent: [Getter],
    ConnectionClosedEvent: [Getter],
    ConnectionCreatedEvent: [Getter],
    ConnectionPoolClearedEvent: [Getter],
    ConnectionPoolClosedEvent: [Getter],
    ConnectionPoolCreatedEvent: [Getter],
    ConnectionPoolMonitoringEvent: [Getter],
    ConnectionPoolReadyEvent: [Getter],
    ConnectionReadyEvent: [Getter],
    ServerClosedEvent: [Getter],
    ServerDescriptionChangedEvent: [Getter],
    ServerHeartbeatFailedEvent: [Getter],
    ServerHeartbeatStartedEvent: [Getter],
    ServerHeartbeatSucceededEvent: [Getter],
    ServerOpeningEvent: [Getter],
    TopologyClosedEvent: [Getter],
    TopologyDescriptionChangedEvent: [Getter],
    TopologyOpeningEvent: [Getter],
    SrvPollingEvent: [Getter]
  },
  curCol: 'fs'
}

package versions:

"gridfs-stream": "^1.1.1",
"mongoose": "^7.3.1",