customized-fabric 1.0.0 → 1.0.2

package/src/objectId/index.ts

@@ -1,354 +0,0 @@
-import { BSONValue } from "./bson_value";
-import { BSONError } from "./error";
-import { isUint8Array } from "./parser/utils";
-import { BSONDataView, ByteUtils } from "./utils/byte_utils";
-
-// Regular expression that checks for hex value
-const checkForHexRegExp = new RegExp("^[0-9a-fA-F]{24}$");
-
-// Unique sequence for the current process (initialized on first use)
-let PROCESS_UNIQUE: Uint8Array | null = null;
-
-/** @public */
-export interface ObjectIdLike {
-  id: string | Uint8Array;
-  __id?: string;
-  toHexString(): string;
-}
-
-/** @public */
-export interface ObjectIdExtended {
-  $oid: string;
-}
-
-const kId = Symbol("id");
-
-/**
- * A class representation of the BSON ObjectId type.
- * @public
- * @category BSONType
- */
-export class ObjectId extends BSONValue {
-  get _bsontype(): "ObjectId" {
-    return "ObjectId";
-  }
-
-  /** @internal */
-  private static index = Math.floor(Math.random() * 0xffffff);
-
-  static cacheHexString: boolean;
-
-  /** ObjectId Bytes @internal */
-  private [kId]!: Uint8Array;
-  /** ObjectId hexString cache @internal */
-  private __id?: string;
-
-  /**
-   * Create an ObjectId type
-   *
-   * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
-   */
-  constructor(
-    inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array
-  ) {
-    super();
-    // workingId is set based on type of input and whether valid id exists for the input
-    let workingId;
-    if (typeof inputId === "object" && inputId && "id" in inputId) {
-      if (typeof inputId.id !== "string" && !ArrayBuffer.isView(inputId.id)) {
-        throw new BSONError(
-          "Argument passed in must have an id that is of type string or Buffer"
-        );
-      }
-      if (
-        "toHexString" in inputId &&
-        typeof inputId.toHexString === "function"
-      ) {
-        workingId = ByteUtils.fromHex(inputId.toHexString());
-      } else {
-        workingId = inputId.id;
-      }
-    } else {
-      workingId = inputId;
-    }
-
-    // the following cases use workingId to construct an ObjectId
-    if (workingId == null || typeof workingId === "number") {
-      // The most common use case (blank id, new objectId instance)
-      // Generate a new id
-      this[kId] = ObjectId.generate(
-        typeof workingId === "number" ? workingId : undefined
-      );
-    } else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
-      // If intstanceof matches we can escape calling ensure buffer in Node.js environments
-      this[kId] = ByteUtils.toLocalBufferType(workingId);
-    } else if (typeof workingId === "string") {
-      if (workingId.length === 12) {
-        // TODO(NODE-4361): Remove string of length 12 support
-        const bytes = ByteUtils.fromUTF8(workingId);
-        if (bytes.byteLength === 12) {
-          this[kId] = bytes;
-        } else {
-          throw new BSONError(
-            "Argument passed in must be a string of 12 bytes"
-          );
-        }
-      } else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
-        this[kId] = ByteUtils.fromHex(workingId);
-      } else {
-        throw new BSONError(
-          "Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer"
-        );
-      }
-    } else {
-      throw new BSONError(
-        "Argument passed in does not match the accepted types"
-      );
-    }
-    // If we are caching the hex string
-    if (ObjectId.cacheHexString) {
-      this.__id = ByteUtils.toHex(this.id);
-    }
-  }
-
-  /**
-   * The ObjectId bytes
-   * @readonly
-   */
-  get id(): Uint8Array {
-    return this[kId];
-  }
-
-  set id(value: Uint8Array) {
-    this[kId] = value;
-    if (ObjectId.cacheHexString) {
-      this.__id = ByteUtils.toHex(value);
-    }
-  }
-
-  /** Returns the ObjectId id as a 24 character hex string representation */
-  toHexString(): string {
-    if (ObjectId.cacheHexString && this.__id) {
-      return this.__id;
-    }
-
-    const hexString = ByteUtils.toHex(this.id);
-
-    if (ObjectId.cacheHexString && !this.__id) {
-      this.__id = hexString;
-    }
-
-    return hexString;
-  }
-
-  /**
-   * Update the ObjectId index
-   * @internal
-   */
-  private static getInc(): number {
-    return (ObjectId.index = (ObjectId.index + 1) % 0xffffff);
-  }
-
-  /**
-   * Generate a 12 byte id buffer used in ObjectId's
-   *
-   * @param time - pass in a second based timestamp.
-   */
-  static generate(time?: number): Uint8Array {
-    if ("number" !== typeof time) {
-      time = Math.floor(Date.now() / 1000);
-    }
-
-    const inc = ObjectId.getInc();
-    const buffer = ByteUtils.allocate(12);
-
-    // 4-byte timestamp
-    BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
-
-    // set PROCESS_UNIQUE if yet not initialized
-    if (PROCESS_UNIQUE === null) {
-      PROCESS_UNIQUE = ByteUtils.randomBytes(5);
-    }
-
-    // 5-byte process unique
-    buffer[4] = PROCESS_UNIQUE[0];
-    buffer[5] = PROCESS_UNIQUE[1];
-    buffer[6] = PROCESS_UNIQUE[2];
-    buffer[7] = PROCESS_UNIQUE[3];
-    buffer[8] = PROCESS_UNIQUE[4];
-
-    // 3-byte counter
-    buffer[11] = inc & 0xff;
-    buffer[10] = (inc >> 8) & 0xff;
-    buffer[9] = (inc >> 16) & 0xff;
-
-    return buffer;
-  }
-
-  /**
-   * Converts the id into a 24 character hex string for printing, unless encoding is provided.
-   * @param encoding - hex or base64
-   */
-  toString(encoding?: "hex" | "base64"): string {
-    // Is the id a buffer then use the buffer toString method to return the format
-    if (encoding === "base64") return ByteUtils.toBase64(this.id);
-    if (encoding === "hex") return this.toHexString();
-    return this.toHexString();
-  }
-
-  /** Converts to its JSON the 24 character hex string representation. */
-  toJSON(): string {
-    return this.toHexString();
-  }
-
-  /**
-   * Compares the equality of this ObjectId with `otherID`.
-   *
-   * @param otherId - ObjectId instance to compare against.
-   */
-  equals(otherId: string | ObjectId | ObjectIdLike): boolean {
-    if (otherId === undefined || otherId === null) {
-      return false;
-    }
-
-    if (otherId instanceof ObjectId) {
-      return (
-        this[kId][11] === otherId[kId][11] &&
-        ByteUtils.equals(this[kId], otherId[kId])
-      );
-    }
-
-    if (
-      typeof otherId === "string" &&
-      ObjectId.isValid(otherId) &&
-      otherId.length === 12 &&
-      isUint8Array(this.id)
-    ) {
-      return ByteUtils.equals(this.id, ByteUtils.fromISO88591(otherId));
-    }
-
-    if (
-      typeof otherId === "string" &&
-      ObjectId.isValid(otherId) &&
-      otherId.length === 24
-    ) {
-      return otherId.toLowerCase() === this.toHexString();
-    }
-
-    if (
-      typeof otherId === "string" &&
-      ObjectId.isValid(otherId) &&
-      otherId.length === 12
-    ) {
-      return ByteUtils.equals(ByteUtils.fromUTF8(otherId), this.id);
-    }
-
-    if (
-      typeof otherId === "object" &&
-      "toHexString" in otherId &&
-      typeof otherId.toHexString === "function"
-    ) {
-      const otherIdString = otherId.toHexString();
-      const thisIdString = this.toHexString().toLowerCase();
-      return (
-        typeof otherIdString === "string" &&
-        otherIdString.toLowerCase() === thisIdString
-      );
-    }
-
-    return false;
-  }
-
-  /** Returns the generation date (accurate up to the second) that this ID was generated. */
-  getTimestamp(): Date {
-    const timestamp = new Date();
-    const time = BSONDataView.fromUint8Array(this.id).getUint32(0, false);
-    timestamp.setTime(Math.floor(time) * 1000);
-    return timestamp;
-  }
-
-  /** @internal */
-  static createPk(): ObjectId {
-    return new ObjectId();
-  }
-
-  /**
-   * Creates an ObjectId from a second based number, with the rest of the ObjectId zeroed out. Used for comparisons or sorting the ObjectId.
-   *
-   * @param time - an integer number representing a number of seconds.
-   */
-  static createFromTime(time: number): ObjectId {
-    const buffer = ByteUtils.fromNumberArray([
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ]);
-    // Encode time into first 4 bytes
-    BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
-    // Return the new objectId
-    return new ObjectId(buffer);
-  }
-
-  /**
-   * Creates an ObjectId from a hex string representation of an ObjectId.
-   *
-   * @param hexString - create a ObjectId from a passed in 24 character hexstring.
-   */
-  static createFromHexString(hexString: string): ObjectId {
-    if (hexString?.length !== 24) {
-      throw new BSONError("hex string must be 24 characters");
-    }
-
-    return new ObjectId(ByteUtils.fromHex(hexString));
-  }
-
-  /** Creates an ObjectId instance from a base64 string */
-  static createFromBase64(base64: string): ObjectId {
-    if (base64?.length !== 16) {
-      throw new BSONError("base64 string must be 16 characters");
-    }
-
-    return new ObjectId(ByteUtils.fromBase64(base64));
-  }
-
-  /**
-   * Checks if a value is a valid bson ObjectId
-   *
-   * @param id - ObjectId instance to validate.
-   */
-  static isValid(
-    id: string | number | ObjectId | ObjectIdLike | Uint8Array
-  ): boolean {
-    if (id == null) return false;
-
-    try {
-      new ObjectId(id);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /** @internal */
-  toExtendedJSON(): ObjectIdExtended {
-    if (this.toHexString) return { $oid: this.toHexString() };
-    return { $oid: this.toString("hex") };
-  }
-
-  /** @internal */
-  static fromExtendedJSON(doc: ObjectIdExtended): ObjectId {
-    return new ObjectId(doc.$oid);
-  }
-
-  /**
-   * Converts to a string representation of this Id.
-   *
-   * @returns return the 24 character hex string representation.
-   * @internal
-   */
-  [Symbol.for("nodejs.util.inspect.custom")](): string {
-    return this.inspect();
-  }
-
-  inspect(): string {
-    return `new ObjectId("${this.toHexString()}")`;
-  }
-}

package/src/objectId/parser/utils.ts

@@ -1,29 +0,0 @@
-export function isAnyArrayBuffer(value: unknown): value is ArrayBuffer {
-  return ["[object ArrayBuffer]", "[object SharedArrayBuffer]"].includes(
-    Object.prototype.toString.call(value)
-  );
-}
-
-export function isUint8Array(value: unknown): value is Uint8Array {
-  return Object.prototype.toString.call(value) === "[object Uint8Array]";
-}
-
-export function isBigInt64Array(value: unknown): value is BigInt64Array {
-  return Object.prototype.toString.call(value) === "[object BigInt64Array]";
-}
-
-export function isBigUInt64Array(value: unknown): value is BigUint64Array {
-  return Object.prototype.toString.call(value) === "[object BigUint64Array]";
-}
-
-export function isRegExp(d: unknown): d is RegExp {
-  return Object.prototype.toString.call(d) === "[object RegExp]";
-}
-
-export function isMap(d: unknown): d is Map<unknown, unknown> {
-  return Object.prototype.toString.call(d) === "[object Map]";
-}
-
-export function isDate(d: unknown): d is Date {
-  return Object.prototype.toString.call(d) === "[object Date]";
-}

package/src/objectId/utils/byte_utils.ts

@@ -1,72 +0,0 @@
-import { nodeJsByteUtils } from "./node_byte_utils";
-import { webByteUtils } from "./web_byte_utils";
-
-/** @internal */
-export type ByteUtils = {
-  /** Transforms the input to an instance of Buffer if running on node, otherwise Uint8Array */
-  toLocalBufferType(
-    buffer: Uint8Array | ArrayBufferView | ArrayBuffer
-  ): Uint8Array;
-  /** Create empty space of size */
-  allocate: (size: number) => Uint8Array;
-  /** Check if two Uint8Arrays are deep equal */
-  equals: (a: Uint8Array, b: Uint8Array) => boolean;
-  /** Check if two Uint8Arrays are deep equal */
-  fromNumberArray: (array: number[]) => Uint8Array;
-  /** Create a Uint8Array from a base64 string */
-  fromBase64: (base64: string) => Uint8Array;
-  /** Create a base64 string from bytes */
-  toBase64: (buffer: Uint8Array) => string;
-  /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
-  fromISO88591: (codePoints: string) => Uint8Array;
-  /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
-  toISO88591: (buffer: Uint8Array) => string;
-  /** Create a Uint8Array from a hex string */
-  fromHex: (hex: string) => Uint8Array;
-  /** Create a hex string from bytes */
-  toHex: (buffer: Uint8Array) => string;
-  /** Create a Uint8Array containing utf8 code units from a string */
-  fromUTF8: (text: string) => Uint8Array;
-  /** Create a string from utf8 code units */
-  toUTF8: (buffer: Uint8Array, start: number, end: number) => string;
-  /** Get the utf8 code unit count from a string if it were to be transformed to utf8 */
-  utf8ByteLength: (input: string) => number;
-  /** Encode UTF8 bytes generated from `source` string into `destination` at byteOffset. Returns the number of bytes encoded. */
-  encodeUTF8Into(
-    destination: Uint8Array,
-    source: string,
-    byteOffset: number
-  ): number;
-  /** Generate a Uint8Array filled with random bytes with byteLength */
-  randomBytes(byteLength: number): Uint8Array;
-};
-
-declare const Buffer:
-  | { new (): unknown; prototype?: { _isBuffer?: boolean } }
-  | undefined;
-
-/**
- * Check that a global Buffer exists that is a function and
- * does not have a '_isBuffer' property defined on the prototype
- * (this is to prevent using the npm buffer)
- */
-const hasGlobalBuffer =
-  typeof Buffer === "function" && Buffer.prototype?._isBuffer !== true;
-
-/**
- * This is the only ByteUtils that should be used across the rest of the BSON library.
- *
- * The type annotation is important here, it asserts that each of the platform specific
- * utils implementations are compatible with the common one.
- *
- * @internal
- */
-export const ByteUtils: ByteUtils = hasGlobalBuffer
-  ? nodeJsByteUtils
-  : webByteUtils;
-
-export class BSONDataView extends DataView {
-  static fromUint8Array(input: Uint8Array) {
-    return new DataView(input.buffer, input.byteOffset, input.byteLength);
-  }
-}

package/src/objectId/utils/node_byte_utils.ts

@@ -1,173 +0,0 @@
-import { BSONError } from "../error";
-
-type NodeJsEncoding = "base64" | "hex" | "utf8" | "binary";
-type NodeJsBuffer = ArrayBufferView &
-  Uint8Array & {
-    write(
-      string: string,
-      offset: number,
-      length: undefined,
-      encoding: "utf8"
-    ): number;
-    copy(
-      target: Uint8Array,
-      targetStart: number,
-      sourceStart: number,
-      sourceEnd: number
-    ): number;
-    toString: (
-      this: Uint8Array,
-      encoding: NodeJsEncoding,
-      start?: number,
-      end?: number
-    ) => string;
-    equals: (this: Uint8Array, other: Uint8Array) => boolean;
-  };
-type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, "from"> & {
-  alloc: (size: number) => NodeJsBuffer;
-  from(array: number[]): NodeJsBuffer;
-  from(array: Uint8Array): NodeJsBuffer;
-  from(array: ArrayBuffer): NodeJsBuffer;
-  from(
-    array: ArrayBuffer,
-    byteOffset: number,
-    byteLength: number
-  ): NodeJsBuffer;
-  from(base64: string, encoding: NodeJsEncoding): NodeJsBuffer;
-  byteLength(input: string, encoding: "utf8"): number;
-  isBuffer(value: unknown): value is NodeJsBuffer;
-};
-
-// This can be nullish, but we gate the nodejs functions on being exported whether or not this exists
-// Node.js global
-declare const Buffer: NodeJsBufferConstructor;
-declare const require: (mod: "crypto") => {
-  randomBytes: (byteLength: number) => Uint8Array;
-};
-
-/** @internal */
-export function nodejsMathRandomBytes(byteLength: number) {
-  return nodeJsByteUtils.fromNumberArray(
-    Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256))
-  );
-}
-
-/**
- * @internal
- * WARNING: REQUIRE WILL BE REWRITTEN
- *
- * This code is carefully used by require_rewriter.mjs any modifications must be reflected in the plugin.
- *
- * @remarks
- * "crypto" is the only dependency BSON needs. This presents a problem for creating a bundle of the BSON library
- * in an es module format that can be used both on the browser and in Node.js. In Node.js when BSON is imported as
- * an es module, there will be no global require function defined, making the code below fallback to the much less desireable math.random bytes.
- * In order to make our es module bundle work as expected on Node.js we need to change this `require()` to a dynamic import, and the dynamic
- * import must be top-level awaited since es modules are async. So we rely on a custom rollup plugin to seek out the following lines of code
- * and replace `require` with `await import` and the IIFE line (`nodejsRandomBytes = (() => { ... })()`) with `nodejsRandomBytes = await (async () => { ... })()`
- * when generating an es module bundle.
- */
-const nodejsRandomBytes: (byteLength: number) => Uint8Array = (() => {
-  try {
-    return require("crypto").randomBytes;
-  } catch {
-    return nodejsMathRandomBytes;
-  }
-})();
-
-/** @internal */
-export const nodeJsByteUtils = {
-  toLocalBufferType(
-    potentialBuffer: Uint8Array | NodeJsBuffer | ArrayBuffer
-  ): NodeJsBuffer {
-    if (Buffer.isBuffer(potentialBuffer)) {
-      return potentialBuffer;
-    }
-
-    if (ArrayBuffer.isView(potentialBuffer)) {
-      return Buffer.from(
-        potentialBuffer.buffer,
-        potentialBuffer.byteOffset,
-        potentialBuffer.byteLength
-      );
-    }
-
-    const stringTag =
-      potentialBuffer?.[Symbol.toStringTag] ??
-      Object.prototype.toString.call(potentialBuffer);
-    if (
-      stringTag === "ArrayBuffer" ||
-      stringTag === "SharedArrayBuffer" ||
-      stringTag === "[object ArrayBuffer]" ||
-      stringTag === "[object SharedArrayBuffer]"
-    ) {
-      return Buffer.from(potentialBuffer);
-    }
-
-    throw new BSONError(`Cannot create Buffer from ${String(potentialBuffer)}`);
-  },
-
-  allocate(size: number): NodeJsBuffer {
-    return Buffer.alloc(size);
-  },
-
-  equals(a: Uint8Array, b: Uint8Array): boolean {
-    return nodeJsByteUtils.toLocalBufferType(a).equals(b);
-  },
-
-  fromNumberArray(array: number[]): NodeJsBuffer {
-    return Buffer.from(array);
-  },
-
-  fromBase64(base64: string): NodeJsBuffer {
-    return Buffer.from(base64, "base64");
-  },
-
-  toBase64(buffer: Uint8Array): string {
-    return nodeJsByteUtils.toLocalBufferType(buffer).toString("base64");
-  },
-
-  /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
-  fromISO88591(codePoints: string): NodeJsBuffer {
-    return Buffer.from(codePoints, "binary");
-  },
-
-  /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
-  toISO88591(buffer: Uint8Array): string {
-    return nodeJsByteUtils.toLocalBufferType(buffer).toString("binary");
-  },
-
-  fromHex(hex: string): NodeJsBuffer {
-    return Buffer.from(hex, "hex");
-  },
-
-  toHex(buffer: Uint8Array): string {
-    return nodeJsByteUtils.toLocalBufferType(buffer).toString("hex");
-  },
-
-  fromUTF8(text: string): NodeJsBuffer {
-    return Buffer.from(text, "utf8");
-  },
-
-  toUTF8(buffer: Uint8Array, start: number, end: number): string {
-    return nodeJsByteUtils
-      .toLocalBufferType(buffer)
-      .toString("utf8", start, end);
-  },
-
-  utf8ByteLength(input: string): number {
-    return Buffer.byteLength(input, "utf8");
-  },
-
-  encodeUTF8Into(
-    buffer: Uint8Array,
-    source: string,
-    byteOffset: number
-  ): number {
-    return nodeJsByteUtils
-      .toLocalBufferType(buffer)
-      .write(source, byteOffset, undefined, "utf8");
-  },
-
-  randomBytes: nodejsRandomBytes,
-};