Socket
Socket
Sign inDemoInstall

@mongosh/service-provider-server

Package Overview
Dependencies
Maintainers
11
Versions
120
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@mongosh/service-provider-server - npm Package Compare versions

Comparing version 0.5.0 to 0.5.1

82

lib/cli-service-provider.d.ts
import { MongoClient } from 'mongodb';
import { ServiceProvider, Document, Cursor, Result, BulkWriteResult, DatabaseOptions, WriteConcern, CommandOptions, ReplPlatform, ServiceProviderCore, AuthOptions, ReadConcern, ReadPreference } from '@mongosh/service-provider-core';
import type { CollStats, IndexSpecification, FindOneAndUpdateOption, CollectionInsertOneOptions, CollectionInsertManyOptions, FindAndModifyWriteOpResultObject, CollectionAggregationOptions, CollectionBulkWriteOptions, ReplaceWriteOpResult, FilterQuery, UpdateManyOptions, UpdateOneOptions, UpdateWriteOpResult, Collection, MongoCountPreferences, CommonOptions, DeleteWriteOpResultObject, MongoDistinctPreferences, FindOneOptions, FindOneAndDeleteOption, FindOneAndReplaceOption, UpdateQuery, WriteOpResult, OrderedBulkOperation, UnorderedBulkOperation, InsertWriteOpResult, ReplaceOneOptions, InsertOneWriteOpResult } from 'mongodb';
import { ServiceProvider, Document, Cursor, Result, BulkWriteResult, DatabaseOptions, WriteConcern, CommandOptions, getConnectInfo, ReplPlatform, ServiceProviderCore, AuthOptions, ReadConcern, ReadPreference } from '@mongosh/service-provider-core';
import NodeOptions from './node/node-options';

@@ -8,6 +9,9 @@ declare type DropDatabaseResult = {

};
declare type ConnectionInfo = ReturnType<typeof getConnectInfo>;
declare class CliServiceProvider extends ServiceProviderCore implements ServiceProvider {
readonly platform: ReplPlatform;
readonly initialDb: string;
static connect(uri: string, options?: NodeOptions, cliOptions?: any): Promise<CliServiceProvider>;
static connect(uri: string, options?: NodeOptions, cliOptions?: {
nodb?: boolean;
}): Promise<CliServiceProvider>;
mongoClient: MongoClient;

@@ -18,32 +22,38 @@ private readonly uri?;

getNewConnection(uri: string, options?: NodeOptions): Promise<CliServiceProvider>;
getConnectionInfo(): Promise<any>;
renameCollection(database: string, oldName: string, newName: string, options?: Document, dbOptions?: DatabaseOptions): Promise<any>;
findAndModify(database: string, collection: string, query: Document, sort: any[] | Document, update: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<any>;
convertToCapped(database: string, collection: string, size: number, options?: CommandOptions, dbOptions?: DatabaseOptions): Promise<any>;
getConnectionInfo(): Promise<{
buildInfo: any;
topology: any;
extraInfo: ConnectionInfo;
}>;
renameCollection(database: string, oldName: string, newName: string, options?: Document, dbOptions?: DatabaseOptions): Promise<Collection>;
findAndModify(database: string, collection: string, query: Document, sort: any[] | Document | undefined, update: Document | undefined, options?: Document, dbOptions?: DatabaseOptions): Promise<FindAndModifyWriteOpResultObject<any>>;
convertToCapped(database: string, collection: string, size: number, options?: CommandOptions, dbOptions?: DatabaseOptions): Promise<undefined | object>;
private db;
aggregate(database: string, collection: string, pipeline?: Document[], options?: Document, dbOptions?: DatabaseOptions): Cursor;
aggregate(database: string, collection: string, pipeline?: Document[], options?: CollectionAggregationOptions, dbOptions?: DatabaseOptions): Cursor;
aggregateDb(database: string, pipeline?: Document[], options?: Document, dbOptions?: DatabaseOptions): Cursor;
bulkWrite(database: string, collection: string, requests: any, options?: Document, dbOptions?: DatabaseOptions): Promise<BulkWriteResult>;
bulkWrite(database: string, collection: string, requests: any[], options?: CollectionBulkWriteOptions, dbOptions?: DatabaseOptions): Promise<BulkWriteResult>;
close(force: boolean): Promise<void>;
count(database: string, collection: string, query?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
countDocuments(database: string, collection: string, filter?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
deleteMany(database: string, collection: string, filter?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
deleteOne(database: string, collection: string, filter?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
distinct(database: string, collection: string, fieldName: string, filter?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<any>;
estimatedDocumentCount(database: string, collection: string, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
find(database: string, collection: string, filter?: Document, options?: Document, dbOptions?: DatabaseOptions): Cursor;
findOneAndDelete(database: string, collection: string, filter?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
findOneAndReplace(database: string, collection: string, filter?: Document, replacement?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
findOneAndUpdate(database: string, collection: string, filter?: Document, update?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
insertMany(database: string, collection: string, docs?: Document[], options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
insertOne(database: string, collection: string, doc?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
isCapped(database: string, collection: string, dbOptions?: DatabaseOptions): Promise<Result>;
remove(database: string, collection: string, query?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
save(database: string, collection: string, doc: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
replaceOne(database: string, collection: string, filter?: Document, replacement?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
runCommand(database: string, spec?: Document, options?: CommandOptions, dbOptions?: DatabaseOptions): Promise<Result>;
runCommandWithCheck(database: string, spec?: Document, options?: CommandOptions, dbOptions?: DatabaseOptions): Promise<Result>;
listDatabases(database: string): Promise<Result>;
updateMany(database: string, collection: string, filter?: Document, update?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
updateOne(database: string, collection: string, filter?: Document, update?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
count(database: string, collection: string, query?: FilterQuery<any>, options?: MongoCountPreferences, dbOptions?: DatabaseOptions): Promise<number>;
countDocuments(database: string, collection: string, filter?: FilterQuery<any>, options?: MongoCountPreferences, dbOptions?: DatabaseOptions): Promise<number>;
deleteMany(database: string, collection: string, filter?: FilterQuery<any>, options?: CommonOptions, dbOptions?: DatabaseOptions): Promise<DeleteWriteOpResultObject>;
deleteOne(database: string, collection: string, filter?: FilterQuery<any>, options?: Document, dbOptions?: DatabaseOptions): Promise<DeleteWriteOpResultObject>;
distinct(database: string, collection: string, fieldName: string, filter?: FilterQuery<any>, options?: MongoDistinctPreferences, dbOptions?: DatabaseOptions): Promise<any[]>;
estimatedDocumentCount(database: string, collection: string, options?: MongoCountPreferences, dbOptions?: DatabaseOptions): Promise<number>;
find(database: string, collection: string, filter?: FilterQuery<any>, options?: FindOneOptions<any>, dbOptions?: DatabaseOptions): Cursor;
findOneAndDelete(database: string, collection: string, filter?: FilterQuery<any>, options?: FindOneAndDeleteOption<any>, dbOptions?: DatabaseOptions): Promise<FindAndModifyWriteOpResultObject<any>>;
findOneAndReplace(database: string, collection: string, filter?: FilterQuery<any>, replacement?: Document, options?: FindOneAndReplaceOption<any>, dbOptions?: DatabaseOptions): Promise<FindAndModifyWriteOpResultObject<any>>;
findOneAndUpdate(database: string, collection: string, filter?: FilterQuery<any>, update?: UpdateQuery<any>, options?: FindOneAndUpdateOption<any>, dbOptions?: DatabaseOptions): Promise<FindAndModifyWriteOpResultObject<any>>;
insertMany(database: string, collection: string, docs?: Document[], options?: CollectionInsertManyOptions, dbOptions?: DatabaseOptions): Promise<InsertWriteOpResult<any>>;
insertOne(database: string, collection: string, doc?: Document, options?: CollectionInsertOneOptions, dbOptions?: DatabaseOptions): Promise<InsertOneWriteOpResult<any>>;
isCapped(database: string, collection: string, dbOptions?: DatabaseOptions): Promise<any>;
remove(database: string, collection: string, query?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<WriteOpResult>;
save(database: string, collection: string, doc: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<WriteOpResult>;
replaceOne(database: string, collection: string, filter?: FilterQuery<any>, replacement?: Document, options?: ReplaceOneOptions, dbOptions?: DatabaseOptions): Promise<ReplaceWriteOpResult>;
runCommand(database: string, spec?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<any>;
runCommandWithCheck(database: string, spec?: Document, options?: CommandOptions, dbOptions?: DatabaseOptions): Promise<any & {
ok: 1;
}>;
listDatabases(database: string): Promise<any>;
updateMany(database: string, collection: string, filter?: FilterQuery<any>, update?: Document, options?: UpdateManyOptions, dbOptions?: DatabaseOptions): Promise<UpdateWriteOpResult>;
updateOne(database: string, collection: string, filter?: FilterQuery<any>, update?: Document, options?: UpdateOneOptions, dbOptions?: DatabaseOptions): Promise<UpdateWriteOpResult>;
getTopology(): any;

@@ -53,12 +63,14 @@ buildInfo(): Promise<Result>;

dropDatabase(db: string, writeConcern?: WriteConcern, dbOptions?: DatabaseOptions): Promise<DropDatabaseResult>;
createIndexes(database: string, collection: string, indexSpecs: Document[], options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
getIndexes(database: string, collection: string, dbOptions?: DatabaseOptions): Promise<Result>;
createIndexes(database: string, collection: string, indexSpecs: IndexSpecification[], options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
getIndexes(database: string, collection: string, dbOptions?: DatabaseOptions): Promise<any[]>;
dropIndexes(database: string, collection: string, indexes: string | string[] | Document | Document[], options?: CommandOptions, dbOptions?: DatabaseOptions): Promise<Result>;
listCollections(database: string, filter?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result>;
stats(database: string, collection: string, options?: Document, dbOptions?: DatabaseOptions): Promise<any>;
listCollections(database: string, filter?: Document, options?: Document, dbOptions?: DatabaseOptions): Promise<Result[]>;
stats(database: string, collection: string, options?: Document, dbOptions?: DatabaseOptions): Promise<CollStats>;
reIndex(database: string, collection: string, options?: CommandOptions, dbOptions?: DatabaseOptions): Promise<Result>;
dropCollection(database: string, collection: string, dbOptions?: DatabaseOptions): Promise<boolean>;
authenticate(authDoc: AuthOptions): Promise<any>;
authenticate(authDoc: AuthOptions): Promise<{
ok: 1;
}>;
createCollection(dbName: string, collName: string, options: any, dbOptions?: any): Promise<any>;
initializeBulkOp(dbName: string, collName: string, ordered: boolean, options?: {}, dbOptions?: any): Promise<any>;
initializeBulkOp(dbName: string, collName: string, ordered: boolean, options?: {}, dbOptions?: any): Promise<OrderedBulkOperation | UnorderedBulkOperation>;
getReadPreference(): ReadPreference;

@@ -65,0 +77,0 @@ getReadConcern(): ReadConcern | undefined;

862

lib/cli-service-provider.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {

@@ -45,271 +21,149 @@ if (k2 === undefined) k2 = k;

};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var mongodb_1 = __importStar(require("mongodb"));
var service_provider_core_1 = require("@mongosh/service-provider-core");
var errors_1 = require("@mongosh/errors");
var DEFAULT_DRIVER_OPTIONS = Object.freeze({
const mongodb_1 = __importStar(require("mongodb"));
const service_provider_core_1 = require("@mongosh/service-provider-core");
const errors_1 = require("@mongosh/errors");
const DEFAULT_DRIVER_OPTIONS = Object.freeze({
useNewUrlParser: true,
useUnifiedTopology: true
});
var DEFAULT_BASE_OPTIONS = Object.freeze({
const DEFAULT_BASE_OPTIONS = Object.freeze({
serializeFunctions: true
});
var CliServiceProvider = (function (_super) {
__extends(CliServiceProvider, _super);
function CliServiceProvider(mongoClient, clientOptions, uri) {
if (clientOptions === void 0) { clientOptions = {}; }
var _this = _super.call(this, mongodb_1.default) || this;
_this.mongoClient = mongoClient;
_this.uri = uri;
_this.platform = service_provider_core_1.ReplPlatform.CLI;
class CliServiceProvider extends service_provider_core_1.ServiceProviderCore {
constructor(mongoClient, clientOptions = {}, uri) {
super(mongodb_1.default);
this.mongoClient = mongoClient;
this.uri = uri;
this.platform = service_provider_core_1.ReplPlatform.CLI;
try {
_this.initialDb = mongoClient.s.options.dbName || service_provider_core_1.DEFAULT_DB;
this.initialDb = mongoClient.s.options.dbName || service_provider_core_1.DEFAULT_DB;
}
catch (err) {
_this.initialDb = service_provider_core_1.DEFAULT_DB;
this.initialDb = service_provider_core_1.DEFAULT_DB;
}
_this.initialOptions = clientOptions;
return _this;
this.initialOptions = clientOptions;
}
CliServiceProvider.connect = function (uri, options, cliOptions) {
if (options === void 0) { options = {}; }
if (cliOptions === void 0) { cliOptions = {}; }
return __awaiter(this, void 0, void 0, function () {
var clientOptions, mongoClient, _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
clientOptions = __assign(__assign({}, DEFAULT_DRIVER_OPTIONS), options);
if (!!cliOptions.nodb) return [3, 2];
return [4, mongodb_1.MongoClient.connect(uri, clientOptions)];
case 1:
_a = _b.sent();
return [3, 3];
case 2:
_a = new mongodb_1.MongoClient(uri, clientOptions);
_b.label = 3;
case 3:
mongoClient = _a;
return [2, new CliServiceProvider(mongoClient, clientOptions, uri)];
}
});
});
};
CliServiceProvider.prototype.getNewConnection = function (uri, options) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var clientOptions, mongoClient;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
clientOptions = __assign(__assign({}, DEFAULT_DRIVER_OPTIONS), options);
return [4, mongodb_1.MongoClient.connect(uri, clientOptions)];
case 1:
mongoClient = _a.sent();
return [2, new CliServiceProvider(mongoClient, uri)];
}
});
});
};
CliServiceProvider.prototype.getConnectionInfo = function () {
return __awaiter(this, void 0, void 0, function () {
var buildInfo, topology, version, cmdLineOpts, e_1, connectInfo;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.buildInfo()];
case 1:
buildInfo = _a.sent();
return [4, this.getTopology()];
case 2:
topology = _a.sent();
version = require('../package.json').version;
cmdLineOpts = null;
_a.label = 3;
case 3:
_a.trys.push([3, 5, , 6]);
return [4, this.getCmdLineOpts()];
case 4:
cmdLineOpts = _a.sent();
return [3, 6];
case 5:
e_1 = _a.sent();
return [3, 6];
case 6:
connectInfo = service_provider_core_1.getConnectInfo(this.uri ? this.uri : '', version, buildInfo, cmdLineOpts, topology);
return [2, {
buildInfo: buildInfo,
topology: topology,
extraInfo: connectInfo
}];
}
});
});
};
CliServiceProvider.prototype.renameCollection = function (database, oldName, newName, options, dbOptions) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [4, this.db(database, dbOptions)
.renameCollection(oldName, newName, options)];
case 1: return [2, _a.sent()];
}
});
});
};
CliServiceProvider.prototype.findAndModify = function (database, collection, query, sort, update, options, dbOptions) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [4, this.db(database, dbOptions)
.collection(collection)
.findAndModify(query, sort, update, options)];
case 1: return [2, _a.sent()];
}
});
});
};
CliServiceProvider.prototype.convertToCapped = function (database, collection, size, options, dbOptions) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [4, this.runCommandWithCheck(database, {
convertToCapped: collection,
size: size
}, options, dbOptions)];
case 1:
result = _a.sent();
if (!result) {
return [2];
}
return [2, result];
}
});
});
};
CliServiceProvider.prototype.db = function (name, dbOptions) {
var optionsWithForceNewInstace = __assign(__assign({}, dbOptions), { returnNonCachedInstance: true });
static async connect(uri, options = {}, cliOptions = {}) {
const clientOptions = {
...DEFAULT_DRIVER_OPTIONS,
...options
};
const mongoClient = !cliOptions.nodb ?
await mongodb_1.MongoClient.connect(uri, clientOptions) :
new mongodb_1.MongoClient(uri, clientOptions);
return new CliServiceProvider(mongoClient, clientOptions, uri);
}
async getNewConnection(uri, options = {}) {
const clientOptions = {
...DEFAULT_DRIVER_OPTIONS,
...options
};
const mongoClient = await mongodb_1.MongoClient.connect(uri, clientOptions);
return new CliServiceProvider(mongoClient, uri);
}
async getConnectionInfo() {
const buildInfo = await this.buildInfo();
const topology = await this.getTopology();
const { version } = require('../package.json');
let cmdLineOpts = null;
try {
cmdLineOpts = await this.getCmdLineOpts();
}
catch (e) {
}
const connectInfo = service_provider_core_1.getConnectInfo(this.uri ? this.uri : '', version, buildInfo, cmdLineOpts, topology);
return {
buildInfo: buildInfo,
topology: topology,
extraInfo: connectInfo
};
}
async renameCollection(database, oldName, newName, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.db(database, dbOptions)
.renameCollection(oldName, newName, options);
}
async findAndModify(database, collection, query, sort, update, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.db(database, dbOptions)
.collection(collection)
.findAndModify(query, sort, update, options);
}
async convertToCapped(database, collection, size, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
const result = await this.runCommandWithCheck(database, {
convertToCapped: collection,
size: size
}, options, dbOptions);
if (!result) {
return;
}
return result;
}
db(name, dbOptions) {
const optionsWithForceNewInstace = {
...dbOptions,
returnNonCachedInstance: true
};
return this.mongoClient.db(name, optionsWithForceNewInstace);
};
CliServiceProvider.prototype.aggregate = function (database, collection, pipeline, options, dbOptions) {
if (pipeline === void 0) { pipeline = []; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
aggregate(database, collection, pipeline = [], options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.aggregate(pipeline, options);
};
CliServiceProvider.prototype.aggregateDb = function (database, pipeline, options, dbOptions) {
if (pipeline === void 0) { pipeline = []; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
var db = this.db(database, dbOptions);
}
aggregateDb(database, pipeline = [], options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
const db = this.db(database, dbOptions);
return db.aggregate(pipeline, options);
};
CliServiceProvider.prototype.bulkWrite = function (database, collection, requests, options, dbOptions) {
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
bulkWrite(database, collection, requests, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.bulkWrite(requests, options);
};
CliServiceProvider.prototype.close = function (force) {
}
close(force) {
return this.mongoClient.close(force);
};
CliServiceProvider.prototype.count = function (database, collection, query, options, dbOptions) {
if (query === void 0) { query = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
count(database, collection, query = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.count(query, options);
};
CliServiceProvider.prototype.countDocuments = function (database, collection, filter, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
countDocuments(database, collection, filter = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.countDocuments(filter, options);
};
CliServiceProvider.prototype.deleteMany = function (database, collection, filter, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
deleteMany(database, collection, filter = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.deleteMany(filter, options);
};
CliServiceProvider.prototype.deleteOne = function (database, collection, filter, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
deleteOne(database, collection, filter = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.deleteOne(filter, options);
};
CliServiceProvider.prototype.distinct = function (database, collection, fieldName, filter, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
distinct(database, collection, fieldName, filter = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.distinct(fieldName, filter, options);
};
CliServiceProvider.prototype.estimatedDocumentCount = function (database, collection, options, dbOptions) {
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
estimatedDocumentCount(database, collection, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.estimatedDocumentCount(options);
};
CliServiceProvider.prototype.find = function (database, collection, filter, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (options === void 0) { options = {}; }
var findOptions = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
find(database, collection, filter = {}, options = {}, dbOptions) {
const findOptions = { ...DEFAULT_BASE_OPTIONS, ...options };
if ('allowPartialResults' in findOptions) {

@@ -327,16 +181,11 @@ findOptions.partial = findOptions.allowPartialResults;

.find(filter, findOptions);
};
CliServiceProvider.prototype.findOneAndDelete = function (database, collection, filter, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
findOneAndDelete(database, collection, filter = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection).
findOneAndDelete(filter, options);
};
CliServiceProvider.prototype.findOneAndReplace = function (database, collection, filter, replacement, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (replacement === void 0) { replacement = {}; }
if (options === void 0) { options = {}; }
var findOneAndReplaceOptions = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
findOneAndReplace(database, collection, filter = {}, replacement = {}, options = {}, dbOptions) {
const findOneAndReplaceOptions = { ...DEFAULT_BASE_OPTIONS, ...options };
if ('returnDocument' in options) {

@@ -347,8 +196,5 @@ findOneAndReplaceOptions.returnOriginal = options.returnDocument;

return this.db(database, dbOptions).collection(collection).findOneAndReplace(filter, replacement, findOneAndReplaceOptions);
};
CliServiceProvider.prototype.findOneAndUpdate = function (database, collection, filter, update, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (update === void 0) { update = {}; }
if (options === void 0) { options = {}; }
var findOneAndUpdateOptions = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
findOneAndUpdate(database, collection, filter = {}, update = {}, options = {}, dbOptions) {
const findOneAndUpdateOptions = { ...DEFAULT_BASE_OPTIONS, ...options };
if ('returnDocument' in options) {

@@ -361,340 +207,186 @@ findOneAndUpdateOptions.returnOriginal = options.returnDocument;

.findOneAndUpdate(filter, update, findOneAndUpdateOptions);
};
CliServiceProvider.prototype.insertMany = function (database, collection, docs, options, dbOptions) {
if (docs === void 0) { docs = []; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
insertMany(database, collection, docs = [], options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.insertMany(docs, options);
};
CliServiceProvider.prototype.insertOne = function (database, collection, doc, options, dbOptions) {
if (doc === void 0) { doc = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
insertOne(database, collection, doc = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.insertOne(doc, options);
};
CliServiceProvider.prototype.isCapped = function (database, collection, dbOptions) {
}
isCapped(database, collection, dbOptions) {
return this.db(database, dbOptions).collection(collection).isCapped();
};
CliServiceProvider.prototype.remove = function (database, collection, query, options, dbOptions) {
if (query === void 0) { query = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
remove(database, collection, query = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.remove(query, options);
};
CliServiceProvider.prototype.save = function (database, collection, doc, options, dbOptions) {
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
save(database, collection, doc, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions).collection(collection).
save(doc, options);
};
CliServiceProvider.prototype.replaceOne = function (database, collection, filter, replacement, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (replacement === void 0) { replacement = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
replaceOne(database, collection, filter = {}, replacement = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.replaceOne(filter, replacement, options);
};
CliServiceProvider.prototype.runCommand = function (database, spec, options, dbOptions) {
if (spec === void 0) { spec = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
var db = this.db(database, dbOptions);
}
runCommand(database, spec = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
const db = this.db(database, dbOptions);
return db.command(spec, options);
};
CliServiceProvider.prototype.runCommandWithCheck = function (database, spec, options, dbOptions) {
if (spec === void 0) { spec = {}; }
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
var db, result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
db = this.db(database, dbOptions);
return [4, db.command(spec, options)];
case 1:
result = _a.sent();
if (result.ok === 0) {
throw new errors_1.MongoshCommandFailed(JSON.stringify(spec));
}
return [2, result];
}
});
});
};
CliServiceProvider.prototype.listDatabases = function (database) {
}
async runCommandWithCheck(database, spec = {}, options = {}, dbOptions) {
const result = await this.runCommand(database, spec, options, dbOptions);
if (result.ok === 0) {
throw new errors_1.MongoshCommandFailed(JSON.stringify(spec));
}
return result;
}
listDatabases(database) {
return this.db(database).admin().listDatabases();
};
CliServiceProvider.prototype.updateMany = function (database, collection, filter, update, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (update === void 0) { update = {}; }
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [4, this.db(database, dbOptions)
.collection(collection)
.updateMany(filter, update, options)];
case 1: return [2, _a.sent()];
}
});
});
};
CliServiceProvider.prototype.updateOne = function (database, collection, filter, update, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (update === void 0) { update = {}; }
if (options === void 0) { options = {}; }
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
}
async updateMany(database, collection, filter = {}, update = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.db(database, dbOptions)
.collection(collection)
.updateMany(filter, update, options);
}
updateOne(database, collection, filter = {}, update = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.updateOne(filter, update, options);
};
CliServiceProvider.prototype.getTopology = function () {
}
getTopology() {
return this.mongoClient.topology;
};
CliServiceProvider.prototype.buildInfo = function () {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.runCommandWithCheck('admin', {
buildInfo: 1
}, {})];
case 1:
result = _a.sent();
if (!result)
return [2];
return [2, result];
}
});
});
};
CliServiceProvider.prototype.getCmdLineOpts = function () {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.runCommandWithCheck('admin', { getCmdLineOpts: 1 }, {})];
case 1:
result = _a.sent();
if (!result)
return [2];
return [2, result];
}
});
});
};
CliServiceProvider.prototype.dropDatabase = function (db, writeConcern, dbOptions) {
if (writeConcern === void 0) { writeConcern = {}; }
if (dbOptions === void 0) { dbOptions = {}; }
return __awaiter(this, void 0, void 0, function () {
var nativeResult, ok;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.db(db, dbOptions)
.dropDatabase(writeConcern)];
case 1:
nativeResult = _a.sent();
ok = nativeResult ? 1 : 0;
return [2, __assign({ ok: ok }, (ok ? { dropped: db } : {}))];
}
});
});
};
CliServiceProvider.prototype.createIndexes = function (database, collection, indexSpecs, options, dbOptions) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [2, this.db(database, dbOptions)
.collection(collection)
.createIndexes(indexSpecs, options)];
});
});
};
CliServiceProvider.prototype.getIndexes = function (database, collection, dbOptions) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2, this.db(database, dbOptions)
.collection(collection)
.listIndexes()
.toArray()];
});
});
};
CliServiceProvider.prototype.dropIndexes = function (database, collection, indexes, options, dbOptions) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [4, this.runCommandWithCheck(database, {
dropIndexes: collection,
index: indexes,
}, options, dbOptions)];
case 1: return [2, _a.sent()];
}
});
});
};
CliServiceProvider.prototype.listCollections = function (database, filter, options, dbOptions) {
if (filter === void 0) { filter = {}; }
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [4, this.db(database, dbOptions).listCollections(filter, options).toArray()];
case 1: return [2, _a.sent()];
}
});
});
};
CliServiceProvider.prototype.stats = function (database, collection, options, dbOptions) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [4, this.db(database, dbOptions)
.collection(collection)
.stats(options)];
case 1: return [2, _a.sent()];
}
});
});
};
CliServiceProvider.prototype.reIndex = function (database, collection, options, dbOptions) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
options = __assign(__assign({}, DEFAULT_BASE_OPTIONS), options);
return [4, this.runCommandWithCheck(database, {
reIndex: collection
}, options, dbOptions)];
case 1: return [2, _a.sent()];
}
});
});
};
CliServiceProvider.prototype.dropCollection = function (database, collection, dbOptions) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2, this.db(database, dbOptions)
.collection(collection)
.drop()];
});
});
};
CliServiceProvider.prototype.authenticate = function (authDoc) {
return __awaiter(this, void 0, void 0, function () {
var clientOptions, _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
clientOptions = __assign(__assign(__assign({}, DEFAULT_DRIVER_OPTIONS), this.initialOptions), { auth: { user: authDoc.user, password: authDoc.pwd }, authMechanism: authDoc.mechanism, authSource: authDoc.authDb });
_a = this;
return [4, mongodb_1.MongoClient.connect(this.uri, clientOptions)];
case 1:
_a.mongoClient = _b.sent();
return [2, { ok: 1 }];
}
});
});
};
CliServiceProvider.prototype.createCollection = function (dbName, collName, options, dbOptions) {
return __awaiter(this, void 0, void 0, function () {
var e_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
return [4, this.db(dbName, dbOptions).createCollection(collName, options)];
case 1:
_a.sent();
return [2, { ok: 1 }];
case 2:
e_2 = _a.sent();
return [2, {
ok: 0,
errmsg: e_2.message,
code: e_2.code
}];
case 3: return [2];
}
});
});
};
CliServiceProvider.prototype.initializeBulkOp = function (dbName, collName, ordered, options, dbOptions) {
if (options === void 0) { options = {}; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!ordered) return [3, 2];
return [4, this.db(dbName, dbOptions).collection(collName).initializeOrderedBulkOp(options)];
case 1: return [2, _a.sent()];
case 2: return [4, this.db(dbName, dbOptions).collection(collName).initializeUnorderedBulkOp(options)];
case 3: return [2, _a.sent()];
}
});
});
};
CliServiceProvider.prototype.getReadPreference = function () {
}
async buildInfo() {
const result = await this.runCommandWithCheck('admin', {
buildInfo: 1
}, {});
if (!result)
return;
return result;
}
async getCmdLineOpts() {
const result = await this.runCommandWithCheck('admin', { getCmdLineOpts: 1 }, {});
if (!result)
return;
return result;
}
async dropDatabase(db, writeConcern = {}, dbOptions = {}) {
const nativeResult = await this.db(db, dbOptions)
.dropDatabase(writeConcern);
const ok = nativeResult ? 1 : 0;
return {
ok,
...(ok ? { dropped: db } : {})
};
}
async createIndexes(database, collection, indexSpecs, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return this.db(database, dbOptions)
.collection(collection)
.createIndexes(indexSpecs, options);
}
async getIndexes(database, collection, dbOptions) {
return this.db(database, dbOptions)
.collection(collection)
.listIndexes()
.toArray();
}
async dropIndexes(database, collection, indexes, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.runCommandWithCheck(database, {
dropIndexes: collection,
index: indexes,
}, options, dbOptions);
}
async listCollections(database, filter = {}, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.db(database, dbOptions).listCollections(filter, options).toArray();
}
async stats(database, collection, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.db(database, dbOptions)
.collection(collection)
.stats(options);
}
async reIndex(database, collection, options = {}, dbOptions) {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.runCommandWithCheck(database, {
reIndex: collection
}, options, dbOptions);
}
async dropCollection(database, collection, dbOptions) {
return this.db(database, dbOptions)
.collection(collection)
.drop();
}
async authenticate(authDoc) {
const clientOptions = {
...DEFAULT_DRIVER_OPTIONS,
...this.initialOptions,
auth: { user: authDoc.user, password: authDoc.pwd },
authMechanism: authDoc.mechanism,
authSource: authDoc.authDb
};
this.mongoClient = await mongodb_1.MongoClient.connect(this.uri, clientOptions);
return { ok: 1 };
}
async createCollection(dbName, collName, options, dbOptions) {
try {
await this.db(dbName, dbOptions).createCollection(collName, options);
return { ok: 1 };
}
catch (e) {
return {
ok: 0,
errmsg: e.message,
code: e.code
};
}
}
async initializeBulkOp(dbName, collName, ordered, options = {}, dbOptions) {
if (ordered) {
return await this.db(dbName, dbOptions).collection(collName).initializeOrderedBulkOp(options);
}
return await this.db(dbName, dbOptions).collection(collName).initializeUnorderedBulkOp(options);
}
getReadPreference() {
return this.mongoClient.readPreference;
};
CliServiceProvider.prototype.getReadConcern = function () {
}
getReadConcern() {
return this.mongoClient.s.options.readConcern;
};
CliServiceProvider.prototype.getWriteConcern = function () {
}
getWriteConcern() {
return this.mongoClient.writeConcern;
};
CliServiceProvider.prototype.resetConnectionOptions = function (options) {
return __awaiter(this, void 0, void 0, function () {
var pr, clientOptions, _a, mc;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if ('readPreference' in options) {
pr = new mongodb_1.ReadPreference(options.readPreference.mode, options.readPreference.tagSet, options.hedgeOptions);
options.readPreference = pr;
}
clientOptions = __assign(__assign(__assign({}, DEFAULT_DRIVER_OPTIONS), this.initialOptions), options);
_b.label = 1;
case 1:
_b.trys.push([1, 3, , 4]);
return [4, this.mongoClient.close()];
case 2:
_b.sent();
return [3, 4];
case 3:
_a = _b.sent();
return [3, 4];
case 4: return [4, mongodb_1.MongoClient.connect(this.uri, clientOptions)];
case 5:
mc = _b.sent();
this.mongoClient = mc;
return [2];
}
});
});
};
return CliServiceProvider;
}(service_provider_core_1.ServiceProviderCore));
}
async resetConnectionOptions(options) {
if ('readPreference' in options) {
const pr = new mongodb_1.ReadPreference(options.readPreference.mode, options.readPreference.tagSet, options.hedgeOptions);
options.readPreference = pr;
}
const clientOptions = {
...DEFAULT_DRIVER_OPTIONS,
...this.initialOptions,
...options
};
try {
await this.mongoClient.close();
}
catch (_a) { }
const mc = await mongodb_1.MongoClient.connect(this.uri, clientOptions);
this.mongoClient = mc;
}
}
exports.default = CliServiceProvider;
//# sourceMappingURL=cli-service-provider.js.map

40

lib/compass/compass-service-provider.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {

@@ -19,24 +6,21 @@ return (mod && mod.__esModule) ? mod : { "default": mod };

Object.defineProperty(exports, "__esModule", { value: true });
var cli_service_provider_1 = __importDefault(require("../cli-service-provider"));
var service_provider_core_1 = require("@mongosh/service-provider-core");
var CompassServiceProvider = (function (_super) {
__extends(CompassServiceProvider, _super);
function CompassServiceProvider(mongoClient, uri) {
var _this = _super.call(this, mongoClient, uri) || this;
_this.platform = service_provider_core_1.ReplPlatform.Compass;
const cli_service_provider_1 = __importDefault(require("../cli-service-provider"));
const service_provider_core_1 = require("@mongosh/service-provider-core");
class CompassServiceProvider extends cli_service_provider_1.default {
constructor(mongoClient, uri) {
super(mongoClient, uri);
this.platform = service_provider_core_1.ReplPlatform.Compass;
try {
_this.initialDb = mongoClient.s.options.dbName || service_provider_core_1.DEFAULT_DB;
this.initialDb = mongoClient.s.options.dbName || service_provider_core_1.DEFAULT_DB;
}
catch (err) {
_this.initialDb = service_provider_core_1.DEFAULT_DB;
this.initialDb = service_provider_core_1.DEFAULT_DB;
}
return _this;
}
CompassServiceProvider.fromDataService = function (dataService) {
var mongoClient = dataService.client.client;
static fromDataService(dataService) {
const mongoClient = dataService.client.client;
return new CompassServiceProvider(mongoClient);
};
return CompassServiceProvider;
}(cli_service_provider_1.default));
}
}
exports.default = CompassServiceProvider;
//# sourceMappingURL=compass-service-provider.js.map

6

lib/index.js

@@ -7,7 +7,7 @@ "use strict";

exports.generateUri = exports.Scheme = exports.DEFAULT_DB = exports.CompassServiceProvider = exports.CliServiceProvider = void 0;
var cli_service_provider_1 = __importDefault(require("./cli-service-provider"));
const cli_service_provider_1 = __importDefault(require("./cli-service-provider"));
exports.CliServiceProvider = cli_service_provider_1.default;
var compass_service_provider_1 = __importDefault(require("./compass/compass-service-provider"));
const compass_service_provider_1 = __importDefault(require("./compass/compass-service-provider"));
exports.CompassServiceProvider = compass_service_provider_1.default;
var service_provider_core_1 = require("@mongosh/service-provider-core");
const service_provider_core_1 = require("@mongosh/service-provider-core");
Object.defineProperty(exports, "DEFAULT_DB", { enumerable: true, get: function () { return service_provider_core_1.DEFAULT_DB; } });

@@ -14,0 +14,0 @@ Object.defineProperty(exports, "Scheme", { enumerable: true, get: function () { return service_provider_core_1.Scheme; } });

4

lib/node/node-auth-options.d.ts
export default interface NodeAuthOptions {
user?: string;
password?: string;
user: string;
password: string;
}

17

package.json
{
"name": "@mongosh/service-provider-server",
"version": "0.5.0",
"version": "0.5.1",
"description": "MongoDB Shell Server Service Provider Package",

@@ -15,4 +15,4 @@ "main": "lib/index.js",

"compile-ts": "tsc -p tsconfig.json",
"test": "mocha -r \"../../scripts/import-expansions.js\" --timeout 60000 --colors -r ts-node/register \"./src/**/*.spec.ts\"",
"test-ci": "mocha -r \"../../scripts/import-expansions.js\" --timeout 60000 -r ts-node/register \"./src/**/*.spec.ts\"",
"test": "cross-env TS_NODE_PROJECT=../../config/tsconfig.test.json mocha -r \"../../scripts/import-expansions.js\" --timeout 60000 --colors -r ts-node/register \"./src/**/*.spec.ts\"",
"test-ci": "cross-env TS_NODE_PROJECT=../../config/tsconfig.test.json mocha -r \"../../scripts/import-expansions.js\" --timeout 60000 -r ts-node/register \"./src/**/*.spec.ts\"",
"prepublish": "npm run compile-ts",

@@ -42,10 +42,13 @@ "lint": "eslint \"**/*.{js,ts,tsx}\"",

"dependencies": {
"@mongosh/errors": "^0.5.0",
"@mongosh/service-provider-core": "^0.5.0",
"@mongosh/errors": "^0.5.1",
"@mongosh/service-provider-core": "^0.5.1",
"@types/sinon": "^7.5.1",
"@types/sinon-chai": "^3.2.3",
"mongodb": "^3.6.1",
"saslprep": "^1.0.3"
"saslprep": "mongodb-js/saslprep#v1.0.4"
},
"gitHead": "3b9b52c082c7e1c3c42e8d73d14c4cd0f05155bf"
"devDependencies": {
"@types/mongodb": "^3.5.32"
},
"gitHead": "c81dccda2cc98d1d926a3acbac66240e5ed4f73c"
}

6

src/cli-service-provider.integration.spec.ts

@@ -580,3 +580,3 @@ import CliServiceProvider from './cli-service-provider';

expect(
(await serviceProvider.listCollections(dbName)).map((c) => c.name)
(await serviceProvider.listCollections(dbName)).map((c: any) => c.name)
).to.deep.equal(['coll1']);

@@ -590,3 +590,3 @@ });

expect(
(await serviceProvider.listCollections(dbName, { name: 'coll2' })).map((c) => c.name)
(await serviceProvider.listCollections(dbName, { name: 'coll2' })).map((c: any) => c.name)
).to.deep.equal(['coll2']);

@@ -622,3 +622,3 @@ });

const result = await serviceProvider.reIndex(
const result: any = await serviceProvider.reIndex(
dbName,

@@ -625,0 +625,0 @@ collName

68

src/cli-service-provider.spec.ts

@@ -24,8 +24,8 @@ import mongodb, { MongoClient, Db } from 'mongodb';

const createClientStub = (collectionStub): MongoClient => {
const dbStub = sinon.createStubInstance(Db, {
collection: sinon.stub().returns(collectionStub)
const dbStub: any = sinon.createStubInstance(Db, {
collection: sinon.stub().returns(collectionStub) as any
});
return sinon.createStubInstance(MongoClient, {
db: sinon.stub().returns(dbStub)
});
db: sinon.stub().returns(dbStub) as any
}) as any;
};

@@ -37,3 +37,3 @@

describe('#constructor', () => {
const mongoClient = sinon.spy();
const mongoClient: any = sinon.spy();
serviceProvider = new CliServiceProvider(mongoClient);

@@ -372,4 +372,4 @@

describe('#runCommand', () => {
let clientStub;
let dbStub;
let clientStub: any;
let dbStub: any;
const commandResult = { ismaster: true };

@@ -381,7 +381,7 @@ const commandMock = sinon.mock().

dbStub = sinon.createStubInstance(Db, {
command: commandMock
});
command: commandMock as any
}) as any;
clientStub = sinon.createStubInstance(MongoClient, {
db: sinon.stub().returns(dbStub)
});
db: sinon.stub().returns(dbStub) as any
}) as any;
serviceProvider = new CliServiceProvider(clientStub);

@@ -404,4 +404,4 @@ });

describe('#runCommandWithCheck', () => {
let clientStub;
let dbStub;
let clientStub: any;
let dbStub: any;
const commandResult = { ok: 0 };

@@ -412,6 +412,6 @@ const commandMock = sinon.mock().withArgs({ ismaster: 1 }).resolves(commandResult);

dbStub = sinon.createStubInstance(Db, {
command: commandMock
});
command: commandMock as any
}) as any;
clientStub = sinon.createStubInstance(MongoClient, {
db: sinon.stub().returns(dbStub)
db: sinon.stub().returns(dbStub) as any
});

@@ -493,4 +493,4 @@ serviceProvider = new CliServiceProvider(clientStub);

clientStub = sinon.createStubInstance(MongoClient, {
db: sinon.stub().returns(dbStub)
});
db: sinon.stub().returns(dbStub) as any
}) as any;

@@ -564,3 +564,3 @@ serviceProvider = new CliServiceProvider(clientStub);

db: dbMock
});
}) as any;

@@ -611,3 +611,3 @@ serviceProvider = new CliServiceProvider(clientStub);

db: dbMock
});
}) as any;

@@ -645,3 +645,3 @@ serviceProvider = new CliServiceProvider(clientStub);

db: dbMock
});
}) as any;

@@ -751,3 +751,3 @@ serviceProvider = new CliServiceProvider(clientStub);

db: dbMock
});
}) as any;

@@ -793,3 +793,3 @@ serviceProvider = new CliServiceProvider(clientStub);

db: dbMock
});
}) as any;

@@ -837,4 +837,4 @@ serviceProvider = new CliServiceProvider(clientStub);

describe('#reIndex', () => {
let commandMock;
let dbMock;
let commandMock: any;
let dbMock: any;
let clientStub: MongoClient;

@@ -857,3 +857,3 @@

db: dbMock
});
}) as any;

@@ -872,4 +872,4 @@ serviceProvider = new CliServiceProvider(clientStub);

describe('#renameCollection', () => {
let commandMock;
let dbMock;
let commandMock: any;
let dbMock: any;
let clientStub: MongoClient;

@@ -899,3 +899,3 @@

db: dbMock
});
}) as any;

@@ -919,4 +919,4 @@ serviceProvider = new CliServiceProvider(clientStub);

describe('#createCollection', () => {
let commandMock;
let dbMock;
let commandMock: any;
let dbMock: any;
let clientStub: MongoClient;

@@ -945,3 +945,3 @@

db: dbMock
});
}) as any;

@@ -971,4 +971,4 @@ serviceProvider = new CliServiceProvider(clientStub);

clientStub = sinon.createStubInstance(MongoClient, {
db: sinon.stub().returns(dbStub)
});
db: sinon.stub().returns(dbStub) as any
}) as any;
serviceProvider = new CliServiceProvider(clientStub);

@@ -975,0 +975,0 @@ });

214

src/cli-service-provider.ts

@@ -6,2 +6,33 @@ import mongodb, {

} from 'mongodb';
import type {
MongoClientOptions,
CollStats,
IndexSpecification,
FindOneAndUpdateOption,
CollectionInsertOneOptions,
CollectionInsertManyOptions,
FindAndModifyWriteOpResultObject,
CollectionAggregationOptions,
CollectionBulkWriteOptions,
ReplaceWriteOpResult,
FilterQuery,
UpdateManyOptions,
UpdateOneOptions,
UpdateWriteOpResult,
Collection,
MongoCountPreferences,
CommonOptions,
DeleteWriteOpResultObject,
MongoDistinctPreferences,
FindOneOptions,
FindOneAndDeleteOption,
FindOneAndReplaceOption,
UpdateQuery,
WriteOpResult,
OrderedBulkOperation,
UnorderedBulkOperation,
InsertWriteOpResult,
ReplaceOneOptions,
InsertOneWriteOpResult
} from 'mongodb';

@@ -35,2 +66,4 @@ import {

type ConnectionInfo = ReturnType<typeof getConnectInfo>;
/**

@@ -69,5 +102,5 @@ * Default driver options we always use.

options: NodeOptions = {},
cliOptions: any = {}
cliOptions: { nodb?: boolean } = {}
): Promise<CliServiceProvider> {
const clientOptions: any = {
const clientOptions: MongoClientOptions = {
...DEFAULT_DRIVER_OPTIONS,

@@ -104,3 +137,3 @@ ...options

try {
this.initialDb = mongoClient.s.options.dbName || DEFAULT_DB;
this.initialDb = (mongoClient as any).s.options.dbName || DEFAULT_DB;
} catch (err) {

@@ -113,3 +146,3 @@ this.initialDb = DEFAULT_DB;

async getNewConnection(uri: string, options: NodeOptions = {}): Promise<CliServiceProvider> {
const clientOptions: any = {
const clientOptions: MongoClientOptions = {
...DEFAULT_DRIVER_OPTIONS,

@@ -126,3 +159,7 @@ ...options

async getConnectionInfo(): Promise<any> {
async getConnectionInfo(): Promise<{
buildInfo: any;
topology: any;
extraInfo: ConnectionInfo;
}> {
const buildInfo = await this.buildInfo();

@@ -158,3 +195,3 @@ const topology = await this.getTopology();

options: Document = {},
dbOptions?: DatabaseOptions): Promise<any> {
dbOptions?: DatabaseOptions): Promise<Collection> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -169,10 +206,10 @@ return await this.db(database, dbOptions)

query: Document,
sort: any[] | Document,
update: Document,
sort: any[] | Document | undefined,
update: Document | undefined,
options: Document = {},
dbOptions?: DatabaseOptions
): Promise<any> {
): Promise<FindAndModifyWriteOpResultObject<any>> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.db(database, dbOptions)
.collection(collection)
return await (this.db(database, dbOptions)
.collection(collection) as any)
.findAndModify(query, sort, update, options);

@@ -197,3 +234,3 @@ }

dbOptions?: DatabaseOptions
): Promise<any> {
): Promise<undefined | object> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -263,3 +300,3 @@ const result: any = await this.runCommandWithCheck(

pipeline: Document[] = [],
options: Document = {},
options: CollectionAggregationOptions = {},
dbOptions?: DatabaseOptions): Cursor {

@@ -318,4 +355,4 @@ options = { ...DEFAULT_BASE_OPTIONS, ...options };

collection: string,
requests,
options: Document = {},
requests: any[],
options: CollectionBulkWriteOptions = {},
dbOptions?: DatabaseOptions): Promise<BulkWriteResult> {

@@ -325,3 +362,3 @@ options = { ...DEFAULT_BASE_OPTIONS, ...options };

.collection(collection)
.bulkWrite(requests as any[], options);
.bulkWrite(requests, options) as Promise<BulkWriteResult>;
}

@@ -358,5 +395,5 @@

collection: string,
query: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
query: FilterQuery<any> = {},
options: MongoCountPreferences = {},
dbOptions?: DatabaseOptions): Promise<number> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -384,5 +421,5 @@ return this.db(database, dbOptions)

collection: string,
filter: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
filter: FilterQuery<any> = {},
options: MongoCountPreferences = {},
dbOptions?: DatabaseOptions): Promise<number> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -408,5 +445,5 @@ return this.db(database, dbOptions)

collection: string,
filter: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
filter: FilterQuery<any> = {},
options: CommonOptions = {},
dbOptions?: DatabaseOptions): Promise<DeleteWriteOpResultObject> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -432,5 +469,5 @@ return this.db(database, dbOptions)

collection: string,
filter: Document = {},
filter: FilterQuery<any> = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
dbOptions?: DatabaseOptions): Promise<DeleteWriteOpResultObject> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -458,5 +495,5 @@ return this.db(database, dbOptions)

fieldName: string,
filter: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<any> {
filter: FilterQuery<any> = {},
options: MongoDistinctPreferences = {},
dbOptions?: DatabaseOptions): Promise<any[]> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -481,4 +518,4 @@ return this.db(database, dbOptions)

collection: string,
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
options: MongoCountPreferences = {},
dbOptions?: DatabaseOptions): Promise<number> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -503,4 +540,4 @@ return this.db(database, dbOptions)

collection: string,
filter: Document = {},
options: Document = {},
filter: FilterQuery<any> = {},
options: FindOneOptions<any> = {},
dbOptions?: DatabaseOptions): Cursor {

@@ -536,5 +573,5 @@ const findOptions: any = { ...DEFAULT_BASE_OPTIONS, ...options };

collection: string,
filter: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
filter: FilterQuery<any> = {},
options: FindOneAndDeleteOption<any> = {},
dbOptions?: DatabaseOptions): Promise<FindAndModifyWriteOpResultObject<any>> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -560,10 +597,10 @@ return this.db(database, dbOptions)

collection: string,
filter: Document = {},
filter: FilterQuery<any> = {},
replacement: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
options: FindOneAndReplaceOption<any> = {},
dbOptions?: DatabaseOptions): Promise<FindAndModifyWriteOpResultObject<any>> {
const findOneAndReplaceOptions: any = { ...DEFAULT_BASE_OPTIONS, ...options };
if ('returnDocument' in options) {
findOneAndReplaceOptions.returnOriginal = options.returnDocument;
delete findOneAndReplaceOptions.returnDocument;
findOneAndReplaceOptions.returnOriginal = (options as any).returnDocument;
delete (findOneAndReplaceOptions as any).returnDocument;
}

@@ -590,10 +627,10 @@

collection: string,
filter: Document = {},
update: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
const findOneAndUpdateOptions: any = { ...DEFAULT_BASE_OPTIONS, ...options };
filter: FilterQuery<any> = {},
update: UpdateQuery<any> = {},
options: FindOneAndUpdateOption<any> = {},
dbOptions?: DatabaseOptions): Promise<FindAndModifyWriteOpResultObject<any>> {
const findOneAndUpdateOptions = { ...DEFAULT_BASE_OPTIONS, ...options };
if ('returnDocument' in options) {
findOneAndUpdateOptions.returnOriginal = options.returnDocument;
delete findOneAndUpdateOptions.returnDocument;
findOneAndUpdateOptions.returnOriginal = (options as any).returnDocument;
delete (findOneAndUpdateOptions as any).returnDocument;
}

@@ -625,4 +662,4 @@

docs: Document[] = [],
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
options: CollectionInsertManyOptions = {},
dbOptions?: DatabaseOptions): Promise<InsertWriteOpResult<any>> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -649,4 +686,4 @@ return this.db(database, dbOptions)

doc: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
options: CollectionInsertOneOptions = {},
dbOptions?: DatabaseOptions): Promise<InsertOneWriteOpResult<any>> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -668,3 +705,3 @@ return this.db(database, dbOptions)

collection: string,
dbOptions?: DatabaseOptions): Promise<Result> {
dbOptions?: DatabaseOptions): Promise<any> {
return this.db(database, dbOptions).collection(collection).isCapped();

@@ -687,3 +724,3 @@ }

options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
dbOptions?: DatabaseOptions): Promise<WriteOpResult> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -713,3 +750,3 @@ return this.db(database, dbOptions)

options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
dbOptions?: DatabaseOptions): Promise<WriteOpResult> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -735,7 +772,7 @@ return this.db(database, dbOptions).collection(collection).

collection: string,
filter: Document = {},
filter: FilterQuery<any> = {},
replacement: Document = {},
options: Document = {},
options: ReplaceOneOptions = {},
dbOptions?: DatabaseOptions
): Promise<Result> {
): Promise<ReplaceWriteOpResult> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -760,7 +797,7 @@ return this.db(database, dbOptions)

spec: Document = {},
options: CommandOptions = {},
options: Document = {},
dbOptions?: DatabaseOptions
): Promise<Result> {
): Promise<any> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
const db: any = this.db(database, dbOptions);
const db = this.db(database, dbOptions);
return db.command(

@@ -787,13 +824,8 @@ spec,

dbOptions?: DatabaseOptions
): Promise<Result> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
const db: any = this.db(database, dbOptions);
const result = await db.command(
spec,
options
);
): Promise<any & { ok: 1 }> {
const result = await this.runCommand(database, spec, options, dbOptions);
if (result.ok === 0) {
throw new MongoshCommandFailed(JSON.stringify(spec));
}
return result;
return result as { ok: 1 };
}

@@ -808,3 +840,3 @@

*/
listDatabases(database: string): Promise<Result> {
listDatabases(database: string): Promise<any> {
return this.db(database).admin().listDatabases();

@@ -828,6 +860,6 @@ }

collection: string,
filter: Document = {},
filter: FilterQuery<any> = {},
update: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
options: UpdateManyOptions = {},
dbOptions?: DatabaseOptions): Promise<UpdateWriteOpResult> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -854,6 +886,6 @@ return await this.db(database, dbOptions)

collection: string,
filter: Document = {},
filter: FilterQuery<any> = {},
update: Document = {},
options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
options: UpdateOneOptions = {},
dbOptions?: DatabaseOptions): Promise<UpdateWriteOpResult> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -871,3 +903,3 @@ return this.db(database, dbOptions)

getTopology(): any {
return this.mongoClient.topology;
return (this.mongoClient as any).topology;
}

@@ -945,3 +977,3 @@

collection: string,
indexSpecs: Document[],
indexSpecs: IndexSpecification[],
options: Document = {},

@@ -969,3 +1001,3 @@ dbOptions?: DatabaseOptions): Promise<Result> {

collection: string,
dbOptions?: DatabaseOptions): Promise<Result> {
dbOptions?: DatabaseOptions): Promise<any[]> {
return this.db(database, dbOptions)

@@ -1016,3 +1048,3 @@ .collection(collection)

options: Document = {},
dbOptions?: DatabaseOptions): Promise<Result> {
dbOptions?: DatabaseOptions): Promise<Result[]> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };

@@ -1037,7 +1069,7 @@ return await this.db(database, dbOptions).listCollections(

options: Document = {},
dbOptions?: DatabaseOptions): Promise<any> {
dbOptions?: DatabaseOptions): Promise<CollStats> {
options = { ...DEFAULT_BASE_OPTIONS, ...options };
return await this.db(database, dbOptions)
.collection(collection)
.stats(options);
.stats(options as { scale: 1 });
}

@@ -1092,5 +1124,5 @@

authDoc: AuthOptions
): Promise<any> {
): Promise<{ ok: 1 }> {
// NOTE: we keep all the original options and just overwrite the auth ones.
const clientOptions: any = {
const clientOptions: MongoClientOptions = {
...DEFAULT_DRIVER_OPTIONS,

@@ -1103,3 +1135,3 @@ ...this.initialOptions,

this.mongoClient = await MongoClient.connect(
this.uri,
this.uri as string,
clientOptions

@@ -1136,3 +1168,3 @@ );

dbOptions?: any
): Promise<any> {
): Promise<OrderedBulkOperation | UnorderedBulkOperation> {
if (ordered) {

@@ -1145,3 +1177,3 @@ return await this.db(dbName, dbOptions).collection(collName).initializeOrderedBulkOp(options);

getReadPreference(): ReadPreference {
return this.mongoClient.readPreference; // TODO: node driver bug always returns primary NODE-2806
return this.mongoClient.readPreference as ReadPreference; // TODO: node driver bug always returns primary NODE-2806
}

@@ -1151,3 +1183,3 @@

// return this.mongoClient.readConcern; TODO: this is only on latest driver, for now use workaround
return this.mongoClient.s.options.readConcern;
return (this.mongoClient as any).s.options.readConcern;
}

@@ -1174,3 +1206,3 @@

}
const clientOptions: any = {
const clientOptions: MongoClientOptions = {
...DEFAULT_DRIVER_OPTIONS,

@@ -1185,3 +1217,3 @@ ...this.initialOptions,

const mc = await MongoClient.connect(
this.uri,
this.uri as string,
clientOptions

@@ -1188,0 +1220,0 @@ );

2

src/compass/compass-service-provider.ts

@@ -28,3 +28,3 @@ import CliServiceProvider from '../cli-service-provider';

try {
this.initialDb = mongoClient.s.options.dbName || DEFAULT_DB;
this.initialDb = (mongoClient as any).s.options.dbName || DEFAULT_DB;
} catch (err) {

@@ -31,0 +31,0 @@ this.initialDb = DEFAULT_DB;

4

src/node/node-auth-options.ts

@@ -6,4 +6,4 @@ /**

export default interface NodeAuthOptions {
user?: string;
password?: string;
user: string;
password: string;
}
lib/cli-service-provider.js.map

Sorry, the diff of this file is not supported yet

lib/compass/compass-service-provider.js.map

Sorry, the diff of this file is not supported yet

lib/index.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc