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 ofrece soporte básico para MongoDB. La mayor parte de la funcionalidad de TypeORM es específica para RDBMS, esta página contiene toda la documentación de funcionalidad específica para MongoDB.

Instalación

npm install mongodb

Opciones de Data Source

• 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.

• host - Host de la base de datos.

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

• username - Nombre de usuario de la base de datos (alternativa para auth.user).

• password - Contraseña de la base de datos (alternativa para auth.password).

• database - Nombre de la base de datos.

• poolSize - Establece el tamaño máximo del pool para cada conexión de servidor o proxy.

• tls - Usa una conexión TLS/SSL (requiere servidor mongod con soporte SSL, versión 2.4 o superior). Valor predeterminado: false.

• tlsAllowInvalidCertificates - Especifica si el controlador genera un error cuando el certificado TLS del servidor es inválido. 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.

• keepAlive - Número de milisegundos a esperar antes de iniciar keepAlive en el socket TCP. Valor predeterminado: 30000.

• connectTimeoutMS - Configuración de tiempo de espera para conexión TCP. Valor predeterminado: 30000.

• socketTimeoutMS - Configuración de tiempo de espera para socket TCP. Valor predeterminado: 360000.

• replicaSet - Nombre del conjunto de réplicas al que conectarse.

• authSource - Si la autenticación de la base de datos depende de otro databaseName.

• writeConcern - La política de escritura (write concern).

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

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

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

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

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

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

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

• readPreference - Preferencia de lectura:

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

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

• readConcern - Especifica una política de lectura (read concern) para la colección (soportado solo en MongoDB 3.2+).

• maxStalenessSeconds - Especifica un valor maxStalenessSeconds para lecturas secundarias (mínimo 90 segundos).

• appName - Nombre de la aplicación que creó esta instancia de MongoClient. MongoDB 3.4+ mostrará 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.

• directConnection - Especifica si se debe forzar el envío de todas las operaciones al host especificado.

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 { Entity, ObjectId, 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 { Entity, ObjectId, ObjectIdColumn, Column } from "typeorm"

export class Profile {
    @Column()
    about: string

    @Column()
    education: string

    @Column()
    career: string
}

import { Entity, ObjectId, 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:

import { getMongoManager } from "typeorm"

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),
]

const manager = getMongoManager()
await 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 (soportado solo en MongoDB 2.6+). Versiones anteriores generarán error. 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.

stats

Obtiene todas las estadísticas de la colección.

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.