TypeScript Db.open方法代码示例

async function openDB() {
  try {
    await db.open();
    console.log('Connected to mongodb');
  } catch (error) {
    console.error('Error connecting to mongodb.', error);
  }
}

        return new Promise<mongodb.Db>(function (resolve, reject)
        {
            if (!host)
                return reject(new Error("Please provide a 'host' field in your configuration"));
            if (!port)
                return reject(new Error("Please provide a 'port' field in your configuration"));
            if (!database)
                return reject(new Error("Please provide a 'databaseName' field in your configuration"));

            var mongoServer: mongodb.Server = new mongodb.Server(host, port, opts);
            var mongoDB: mongodb.Db = new mongodb.Db(database, mongoServer, { w: 1 });
            mongoDB.open(function (err: Error, db: mongodb.Db)
            {
                if (err || !db)
                    reject(err);
                else
                    resolve(db);
            });
        });

        public getAll(callback: Function) {
            var url = global.config.appSettings.database.mongodb.host;
            var Db = require('mongodb').Db;
            var Server = require('mongodb').Server;

            var db = new Db('scripter', new Server('localhost', 27017));
            // Establish connection to db
            db.open(function (err: any, db1: any) {
                assert.equal(null, err);
                // Return the information of a all collections, using the callback format
                db.collections(function (err: any, items: any) {
                    assert.ok(items.length > 0);
                    var fitems: any = [];
                    for (var i = 0; i < items.length; i++) {
                        fitems.push(items[i].s.name);
                    }
                    callback(fitems);
                });
            });
        }

//setup mongodb
var dbServer = new mongo.Server(CodeSoar.Server.Config.Get().MONGODB_HOST,
								CodeSoar.Server.Config.Get().MONGODB_PORT);

var db = new mongo.Db(CodeSoar.Server.Config.Get().MONGODB_DB_NAME,
					  dbServer, {auto_reconnect: true, w:1});

//open connection to mongodb and authenticate ourselves.
db.open(function(err, db) {

	if (err)
		throw err;

	db.authenticate(CodeSoar.Server.Config.Get().MONGODB_USERNAME,
					CodeSoar.Server.Config.Get().MONGODB_PASSWORD,
					function (err, result) {

						if (err)
							throw err;

					});

});

//Setup Docs and Changes collections for mongodb
var docsDb;
var changesDb;

db.createCollection('docs');
db.createCollection('changes');

import {MongoClient, Db, Server, ServerOptions} from 'mongodb';
import * as Rx from "rx";
import {IArticle} from '../models/article';

var o: ServerOptions = {}
var server = new Server('localhost', 27017, o)
var db = new Db('dea', server, { w: 1 });
db.open(function() { });

export function count(title: string): Rx.Observable<number> {
    return Rx.Observable.create((observer: Rx.Observer<number>) => {
        db.collection("articles")
            .count({ title: { $regex: `\\b${title}\\b`, $options: 'i' } }, (err, count) => {
                if (err) { observer.onError(err); }
                observer.onNext(count);
                observer.onCompleted();
            });
    });
}

export function find(title: string): Rx.Observable<IArticle[]> {
    return Rx.Observable.create((observer: Rx.Observer<IArticle[]>) => {
        db.collection("articles")
            .find({ title: { $regex: `\\b${title}\\b`, $options: 'i' } })
            .toArray((err, result) => {
                if (err) { observer.onError(err); }
                observer.onNext(result);
                observer.onCompleted();
            });
    });
}

export async function initialize() {

    initializeLogger();
    const config = loadConfig()!;

    info( `Attempting to connect to mongodb...` );

    if ( !config.database )
        throw new Error( 'No database object defined in the config file' );

    const mongoServer = new MongoServer( config.database.host, config.database.port, { servername: config.database.name } );
    const mongoDB = new Db( config.database.name, mongoServer, { w: 1 } );
    const db = await mongoDB.open();

    info( `Successfully connected to '${config.database.name}' at ${config.database.host}:${config.database.port}` );
    info( `Starting up HTTP servers...` );

    // Create each of your servers here
    const promises: Array<Promise<any>> = [];

    await prepare( db, config );
    const clients = await discoverClients( config );

    const servers: Server[] = [];

    // First create the servers
    for ( const client of clients ) {
        if ( typeof client.server !== 'string' )
            servers.push( new Server( client.server, client.path ) );
    }

    // Now go through the add on clients and add the controllers
    // to any existing servers defined in the client
    for ( const client of clients ) {
        let server: Server | undefined;
        let clientServer = client.server;

        if ( typeof clientServer === 'string' )
            server = servers.find( s => s.server.host === clientServer );
        else
            server = servers.find( s => s.server.host === ( clientServer as IServer ).host );

        if ( !server ) {
            error( `Could not find an existing server with the name ${client.server}` );
            process.exit();
        }

        server!.parseClient( client );
    }

    for ( const server of servers )
        promises.push( server.initialize( db ) );

    // Load each of the servers
    await Promise.all( promises );

    info( `Server instances loaded...` );

    // Create the console manager
    if ( !args.runningTests )
        new ConsoleManager().initialize();
}

// Mongo
import {Server} from "mongodb";
import {Db} from "mongodb";


var server = new Server("localhost", 27017, {auto_reconnect: true});
var db = new Db("chronicledb", server, {w: 1});
db.open(null);

export = db;

 private ouvrirConnection() {
     this._db.open(function () { });
     this.ecrireLog("Connection base");
 }

 open: function (callback) {
     db.open(callback);
 }