"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.parsePackageVersion = exports.supportsRetryableWrites = exports.enumToString = exports.emitWarningOnce = exports.emitWarning = exports.MONGODB_WARNING_CODE = exports.DEFAULT_PK_FACTORY = exports.HostAddress = exports.BufferPool = exports.deepCopy = exports.isRecord = exports.setDifference = exports.isHello = exports.isSuperset = exports.resolveOptions = exports.hasAtomicOperators = exports.makeInterruptibleAsyncInterval = exports.calculateDurationInMs = exports.now = exports.makeClientMetadata = exports.makeStateMachine = exports.errorStrictEqual = exports.arrayStrictEqual = exports.eachAsyncSeries = exports.eachAsync = exports.collationNotSupported = exports.maxWireVersion = exports.uuidV4 = exports.databaseNamespace = exports.maybePromise = exports.makeCounter = exports.MongoDBNamespace = exports.ns = exports.deprecateOptions = exports.defaultMsgHandler = exports.getTopology = exports.decorateWithExplain = exports.decorateWithReadConcern = exports.decorateWithCollation = exports.isPromiseLike = exports.applyWriteConcern = exports.applyRetryableWrites = exports.executeLegacyOperation = exports.filterOptions = exports.mergeOptions = exports.isObject = exports.parseIndexOptions = exports.normalizeHintField = exports.checkCollectionName = exports.MAX_JS_INT = void 0; exports.commandSupportsReadConcern = exports.shuffle = void 0; const crypto = require("crypto"); const os = require("os"); const url_1 = require("url"); const bson_1 = require("./bson"); const constants_1 = require("./cmap/wire_protocol/constants"); const constants_2 = require("./constants"); const error_1 = require("./error"); const promise_provider_1 = require("./promise_provider"); const read_concern_1 = require("./read_concern"); const read_preference_1 = require("./read_preference"); const common_1 = require("./sdam/common"); const write_concern_1 = require("./write_concern"); exports.MAX_JS_INT = Number.MAX_SAFE_INTEGER + 1; /** * Throws if collectionName is not a valid mongodb collection namespace. * @internal */ function checkCollectionName(collectionName) { if ('string' !== typeof collectionName) { throw new error_1.MongoInvalidArgumentError('Collection name must be a String'); } if (!collectionName || collectionName.indexOf('..') !== -1) { throw new error_1.MongoInvalidArgumentError('Collection names cannot be empty'); } if (collectionName.indexOf('$') !== -1 && collectionName.match(/((^\$cmd)|(oplog\.\$main))/) == null) { // TODO(NODE-3483): Use MongoNamespace static method throw new error_1.MongoInvalidArgumentError("Collection names must not contain '$'"); } if (collectionName.match(/^\.|\.$/) != null) { // TODO(NODE-3483): Use MongoNamespace static method throw new error_1.MongoInvalidArgumentError("Collection names must not start or end with '.'"); } // Validate that we are not passing 0x00 in the collection name if (collectionName.indexOf('\x00') !== -1) { // TODO(NODE-3483): Use MongoNamespace static method throw new error_1.MongoInvalidArgumentError('Collection names cannot contain a null character'); } } exports.checkCollectionName = checkCollectionName; /** * Ensure Hint field is in a shape we expect: * - object of index names mapping to 1 or -1 * - just an index name * @internal */ function normalizeHintField(hint) { let finalHint = undefined; if (typeof hint === 'string') { finalHint = hint; } else if (Array.isArray(hint)) { finalHint = {}; hint.forEach(param => { finalHint[param] = 1; }); } else if (hint != null && typeof hint === 'object') { finalHint = {}; for (const name in hint) { finalHint[name] = hint[name]; } } return finalHint; } exports.normalizeHintField = normalizeHintField; /** * Create an index specifier based on * @internal */ function parseIndexOptions(indexSpec) { const fieldHash = {}; const indexes = []; let keys; // Get all the fields accordingly if ('string' === typeof indexSpec) { // 'type' indexes.push(indexSpec + '_' + 1); fieldHash[indexSpec] = 1; } else if (Array.isArray(indexSpec)) { indexSpec.forEach((f) => { if ('string' === typeof f) { // [{location:'2d'}, 'type'] indexes.push(f + '_' + 1); fieldHash[f] = 1; } else if (Array.isArray(f)) { // [['location', '2d'],['type', 1]] indexes.push(f[0] + '_' + (f[1] || 1)); fieldHash[f[0]] = f[1] || 1; } else if (isObject(f)) { // [{location:'2d'}, {type:1}] keys = Object.keys(f); keys.forEach(k => { indexes.push(k + '_' + f[k]); fieldHash[k] = f[k]; }); } else { // undefined (ignore) } }); } else if (isObject(indexSpec)) { // {location:'2d', type:1} keys = Object.keys(indexSpec); Object.entries(indexSpec).forEach(([key, value]) => { indexes.push(key + '_' + value); fieldHash[key] = value; }); } return { name: indexes.join('_'), keys: keys, fieldHash: fieldHash }; } exports.parseIndexOptions = parseIndexOptions; /** * Checks if arg is an Object: * - **NOTE**: the check is based on the `[Symbol.toStringTag]() === 'Object'` * @internal */ // eslint-disable-next-line @typescript-eslint/ban-types function isObject(arg) { return '[object Object]' === Object.prototype.toString.call(arg); } exports.isObject = isObject; /** @internal */ function mergeOptions(target, source) { return { ...target, ...source }; } exports.mergeOptions = mergeOptions; /** @internal */ function filterOptions(options, names) { const filterOptions = {}; for (const name in options) { if (names.includes(name)) { filterOptions[name] = options[name]; } } // Filtered options return filterOptions; } exports.filterOptions = filterOptions; /** * Executes the given operation with provided arguments. * * @remarks * This method reduces large amounts of duplication in the entire codebase by providing * a single point for determining whether callbacks or promises should be used. Additionally * it allows for a single point of entry to provide features such as implicit sessions, which * are required by the Driver Sessions specification in the event that a ClientSession is * not provided * * @internal * * @param topology - The topology to execute this operation on * @param operation - The operation to execute * @param args - Arguments to apply the provided operation * @param options - Options that modify the behavior of the method */ function executeLegacyOperation(topology, operation, args, options) { const Promise = promise_provider_1.PromiseProvider.get(); if (!Array.isArray(args)) { // TODO(NODE-3483) throw new error_1.MongoRuntimeError('This method requires an array of arguments to apply'); } options = options !== null && options !== void 0 ? options : {}; let callback = args[args.length - 1]; // The driver sessions spec mandates that we implicitly create sessions for operations // that are not explicitly provided with a session. let session; let opOptions; let owner; if (!options.skipSessions && topology.hasSessionSupport()) { opOptions = args[args.length - 2]; if (opOptions == null || opOptions.session == null) { owner = Symbol(); session = topology.startSession({ owner }); const optionsIndex = args.length - 2; args[optionsIndex] = Object.assign({}, args[optionsIndex], { session: session }); } else if (opOptions.session && opOptions.session.hasEnded) { throw new error_1.MongoExpiredSessionError(); } } function makeExecuteCallback(resolve, reject) { return function (err, result) { if (session && session.owner === owner && !(options === null || options === void 0 ? void 0 : options.returnsCursor)) { session.endSession(() => { delete opOptions.session; if (err) return reject(err); resolve(result); }); } else { if (err) return reject(err); resolve(result); } }; } // Execute using callback if (typeof callback === 'function') { callback = args.pop(); const handler = makeExecuteCallback(result => callback(undefined, result), err => callback(err, null)); args.push(handler); try { return operation(...args); } catch (e) { handler(e); throw e; } } // Return a Promise if (args[args.length - 1] != null) { // TODO(NODE-3483) throw new error_1.MongoRuntimeError('Final argument to `executeLegacyOperation` must be a callback'); } return new Promise((resolve, reject) => { const handler = makeExecuteCallback(resolve, reject); args[args.length - 1] = handler; try { return operation(...args); } catch (e) { handler(e); } }); } exports.executeLegacyOperation = executeLegacyOperation; /** * Applies retryWrites: true to a command if retryWrites is set on the command's database. * @internal * * @param target - The target command to which we will apply retryWrites. * @param db - The database from which we can inherit a retryWrites value. */ function applyRetryableWrites(target, db) { var _a; if (db && ((_a = db.s.options) === null || _a === void 0 ? void 0 : _a.retryWrites)) { target.retryWrites = true; } return target; } exports.applyRetryableWrites = applyRetryableWrites; /** * Applies a write concern to a command based on well defined inheritance rules, optionally * detecting support for the write concern in the first place. * @internal * * @param target - the target command we will be applying the write concern to * @param sources - sources where we can inherit default write concerns from * @param options - optional settings passed into a command for write concern overrides */ function applyWriteConcern(target, sources, options) { options = options !== null && options !== void 0 ? options : {}; const db = sources.db; const coll = sources.collection; if (options.session && options.session.inTransaction()) { // writeConcern is not allowed within a multi-statement transaction if (target.writeConcern) { delete target.writeConcern; } return target; } const writeConcern = write_concern_1.WriteConcern.fromOptions(options); if (writeConcern) { return Object.assign(target, { writeConcern }); } if (coll && coll.writeConcern) { return Object.assign(target, { writeConcern: Object.assign({}, coll.writeConcern) }); } if (db && db.writeConcern) { return Object.assign(target, { writeConcern: Object.assign({}, db.writeConcern) }); } return target; } exports.applyWriteConcern = applyWriteConcern; /** * Checks if a given value is a Promise * * @typeParam T - The result type of maybePromise * @param maybePromise - An object that could be a promise * @returns true if the provided value is a Promise */ function isPromiseLike(maybePromise) { return !!maybePromise && typeof maybePromise.then === 'function'; } exports.isPromiseLike = isPromiseLike; /** * Applies collation to a given command. * @internal * * @param command - the command on which to apply collation * @param target - target of command * @param options - options containing collation settings */ function decorateWithCollation(command, target, options) { const capabilities = getTopology(target).capabilities; if (options.collation && typeof options.collation === 'object') { if (capabilities && capabilities.commandsTakeCollation) { command.collation = options.collation; } else { throw new error_1.MongoCompatibilityError(`Current topology does not support collation`); } } } exports.decorateWithCollation = decorateWithCollation; /** * Applies a read concern to a given command. * @internal * * @param command - the command on which to apply the read concern * @param coll - the parent collection of the operation calling this method */ function decorateWithReadConcern(command, coll, options) { if (options && options.session && options.session.inTransaction()) { return; } const readConcern = Object.assign({}, command.readConcern || {}); if (coll.s.readConcern) { Object.assign(readConcern, coll.s.readConcern); } if (Object.keys(readConcern).length > 0) { Object.assign(command, { readConcern: readConcern }); } } exports.decorateWithReadConcern = decorateWithReadConcern; /** * Applies an explain to a given command. * @internal * * @param command - the command on which to apply the explain * @param options - the options containing the explain verbosity */ function decorateWithExplain(command, explain) { if (command.explain) { return command; } return { explain: command, verbosity: explain.verbosity }; } exports.decorateWithExplain = decorateWithExplain; /** * A helper function to get the topology from a given provider. Throws * if the topology cannot be found. * @internal */ function getTopology(provider) { if (`topology` in provider && provider.topology) { return provider.topology; } else if ('client' in provider.s && provider.s.client.topology) { return provider.s.client.topology; } else if ('db' in provider.s && provider.s.db.s.client.topology) { return provider.s.db.s.client.topology; } throw new error_1.MongoNotConnectedError('MongoClient must be connected to perform this operation'); } exports.getTopology = getTopology; /** * Default message handler for generating deprecation warnings. * @internal * * @param name - function name * @param option - option name * @returns warning message */ function defaultMsgHandler(name, option) { return `${name} option [${option}] is deprecated and will be removed in a later version.`; } exports.defaultMsgHandler = defaultMsgHandler; /** * Deprecates a given function's options. * @internal * * @param this - the bound class if this is a method * @param config - configuration for deprecation * @param fn - the target function of deprecation * @returns modified function that warns once per deprecated option, and executes original function */ function deprecateOptions(config, fn) { if (process.noDeprecation === true) { return fn; } const msgHandler = config.msgHandler ? config.msgHandler : defaultMsgHandler; const optionsWarned = new Set(); function deprecated(...args) { const options = args[config.optionsIndex]; // ensure options is a valid, non-empty object, otherwise short-circuit if (!isObject(options) || Object.keys(options).length === 0) { return fn.bind(this)(...args); // call the function, no change } // interrupt the function call with a warning for (const deprecatedOption of config.deprecatedOptions) { if (deprecatedOption in options && !optionsWarned.has(deprecatedOption)) { optionsWarned.add(deprecatedOption); const msg = msgHandler(config.name, deprecatedOption); emitWarning(msg); if (this && 'getLogger' in this) { const logger = this.getLogger(); if (logger) { logger.warn(msg); } } } } return fn.bind(this)(...args); } // These lines copied from https://github.com/nodejs/node/blob/25e5ae41688676a5fd29b2e2e7602168eee4ceb5/lib/internal/util.js#L73-L80 // The wrapper will keep the same prototype as fn to maintain prototype chain Object.setPrototypeOf(deprecated, fn); if (fn.prototype) { // Setting this (rather than using Object.setPrototype, as above) ensures // that calling the unwrapped constructor gives an instanceof the wrapped // constructor. deprecated.prototype = fn.prototype; } return deprecated; } exports.deprecateOptions = deprecateOptions; /** @internal */ function ns(ns) { return MongoDBNamespace.fromString(ns); } exports.ns = ns; /** @public */ class MongoDBNamespace { /** * Create a namespace object * * @param db - database name * @param collection - collection name */ constructor(db, collection) { this.db = db; this.collection = collection; } toString() { return this.collection ? `${this.db}.${this.collection}` : this.db; } withCollection(collection) { return new MongoDBNamespace(this.db, collection); } static fromString(namespace) { if (!namespace) { // TODO(NODE-3483): Replace with MongoNamespaceError throw new error_1.MongoRuntimeError(`Cannot parse namespace from "${namespace}"`); } const [db, ...collection] = namespace.split('.'); return new MongoDBNamespace(db, collection.join('.')); } } exports.MongoDBNamespace = MongoDBNamespace; /** @internal */ function* makeCounter(seed = 0) { let count = seed; while (true) { const newCount = count; count += 1; yield newCount; } } exports.makeCounter = makeCounter; /** * Helper function for either accepting a callback, or returning a promise * @internal * * @param callback - The last function argument in exposed method, controls if a Promise is returned * @param wrapper - A function that wraps the callback * @returns Returns void if a callback is supplied, else returns a Promise. */ function maybePromise(callback, wrapper) { const Promise = promise_provider_1.PromiseProvider.get(); let result; if (typeof callback !== 'function') { result = new Promise((resolve, reject) => { callback = (err, res) => { if (err) return reject(err); resolve(res); }; }); } wrapper((err, res) => { if (err != null) { try { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion callback(err); } catch (error) { process.nextTick(() => { throw error; }); } return; } // eslint-disable-next-line @typescript-eslint/no-non-null-assertion callback(err, res); }); return result; } exports.maybePromise = maybePromise; /** @internal */ function databaseNamespace(ns) { return ns.split('.')[0]; } exports.databaseNamespace = databaseNamespace; /** * Synchronously Generate a UUIDv4 * @internal */ function uuidV4() { const result = crypto.randomBytes(16); result[6] = (result[6] & 0x0f) | 0x40; result[8] = (result[8] & 0x3f) | 0x80; return result; } exports.uuidV4 = uuidV4; /** * A helper function for determining `maxWireVersion` between legacy and new topology instances * @internal */ function maxWireVersion(topologyOrServer) { if (topologyOrServer) { if (topologyOrServer.loadBalanced) { // Since we do not have a monitor, we assume the load balanced server is always // pointed at the latest mongodb version. There is a risk that for on-prem // deployments that don't upgrade immediately that this could alert to the // application that a feature is avaiable that is actually not. return constants_1.MAX_SUPPORTED_WIRE_VERSION; } if (topologyOrServer.hello) { return topologyOrServer.hello.maxWireVersion; } if ('lastHello' in topologyOrServer && typeof topologyOrServer.lastHello === 'function') { const lastHello = topologyOrServer.lastHello(); if (lastHello) { return lastHello.maxWireVersion; } } if (topologyOrServer.description && 'maxWireVersion' in topologyOrServer.description && topologyOrServer.description.maxWireVersion != null) { return topologyOrServer.description.maxWireVersion; } } return 0; } exports.maxWireVersion = maxWireVersion; /** * Checks that collation is supported by server. * @internal * * @param server - to check against * @param cmd - object where collation may be specified */ function collationNotSupported(server, cmd) { return cmd && cmd.collation && maxWireVersion(server) < 5; } exports.collationNotSupported = collationNotSupported; /** * Applies the function `eachFn` to each item in `arr`, in parallel. * @internal * * @param arr - An array of items to asynchronously iterate over * @param eachFn - A function to call on each item of the array. The callback signature is `(item, callback)`, where the callback indicates iteration is complete. * @param callback - The callback called after every item has been iterated */ function eachAsync(arr, eachFn, callback) { arr = arr || []; let idx = 0; let awaiting = 0; for (idx = 0; idx < arr.length; ++idx) { awaiting++; eachFn(arr[idx], eachCallback); } if (awaiting === 0) { callback(); return; } function eachCallback(err) { awaiting--; if (err) { callback(err); return; } if (idx === arr.length && awaiting <= 0) { callback(); } } } exports.eachAsync = eachAsync; /** @internal */ function eachAsyncSeries(arr, eachFn, callback) { arr = arr || []; let idx = 0; let awaiting = arr.length; if (awaiting === 0) { callback(); return; } function eachCallback(err) { idx++; awaiting--; if (err) { callback(err); return; } if (idx === arr.length && awaiting <= 0) { callback(); return; } eachFn(arr[idx], eachCallback); } eachFn(arr[idx], eachCallback); } exports.eachAsyncSeries = eachAsyncSeries; /** @internal */ function arrayStrictEqual(arr, arr2) { if (!Array.isArray(arr) || !Array.isArray(arr2)) { return false; } return arr.length === arr2.length && arr.every((elt, idx) => elt === arr2[idx]); } exports.arrayStrictEqual = arrayStrictEqual; /** @internal */ function errorStrictEqual(lhs, rhs) { if (lhs === rhs) { return true; } if (!lhs || !rhs) { return lhs === rhs; } if ((lhs == null && rhs != null) || (lhs != null && rhs == null)) { return false; } if (lhs.constructor.name !== rhs.constructor.name) { return false; } if (lhs.message !== rhs.message) { return false; } return true; } exports.errorStrictEqual = errorStrictEqual; /** @internal */ function makeStateMachine(stateTable) { return function stateTransition(target, newState) { const legalStates = stateTable[target.s.state]; if (legalStates && legalStates.indexOf(newState) < 0) { throw new error_1.MongoRuntimeError(`illegal state transition from [${target.s.state}] => [${newState}], allowed: [${legalStates}]`); } target.emit('stateChanged', target.s.state, newState); target.s.state = newState; }; } exports.makeStateMachine = makeStateMachine; // eslint-disable-next-line @typescript-eslint/no-var-requires const NODE_DRIVER_VERSION = require('../package.json').version; function makeClientMetadata(options) { options = options !== null && options !== void 0 ? options : {}; const metadata = { driver: { name: 'nodejs', version: NODE_DRIVER_VERSION }, os: { type: os.type(), name: process.platform, architecture: process.arch, version: os.release() }, platform: `Node.js ${process.version}, ${os.endianness()} (unified)` }; // support optionally provided wrapping driver info if (options.driverInfo) { if (options.driverInfo.name) { metadata.driver.name = `${metadata.driver.name}|${options.driverInfo.name}`; } if (options.driverInfo.version) { metadata.version = `${metadata.driver.version}|${options.driverInfo.version}`; } if (options.driverInfo.platform) { metadata.platform = `${metadata.platform}|${options.driverInfo.platform}`; } } if (options.appName) { // MongoDB requires the appName not exceed a byte length of 128 const buffer = Buffer.from(options.appName); metadata.application = { name: buffer.byteLength > 128 ? buffer.slice(0, 128).toString('utf8') : options.appName }; } return metadata; } exports.makeClientMetadata = makeClientMetadata; /** @internal */ function now() { const hrtime = process.hrtime(); return Math.floor(hrtime[0] * 1000 + hrtime[1] / 1000000); } exports.now = now; /** @internal */ function calculateDurationInMs(started) { if (typeof started !== 'number') { throw new error_1.MongoInvalidArgumentError('Numeric value required to calculate duration'); } const elapsed = now() - started; return elapsed < 0 ? 0 : elapsed; } exports.calculateDurationInMs = calculateDurationInMs; /** * Creates an interval timer which is able to be woken up sooner than * the interval. The timer will also debounce multiple calls to wake * ensuring that the function is only ever called once within a minimum * interval window. * @internal * * @param fn - An async function to run on an interval, must accept a `callback` as its only parameter */ function makeInterruptibleAsyncInterval(fn, options) { let timerId; let lastCallTime; let cannotBeExpedited = false; let stopped = false; options = options !== null && options !== void 0 ? options : {}; const interval = options.interval || 1000; const minInterval = options.minInterval || 500; const immediate = typeof options.immediate === 'boolean' ? options.immediate : false; const clock = typeof options.clock === 'function' ? options.clock : now; function wake() { const currentTime = clock(); const nextScheduledCallTime = lastCallTime + interval; const timeUntilNextCall = nextScheduledCallTime - currentTime; // For the streaming protocol: there is nothing obviously stopping this // interval from being woken up again while we are waiting "infinitely" // for `fn` to be called again`. Since the function effectively // never completes, the `timeUntilNextCall` will continue to grow // negatively unbounded, so it will never trigger a reschedule here. // This is possible in virtualized environments like AWS Lambda where our // clock is unreliable. In these cases the timer is "running" but never // actually completes, so we want to execute immediately and then attempt // to reschedule. if (timeUntilNextCall < 0) { executeAndReschedule(); return; } // debounce multiple calls to wake within the `minInterval` if (cannotBeExpedited) { return; } // reschedule a call as soon as possible, ensuring the call never happens // faster than the `minInterval` if (timeUntilNextCall > minInterval) { reschedule(minInterval); cannotBeExpedited = true; } } function stop() { stopped = true; if (timerId) { clearTimeout(timerId); timerId = undefined; } lastCallTime = 0; cannotBeExpedited = false; } function reschedule(ms) { if (stopped) return; if (timerId) { clearTimeout(timerId); } timerId = setTimeout(executeAndReschedule, ms || interval); } function executeAndReschedule() { cannotBeExpedited = false; lastCallTime = clock(); fn(err => { if (err) throw err; reschedule(interval); }); } if (immediate) { executeAndReschedule(); } else { lastCallTime = clock(); reschedule(undefined); } return { wake, stop }; } exports.makeInterruptibleAsyncInterval = makeInterruptibleAsyncInterval; /** @internal */ function hasAtomicOperators(doc) { if (Array.isArray(doc)) { for (const document of doc) { if (hasAtomicOperators(document)) { return true; } } return false; } const keys = Object.keys(doc); return keys.length > 0 && keys[0][0] === '$'; } exports.hasAtomicOperators = hasAtomicOperators; /** * Merge inherited properties from parent into options, prioritizing values from options, * then values from parent. * @internal */ function resolveOptions(parent, options) { var _a, _b, _c; const result = Object.assign({}, options, (0, bson_1.resolveBSONOptions)(options, parent)); // Users cannot pass a readConcern/writeConcern to operations in a transaction const session = options === null || options === void 0 ? void 0 : options.session; if (!(session === null || session === void 0 ? void 0 : session.inTransaction())) { const readConcern = (_a = read_concern_1.ReadConcern.fromOptions(options)) !== null && _a !== void 0 ? _a : parent === null || parent === void 0 ? void 0 : parent.readConcern; if (readConcern) { result.readConcern = readConcern; } const writeConcern = (_b = write_concern_1.WriteConcern.fromOptions(options)) !== null && _b !== void 0 ? _b : parent === null || parent === void 0 ? void 0 : parent.writeConcern; if (writeConcern) { result.writeConcern = writeConcern; } } const readPreference = (_c = read_preference_1.ReadPreference.fromOptions(options)) !== null && _c !== void 0 ? _c : parent === null || parent === void 0 ? void 0 : parent.readPreference; if (readPreference) { result.readPreference = readPreference; } return result; } exports.resolveOptions = resolveOptions; function isSuperset(set, subset) { set = Array.isArray(set) ? new Set(set) : set; subset = Array.isArray(subset) ? new Set(subset) : subset; for (const elem of subset) { if (!set.has(elem)) { return false; } } return true; } exports.isSuperset = isSuperset; /** * Checks if the document is a Hello request * @internal */ function isHello(doc) { return doc[constants_2.LEGACY_HELLO_COMMAND] || doc.hello ? true : false; } exports.isHello = isHello; /** Returns the items that are uniquely in setA */ function setDifference(setA, setB) { const difference = new Set(setA); for (const elem of setB) { difference.delete(elem); } return difference; } exports.setDifference = setDifference; function isRecord(value, requiredKeys = undefined) { const toString = Object.prototype.toString; const hasOwnProperty = Object.prototype.hasOwnProperty; const isObject = (v) => toString.call(v) === '[object Object]'; if (!isObject(value)) { return false; } const ctor = value.constructor; if (ctor && ctor.prototype) { if (!isObject(ctor.prototype)) { return false; } // Check to see if some method exists from the Object exists if (!hasOwnProperty.call(ctor.prototype, 'isPrototypeOf')) { return false; } } if (requiredKeys) { const keys = Object.keys(value); return isSuperset(keys, requiredKeys); } return true; } exports.isRecord = isRecord; /** * Make a deep copy of an object * * NOTE: This is not meant to be the perfect implementation of a deep copy, * but instead something that is good enough for the purposes of * command monitoring. */ function deepCopy(value) { if (value == null) { return value; } else if (Array.isArray(value)) { return value.map(item => deepCopy(item)); } else if (isRecord(value)) { const res = {}; for (const key in value) { res[key] = deepCopy(value[key]); } return res; } const ctor = value.constructor; if (ctor) { switch (ctor.name.toLowerCase()) { case 'date': return new ctor(Number(value)); case 'map': return new Map(value); case 'set': return new Set(value); case 'buffer': return Buffer.from(value); } } return value; } exports.deepCopy = deepCopy; /** @internal */ const kBuffers = Symbol('buffers'); /** @internal */ const kLength = Symbol('length'); /** * A pool of Buffers which allow you to read them as if they were one * @internal */ class BufferPool { constructor() { this[kBuffers] = []; this[kLength] = 0; } get length() { return this[kLength]; } /** Adds a buffer to the internal buffer pool list */ append(buffer) { this[kBuffers].push(buffer); this[kLength] += buffer.length; } /** Returns the requested number of bytes without consuming them */ peek(size) { return this.read(size, false); } /** Reads the requested number of bytes, optionally consuming them */ read(size, consume = true) { if (typeof size !== 'number' || size < 0) { throw new error_1.MongoInvalidArgumentError('Argument "size" must be a non-negative number'); } if (size > this[kLength]) { return Buffer.alloc(0); } let result; // read the whole buffer if (size === this.length) { result = Buffer.concat(this[kBuffers]); if (consume) { this[kBuffers] = []; this[kLength] = 0; } } // size is within first buffer, no need to concat else if (size <= this[kBuffers][0].length) { result = this[kBuffers][0].slice(0, size); if (consume) { this[kBuffers][0] = this[kBuffers][0].slice(size); this[kLength] -= size; } } // size is beyond first buffer, need to track and copy else { result = Buffer.allocUnsafe(size); let idx; let offset = 0; let bytesToCopy = size; for (idx = 0; idx < this[kBuffers].length; ++idx) { let bytesCopied; if (bytesToCopy > this[kBuffers][idx].length) { bytesCopied = this[kBuffers][idx].copy(result, offset, 0); offset += bytesCopied; } else { bytesCopied = this[kBuffers][idx].copy(result, offset, 0, bytesToCopy); if (consume) { this[kBuffers][idx] = this[kBuffers][idx].slice(bytesCopied); } offset += bytesCopied; break; } bytesToCopy -= bytesCopied; } // compact the internal buffer array if (consume) { this[kBuffers] = this[kBuffers].slice(idx); this[kLength] -= size; } } return result; } } exports.BufferPool = BufferPool; /** @public */ class HostAddress { constructor(hostString) { const escapedHost = hostString.split(' ').join('%20'); // escape spaces, for socket path hosts const { hostname, port } = new url_1.URL(`mongodb://${escapedHost}`); if (hostname.endsWith('.sock')) { // heuristically determine if we're working with a domain socket this.socketPath = decodeURIComponent(hostname); } else if (typeof hostname === 'string') { this.isIPv6 = false; let normalized = decodeURIComponent(hostname).toLowerCase(); if (normalized.startsWith('[') && normalized.endsWith(']')) { this.isIPv6 = true; normalized = normalized.substring(1, hostname.length - 1); } this.host = normalized.toLowerCase(); if (typeof port === 'number') { this.port = port; } else if (typeof port === 'string' && port !== '') { this.port = Number.parseInt(port, 10); } else { this.port = 27017; } if (this.port === 0) { throw new error_1.MongoParseError('Invalid port (zero) with hostname'); } } else { throw new error_1.MongoInvalidArgumentError('Either socketPath or host must be defined.'); } Object.freeze(this); } [Symbol.for('nodejs.util.inspect.custom')]() { return this.inspect(); } inspect() { return `new HostAddress('${this.toString(true)}')`; } /** * @param ipv6Brackets - optionally request ipv6 bracket notation required for connection strings */ toString(ipv6Brackets = false) { if (typeof this.host === 'string') { if (this.isIPv6 && ipv6Brackets) { return `[${this.host}]:${this.port}`; } return `${this.host}:${this.port}`; } return `${this.socketPath}`; } static fromString(s) { return new HostAddress(s); } static fromHostPort(host, port) { if (host.includes(':')) { host = `[${host}]`; // IPv6 address } return HostAddress.fromString(`${host}:${port}`); } static fromSrvRecord({ name, port }) { return HostAddress.fromHostPort(name, port); } } exports.HostAddress = HostAddress; exports.DEFAULT_PK_FACTORY = { // We prefer not to rely on ObjectId having a createPk method createPk() { return new bson_1.ObjectId(); } }; /** * When the driver used emitWarning the code will be equal to this. * @public * * @example * ```js * process.on('warning', (warning) => { * if (warning.code === MONGODB_WARNING_CODE) console.error('Ah an important warning! :)') * }) * ``` */ exports.MONGODB_WARNING_CODE = 'MONGODB DRIVER'; /** @internal */ function emitWarning(message) { return process.emitWarning(message, { code: exports.MONGODB_WARNING_CODE }); } exports.emitWarning = emitWarning; const emittedWarnings = new Set(); /** * Will emit a warning once for the duration of the application. * Uses the message to identify if it has already been emitted * so using string interpolation can cause multiple emits * @internal */ function emitWarningOnce(message) { if (!emittedWarnings.has(message)) { emittedWarnings.add(message); return emitWarning(message); } } exports.emitWarningOnce = emitWarningOnce; /** * Takes a JS object and joins the values into a string separated by ', ' */ function enumToString(en) { return Object.values(en).join(', '); } exports.enumToString = enumToString; /** * Determine if a server supports retryable writes. * * @internal */ function supportsRetryableWrites(server) { return (!!server.loadBalanced || (server.description.maxWireVersion >= 6 && !!server.description.logicalSessionTimeoutMinutes && server.description.type !== common_1.ServerType.Standalone)); } exports.supportsRetryableWrites = supportsRetryableWrites; function parsePackageVersion({ version }) { const [major, minor, patch] = version.split('.').map((n) => Number.parseInt(n, 10)); return { major, minor, patch }; } exports.parsePackageVersion = parsePackageVersion; /** * Fisher–Yates Shuffle * * Reference: https://bost.ocks.org/mike/shuffle/ * @param sequence - items to be shuffled * @param limit - Defaults to `0`. If nonzero shuffle will slice the randomized array e.g, `.slice(0, limit)` otherwise will return the entire randomized array. */ function shuffle(sequence, limit = 0) { const items = Array.from(sequence); // shallow copy in order to never shuffle the input if (limit > items.length) { throw new error_1.MongoRuntimeError('Limit must be less than the number of items'); } let remainingItemsToShuffle = items.length; const lowerBound = limit % items.length === 0 ? 1 : items.length - limit; while (remainingItemsToShuffle > lowerBound) { // Pick a remaining element const randomIndex = Math.floor(Math.random() * remainingItemsToShuffle); remainingItemsToShuffle -= 1; // And swap it with the current element const swapHold = items[remainingItemsToShuffle]; items[remainingItemsToShuffle] = items[randomIndex]; items[randomIndex] = swapHold; } return limit % items.length === 0 ? items : items.slice(lowerBound); } exports.shuffle = shuffle; // TODO: this should be codified in command construction // @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#read-concern function commandSupportsReadConcern(command, options) { if (command.aggregate || command.count || command.distinct || command.find || command.geoNear) { return true; } if (command.mapReduce && options && options.out && (options.out.inline === 1 || options.out === 'inline')) { return true; } return false; } exports.commandSupportsReadConcern = commandSupportsReadConcern; //# sourceMappingURL=utils.js.map