Global Modules

JSON Web Tokens (utils.jwt)

Puedes crear y leer JSON Web Tokens con la interfaz de utils.jwt.

utils.jwt.encode()

Genera una cadena de token web JSON codificada para payload en función de signingMethod y secret especificados.

utils.jwt.encode(
   signingMethod: string,
   payload: object,
   secret: string,
   customHeaderFields: object
): string

Parameter	Tipo	Descripción
signingMethod	string	El algoritmo criptográfico que se utiliza al codificar el JWT. Atlas App Services admite los siguientes métodos de firma JWT: Método de firma Descripción "HS256" HMAC using SHA-256 "HS384" HMAC usando SHA-384 "HS512" HMAC usando SHA-512 "RS256" RSASSA-PKCS1-v1_5 usando SHA-256 "RS384" RSASSA-PKCS1-v1_5 using SHA-384 "RS512" RSASSA-PKCS1-v1_5 usando SHA-512 "ES256" ECDSA utilizando P-256 y SHA-256 "ES384" ECDSA utilizando P-384 y SHA-384 "ES512" ECDSA utilizando P-512 y SHA-512 "PS256" RSASSA-PSS usando SHA-256 y MGF1 con SHA-256 "PS384" RSASSA-PSS usando SHA-384 y MGF1 con SHA-384 "PS512" RSASSA-PSS usando SHA-512 y MGF1 con SHA-512
payload	Objeto	Un objeto JSON que especifica las reclamaciones del token y cualquier dato adicional relacionado.
secret	string	Una cadena secreta que App Services usa para firmar el token. El valor de la cadena depende del método de firma que uses: Métodos de firma Descripción "HS256" "HS384" "HS512" Una cadena aleatoria. "RS256" "RS384" "RS512" Una clave privada RSA-SHA en formato PKCS#8. "PS256" "PS384" "PS512" Una clave privada RSA-PSS en formato PKCS#8. "ES256" "ES384" "ES512" Una clave privada ECDSA en8 formato PKCS#.
customHeaderFields	Objeto	Un objeto JSON que especifica campos adicionales para incluir en el encabezado JOSE de JWT.

Devuelve:	Una cadena de token web JSON codificada para el payload proporcionado.

Ejemplo

Considere el siguiente objeto de claims JWT:

{
  "sub": "1234567890",
  "name": "Joe Example",
  "iat": 1565721223187
}

Podemos codificar el objeto de reclamaciones como una cadena JWT llamando a utils.jwt.encode(). La siguiente función codifica el JWT utilizando el método de firma HS512 y el secreto "SuperSecret":

exports = function() {
  const signingMethod = "HS512";
  const payload = {
    "sub": "1234567890",
    "name": "Joe Example",
    "iat": 1565721223187
  };
  const secret = "SuperSecret";
  return utils.jwt.encode(signingMethod, payload, secret);
}

OCULTAR SALIDA

"eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvZSBTY2htb2UiLCJpYXQiOjE1NjU3MjEyMjMxODd9.-QL15ldu2BYuJokNWT6YRiwZQIiIpvq6Kyv-C6qslNdNiUVxo8zqLJZ1iEkNf2yZKMIrQuMCtIC1tzd2H31AxA"

utils.jwt.decode()

Decodifica el payload de la string proporcionada del JSON Web Token. El valor de key debe coincidir con el valor secreto que se utilizó para codificar la string JWT.

utils.jwt.decode(
   jwtString: string,
   key: string,
   returnHeader: boolean
): object

Parameter	Tipo	Descripción
jwtString	string	Una cadena de JSON Web Token que codifica un conjunto de claims firmados con un valor secreto.
key	string	A string that App Services uses to verify the token signature. The value of the string depends on the signing method that you use: Métodos de firma Descripción "HS256" "HS384" "HS512" The random string that was used to sign the token. "RS256" "RS384" "RS512" La clave pública RSA-SHA que corresponde a la clave privada que se utilizó para firmar el token. "PS256" "PS384" "PS512" La clave pública RSA-PSS que corresponde a la clave privada que se utilizó para firmar el token. "ES256" "ES384" "ES512" La clave pública ECDSA que corresponde a la clave privada que se utilizó para firmar el token.
returnHeader	booleano	Si true, devuelve el encabezado JOSE del JWT además de la carga útil decodificada.
acceptedSigningMethods	string[]	opcional. Arreglo de métodos de firma aceptados. Por ejemplo, ["PS256", "HS256"]. Este argumento debe incluirse para prevenir vulnerabilidades de seguridad JWT conocidas.

Devuelve:	Si returnHeader es false, devuelve la carga de EJSON decodificada. Si returnHeader es true, devuelve un objeto que contiene la cabecera JOSE en el campo header y la carga útil decodificada en formato EJSON en el campo payload. { "header": { "<JOSE Header Field>": <JOSE Header Value>, ... }, "payload": { "<JWT Claim Field>": <JWT Claim Value>, ... } }

Ejemplo

Considera la siguiente JWT firmada string:

"eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvZSBTY2htb2UiLCJpYXQiOjE1NjU3MjEyMjMxODd9.-QL15ldu2BYuJokNWT6YRiwZQIiIpvq6Kyv-C6qslNdNiUVxo8zqLJZ1iEkNf2yZKMIrQuMCtIC1tzd2H31AxA"

El JWT se firmó utilizando el método de firma HS512 con el valor secreto "SuperSecret". Podemos decodificar el objeto de claims utils.jwt.decode() del JWT. La siguiente función decodifica la JWT string en un objeto EJSON:

exports = function(jwtString) {
  const key = "SuperSecret";
  return utils.jwt.decode(jwtString, key, false, ["HS512"]);
}

OCULTAR SALIDA

{
  "sub": "1234567890",
  "name": "Joe Example",
  "iat": { "$numberDouble": 1565721223187 }
}

Criptografíautils.crypto ()

Puede cifrar, descifrar, firmar y verificar datos utilizando algoritmos criptográficos con la interfaz utils.crypto.

utils.crypto.encrypt()

Genera un string de texto cifrado a partir del texto proporcionado utilizando el método de cifrado y la clave especificados.

utils.crypto.encrypt(
  encryptionType: string,
  message: string,
  key: string
): BSON.Binary

Parameter	Tipo	Descripción
encryptionType	string	El tipo de cifrado con el que se cifrará el mensaje. Se admiten los siguientes tipos de cifrado: Cifrado AES ("aes")
message	string	La string de texto que deseas cifrar.
key	string	Una clave criptográfica utilizada para cifrar el texto. La llave que debes usar depende del método de cifrado: Tipo de cifrado llave de cifrado AES Una cadena aleatoria de 16 bytes, 24 bytes o 32 bytes

Devuelve:	Un BSON Binario objeto que contiene la string cifrada con el tipo de cifrado especificado y la clave.

Ejemplo

Assume that we have defined a value named aesEncryptionKey that contains the following 32-byte AES encryption key:

"603082712271C525E087BD999A4E0738"

Con esta clave AES, podemos cifrar un mensaje en una string base64 utilizando la siguiente función:

exports = function() {
  const message = "MongoDB is great!"
  const key = context.values.get("aesEncryptionKey");
  const encryptedMessage = utils.crypto.encrypt("aes", message, key);
  return encryptedMessage.toBase64();
}

OCULTAR SALIDA

"WPBuIvJ6Bity43Uh822dW8QlVYVJaFUiDeUjlTiJXzptUuTYIKPlXekBQAJb"

utils.crypto.decrypt()

Décrypte la string de texte fournie à l’aide du type de cifrado et de la clé spécifiés. Si tanto el tipo de cifrado como la clave son los mismos que se usaron para cifrar, esto devuelve el texto original, sin cifrar.

utils.crypto.decrypt(
  encryptionType: string,
  encryptedMessage: BSON.Binary,
  key: string
): BSON.Binary

Parameter	Tipo	Descripción
encryptionType	string	El tipo de cifrado que se utilizó para cifrar el texto proporcionado. Se admiten los siguientes tipos de cifrado: Cifrado AES ("aes")
encryptedMessage	BSON.Binary	Un BSON binario que codifica la string de texto cifrada que deseas descifrar.
key	string	Una clave criptográfica utilizada para descifrar el texto. La clave que debe usar depende del tipo de cifrado: Tipo de cifrado llave de cifrado AES Una cadena aleatoria de 16 bytes, 24 bytes o 32 bytes

Devuelve:	Un objeto BSON Binario que contiene el mensaje descifrado. Si el mensaje cifrado proporcionado se cifró con el método y clave especificados, entonces el mensaje descifrado es idéntico al mensaje original.

Ejemplo

Assume that we have defined a Value named aesEncryptionKey that contains the following 32-byte AES encryption key:

"603082712271C525E087BD999A4E0738"

Podemos usar esta clave AES para descifrar cualquier cadena base64 que haya sido cifrada con la misma clave utilizando la siguiente función:

exports = function(encryptedMessage) {
  // The encrypted message must be a BSON.Binary
  if(typeof encryptedMessage === "string") {
    encryptedMessage = BSON.Binary.fromBase64(encryptedMessage)
  }
  const key = context.values.get("aesEncryptionKey");
  const decryptedMessage = utils.crypto.decrypt("aes", encryptedMessage, key);
  return decryptedMessage.text();
}

OCULTAR SALIDA

"MongoDB is great!"

utils.crypto.sign()

Genera una firma criptográficamente única para un mensaje utilizando una clave privada. La firma puede ser verificada con la llave pública correspondiente para asegurar que el firmante tenga acceso a la llave privada y que el contenido del mensaje no haya sido alterado desde que fue firmado.

utils.crypto.sign(
  encryptionType: string,
  message: string,
  privateKey: string,
  signatureScheme: string
): BSON.Binary

Parameter	Tipo	Descripción
encryptionType	string	El tipo de cifrado que se utilizó para generar el par de claves privadas/públicas. Se admiten los siguientes tipos de cifrado: RSA cifrado ("rsa")
message	string	La string que deseas firmar.
privateKey	string	Una clave privada generada con el tipo de cifrado especificado. Importante Formato de Clave No todas las claves RSA utilizan el mismo formato. Los servicios de aplicación solo pueden firmar mensajes con una clave privada que se ajuste al formato estándar PKCS#1. Las claves privadas en este formato tienen el encabezado -----BEGIN RSA PRIVATE KEY-----. Puede utilizar el siguiente script de shell para generar un par de claves privadas/públicas RSA válido y guardar cada clave en su propio archivo de texto: # Generate an RSA SSH key pair # Save the key to a file called `rsa_key` when prompted ssh-keygen -t rsa -m PEM -b 2048 -C "2048-bit RSA Key" # Private Key cat rsa_key > rsa.private.txt # Public Key ssh-keygen -f rsa_key.pub -e -m pem > rsa.public.txt
signatureScheme	string	Opcional. Por defecto: "pss" El esquema de relleno que debe usar la firma. App Services admite la firma de mensajes con los siguientes esquemas: Esquema de firma probabilística ("pss") PKCS1v1.5 ("pkcs1v15")

Devuelve:	Un BSON.Binary firma criptográfica para el mensaje firmado usando la llave privada especificada.

Ejemplo

Supongamos que hemos definido un valor llamado rsaPrivateKey que contiene la siguiente llave privada RSA:

-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQDVsEjse2qO4v3p8RM/q8Rqzloc1lee34yoYuKZ2cemuUu8Jpc7
KFO1+aJpXdbSPZNhGLdANn8f2oMIZ1R9hgEJRn/Qm/YyC4RPTGg55nzHqSlziNZJ
JAyEUyU7kx5+Kb6ktgojhk8ocZRkorM8FEylkrKzgSrfay0PcWHPsKlmeQIDAQAB
AoGAHlVK1L7kLmpMbuP4voYMeLjYE9XdVEEZf2GiFwLSE3mkJY44033y/Bb2lgxr
DScOf675fFUAEK59ATlhxfu6s6rgx+g9qQQ+mL74YZWPqiZHBPjyMRaBalDVC4QF
YJ+DopFcB8hY2ElXnbK70ALmVYNjw3RdmC97h0YfOsQcWW0CQQD18aeuPNicVnse
Ku22vvhvQYlabaQh4xdkEIxz1TthZj48f61wZwEMipYqOAc5XEtDlNnxgeipv0yF
RHstUjwXAkEA3m0Br/U/vC9evuXppWbONana08KLgfELyd3Uw9jG7VKJZTBH5mS8
7CB68aEF8egrJpo8Ss8BkWrvCxYDb4Y77wJAUlbOMZozVtvpKidrIFR9Lho91uWA
Hsw9h4W20AzibXBig7SnJ0uE4WMAdS/+0yhgFkceVCmO8E2YW8Gaj4jJjwJASxtg
AHy+ItuUEL4uIW4Pn8tVW0BMP3qX0niXyfI/ag/+2S5uePv3V3y4RzNqgH83Yved
+FziWKpVQdcTHeuj/QJBAJl1G3WFruk0llIoKKbKljaEiCm1WCTcuEPbdOtkJYvO
9ZYQg/fji70FERkq2KHtY7aLhCHzy0d4n9xgE/pjV+I=
-----END RSA PRIVATE KEY-----

Con esta clave RSA, podemos firmar un mensaje usando la siguiente función:

exports = function() {
  const message = "MongoDB is great!"
  const rsaPrivateKey = context.values.get("rsaPrivateKey");
  const signature = utils.crypto.sign("rsa", message, rsaPrivateKey, "pss");
  return signature.toBase64();
}

OCULTAR SALIDA

"SpfXcJwPbypArt+XuYQyuZqU52YCAY/sZj2kiuin2b6/RzyM4Ek3n3spOtqZJqxn1tfQavxIX4V+prbs74/pOaQkCLekl9Hoa1xOzSKcGoRd8U+n1+UBY3d3cyODGMpyr8Tim2HZAeLPE/D3Q36/K+jpgjvrJFXsJoAy5/PV7iEGV1fkzogmZtXWDcUUBBTTNPY4qZTzjNhL4RAFOc7Mfci+ojE/lLsNaumUVU1/Eky4vasmyjqunm+ULCcRmgWtGDMGHaQV4OXC2LMUe9GOqd3Q9ghCe0Vlhn25oTh8cXoGpd1Fr8wolNa//9dUqSM+QYDpZJXGLShX/Oa8mPwJZKDKHtqrS+2vE6S4dDWR7zKDza+DeovOeCih71QyuSYMXSz+WWGgfLzv/syhmUXP/mjqgLmJU6Kwg5htajDoylpzLC0BLGT4zDZEwBrq/AjwRs/EPjYdFgGCt1WCbbVlDyXvvH1ekDrzACzumhiMSZNNa+ZH3JmMJxTCQWDfiTeAfkauaaZHKIj2q2/QE7vuAhNcVPJ2YgpXnvnQHJpEZBc/Y3Q6JLxom6+cGC4P//9d++r2cwzXIkqD+wSGZVSVtpm5CLtWMRSK5FX2dv16bM+LE8ozoRvtMUDTrQ8SSSDGxyuYbvN9b2fYYPcWpCMchqOBXV6eZGoMldaHX3Qy5h8="

utils.crypto.verify()

Verifica que la firma proporcionada sea válida para el mensaje y la clave pública especificados.

Si la firma es válida, garantiza que el firmante tiene acceso a la clave privada correspondiente y que el contenido del mensaje no ha sido alterado desde que fue firmado.

utils.crypto.verify(
  encryptionType: string,
  message: string,
  publicKey: string,
  signature: BSON.Binary,
  signatureScheme: string
): boolean

Parameter	Tipo	Descripción
encryptionType	string	El tipo de cifrado que se utilizó para generar el par de claves privadas/públicas. Se admiten los siguientes tipos de cifrado: RSA cifrado ("rsa")
message	string	La cadena de texto para la que desea verificar la firma. Si la firma es válida, este es exactamente el mensaje que fue firmado.
publicKey	string	La clave pública para la que se desea verificar la firma. Si la firma es válida, esta es la clave pública correspondiente a la clave privada que se usó para firmar el mensaje. Importante Formato de Clave No todas las claves RSA usan el mismo formato. App Services solo puede verificar firmas con claves RSA que cumplan con el formato estándar PKCS#.1 Las claves públicas en este formato tienen el -----BEGIN RSA PUBLIC KEY----- encabezado. Puede utilizar el siguiente script de shell para generar un par de claves privadas/públicas RSA válido y guardar cada clave en su propio archivo de texto: # Generate an RSA SSH key pair # Save the key to a file called `rsa_key` when prompted ssh-keygen -t rsa -m PEM -b 2048 -C "2048-bit RSA Key" # Private Key cat rsa_key > rsa.private.txt # Public Key ssh-keygen -f rsa_key.pub -e -m pem > rsa.public.txt
signature	BSON.Binary	La firma que desea verificar.
signatureScheme	string	Opcional. Por defecto: "pss" El esquema de relleno que utiliza la firma. App Services admite la verificación de firmas que utilizan los siguientes esquemas: Esquema de firma probabilística ("pss") PKCS1v1.5 ("pkcs1v15")

Devuelve:	Un booleano que, si true, indica si la firma es válida o no para el mensaje y llave pública proporcionados.

Ejemplo

Hemos recibido un mensaje con una firma en formato BSON.Binary y queremos verificar que el mensaje fue firmado con la clave privada que corresponde a la clave pública RSA del remitente:

-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBANWwSOx7ao7i/enxEz+rxGrOWhzWV57fjKhi4pnZx6a5S7wmlzsoU7X5
omld1tI9k2EYt0A2fx/agwhnVH2GAQlGf9Cb9jILhE9MaDnmfMepKXOI1kkxDIRT
JTuTHn4pvqS2CiOGTyhxlGSiszwUTKWSsrOBKt9rLQ9xYc+wqWZ5AgMBAAE=
-----END RSA PUBLIC KEY-----

Con esta clave RSA, podemos verificar un mensaje firmado con la llave privada correspondiente usando la siguiente función:

exports = function() {
  const rsaPublicKey = context.values.get("rsaPublicKey");
  const message = "MongoDB is great!"
  const signature = BSON.Binary.fromBase64("SpfXcJwPbypArt+XuYQyuZqU52YCAY/sZj2kiuin2b6/RzyM4Ek3n3spOtqZJqxn1tfQavxIX4V+prbs74/pOaQkCLekl9Hoa1xOzSKcGoRd8U+n1+UBY3d3cyODGMpyr8Tim2HZAeLPE/D3Q36/K+jpgjvrJFXsJoAy5/PV7iEGV1fkzogmZtXWDcUUBBTTNPY4qZTzjNhL4RAFOc7Mfci+ojE/lLsNaumUVU1/Eky4vasmyjqunm+ULCcRmgWtGDMGHaQV4OXC2LMUe9GOqd3Q9ghCe0Vlhn25oTh8cXoGpd1Fr8wolNa//9dUqSM+QYDpZJXGLShX/Oa8mPwJZKDKHtqrS+2vE6S4dDWR7zKDza+DeovOeCih71QyuSYMXSz+WWGgfLzv/syhmUXP/mjqgLmJU6Kwg5htajDoylpzLC0BLGT4zDZEwBrq/AjwRs/EPjYdFgGCt1WCbbVlDyXvvH1ekDrzACzumhiMSZNNa+ZH3JmMJxTCQWDfiTeAfkauaaZHKIj2q2/QE7vuAhNcVPJ2YgpXnvnQHJpEZBc/Y3Q6JLxom6+cGC4P//9d++r2cwzXIkqD+wSGZVSVtpm5CLtWMRSK5FX2dv16bM+LE8ozoRvtMUDTrQ8SSSDGxyuYbvN9b2fYYPcWpCMchqOBXV6eZGoMldaHX3Qy5h8=")
  const isValid = utils.crypto.verify("rsa", message, rsaPublicKey, signature, "pss");
  return isValid; // true if the signature matches, else false
}

OCULTAR SALIDA

true

utils.crypto.hmac()

Genera un HMAC de la entrada y la clave secreta proporcionadas. Esto es útil al comunicarse con servicios HTTP de terceros que requieren solicitudes firmadas.

utils.crypto.hmac(
  input: string,
  secret: string,
  hash_function: string,
  output_format: string
): string

Parameter	Tipo	Descripción
input	string	La entrada para la que desea generar una firma.
secret	string	La clave secreta a utilizar al generar la firma.
hash_function	string	El nombre de la función de hash que se utilizará al generar la firma. Se admiten las siguientes funciones: "sha1", "sha256", "sha512".
output_format	string	El formato de la firma generada. Puede ser "hex" para una cadena hexadecimal o "base64" para una cadena Base64.

Devuelve:	La firma de la entrada, en el formato especificado por output_format.

Ejemplo

La siguiente función genera una firma sha256 como una cadena base 64:

exports = function() {
  const signature = utils.crypto.hmac(
    "hello!",
    "super-secret",
    "sha256",
    "base64"
  )
  return signature
}

OCULTAR SALIDA

"SUXd6PRMaTXXgBGaGsIHzaDWgTSa6C3D44lRGrvRak0="

utils.crypto.hash()

Genera un valor de hash para la entrada proporcionada utilizando la función de hash especificada.

utils.crypto.hash(
  hash_function: string,
  input: string | BSON.Binary
): BSON.Binary

Parameter	Tipo	Descripción
hash_function	string	El nombre de la función de hash. Se admiten las siguientes funciones: "sha1", "sha256", "md5".
input	string o BSON.Binary	Obligatorio. La entrada para la que desea generar un valor hash.

Devuelve:	Un objeto BSON.Binary que codifica el valor hash de la entrada proporcionada generada por la función hash especificada.

Ejemplo

La siguiente función convierte una cadena de entrada en hash sha256:

exports = function() {
  return utils.crypto.hash(
    "sha256",
    "hello!"
  )
}

OCULTAR SALIDA

"zgYJL7lI2f+sfRo3bkBLJrdXW8wR7gWkYV/vT+w6MIs="

BSON.ObjectId

El tipo BSON.ObjectId representa un identificador MongoDB ObjectId de 12 bytes.

BSON.ObjectId()

Construye un BSON.ObjectId objeto que codifica un ObjectId

new BSON.ObjectId(id: string)

Parameter	Tipo	Descripción
id	string	Optional. A 12-byte string or a string of 24 hex characters.

Devuelve:	Un BSON.ObjectId objeto que codifica la cadena ObjectId especificada o una ObjectId cadena generada si no se especificó ninguna.

Ejemplo

const objectId = new BSON.ObjectId("5e58667d902d38559c802b13");
const generatedObjectId = new BSON.ObjectId();

BSON.BSONRegExp

El tipo BSON.BSONRegExp representa una expresión regular. Puede usar un BSON.BSONRegExp objeto con el $regex operador del query para realizar una query de expresión regular en una colección MongoDB.

BSON.BSONRegExp()

Construye un objeto BSON.BSONRegExp a partir de una string de expresión regular. Puede especificar opcionalmente banderas de configuración.

BSON.BSONRegExp(pattern: string, flags: string)

Parameter	Tipo	Descripción
pattern	string	Un patrón de expresión regular.
flags	string	opcional. Uno o más banderas de expresiones regulares.

Devuelve:	Un BSON.BSONRegExp objeto que codifica el patrón y las banderas de la expresión regular proporcionada.

Ejemplo

const regex = BSON.BSONRegExp("the great", "ig");

BSON.Binary

El tipo BSON.Binary representa una string de datos codificada en binario.

BSON.Binary.fromHex()

Construye un objeto BSON.Binary a partir de datos representados como una cadena hexadecimal.

BSON.Binary.fromHex(
  hexString: string,
  subType?: number
): BSON.Binary

Parameter	Tipo	Descripción
hexString	string	Una alineación a bytes string de caracteres hexadecimales (0-9 y A-F).
subType	entero	opcional. El tipo de datos codificados en la string hexadecimal. El valor debe estar en el rango 0-255 donde 0, el valor por defecto, representa un valor binario genérico. Para obtener una lista completa de subtipos admitidos, consulta la especificación BSON.

Devuelve:	Un objeto BSON.Binary que codifica la cadena hexadecimal proporcionada.

Ejemplo

const binary = BSON.Binary.fromHex("54657374206d65737361676520706c656173652069676e6f7265=");

BSON.Binary.prototype.toHex()

Convierte el objeto BSON.Binary en una cadena hexadecimal.

BSON.Binary.prototype.toHex(): string

Devuelve:	Una representación de cadena hexadecimal del objeto BSON.Binary proporcionado.

Ejemplo

export = function() {
  const binary = BSON.Binary.fromHex(
     "54657374206d65737361676520706c656173652069676e6f7265="
   );
  const hexString = binary.toHex();
  return hexString
}

OCULTAR SALIDA

"54657374206d65737361676520706c656173652069676e6f7265="

BSON.Binary.fromBase64()

Construye un objeto BSON.Binary a partir de datos representados como una cadena base64.

BSON.Binary.fromBase64(
  base64String: string,
  subType?: number
): BSON.Binary

Parameter	Tipo	Descripción
base64String	string	Una string de caracteres codificados en base64. Nota String Padding La cadena codificada en base64 debe incluir uno o dos signos de igual (=), que se denominan "relleno" al final de la cadena. BSON.Binary.fromBase64() no admite cadenas sin relleno.
subType	entero	opcional. El tipo de datos codificados en la string hexadecimal. El valor debe estar en el rango 0-255 donde 0, el valor por defecto, representa un valor binario genérico. Para obtener una lista completa de subtipos admitidos, consulta la especificación BSON.

Devuelve:	Un objeto BSON.Binary que codifica la string base64 proporcionada.

Ejemplo

const binary = BSON.Binary.fromBase64("VGVzdCBtZXNzYWdlIHBsZWFzZSBpZ25vcmU=");

BSON.Binary.prototype.toBase64()

Convierte un objeto BSON.Binary en una cadena base64.

BSON.Binary.prototype.toBase64(): string

Devuelve:	Una representación de cadena base64 del objeto BSON.Binary.

Ejemplo

const binary = BSON.Binary.fromBase64("VGVzdCBtZXNzYWdlIHBsZWFzZSBpZ25vcmU=");
const base64String = binary.toBase64();

BSON.Binary.prototype.text()

Converts the BSON.Binary object into a UTF-8 string.

BSON.Binary.prototype.text(): string

Devuelve:	Una representación de cadena UTF-8 del objeto BSON.Binary proporcionado.

Ejemplo

const binary = BSON.Binary.fromBase64("VGVzdCBtZXNzYWdlIHBsZWFzZSBpZ25vcmU=");
const decodedString = binary.text();

BSON.Clave máxima

El tipo BSON.MaxKey representa un valor que se compara como superior a todos los demás valores BSON.

await collection.findOne({ date: { $lt: BSON.MaxKey } });

BSON.MinKey

El tipo BSON.MinKey representa un valor que se compara como inferior a todos los demás valores BSON.

await collection.findOne({ date: { $gt: BSON.MinKey } });

BSON.Int32

El tipo BSON.Int32 representa un entero con signo de 32 bits.

BSON.Int32()

Construye un objeto BSON.Int32 a partir de un número de 32 bits.

BSON.Int32(low32: number): BSON.Int32

Parameter	Tipo	Descripción
low32	Número	Un número de 32 bits.

Devuelve:	Un objeto BSON.Int32 que codifica el entero especificado. Devuelve 0 si no se suministran argumentos.

Ejemplo

const int32 = BSON.Int32(42);

BSON.Long

El tipo BSON.Long representa un entero con signo de 64 bits.

BSON.Long(low32, high32)

BSON.Long(low32: number, high32: number): BSON.Long

Constructs a BSON.Long object from two 32-bit integers that represent the low 32 bits and the high 32 bits in the 64-bit Long integer.

Parameter	Tipo	Descripción
low32	entero	Optional. The long integer's 32 low bits. These bits represent the least significant digits of the number.
high32	entero	Opcional. Los 32 bits más altos del número entero largo. Estos bits representan los dígitos más significativos del número.

Devuelve:	Un objeto BSON.Long que codifica el entero especificado. Devuelve 0 si no se suministran argumentos. BSON.Long codifica usando la siguiente fórmula: (high32 * (2**32)) + low32

Ejemplo

const long = BSON.Long(600206158, 342);

BSON.Double

El tipo BSON.Double representa un número de punto flotante de 64 bits (8 bytes).

BSON.Double(double)

Construye un objeto BSON.Double a partir de un valor decimal de 64 bits.

BSON.Double(double: number): BSON.Double

Parameter	Tipo	Descripción
double	Número	Un valor decimal de 64 bits.

Devuelve:	Un objeto BSON.Double que codifica el double especificado. Devuelve 0 si no se suministra ningún argumento.

Ejemplo

const double = BSON.Double(1234.5678);

BSON.Decimal128

El tipo BSON.Decimal128 representa un número de punto flotante de 128 bits (16 bytes). Este tipo está destinado para casos de uso en donde los valores decimales deben redondearse exactamente, por ejemplo, datos financieros.

BSON.Decimal128.fromString(decimalString)

Construye un BSON.Decimal128 a partir de una representación de string de un número decimal.

BSON.Decimal128(decimalString: string): BSON.Decimal128

Parameter	Tipo	Descripción
decimalString	string	Una cadena que representa un número decimal, por ejemplo "1234.5678910123456".

Devuelve:	Un BSON.Decimal128 que codifica el valor decimal proporcionado.

Ejemplo

const double = BSON.Decimal128.fromString("1234.5678910123456");