You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
270 lines
11 KiB
JavaScript
270 lines
11 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.IndexInformationOperation = exports.IndexExistsOperation = exports.ListIndexesOperation = exports.DropIndexesOperation = exports.DropIndexOperation = exports.EnsureIndexOperation = exports.CreateIndexOperation = exports.CreateIndexesOperation = exports.IndexesOperation = void 0;
|
|
const error_1 = require("../error");
|
|
const read_preference_1 = require("../read_preference");
|
|
const utils_1 = require("../utils");
|
|
const command_1 = require("./command");
|
|
const common_functions_1 = require("./common_functions");
|
|
const operation_1 = require("./operation");
|
|
const VALID_INDEX_OPTIONS = new Set([
|
|
'background',
|
|
'unique',
|
|
'name',
|
|
'partialFilterExpression',
|
|
'sparse',
|
|
'hidden',
|
|
'expireAfterSeconds',
|
|
'storageEngine',
|
|
'collation',
|
|
'version',
|
|
// text indexes
|
|
'weights',
|
|
'default_language',
|
|
'language_override',
|
|
'textIndexVersion',
|
|
// 2d-sphere indexes
|
|
'2dsphereIndexVersion',
|
|
// 2d indexes
|
|
'bits',
|
|
'min',
|
|
'max',
|
|
// geoHaystack Indexes
|
|
'bucketSize',
|
|
// wildcard indexes
|
|
'wildcardProjection'
|
|
]);
|
|
function isIndexDirection(x) {
|
|
return (typeof x === 'number' || x === '2d' || x === '2dsphere' || x === 'text' || x === 'geoHaystack');
|
|
}
|
|
function isSingleIndexTuple(t) {
|
|
return Array.isArray(t) && t.length === 2 && isIndexDirection(t[1]);
|
|
}
|
|
function makeIndexSpec(indexSpec, options) {
|
|
const key = new Map();
|
|
const indexSpecs = !Array.isArray(indexSpec) || isSingleIndexTuple(indexSpec) ? [indexSpec] : indexSpec;
|
|
// Iterate through array and handle different types
|
|
for (const spec of indexSpecs) {
|
|
if (typeof spec === 'string') {
|
|
key.set(spec, 1);
|
|
}
|
|
else if (Array.isArray(spec)) {
|
|
key.set(spec[0], spec[1] ?? 1);
|
|
}
|
|
else if (spec instanceof Map) {
|
|
for (const [property, value] of spec) {
|
|
key.set(property, value);
|
|
}
|
|
}
|
|
else if ((0, utils_1.isObject)(spec)) {
|
|
for (const [property, value] of Object.entries(spec)) {
|
|
key.set(property, value);
|
|
}
|
|
}
|
|
}
|
|
return { ...options, key };
|
|
}
|
|
/** @internal */
|
|
class IndexesOperation extends operation_1.AbstractCallbackOperation {
|
|
constructor(collection, options) {
|
|
super(options);
|
|
this.options = options;
|
|
this.collection = collection;
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
const coll = this.collection;
|
|
const options = this.options;
|
|
(0, common_functions_1.indexInformation)(coll.s.db, coll.collectionName, { full: true, ...options, readPreference: this.readPreference, session }, callback);
|
|
}
|
|
}
|
|
exports.IndexesOperation = IndexesOperation;
|
|
/** @internal */
|
|
class CreateIndexesOperation extends command_1.CommandCallbackOperation {
|
|
constructor(parent, collectionName, indexes, options) {
|
|
super(parent, options);
|
|
this.options = options ?? {};
|
|
this.collectionName = collectionName;
|
|
this.indexes = indexes.map(userIndex => {
|
|
// Ensure the key is a Map to preserve index key ordering
|
|
const key = userIndex.key instanceof Map ? userIndex.key : new Map(Object.entries(userIndex.key));
|
|
const name = userIndex.name != null ? userIndex.name : Array.from(key).flat().join('_');
|
|
const validIndexOptions = Object.fromEntries(Object.entries({ ...userIndex }).filter(([optionName]) => VALID_INDEX_OPTIONS.has(optionName)));
|
|
return {
|
|
...validIndexOptions,
|
|
name,
|
|
key
|
|
};
|
|
});
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
const options = this.options;
|
|
const indexes = this.indexes;
|
|
const serverWireVersion = (0, utils_1.maxWireVersion)(server);
|
|
const cmd = { createIndexes: this.collectionName, indexes };
|
|
if (options.commitQuorum != null) {
|
|
if (serverWireVersion < 9) {
|
|
callback(new error_1.MongoCompatibilityError('Option `commitQuorum` for `createIndexes` not supported on servers < 4.4'));
|
|
return;
|
|
}
|
|
cmd.commitQuorum = options.commitQuorum;
|
|
}
|
|
// collation is set on each index, it should not be defined at the root
|
|
this.options.collation = undefined;
|
|
super.executeCommandCallback(server, session, cmd, err => {
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
const indexNames = indexes.map(index => index.name || '');
|
|
callback(undefined, indexNames);
|
|
});
|
|
}
|
|
}
|
|
exports.CreateIndexesOperation = CreateIndexesOperation;
|
|
/** @internal */
|
|
class CreateIndexOperation extends CreateIndexesOperation {
|
|
constructor(parent, collectionName, indexSpec, options) {
|
|
super(parent, collectionName, [makeIndexSpec(indexSpec, options)], options);
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
super.executeCallback(server, session, (err, indexNames) => {
|
|
if (err || !indexNames)
|
|
return callback(err);
|
|
return callback(undefined, indexNames[0]);
|
|
});
|
|
}
|
|
}
|
|
exports.CreateIndexOperation = CreateIndexOperation;
|
|
/** @internal */
|
|
class EnsureIndexOperation extends CreateIndexOperation {
|
|
constructor(db, collectionName, indexSpec, options) {
|
|
super(db, collectionName, indexSpec, options);
|
|
this.readPreference = read_preference_1.ReadPreference.primary;
|
|
this.db = db;
|
|
this.collectionName = collectionName;
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
const indexName = this.indexes[0].name;
|
|
const cursor = this.db.collection(this.collectionName).listIndexes({ session });
|
|
cursor.toArray().then(indexes => {
|
|
indexes = Array.isArray(indexes) ? indexes : [indexes];
|
|
if (indexes.some(index => index.name === indexName)) {
|
|
callback(undefined, indexName);
|
|
return;
|
|
}
|
|
super.executeCallback(server, session, callback);
|
|
}, error => {
|
|
if (error instanceof error_1.MongoError && error.code === error_1.MONGODB_ERROR_CODES.NamespaceNotFound) {
|
|
// ignore "NamespaceNotFound" errors
|
|
return super.executeCallback(server, session, callback);
|
|
}
|
|
return callback(error);
|
|
});
|
|
}
|
|
}
|
|
exports.EnsureIndexOperation = EnsureIndexOperation;
|
|
/** @internal */
|
|
class DropIndexOperation extends command_1.CommandCallbackOperation {
|
|
constructor(collection, indexName, options) {
|
|
super(collection, options);
|
|
this.options = options ?? {};
|
|
this.collection = collection;
|
|
this.indexName = indexName;
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
const cmd = { dropIndexes: this.collection.collectionName, index: this.indexName };
|
|
super.executeCommandCallback(server, session, cmd, callback);
|
|
}
|
|
}
|
|
exports.DropIndexOperation = DropIndexOperation;
|
|
/** @internal */
|
|
class DropIndexesOperation extends DropIndexOperation {
|
|
constructor(collection, options) {
|
|
super(collection, '*', options);
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
super.executeCallback(server, session, err => {
|
|
if (err)
|
|
return callback(err, false);
|
|
callback(undefined, true);
|
|
});
|
|
}
|
|
}
|
|
exports.DropIndexesOperation = DropIndexesOperation;
|
|
/** @internal */
|
|
class ListIndexesOperation extends command_1.CommandCallbackOperation {
|
|
constructor(collection, options) {
|
|
super(collection, options);
|
|
this.options = { ...options };
|
|
delete this.options.writeConcern;
|
|
this.collectionNamespace = collection.s.namespace;
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
const serverWireVersion = (0, utils_1.maxWireVersion)(server);
|
|
const cursor = this.options.batchSize ? { batchSize: this.options.batchSize } : {};
|
|
const command = { listIndexes: this.collectionNamespace.collection, cursor };
|
|
// we check for undefined specifically here to allow falsy values
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
if (serverWireVersion >= 9 && this.options.comment !== undefined) {
|
|
command.comment = this.options.comment;
|
|
}
|
|
super.executeCommandCallback(server, session, command, callback);
|
|
}
|
|
}
|
|
exports.ListIndexesOperation = ListIndexesOperation;
|
|
/** @internal */
|
|
class IndexExistsOperation extends operation_1.AbstractCallbackOperation {
|
|
constructor(collection, indexes, options) {
|
|
super(options);
|
|
this.options = options;
|
|
this.collection = collection;
|
|
this.indexes = indexes;
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
const coll = this.collection;
|
|
const indexes = this.indexes;
|
|
(0, common_functions_1.indexInformation)(coll.s.db, coll.collectionName, { ...this.options, readPreference: this.readPreference, session }, (err, indexInformation) => {
|
|
// If we have an error return
|
|
if (err != null)
|
|
return callback(err);
|
|
// Let's check for the index names
|
|
if (!Array.isArray(indexes))
|
|
return callback(undefined, indexInformation[indexes] != null);
|
|
// Check in list of indexes
|
|
for (let i = 0; i < indexes.length; i++) {
|
|
if (indexInformation[indexes[i]] == null) {
|
|
return callback(undefined, false);
|
|
}
|
|
}
|
|
// All keys found return true
|
|
return callback(undefined, true);
|
|
});
|
|
}
|
|
}
|
|
exports.IndexExistsOperation = IndexExistsOperation;
|
|
/** @internal */
|
|
class IndexInformationOperation extends operation_1.AbstractCallbackOperation {
|
|
constructor(db, name, options) {
|
|
super(options);
|
|
this.options = options ?? {};
|
|
this.db = db;
|
|
this.name = name;
|
|
}
|
|
executeCallback(server, session, callback) {
|
|
const db = this.db;
|
|
const name = this.name;
|
|
(0, common_functions_1.indexInformation)(db, name, { ...this.options, readPreference: this.readPreference, session }, callback);
|
|
}
|
|
}
|
|
exports.IndexInformationOperation = IndexInformationOperation;
|
|
(0, operation_1.defineAspects)(ListIndexesOperation, [
|
|
operation_1.Aspect.READ_OPERATION,
|
|
operation_1.Aspect.RETRYABLE,
|
|
operation_1.Aspect.CURSOR_CREATING
|
|
]);
|
|
(0, operation_1.defineAspects)(CreateIndexesOperation, [operation_1.Aspect.WRITE_OPERATION]);
|
|
(0, operation_1.defineAspects)(CreateIndexOperation, [operation_1.Aspect.WRITE_OPERATION]);
|
|
(0, operation_1.defineAspects)(EnsureIndexOperation, [operation_1.Aspect.WRITE_OPERATION]);
|
|
(0, operation_1.defineAspects)(DropIndexOperation, [operation_1.Aspect.WRITE_OPERATION]);
|
|
(0, operation_1.defineAspects)(DropIndexesOperation, [operation_1.Aspect.WRITE_OPERATION]);
|
|
//# sourceMappingURL=indexes.js.map
|