MongoDB

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Soporte para MongoDB

TypeORM tiene soporte básico para MongoDB (con el driver de Node.js v7 o superior).

La mayoría de la funcionalidad de TypeORM es específica para RDBMS; esta página contiene toda la funcionalidad específica de MongoDB.

Instalación

npm install mongodb

Opciones de Data Source

• appName - Nombre de la aplicación que creó esta instancia de MongoClient. MongoDB imprimirá este valor en el registro del servidor al establecer cada conexión. También se registra en el registro de consultas lentas y colecciones de perfil.

• authMechanism - Define el mecanismo de autenticación que MongoDB usará para autenticar la conexión.

• authSource - Especifica el nombre de la base de datos asociada con las credenciales del usuario.

• autoEncryption - Opcionalmente habilita el cifrado automático en uso.

• checkServerIdentity - Verifica que el certificado cert fue emitido para hostname.

• compressors - Un array o string delimitado por comas de compresores para habilitar compresión de red en la comunicación entre este cliente y una instancia mongod/mongos.

• connectTimeoutMS - Tiempo en milisegundos para intentar una conexión antes de agotar el tiempo. Valor predeterminado: 30000.

• database - Nombre de la base de datos.

• directConnection - Permite que el driver fuerce un tipo de topología Single con una cadena de conexión que contenga un único host.

• driver - Objeto del driver. Por defecto es require("mongodb").

• family - Familia IP.

• forceServerObjectId - Fuerza al servidor a asignar valores _id en lugar del controlador. Valor predeterminado: false.

• host - Host de la base de datos.

• hostReplicaSet - Conjunto de réplicas del host de la base de datos.

• ignoreUndefined - Especifica si el serializador BSON debe ignorar campos indefinidos. Valor predeterminado: false.

• localThresholdMS - Tamaño (en milisegundos) de la ventana de latencia para seleccionar entre múltiples instancias de MongoDB adecuadas.

• maxStalenessSeconds - Especifica, en segundos, cuán desactualizada puede estar una réplica secundaria antes de que el cliente deje de usarla para operaciones de lectura. Mínimo 90 segundos.

• minPoolSize - Número mínimo de conexiones en el grupo de conexiones.

• monitorCommands - Habilita el monitoreo de comandos para este cliente.

• noDelay - Conexión TCP sin retraso.

• password - Contraseña de la base de datos.

• pkFactory - Objeto factory para claves primarias que genera _id personalizados.

• poolSize - Número máximo de conexiones en el grupo de conexiones. Se asigna a la opción maxPoolSize del driver de MongoDB.

• port - Puerto del host de la base de datos. El puerto predeterminado de MongoDB es 27017.

• promoteBuffers - Convierte valores BSON Binary a Buffers nativos de Node. Valor predeterminado: false.

• promoteLongs - Convierte valores Long a number si caben en resolución de 53 bits. Valor predeterminado: true.

• promoteValues - Convierte valores BSON a tipos nativos cuando es posible; configurar en false para recibir solo tipos wrapper. Valor predeterminado: true.

• proxyHost - Configura un host proxy Socks5 usado para crear conexiones TCP.

• proxyPassword - Configura una contraseña para proxy Socks5 cuando requiere autenticación de usuario/contraseña.

• proxyPort - Configura un puerto proxy Socks5 usado para crear conexiones TCP.

• proxyUsername - Configura un usuario para proxy Socks5 cuando requiere autenticación de usuario/contraseña.

• raw - Devuelve resultados de documentos como búferes BSON sin procesar. Valor predeterminado: false.

• readConcern - Especifica un nivel de consistencia de lectura (read concern) para la colección.

• readPreference - Preferencia de lectura:

  • ReadPreference.PRIMARY
  • ReadPreference.PRIMARY_PREFERRED
  • ReadPreference.SECONDARY
  • ReadPreference.SECONDARY_PREFERRED
  • ReadPreference.NEAREST

• readPreferenceTags - Especifica el documento de tags como una lista de pares clave-valor separados por dos puntos y delimitados por comas.

• replicaSet - Especifica el nombre del conjunto de réplicas, si mongod es miembro de un replica set.

• retryWrites - Habilita escrituras reintentables.

• serializeFunctions - Serializa funciones en cualquier objeto. Valor predeterminado: false.

• socketTimeoutMS - Tiempo en milisegundos para intentar enviar o recibir en un socket antes de agotar el tiempo. Valor predeterminado: 360000.

• tls - Habilita o deshabilita TLS/SSL para la conexión. Valor predeterminado: false.

• tlsAllowInvalidCertificates - Omite la validación de certificados presentados por la instancia mongod/mongos. Valor predeterminado: false.

• tlsCAFile - Especifica la ubicación de un archivo local .pem que contiene la cadena de certificados raíz de la Autoridad de Certificación.

• tlsCertificateKeyFile - Especifica la ubicación de un archivo local .pem que contiene el certificado TLS/SSL y la clave del cliente.

• tlsCertificateKeyFilePassword - Especifica la contraseña para descifrar el tlsCertificateKeyFile.

• url - URL de conexión donde se realiza la conexión. Ten en cuenta que otras opciones del data source sobreescribirán parámetros establecidos en la URL.

• username - Nombre de usuario de la base de datos.

• writeConcern - Un WriteConcern de MongoDB, que describe el nivel de confirmación solicitado a MongoDB para operaciones de escritura.

Se pueden agregar opciones adicionales al objeto extra, que se pasarán directamente a la biblioteca cliente. Consulta más en la documentación de mongodb sobre Opciones de conexión.

Definición de entidades y columnas

Definir entidades y columnas es casi igual que en bases de datos relacionales. La principal diferencia es que debes usar @ObjectIdColumn en lugar de @PrimaryColumn o @PrimaryGeneratedColumn.

Ejemplo de entidad simple:

import { ObjectId } from "mongodb"
import { Entity, ObjectIdColumn, Column } from "typeorm"

@Entity()
export class User {
    @ObjectIdColumn()
    _id: ObjectId

    @Column()
    firstName: string

    @Column()
    lastName: string
}

Y así se inicializa la aplicación:

import { DataSource } from "typeorm"

const myDataSource = new DataSource({
    type: "mongodb",
    host: "localhost",
    port: 27017,
    database: "test",
})

Definición de subdocumentos (documentos incrustados)

Como MongoDB almacena objetos dentro de objetos (o documentos dentro de documentos), puedes hacer lo mismo en TypeORM:

import { ObjectId } from "mongodb"
import { Entity, ObjectIdColumn, Column } from "typeorm"

export class Profile {
    @Column()
    about: string

    @Column()
    education: string

    @Column()
    career: string
}

import { ObjectId } from "mongodb"
import { Entity, ObjectIdColumn, Column } from "typeorm"

export class Photo {
    @Column()
    url: string

    @Column()
    description: string

    @Column()
    size: number

    constructor(url: string, description: string, size: number) {
        this.url = url
        this.description = description
        this.size = size
    }
}

import { Entity, ObjectId, ObjectIdColumn, Column } from "typeorm"

@Entity()
export class User {
    @ObjectIdColumn()
    id: ObjectId

    @Column()
    firstName: string

    @Column()
    lastName: string

    @Column((type) => Profile)
    profile: Profile

    @Column((type) => Photo)
    photos: Photo[]
}

Si guardas esta entidad:

const user = new User()
user.firstName = "Timber"
user.lastName = "Saw"
user.profile = new Profile()
user.profile.about = "About Trees and Me"
user.profile.education = "Tree School"
user.profile.career = "Lumberjack"
user.photos = [
    new Photo("me-and-trees.jpg", "Me and Trees", 100),
    new Photo("me-and-chakram.jpg", "Me and Chakram", 200),
]

await myDataSource.manager.save(user)

Se guardará el siguiente documento en la base de datos:

{
    "firstName": "Timber",
    "lastName": "Saw",
    "profile": {
        "about": "About Trees and Me",
        "education": "Tree School",
        "career": "Lumberjack"
    },
    "photos": [
        {
            "url": "me-and-trees.jpg",
            "description": "Me and Trees",
            "size": 100
        },
        {
            "url": "me-and-chakram.jpg",
            "description": "Me and Chakram",
            "size": 200
        }
    ]
}

Uso de MongoEntityManager y MongoRepository

Puedes usar la mayoría de métodos de EntityManager (excepto los específicos de RDBMS como query y transaction). Por ejemplo:

const timber = await myDataSource.manager.findOneBy(User, {
    firstName: "Timber",
    lastName: "Saw",
})

Para MongoDB existe un MongoEntityManager separado que extiende EntityManager.

const timber = await myDataSource.manager.findOneBy(User, {
    firstName: "Timber",
    lastName: "Saw",
})

Al igual que existe un MongoEntityManager separado, hay un MongoRepository que extiende Repository:

const timber = await myDataSource.getMongoRepository(User).findOneBy({
    firstName: "Timber",
    lastName: "Saw",
})

Usa opciones avanzadas en find():

Igual:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        firstName: { $eq: "Timber" },
    },
})

Menor que:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        age: { $lt: 60 },
    },
})

En:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        firstName: { $in: ["Timber", "Zhang"] },
    },
})

No en:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        firstName: { $not: { $in: ["Timber", "Zhang"] } },
    },
})

O:

const timber = await myDataSource.getMongoRepository(User).find({
    where: {
        $or: [{ firstName: "Timber" }, { firstName: "Zhang" }],
    },
})

Consultando subdocumentos

const users = await myDataSource.getMongoRepository(User).find({
    where: {
        "profile.education": { $eq: "Tree School" },
    },
})

Consultando arrays de subdocumentos

// Query users with photos of size less than 500
const users = await myDataSource.getMongoRepository(User).find({
    where: {
        "photos.size": { $lt: 500 },
    },
})

Tanto MongoEntityManager como MongoRepository contienen muchos métodos útiles específicos de MongoDB:

createCursor

Crea un cursor para una consulta que permite iterar sobre resultados de MongoDB.

createEntityCursor

Crea un cursor para una consulta que permite iterar sobre resultados de MongoDB. Devuelve una versión modificada del cursor que transforma cada resultado en modelos de entidad.

aggregate

Ejecuta una pipeline de aggregation framework sobre la colección.

bulkWrite

Realiza una operación bulkWrite sin usar una API fluida.

count

Cuenta los documentos coincidentes con una consulta en la base de datos.

countDocuments

Cuenta los documentos coincidentes con una consulta en la base de datos.

createCollectionIndex

Crea un índice en la base de datos y colección.

createCollectionIndexes

Crea múltiples índices en la colección. Las especificaciones de índices se definen en createIndexes.

deleteMany

Elimina múltiples documentos en MongoDB.

deleteOne

Elimina un documento en MongoDB.

distinct

El comando distinct devuelve una lista de valores únicos para la clave especificada en una colección.

dropCollectionIndex

Elimina un índice de esta colección.

dropCollectionIndexes

Elimina todos los índices de la colección.

findOneAndDelete

Busca un documento y lo elimina en una operación atómica, requiriendo un bloqueo de escritura durante la operación.

findOneAndReplace

Busca un documento y lo reemplaza en una operación atómica, requiriendo un bloqueo de escritura durante la operación.

findOneAndUpdate

Busca un documento y lo actualiza en una operación atómica, requiriendo un bloqueo de escritura durante la operación.

geoHaystackSearch

Ejecuta una búsqueda geoespacial usando un índice geo haystack en una colección.

geoNear

Ejecuta el comando geoNear para buscar elementos en la colección.

group

Ejecuta un comando group sobre una colección.

collectionIndexes

Recupera todos los índices de la colección.

collectionIndexExists

Comprueba si existe un índice en la colección.

collectionIndexInformation

Recupera la información de índices de esta colección.

initializeOrderedBulkOp

Inicia una operación bulk ordenada; las operaciones se ejecutarán en serie según el orden de agregado, creando nuevas operaciones en cada cambio de tipo.

initializeUnorderedBulkOp

Inicia una operación bulk desordenada. Todas las operaciones se almacenarán en búfer como comandos insert/update/remove ejecutados sin orden específico.

insertMany

Inserta un array de documentos en MongoDB.

insertOne

Inserta un documento individual en MongoDB.

isCapped

Indica si la colección es una colección capped (de tamaño fijo).

listCollectionIndexes

Obtiene la lista de toda la información de índices de la colección.

parallelCollectionScan

Devuelve N cursores paralelos para una colección permitiendo lectura paralela de toda la colección. No hay garantías de orden en los resultados.

reIndex

Reconstruye todos los índices de la colección. Advertencia: reIndex es una operación bloqueante (índices se reconstruyen en primer plano) y será lenta para colecciones grandes.

rename

Cambia el nombre de una colección existente.

replaceOne

Reemplaza un documento en MongoDB.

updateMany

Actualiza múltiples documentos en la colección según el filtro.

updateOne

Actualiza un documento individual en la colección según el filtro.