bson 5.2.0 → 5.3.0

package/lib/bson.d.ts

@@ -0,0 +1,97 @@
+import { Binary, UUID } from './binary';
+import { Code } from './code';
+import { DBRef } from './db_ref';
+import { Decimal128 } from './decimal128';
+import { Double } from './double';
+import { Int32 } from './int_32';
+import { Long } from './long';
+import { MaxKey } from './max_key';
+import { MinKey } from './min_key';
+import { ObjectId } from './objectid';
+import { DeserializeOptions } from './parser/deserializer';
+import { SerializeOptions } from './parser/serializer';
+import { BSONRegExp } from './regexp';
+import { BSONSymbol } from './symbol';
+import { Timestamp } from './timestamp';
+export type { UUIDExtended, BinaryExtended, BinaryExtendedLegacy, BinarySequence } from './binary';
+export type { CodeExtended } from './code';
+export type { DBRefLike } from './db_ref';
+export type { Decimal128Extended } from './decimal128';
+export type { DoubleExtended } from './double';
+export type { EJSONOptions } from './extended_json';
+export type { Int32Extended } from './int_32';
+export type { LongExtended } from './long';
+export type { MaxKeyExtended } from './max_key';
+export type { MinKeyExtended } from './min_key';
+export type { ObjectIdExtended, ObjectIdLike } from './objectid';
+export type { BSONRegExpExtended, BSONRegExpExtendedLegacy } from './regexp';
+export type { BSONSymbolExtended } from './symbol';
+export type { LongWithoutOverrides, TimestampExtended, TimestampOverrides } from './timestamp';
+export type { LongWithoutOverridesClass } from './timestamp';
+export type { SerializeOptions, DeserializeOptions };
+export { Code, BSONSymbol, DBRef, Binary, ObjectId, UUID, Long, Timestamp, Double, Int32, MinKey, MaxKey, BSONRegExp, Decimal128 };
+export { BSONValue } from './bson_value';
+export { BSONError, BSONVersionError, BSONRuntimeError } from './error';
+export { BSONType } from './constants';
+export { EJSON } from './extended_json';
+/** @public */
+export interface Document {
+    [key: string]: any;
+}
+/**
+ * Sets the size of the internal serialization buffer.
+ *
+ * @param size - The desired size for the internal serialization buffer in bytes
+ * @public
+ */
+export declare function setInternalBufferSize(size: number): void;
+/**
+ * Serialize a Javascript object.
+ *
+ * @param object - the Javascript object to serialize.
+ * @returns Buffer object containing the serialized object.
+ * @public
+ */
+export declare function serialize(object: Document, options?: SerializeOptions): Uint8Array;
+/**
+ * Serialize a Javascript object using a predefined Buffer and index into the buffer,
+ * useful when pre-allocating the space for serialization.
+ *
+ * @param object - the Javascript object to serialize.
+ * @param finalBuffer - the Buffer you pre-allocated to store the serialized BSON object.
+ * @returns the index pointing to the last written byte in the buffer.
+ * @public
+ */
+export declare function serializeWithBufferAndIndex(object: Document, finalBuffer: Uint8Array, options?: SerializeOptions): number;
+/**
+ * Deserialize data as BSON.
+ *
+ * @param buffer - the buffer containing the serialized set of BSON documents.
+ * @returns returns the deserialized Javascript Object.
+ * @public
+ */
+export declare function deserialize(buffer: Uint8Array, options?: DeserializeOptions): Document;
+/** @public */
+export type CalculateObjectSizeOptions = Pick<SerializeOptions, 'serializeFunctions' | 'ignoreUndefined'>;
+/**
+ * Calculate the bson size for a passed in Javascript object.
+ *
+ * @param object - the Javascript object to calculate the BSON byte size for
+ * @returns size of BSON object in bytes
+ * @public
+ */
+export declare function calculateObjectSize(object: Document, options?: CalculateObjectSizeOptions): number;
+/**
+ * Deserialize stream data as BSON documents.
+ *
+ * @param data - the buffer containing the serialized set of BSON documents.
+ * @param startIndex - the start index in the data Buffer where the deserialization is to start.
+ * @param numberOfDocuments - number of documents to deserialize.
+ * @param documents - an array where to store the deserialized documents.
+ * @param docStartIndex - the index in the documents array from where to start inserting documents.
+ * @param options - additional options used for the deserialization.
+ * @returns next index in the buffer after deserialization **x** numbers of documents.
+ * @public
+ */
+export declare function deserializeStream(data: Uint8Array | ArrayBuffer, startIndex: number, numberOfDocuments: number, documents: Document[], docStartIndex: number, options: DeserializeOptions): number;
+//# sourceMappingURL=bson.d.ts.map

package/lib/bson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bson.d.ts","sourceRoot":"","sources":["../src/bson.ts"],"names":[],"mappings":"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"}

package/lib/bson.mjs

@@ -1,3 +1,19 @@
+function isAnyArrayBuffer(value) {
+    return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
+}
+function isUint8Array(value) {
+    return Object.prototype.toString.call(value) === '[object Uint8Array]';
+}
+function isRegExp(d) {
+    return Object.prototype.toString.call(d) === '[object RegExp]';
+}
+function isMap(d) {
+    return Object.prototype.toString.call(d) === '[object Map]';
+}
+function isDate(d) {
+    return Object.prototype.toString.call(d) === '[object Date]';
+}
+
 const BSON_MAJOR_VERSION = 5;
 const BSON_INT32_MAX = 0x7fffffff;
 const BSON_INT32_MIN = -0x80000000;
@@ -280,44 +296,6 @@ class BSONDataView extends DataView {
     }
 }
 
-const VALIDATION_REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|[0-9a-f]{12}4[0-9a-f]{3}[89ab][0-9a-f]{15})$/i;
-const uuidValidateString = (str) => typeof str === 'string' && VALIDATION_REGEX.test(str);
-const uuidHexStringToBuffer = (hexString) => {
-    if (!uuidValidateString(hexString)) {
-        throw new BSONError('UUID string representations must be a 32 or 36 character hex string (dashes excluded/included). Format: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" or "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".');
-    }
-    const sanitizedHexString = hexString.replace(/-/g, '');
-    return ByteUtils.fromHex(sanitizedHexString);
-};
-function bufferToUuidHexString(buffer, includeDashes = true) {
-    if (includeDashes) {
-        return [
-            ByteUtils.toHex(buffer.subarray(0, 4)),
-            ByteUtils.toHex(buffer.subarray(4, 6)),
-            ByteUtils.toHex(buffer.subarray(6, 8)),
-            ByteUtils.toHex(buffer.subarray(8, 10)),
-            ByteUtils.toHex(buffer.subarray(10, 16))
-        ].join('-');
-    }
-    return ByteUtils.toHex(buffer);
-}
-
-function isAnyArrayBuffer(value) {
-    return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
-}
-function isUint8Array(value) {
-    return Object.prototype.toString.call(value) === '[object Uint8Array]';
-}
-function isRegExp(d) {
-    return Object.prototype.toString.call(d) === '[object RegExp]';
-}
-function isMap(d) {
-    return Object.prototype.toString.call(d) === '[object Map]';
-}
-function isDate(d) {
-    return Object.prototype.toString.call(d) === '[object Date]';
-}
-
 class BSONValue {
     get [Symbol.for('@@mdb.bson.version')]() {
         return BSON_MAJOR_VERSION;
@@ -479,7 +457,7 @@ class Binary extends BSONValue {
         }
         else if ('$uuid' in doc) {
             type = 4;
-            data = uuidHexStringToBuffer(doc.$uuid);
+            data = UUID.bytesFromString(doc.$uuid);
         }
         if (!data) {
             throw new BSONError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);
@@ -506,47 +484,45 @@ Binary.SUBTYPE_ENCRYPTED = 6;
 Binary.SUBTYPE_COLUMN = 7;
 Binary.SUBTYPE_USER_DEFINED = 128;
 const UUID_BYTE_LENGTH = 16;
+const UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;
+const UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
 class UUID extends Binary {
     constructor(input) {
         let bytes;
-        let hexStr;
         if (input == null) {
             bytes = UUID.generate();
         }
         else if (input instanceof UUID) {
             bytes = ByteUtils.toLocalBufferType(new Uint8Array(input.buffer));
-            hexStr = input.__id;
         }
         else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
             bytes = ByteUtils.toLocalBufferType(input);
         }
         else if (typeof input === 'string') {
-            bytes = uuidHexStringToBuffer(input);
+            bytes = UUID.bytesFromString(input);
         }
         else {
             throw new BSONError('Argument passed in UUID constructor must be a UUID, a 16 byte Buffer or a 32/36 character hex string (dashes excluded/included, format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).');
         }
         super(bytes, BSON_BINARY_SUBTYPE_UUID_NEW);
-        this.__id = hexStr;
     }
     get id() {
         return this.buffer;
     }
     set id(value) {
         this.buffer = value;
-        if (UUID.cacheHexString) {
-            this.__id = bufferToUuidHexString(value);
-        }
     }
     toHexString(includeDashes = true) {
-        if (UUID.cacheHexString && this.__id) {
-            return this.__id;
-        }
-        const uuidHexString = bufferToUuidHexString(this.id, includeDashes);
-        if (UUID.cacheHexString) {
-            this.__id = uuidHexString;
+        if (includeDashes) {
+            return [
+                ByteUtils.toHex(this.buffer.subarray(0, 4)),
+                ByteUtils.toHex(this.buffer.subarray(4, 6)),
+                ByteUtils.toHex(this.buffer.subarray(6, 8)),
+                ByteUtils.toHex(this.buffer.subarray(8, 10)),
+                ByteUtils.toHex(this.buffer.subarray(10, 16))
+            ].join('-');
         }
-        return uuidHexString;
+        return ByteUtils.toHex(this.buffer);
     }
     toString(encoding) {
         if (encoding === 'hex')
@@ -585,27 +561,32 @@ class UUID extends Binary {
         if (!input) {
             return false;
         }
-        if (input instanceof UUID) {
-            return true;
-        }
         if (typeof input === 'string') {
-            return uuidValidateString(input);
+            return UUID.isValidUUIDString(input);
         }
         if (isUint8Array(input)) {
-            if (input.byteLength !== UUID_BYTE_LENGTH) {
-                return false;
-            }
-            return (input[6] & 0xf0) === 0x40 && (input[8] & 0x80) === 0x80;
+            return input.byteLength === UUID_BYTE_LENGTH;
         }
-        return false;
+        return (input._bsontype === 'Binary' &&
+            input.sub_type === this.SUBTYPE_UUID &&
+            input.buffer.byteLength === 16);
     }
     static createFromHexString(hexString) {
-        const buffer = uuidHexStringToBuffer(hexString);
+        const buffer = UUID.bytesFromString(hexString);
         return new UUID(buffer);
     }
     static createFromBase64(base64) {
         return new UUID(ByteUtils.fromBase64(base64));
     }
+    static bytesFromString(representation) {
+        if (!UUID.isValidUUIDString(representation)) {
+            throw new BSONError('UUID string representation must be 32 hex digits or canonical hyphenated representation');
+        }
+        return ByteUtils.fromHex(representation.replace(/-/g, ''));
+    }
+    static isValidUUIDString(representation) {
+        return UUID_WITHOUT_DASHES.test(representation) || UUID_WITH_DASHES.test(representation);
+    }
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.inspect();
     }
@@ -613,6 +594,7 @@ class UUID extends Binary {
         return `new UUID("${this.toHexString()}")`;
     }
 }
+UUID.cacheHexString = false;
 
 class Code extends BSONValue {
     get _bsontype() {
@@ -2789,7 +2771,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 }
                 else {
                     value = new Binary(buffer.slice(index, index + binarySize), subType);
-                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
+                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
                         value = value.toUUID();
                     }
                 }
@@ -2815,11 +2797,11 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 if (promoteBuffers && promoteValues) {
                     value = _buffer;
                 }
-                else if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
-                    value = new Binary(buffer.slice(index, index + binarySize), subType).toUUID();
-                }
                 else {
                     value = new Binary(buffer.slice(index, index + binarySize), subType);
+                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
+                        value = value.toUUID();
+                    }
                 }
             }
             index = index + binarySize;
@@ -4051,32 +4033,32 @@ function deserializeStream(data, startIndex, numberOfDocuments, documents, docSt
 
 var bson = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Code: Code,
+    BSONError: BSONError,
+    BSONRegExp: BSONRegExp,
+    BSONRuntimeError: BSONRuntimeError,
     BSONSymbol: BSONSymbol,
-    DBRef: DBRef,
+    BSONType: BSONType,
+    BSONValue: BSONValue,
+    BSONVersionError: BSONVersionError,
     Binary: Binary,
-    ObjectId: ObjectId,
-    UUID: UUID,
-    Long: Long,
-    Timestamp: Timestamp,
+    Code: Code,
+    DBRef: DBRef,
+    Decimal128: Decimal128,
     Double: Double,
+    EJSON: EJSON,
     Int32: Int32,
-    MinKey: MinKey,
+    Long: Long,
     MaxKey: MaxKey,
-    BSONRegExp: BSONRegExp,
-    Decimal128: Decimal128,
-    setInternalBufferSize: setInternalBufferSize,
-    serialize: serialize,
-    serializeWithBufferAndIndex: serializeWithBufferAndIndex,
-    deserialize: deserialize,
+    MinKey: MinKey,
+    ObjectId: ObjectId,
+    Timestamp: Timestamp,
+    UUID: UUID,
     calculateObjectSize: calculateObjectSize,
+    deserialize: deserialize,
     deserializeStream: deserializeStream,
-    BSONValue: BSONValue,
-    BSONError: BSONError,
-    BSONVersionError: BSONVersionError,
-    BSONRuntimeError: BSONRuntimeError,
-    BSONType: BSONType,
-    EJSON: EJSON
+    serialize: serialize,
+    serializeWithBufferAndIndex: serializeWithBufferAndIndex,
+    setInternalBufferSize: setInternalBufferSize
 });
 
 export { bson as BSON, BSONError, BSONRegExp, BSONRuntimeError, BSONSymbol, BSONType, BSONValue, BSONVersionError, Binary, Code, DBRef, Decimal128, Double, EJSON, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp, UUID, calculateObjectSize, deserialize, deserializeStream, serialize, serializeWithBufferAndIndex, setInternalBufferSize };