feat(NODE-7255): add well-known Symbol alias for _bsontype (#829)

Author: addaleax

src/bson.ts

@@ -50,7 +50,7 @@ export {
   BSONRegExp,
   Decimal128
 };
-export { BSONValue } from './bson_value';
+export { BSONValue, bsonType, type BSONTypeTag } from './bson_value';
 export { BSONError, BSONVersionError, BSONRuntimeError, BSONOffsetError } from './error';
 export { BSONType } from './constants';
 export { EJSON } from './extended_json';

src/bson_value.ts

@@ -2,10 +2,33 @@ import { BSON_MAJOR_VERSION } from './constants';
 import { type InspectFn } from './parser/utils';
 import { BSON_VERSION_SYMBOL } from './constants';
 
+/** @public */
+export type BSONTypeTag =
+  | 'BSONRegExp'
+  | 'BSONSymbol'
+  | 'ObjectId'
+  | 'Binary'
+  | 'Decimal128'
+  | 'Double'
+  | 'Int32'
+  | 'Long'
+  | 'MaxKey'
+  | 'MinKey'
+  | 'Timestamp'
+  | 'Code'
+  | 'DBRef';
+
+/** @public */
+export const bsonType = Symbol.for('@@mdb.bson.type');
+
 /** @public */
 export abstract class BSONValue {
   /** @public */
-  public abstract get _bsontype(): string;
+  public abstract get _bsontype(): BSONTypeTag;
+
+  public get [bsonType](): this['_bsontype'] {
+    return this._bsontype;
+  }
 
   /** @internal */
   get [BSON_VERSION_SYMBOL](): typeof BSON_MAJOR_VERSION {

src/timestamp.ts

@@ -1,10 +1,16 @@
+import { bsonType } from './bson_value';
 import { BSONError } from './error';
 import type { Int32 } from './int_32';
 import { Long } from './long';
 import { type InspectFn, defaultInspect } from './parser/utils';
 
 /** @public */
-export type TimestampOverrides = '_bsontype' | 'toExtendedJSON' | 'fromExtendedJSON' | 'inspect';
+export type TimestampOverrides =
+  | '_bsontype'
+  | 'toExtendedJSON'
+  | 'fromExtendedJSON'
+  | 'inspect'
+  | typeof bsonType;
 /** @public */
 export type LongWithoutOverrides = new (
   low: unknown,
@@ -35,6 +41,9 @@ export class Timestamp extends LongWithoutOverridesClass {
   get _bsontype(): 'Timestamp' {
     return 'Timestamp';
   }
+  get [bsonType](): 'Timestamp' {
+    return 'Timestamp';
+  }
 
   static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 

test/node/exports.test.ts

@@ -37,7 +37,8 @@ const EXPECTED_EXPORTS = [
   'deserialize',
   'calculateObjectSize',
   'deserializeStream',
-  'BSON'
+  'BSON',
+  'bsonType'
 ];
 
 const EXPECTED_EJSON_EXPORTS = ['parse', 'stringify', 'serialize', 'deserialize'];

test/node/type_identifier_tests.js

@@ -14,56 +14,72 @@ const {
   BSONRegExp,
   BSONSymbol,
   Timestamp,
-  UUID
+  UUID,
+  bsonType
 } = require('../register-bson');
 
 describe('_bsontype identifier', () => {
   it('should be equal to ObjectId for ObjectId', () => {
     expect(ObjectId.prototype._bsontype).to.equal('ObjectId');
+    expect(ObjectId.prototype[bsonType]).to.equal('ObjectId');
   });
   it('should be equal to BSONSymbol for BSONSymbol', () => {
     expect(BSONSymbol.prototype._bsontype).to.equal('BSONSymbol');
+    expect(BSONSymbol.prototype[bsonType]).to.equal('BSONSymbol');
   });
   it('should be equal to Timestamp for Timestamp', () => {
     // TODO(NODE-2624): Make Timestamp hold its long value on a property rather than be a subclass
     // Timestamp overrides the value in its constructor
     const timestamp = new Timestamp({ i: 0, t: 0 });
     expect(timestamp._bsontype).to.equal('Timestamp');
     expect(Object.getPrototypeOf(Object.getPrototypeOf(timestamp))._bsontype).to.equal('Long');
+    expect(timestamp[bsonType]).to.equal('Timestamp');
+    expect(Object.getPrototypeOf(Object.getPrototypeOf(timestamp))[bsonType]).to.equal('Long');
   });
 
   // All equal to their constructor names
   it('should be equal to Binary for Binary', () => {
     expect(Binary.prototype._bsontype).to.equal('Binary');
+    expect(Binary.prototype[bsonType]).to.equal('Binary');
   });
   it('should be equal to Code for Code', () => {
     expect(Code.prototype._bsontype).to.equal('Code');
+    expect(Code.prototype[bsonType]).to.equal('Code');
   });
   it('should be equal to DBRef for DBRef', () => {
     expect(DBRef.prototype._bsontype).to.equal('DBRef');
+    expect(DBRef.prototype[bsonType]).to.equal('DBRef');
   });
   it('should be equal to Decimal128 for Decimal128', () => {
     expect(Decimal128.prototype._bsontype).to.equal('Decimal128');
+    expect(Decimal128.prototype[bsonType]).to.equal('Decimal128');
   });
   it('should be equal to Double for Double', () => {
     expect(Double.prototype._bsontype).to.equal('Double');
+    expect(Double.prototype[bsonType]).to.equal('Double');
   });
   it('should be equal to Int32 for Int32', () => {
     expect(Int32.prototype._bsontype).to.equal('Int32');
+    expect(Int32.prototype[bsonType]).to.equal('Int32');
   });
   it('should be equal to Long for Long', () => {
     expect(Long.prototype._bsontype).to.equal('Long');
+    expect(Long.prototype[bsonType]).to.equal('Long');
   });
   it('should be equal to MaxKey for MaxKey', () => {
     expect(MaxKey.prototype._bsontype).to.equal('MaxKey');
+    expect(MaxKey.prototype[bsonType]).to.equal('MaxKey');
   });
   it('should be equal to MinKey for MinKey', () => {
     expect(MinKey.prototype._bsontype).to.equal('MinKey');
+    expect(MinKey.prototype[bsonType]).to.equal('MinKey');
   });
   it('should be equal to BSONRegExp for BSONRegExp', () => {
     expect(BSONRegExp.prototype._bsontype).to.equal('BSONRegExp');
+    expect(BSONRegExp.prototype[bsonType]).to.equal('BSONRegExp');
   });
   it('should be equal to Binary for UUID', () => {
     expect(UUID.prototype._bsontype).to.equal('Binary');
+    expect(UUID.prototype[bsonType]).to.equal('Binary');
   });
 });

test/types/bson.test-d.ts

@@ -18,7 +18,9 @@ import {
   DBRefLike,
   Document,
   Decimal128Extended,
-  BSONValue
+  BSONValue,
+  bsonType,
+  BSONTypeTag
 } from '../../bson'; // import from generated bson.d.ts
 import type { InspectFn } from '../../src/parser/utils';
 
@@ -74,9 +76,25 @@ expectType<'MinKey'>(MinKey.prototype._bsontype)
 expectType<'BSONRegExp'>(BSONRegExp.prototype._bsontype)
 expectType<'Binary'>(UUID.prototype._bsontype)
 
+expectType<'Timestamp'>(Timestamp.prototype[bsonType])
+expectType<'ObjectId'>(ObjectId.prototype[bsonType])
+expectType<'BSONSymbol'>(BSONSymbol.prototype[bsonType])
+expectType<'Binary'>(Binary.prototype[bsonType])
+expectType<'Code'>(Code.prototype[bsonType])
+expectType<'DBRef'>(DBRef.prototype[bsonType])
+expectType<'Decimal128'>(Decimal128.prototype[bsonType])
+expectType<'Double'>(Double.prototype[bsonType])
+expectType<'Int32'>(Int32.prototype[bsonType])
+expectType<'Long'>(Long.prototype[bsonType])
+expectType<'MaxKey'>(MaxKey.prototype[bsonType])
+expectType<'MinKey'>(MinKey.prototype[bsonType])
+expectType<'BSONRegExp'>(BSONRegExp.prototype[bsonType])
+expectType<'Binary'>(UUID.prototype[bsonType])
+
 // Common BSONValue interface
 declare const bsonValue: BSONValue;
-expectType<string>(bsonValue._bsontype);
+expectType<BSONTypeTag>(bsonValue._bsontype);
+expectType<BSONTypeTag>(bsonValue[bsonType]);
 expectType<(depth?: number | undefined, options?: unknown, inspect?: InspectFn | undefined) => string>(bsonValue.inspect);
 
 expectNotDeprecated(new ObjectId('foo'));