@qp-mongosh/service-provider-core 0.0.0-dev.0

package/src/cli-options.ts

@@ -0,0 +1,49 @@
+/**
+ * Valid options that can be parsed from the command line.
+ */
+export default interface CliOptions {
+  // Positional arguments:
+  connectionSpecifier?: string;
+  fileNames?: string[];
+
+  // Non-positional arguments:
+  apiDeprecationErrors?: boolean;
+  apiStrict?: boolean;
+  apiVersion?: string;
+  authenticationDatabase?: string;
+  authenticationMechanism?: string;
+  awsAccessKeyId?: string;
+  awsIamSessionToken?: string;
+  awsSecretAccessKey?: string;
+  awsSessionToken?: string;
+  db?: string;
+  eval?: string;
+  gssapiServiceName?: string;
+  sspiHostnameCanonicalization?: string;
+  sspiRealmOverride?: string;
+  help?: boolean;
+  host?: string;
+  ipv6?: boolean;
+  keyVaultNamespace?: string;
+  kmsURL?: string;
+  nodb?: boolean;
+  norc?: boolean;
+  password?: string;
+  port?: string;
+  quiet?: boolean;
+  retryWrites?: boolean;
+  shell?: boolean;
+  tls?: boolean;
+  tlsAllowInvalidCertificates?: boolean;
+  tlsAllowInvalidHostnames?: boolean;
+  tlsCAFile?: string;
+  tlsCertificateKeyFile?: string;
+  tlsCertificateKeyFilePassword?: string;
+  tlsCertificateSelector?: string;
+  tlsCRLFile?: string;
+  tlsDisabledProtocols?: boolean;
+  tlsFIPSMode?: boolean;
+  username?: string;
+  verbose?: boolean;
+  version?: boolean;
+}

package/src/closable.ts

@@ -0,0 +1,14 @@
+export default interface Closable {
+  /**
+   * Close the connection.
+   *
+   * @param {boolean} force - Whether to force close.
+   */
+  close(force: boolean): Promise<void>;
+
+  /**
+   * Suspends the connection, i.e. temporarily force-closes it
+   * and returns a function that will re-open the connection.
+   */
+  suspend(): Promise<() => Promise<void>>;
+}

package/src/connect-info.spec.ts

@@ -0,0 +1,192 @@
+/* eslint camelcase: 0, camelcase: 0 */
+import { expect } from 'chai';
+import getConnectInfo from './connect-info';
+
+describe('getConnectInfo', function() {
+  const BUILD_INFO = {
+    'version': '3.2.0-rc2',
+    'gitVersion': '8a3acb42742182c5e314636041c2df368232bbc5',
+    'modules': [
+      'enterprise'
+    ],
+    'allocator': 'system',
+    'javascriptEngine': 'mozjs',
+    'sysInfo': 'deprecated',
+    'versionArray': [
+      3,
+      2,
+      0,
+      -48
+    ],
+    'openssl': {
+      'running': 'OpenSSL 0.9.8zg 14 July 2015',
+      'compiled': 'OpenSSL 0.9.8y 5 Feb 2013'
+    },
+    'buildEnvironment': {
+      'distmod': '',
+      'distarch': 'x86_64',
+      'cc': 'gcc: Apple LLVM version 5.1 (clang-503.0.40) (based on LLVM 3.4svn)',
+      'ccflags': '-fno-omit-frame-pointer -fPIC -fno-strict-aliasing -ggdb -pthread -Wall -Wsign-compare -Wno-unknown-pragmas -Winvalid-pch -Werror -O2 -Wno-unused-function -Wno-unused-private-field -Wno-deprecated-declarations -Wno-tautological-constant-out-of-range-compare -Wno-unused-const-variable -Wno-missing-braces -mmacosx-version-min=10.7 -fno-builtin-memcmp',
+      'cxx': 'g++: Apple LLVM version 5.1 (clang-503.0.40) (based on LLVM 3.4svn)',
+      'cxxflags': '-Wnon-virtual-dtor -Woverloaded-virtual -stdlib=libc++ -std=c++11',
+      'linkflags': '-fPIC -pthread -Wl,-bind_at_load -mmacosx-version-min=10.7 -stdlib=libc++ -fuse-ld=gold',
+      'target_arch': 'x86_64',
+      'target_os': 'osx'
+    },
+    'bits': 64,
+    'debug': false,
+    'maxBsonObjectSize': 16777216,
+    'storageEngines': [
+      'devnull',
+      'ephemeralForTest',
+      'inMemory',
+      'mmapv1',
+      'wiredTiger'
+    ],
+    'ok': 1
+  };
+
+  const CMD_LINE_OPTS = {
+    'argv': [
+      '/opt/mongodb-osx-x86_64-enterprise-3.6.3/bin/mongod',
+      '--dbpath=/Users/user/testdata'
+    ],
+    'parsed': {
+      'storage': {
+        'dbPath': '/Users/user/testdata'
+      }
+    },
+    'ok': 1
+  };
+
+  const ATLAS_VERSION = {
+    'atlasVersion': '20210330.0.0.1617063608',
+    'gitVersion': '8f7e5bdde713391e8123a463895bb7fb660a5ffd'
+  };
+
+  const TOPOLOGY_WITH_CREDENTIALS = {
+    's': {
+      'credentials': {
+        'mechanism': 'LDAP'
+      }
+    }
+  };
+
+  const TOPOLOGY_NO_CREDENTIALS = {
+    's': {}
+  };
+
+  const ATLAS_URI = 'mongodb+srv://admin:catscatscats@cat-data-sets.cats.example.net/admin';
+
+  it('reports on an enterprise version >=3.2 of mongodb with credentials', function() {
+    const output = {
+      is_atlas: true,
+      is_localhost: false,
+      is_do: false,
+      server_version: '3.2.0-rc2',
+      mongosh_version: '0.0.6',
+      is_enterprise: true,
+      auth_type: 'LDAP',
+      is_data_lake: false,
+      dl_version: null,
+      atlas_version: '20210330.0.0.1617063608',
+      is_genuine: true,
+      non_genuine_server_name: 'mongodb',
+      server_arch: 'x86_64',
+      node_version: process.version,
+      server_os: 'osx',
+      uri: ATLAS_URI
+    };
+    expect(getConnectInfo(
+      ATLAS_URI,
+      '0.0.6',
+      BUILD_INFO,
+      CMD_LINE_OPTS,
+      ATLAS_VERSION,
+      TOPOLOGY_WITH_CREDENTIALS)).to.deep.equal(output);
+  });
+
+  it('reports on an enterprise version >=3.2 of mongodb with no credentials', function() {
+    const output = {
+      is_atlas: true,
+      is_localhost: false,
+      is_do: false,
+      server_version: '3.2.0-rc2',
+      mongosh_version: '0.0.6',
+      is_enterprise: true,
+      auth_type: null,
+      is_data_lake: false,
+      dl_version: null,
+      atlas_version: '20210330.0.0.1617063608',
+      is_genuine: true,
+      non_genuine_server_name: 'mongodb',
+      server_arch: 'x86_64',
+      node_version: process.version,
+      server_os: 'osx',
+      uri: ATLAS_URI
+    };
+    expect(getConnectInfo(
+      ATLAS_URI,
+      '0.0.6',
+      BUILD_INFO,
+      CMD_LINE_OPTS,
+      ATLAS_VERSION,
+      TOPOLOGY_NO_CREDENTIALS)).to.deep.equal(output);
+  });
+
+  it('reports correct information when an empty uri is passed', function() {
+    const output = {
+      is_atlas: false,
+      is_localhost: false,
+      is_do: false,
+      server_version: '3.2.0-rc2',
+      mongosh_version: '0.0.6',
+      is_enterprise: true,
+      auth_type: 'LDAP',
+      is_data_lake: false,
+      dl_version: null,
+      atlas_version: null,
+      is_genuine: true,
+      non_genuine_server_name: 'mongodb',
+      server_arch: 'x86_64',
+      node_version: process.version,
+      server_os: 'osx',
+      uri: ''
+    };
+    expect(getConnectInfo(
+      '',
+      '0.0.6',
+      BUILD_INFO,
+      CMD_LINE_OPTS,
+      null,
+      TOPOLOGY_WITH_CREDENTIALS)).to.deep.equal(output);
+  });
+
+  it('does not fail when buildInfo is unavailable', function() {
+    const output = {
+      is_atlas: false,
+      is_localhost: false,
+      is_do: false,
+      server_version: undefined,
+      mongosh_version: '0.0.6',
+      is_enterprise: false,
+      auth_type: 'LDAP',
+      is_data_lake: false,
+      dl_version: null,
+      atlas_version: null,
+      is_genuine: true,
+      non_genuine_server_name: 'mongodb',
+      server_arch: null,
+      node_version: process.version,
+      server_os: null,
+      uri: ''
+    };
+    expect(getConnectInfo(
+      '',
+      '0.0.6',
+      null,
+      CMD_LINE_OPTS,
+      null,
+      TOPOLOGY_WITH_CREDENTIALS)).to.deep.equal(output);
+  });
+});

package/src/connect-info.ts

@@ -0,0 +1,57 @@
+/* eslint-disable camelcase */
+// ^ segment data is in snake_case: forgive me javascript, for i have sinned.
+
+import getBuildInfo from 'mongodb-build-info';
+
+export interface ConnectInfo {
+  is_atlas: boolean;
+  is_localhost: boolean;
+  is_do: boolean;
+  server_version: string;
+  mongosh_version: string;
+  server_os?: string;
+  server_arch?: string;
+  is_enterprise: boolean;
+  auth_type?: string;
+  is_data_lake: boolean;
+  dl_version?: string;
+  atlas_version?: string;
+  is_genuine: boolean;
+  non_genuine_server_name: string;
+  node_version: string;
+  uri: string;
+}
+
+export default function getConnectInfo(uri: string, mongoshVersion: string, buildInfo: any, cmdLineOpts: any, atlasVersion: any, topology: any): ConnectInfo {
+  buildInfo ??= {}; // We're currently not getting buildInfo with --apiStrict.
+  const { isGenuine: is_genuine, serverName: non_genuine_server_name } =
+    getBuildInfo.getGenuineMongoDB(buildInfo, cmdLineOpts);
+  const { isDataLake: is_data_lake, dlVersion: dl_version }
+    = getBuildInfo.getDataLake(buildInfo);
+
+  // get this information from topology rather than cmdLineOpts, since not all
+  // connections are able to run getCmdLineOpts command
+  const auth_type = topology.s.credentials
+    ? topology.s.credentials.mechanism : null;
+  const { serverOs: server_os, serverArch: server_arch }
+    = getBuildInfo.getBuildEnv(buildInfo);
+
+  return {
+    is_atlas: !!atlasVersion?.atlasVersion || getBuildInfo.isAtlas(uri),
+    is_localhost: getBuildInfo.isLocalhost(uri),
+    is_do: getBuildInfo.isDigitalOcean(uri),
+    server_version: buildInfo.version,
+    node_version: process.version,
+    mongosh_version: mongoshVersion,
+    server_os,
+    uri,
+    server_arch,
+    is_enterprise: getBuildInfo.isEnterprise(buildInfo),
+    auth_type,
+    is_data_lake,
+    dl_version,
+    atlas_version: atlasVersion?.atlasVersion ?? null,
+    is_genuine,
+    non_genuine_server_name
+  };
+}

package/src/index.ts

@@ -0,0 +1,62 @@
+import './textencoder-polyfill'; // for mongodb-connection-string-url in the java-shell
+import ServiceProvider, { ServiceProviderCore } from './service-provider';
+import getConnectInfo, { ConnectInfo } from './connect-info';
+import { ReplPlatform } from './platform';
+import CliOptions from './cli-options';
+import generateUri from './uri-generator';
+const DEFAULT_DB = 'test';
+import {
+  ObjectId,
+  DBRef,
+  MaxKey,
+  MinKey,
+  Timestamp,
+  BSONSymbol,
+  Code,
+  Decimal128,
+  Int32,
+  Long,
+  Binary,
+  Map,
+  calculateObjectSize,
+  Double,
+  EJSON,
+  BSONRegExp
+} from 'bson';
+import { bsonStringifiers } from './printable-bson';
+import ShellAuthOptions from './shell-auth-options';
+export * from './all-transport-types';
+export * from './all-fle-types';
+
+const bson = {
+  ObjectId,
+  DBRef,
+  MaxKey,
+  MinKey,
+  Timestamp,
+  BSONSymbol,
+  Code,
+  Decimal128,
+  Int32,
+  Long,
+  Binary,
+  Map,
+  calculateObjectSize,
+  Double,
+  EJSON,
+  BSONRegExp
+};
+
+export {
+  ServiceProvider,
+  ShellAuthOptions,
+  getConnectInfo,
+  ReplPlatform,
+  CliOptions,
+  generateUri,
+  DEFAULT_DB,
+  ServiceProviderCore,
+  bson,
+  bsonStringifiers,
+  ConnectInfo
+};

package/src/platform.ts

@@ -0,0 +1,6 @@
+export enum ReplPlatform {
+  Compass,
+  Browser,
+  CLI,
+  JavaShell
+}

package/src/printable-bson.spec.ts

@@ -0,0 +1,75 @@
+import { expect } from 'chai';
+import { bson } from './index';
+import { inspect } from 'util';
+import makePrintableBson from './printable-bson';
+
+describe('BSON printers', function() {
+  before('make BSON objects printable', function() {
+    makePrintableBson(bson);
+  });
+
+  it('formats ObjectIds correctly', function() {
+    expect(inspect(new bson.ObjectId('5fa5694f88211043b23c7f11')))
+      .to.equal('ObjectId("5fa5694f88211043b23c7f11")');
+  });
+
+  it('formats DBRefs correctly', function() {
+    expect(inspect(new bson.DBRef('a', new bson.ObjectId('5f16b8bebe434dc98cdfc9cb'), 'db')))
+      .to.equal('DBRef("a", ObjectId("5f16b8bebe434dc98cdfc9cb"), "db")');
+    expect(inspect(new bson.DBRef('a', 'foo' as any, 'db')))
+      .to.equal('DBRef("a", \'foo\', "db")');
+    expect(inspect(new bson.DBRef('a', { x: 1 } as any, 'db')))
+      .to.equal('DBRef("a", { x: 1 }, "db")');
+  });
+
+  it('formats MinKey and MaxKey correctly', function() {
+    expect(inspect(new bson.MinKey())).to.equal('MinKey()');
+    expect(inspect(new bson.MaxKey())).to.equal('MaxKey()');
+  });
+
+  it('formats NumberInt correctly', function() {
+    expect(inspect(new bson.Int32(32))).to.equal('Int32(32)');
+  });
+
+  it('formats NumberLong correctly', function() {
+    expect(inspect(bson.Long.fromString('64'))).to.equal('Long("64")');
+  });
+
+  it('formats unsigned NumberLong correctly', function() {
+    expect(inspect(bson.Long.fromString('64', true))).to.equal('Long("64", true)');
+  });
+
+  it('formats NumberDecimal correctly', function() {
+    expect(inspect(bson.Decimal128.fromString('1'))).to.equal('Decimal128("1")');
+  });
+
+  it('formats Timestamp correctly', function() {
+    expect(inspect(new bson.Timestamp(new bson.Long(100, 1)))).to.equal('Timestamp({ t: 1, i: 100 })');
+  });
+
+  it('formats Symbol correctly', function() {
+    expect(inspect(new bson.BSONSymbol('abc'))).to.equal('BSONSymbol("abc")');
+  });
+
+  it('formats Code correctly', function() {
+    expect(inspect(new bson.Code('abc'))).to.equal('Code("abc")');
+  });
+
+  it('formats BinData correctly', function() {
+    expect(inspect(new bson.Binary('abc'))).to.equal('Binary(Buffer.from("616263", "hex"), 0)');
+  });
+
+  it('formats BSONRegExp correctly', function() {
+    expect(inspect(new bson.BSONRegExp('(?-i)AA_', 'im'))).to.equal('BSONRegExp("(?-i)AA_", "im")');
+  });
+
+  it('formats UUIDs correctly', function() {
+    expect(inspect(new bson.Binary(Buffer.from('0123456789abcdef0123456789abcdef', 'hex'), 4)))
+      .to.equal('UUID("01234567-89ab-cdef-0123-456789abcdef")');
+  });
+
+  it('formats MD5s correctly', function() {
+    expect(inspect(new bson.Binary(Buffer.from('0123456789abcdef0123456789abcdef', 'hex'), 5)))
+      .to.equal('MD5("0123456789abcdef0123456789abcdef")');
+  });
+});

package/src/printable-bson.ts

@@ -0,0 +1,103 @@
+import { bson as BSON } from './index';
+import { inspect } from 'util';
+const inspectCustom = Symbol.for('nodejs.util.inspect.custom');
+
+export const bsonStringifiers: Record<string, (this: any, depth: any, options: any) => string> = {
+  ObjectId: function(): string {
+    return `ObjectId("${this.toHexString()}")`;
+  },
+
+  DBRef: function(depth: any, options: any): string {
+    return `DBRef("${this.namespace}", ` +
+      inspect(this.oid, options) +
+      (this.db ? `, "${this.db}"` : '') +
+      ')';
+  },
+
+  MaxKey: function(): string {
+    return 'MaxKey()';
+  },
+
+  MinKey: function(): string {
+    return 'MinKey()';
+  },
+
+  Timestamp: function(): string {
+    return `Timestamp({ t: ${this.getHighBits()}, i: ${this.getLowBits()} })`;
+  },
+
+  BSONSymbol: function(): string {
+    return `BSONSymbol("${this.valueOf()}")`;
+  },
+
+  Code: function(): string {
+    const j = this.toJSON();
+    return `Code("${j.code}"${j.scope ? `, ${JSON.stringify(j.scope)}` : ''})`;
+  },
+
+  Decimal128: function(): string {
+    return `Decimal128("${this.toString()}")`;
+  },
+
+  Int32: function(): string {
+    return `Int32(${this.valueOf()})`;
+  },
+
+  Long: function(): string {
+    return `Long("${this.toString()}"${this.unsigned ? ', true' : ''})`;
+  },
+
+  BSONRegExp: function(): string {
+    return `BSONRegExp(${JSON.stringify(this.pattern)}, ${JSON.stringify(this.options)})`;
+  },
+
+  Binary: function(): string {
+    const asBuffer = this.value(true);
+    switch (this.sub_type) {
+      case BSON.Binary.SUBTYPE_MD5:
+        return `MD5("${asBuffer.toString('hex')}")`;
+      case BSON.Binary.SUBTYPE_UUID:
+        if (asBuffer.length === 16) {
+          // Format '0123456789abcdef0123456789abcdef' into
+          // '01234567-89ab-cdef-0123-456789abcdef'.
+          const hex = asBuffer.toString('hex');
+          const asUUID = hex.match(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/)
+            .slice(1, 6).join('-');
+          return `UUID("${asUUID}")`;
+        }
+        // In case somebody did something weird and used an UUID with a
+        // non-standard length, fall through.
+      default:
+        return `Binary(Buffer.from("${asBuffer.toString('hex')}", "hex"), ${this.sub_type})`;
+    }
+  },
+};
+bsonStringifiers.ObjectID = bsonStringifiers.ObjectId;
+
+/**
+ * This method modifies the BSON class passed in as argument. This is required so that
+ * we can have the driver return our BSON classes without having to write our own serializer.
+ * @param {Object} bson
+ */
+export default function(bson?: typeof BSON): void {
+  if (!bson) {
+    bson = BSON;
+  }
+
+  for (const [ key, stringifier ] of Object.entries(bsonStringifiers)) {
+    if (!(key in bson)) {
+      continue;
+    }
+    const cls = bson[key as keyof typeof BSON];
+    for (const key of [inspectCustom, 'inspect']) {
+      try {
+        (cls as any).prototype[key] = stringifier;
+      } catch {
+        // This may fail because bson.ObjectId.prototype[toString] can exist as a
+        // read-only property. https://github.com/mongodb/js-bson/pull/412 takes
+        // care of this. In the CLI repl and Compass this still works fine, because
+        // those are on bson@1.x.
+      }
+    }
+  }
+}