Saltar al contenido principal

API de EntityManager

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 →

  • dataSource - El DataSource utilizado por EntityManager.
const dataSource = manager.dataSource
  • queryRunner - El ejecutor de consultas utilizado por EntityManager. Se usa únicamente en instancias transaccionales de EntityManager.
const queryRunner = manager.queryRunner
  • transaction - Proporciona una transacción donde múltiples solicitudes a la base de datos se ejecutarán en una única transacción. Más información en Transacciones.
await manager.transaction(async (manager) => {
    // NOTE: you must perform all database operations using the given manager instance
    // it's a special instance of EntityManager working with this transaction
    // and don't forget to await things here
})
  • query - Ejecuta una consulta SQL en bruto.
const rawData = await manager.query(`SELECT * FROM USERS`)

// You can also use parameters to avoid SQL injection
// The syntax differs between the drivers

// aurora-mysql, better-sqlite3, capacitor, cordova,
// expo, mariadb, mysql, nativescript, react-native,
// sap, sqlite, sqljs
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = ? and age = ?",
    ["John", 24],
)

// aurora-postgres, cockroachdb, postgres
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = $1 and age = $2",
    ["John", 24],
)

// oracle
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = :1 and age = :2",
    ["John", 24],
)

// spanner
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = @param0 and age = @param1",
    ["John", 24],
)

// mssql
const rawData = await manager.query(
    "SELECT * FROM USERS WHERE name = @0 and age = @1",
    ["John", 24],
)
  • sql - Ejecuta una consulta SQL en bruto utilizando literales de plantilla.
const rawData =
    await manager.sql`SELECT * FROM USERS WHERE name = ${"John"} and age = ${24}`

Más información sobre el uso de la sintaxis de SQL Tag.

  • createQueryBuilder - Crea un constructor de consultas para construir consultas SQL. Más información sobre QueryBuilder.
const users = await manager
    .createQueryBuilder()
    .select()
    .from(User, "user")
    .where("user.name = :name", { name: "John" })
    .getMany()
  • hasId - Verifica si la entidad dada tiene definida su propiedad de columna primaria.
if (manager.hasId(user)) {
    // ... do something
}
  • getId - Obtiene el valor de la propiedad de columna primaria de la entidad dada. Si la entidad tiene claves primarias compuestas, el valor devuelto será un objeto con los nombres y valores de las columnas primarias.
const userId = manager.getId(user) // userId === 1
  • create - Crea una nueva instancia de User. Opcionalmente acepta un objeto literal con propiedades de usuario que se escribirán en el nuevo objeto de usuario creado.
const user = manager.create(User) // same as const user = new User();
const user = manager.create(User, {
    id: 1,
    firstName: "Timber",
    lastName: "Saw",
}) // same as const user = new User(); user.firstName = "Timber"; user.lastName = "Saw";
  • merge - Fusiona múltiples entidades en una sola entidad.
const user = new User()
manager.merge(User, user, { firstName: "Timber" }, { lastName: "Saw" }) // same as user.firstName = "Timber"; user.lastName = "Saw";
  • preload - Crea una nueva entidad a partir del objeto JavaScript plano dado. Si la entidad ya existe en la base de datos, la carga (y todo lo relacionado con ella), reemplaza todos los valores con los nuevos del objeto dado, y devuelve la nueva entidad. La nueva entidad se carga realmente desde la entidad de base de datos con todas las propiedades reemplazadas por las del nuevo objeto.
const partialUser = {
    id: 1,
    firstName: "Rizzrak",
    profile: {
        id: 1,
    },
}
const user = await manager.preload(User, partialUser)
// user will contain all missing data from partialUser with partialUser property values:
// { id: 1, firstName: "Rizzrak", lastName: "Saw", profile: { id: 1, ... } }
  • save - Guarda una entidad o un arreglo de entidades. Si la entidad ya existe en la base de datos, se actualiza. Si la entidad aún no existe en la base de datos, se inserta. Guarda todas las entidades dadas en una única transacción (cuando el entity manager no es transaccional). También admite actualizaciones parciales ya que todas las propiedades indefinidas se omiten. Para establecer un valor como NULL, debes configurar manualmente la propiedad igual a null.
await manager.save(user)
await manager.save([category1, category2, category3])
  • remove - Elimina una entidad o un arreglo de entidades. Elimina todas las entidades dadas en una única transacción (cuando el entity manager no es transaccional).
await manager.remove(user)
await manager.remove([category1, category2, category3])
  • insert - Inserta una nueva entidad o un arreglo de entidades.
await manager.insert(User, {
    firstName: "Timber",
    lastName: "Timber",
})

await manager.insert(User, [
    {
        firstName: "Foo",
        lastName: "Bar",
    },
    {
        firstName: "Rizz",
        lastName: "Rak",
    },
])
  • update - Actualiza entidades por ID de entidad, IDs, condiciones dadas o un arreglo de objetos de condición. Establece campos desde una entidad parcial proporcionada.
await manager.update(User, { age: 18 }, { category: "ADULT" })
// executes UPDATE user SET category = ADULT WHERE age = 18

await manager.update(User, 1, { firstName: "Rizzrak" })
// executes UPDATE user SET firstName = Rizzrak WHERE id = 1

// Bulk updates with different conditions for each operation
await manager.update(User, [
    { criteria: { id: 1 }, data: { firstName: "Rizzrak" } },
    { criteria: { id: 2 }, data: { firstName: "Karzzir" } },
    { criteria: { age: 18 }, data: { category: "ADULT" } },
])
// executes three separate UPDATE queries:
// UPDATE user SET firstName = Rizzrak WHERE id = 1
// UPDATE user SET firstName = Karzzir WHERE id = 2
// UPDATE user SET category = ADULT WHERE age = 18

Puedes pasar un arreglo de objetos de condición para que coincida con múltiples conjuntos distintos de filas en una sola llamada (las condiciones se combinan con OR):

await manager.update(User, [{ status: "expired" }, { flagged: true }], {
    active: false,
})
// executes UPDATE user SET active = false WHERE status = 'expired' OR flagged = true
  • updateAll - Actualiza todas las entidades del tipo objetivo (sin cláusula WHERE). Establece campos desde una entidad parcial proporcionada.
await manager.updateAll(User, { category: "ADULT" })
// executes UPDATE user SET category = ADULT
  • upsert - Inserta una nueva entidad o arreglo de entidades a menos que ya existan, en cuyo caso se actualizan. Compatible con AuroraDataApi, Cockroach, Mysql, Postgres y Sqlite.

Cuando una operación upsert resulta en actualización (debido a conflicto), columnas especiales como @UpdateDateColumn y @VersionColumn se actualizan automáticamente a sus valores actuales.

Las columnas marcadas con update: false o definidas como columnas generadas computadas (a través de asExpression/generatedType) nunca se incluyen en el conjunto de actualización durante conflictos. Si todas las columnas no conflictivas son excluidas por estas reglas (es decir, no hay columnas actualizables), el upsert se degrada a una operación de insertar-o-ignorar y la fila existente permanece completamente sin cambios. En bases de datos que admiten objetivos de conflicto (ej. PostgreSQL, CockroachDB), esto se limita a las columnas de conflicto especificadas; en bases de datos de la familia MySQL, se usa INSERT IGNORE que se aplica a todas las restricciones únicas.

await manager.upsert(
    User,
    [
        { externalId: "abc123", firstName: "Rizzrak" },
        { externalId: "bca321", firstName: "Karzzir" },
    ],
    ["externalId"],
)
/** executes
 *  INSERT INTO user
 *  VALUES
 *      (externalId = abc123, firstName = Rizzrak),
 *      (externalId = cba321, firstName = Karzzir),
 *  ON CONFLICT (externalId) DO UPDATE firstName = EXCLUDED.firstName
 **/
  • delete - Elimina entidades por ID de entidad, IDs, condiciones dadas o un arreglo de objetos de condición.
await manager.delete(User, 1)
await manager.delete(User, [1, 2, 3])
await manager.delete(User, { firstName: "Timber" })

// Bulk deletes with different conditions for each operation
await manager.delete(User, [{ firstName: "Timber" }, { age: 18 }, { id: 42 }])
// executes three separate DELETE queries:
// DELETE FROM user WHERE firstName = Timber
// DELETE FROM user WHERE age = 18
// DELETE FROM user WHERE id = 42

Puedes pasar un arreglo de objetos de condición para que coincida con múltiples conjuntos distintos de filas en una sola llamada (las condiciones se combinan con OR). Esto difiere de pasar un arreglo primitivo, que se interpreta como una lista de IDs:

// Primitive array — interpreted as WHERE id IN (1, 2, 3)
await manager.delete(User, [1, 2, 3])

// Object array — each element is a separate condition (OR'd together)
await manager.delete(User, [{ id: 1 }, { email: "old@example.com" }])
// executes DELETE FROM user WHERE id = 1 OR email = 'old@example.com'

Nota: pasar un objeto vacío {} o [{}] lanza un TypeORMError para prevenir eliminaciones accidentales de tablas completas.

  • deleteAll - Elimina todas las entidades del tipo objetivo (sin cláusula WHERE).
await manager.deleteAll(User)
// executes DELETE FROM user

Consulta también el método clear, que realiza una operación TRUNCATE TABLE en la base de datos.

  • increment - Incrementa una columna en el valor proporcionado para entidades que coinciden con las opciones dadas.
await manager.increment(User, { firstName: "Timber" }, "age", 3)
  • decrement - Decrementa una columna en el valor proporcionado para entidades que coinciden con las opciones dadas.
await manager.decrement(User, { firstName: "Timber" }, "age", 3)
  • exists - Verifica si existe alguna entidad que coincida con FindOptions.
const exists = await manager.exists(User, {
    where: {
        firstName: "Timber",
    },
})
  • existsBy - Verifica si existe alguna entidad que coincida con FindOptionsWhere.
const exists = await manager.existsBy(User, { firstName: "Timber" })
  • count - Cuenta las entidades que coinciden con FindOptions. Útil para paginación.
const count = await manager.count(User, {
    where: {
        firstName: "Timber",
    },
})
  • countBy - Cuenta las entidades que coinciden con FindOptionsWhere. Útil para paginación.
const count = await manager.countBy(User, { firstName: "Timber" })
  • find - Busca entidades que coincidan con FindOptions.
const timbers = await manager.find(User, {
    where: {
        firstName: "Timber",
    },
})
  • findBy - Busca entidades que coincidan con FindWhereOptions.
const timbers = await manager.findBy(User, {
    firstName: "Timber",
})
  • findAndCount - Busca entidades que coincidan con FindOptions. También cuenta todas las entidades que coinciden con las condiciones dadas, ignorando la configuración de paginación (opciones from y take).
const [timbers, timbersCount] = await manager.findAndCount(User, {
    where: {
        firstName: "Timber",
    },
})
  • findAndCountBy - Encuentra entidades que coinciden con las opciones FindOptionsWhere. También cuenta todas las entidades que cumplen las condiciones dadas, ignorando la paginación (opciones from y take).
const [timbers, timbersCount] = await manager.findAndCountBy(User, {
    firstName: "Timber",
})
  • findOne - Encuentra la primera entidad que coincide con las opciones FindOptions.
const timber = await manager.findOne(User, {
    where: {
        firstName: "Timber",
    },
})
  • findOneBy - Encuentra la primera entidad que coincide con las opciones FindOptionsWhere.
const timber = await manager.findOneBy(User, { firstName: "Timber" })
  • findOneOrFail - Encuentra la primera entidad que coincide con algún ID u opciones de búsqueda. Rechaza la promesa devuelta si no se encuentra ninguna coincidencia.
const timber = await manager.findOneOrFail(User, {
    where: {
        firstName: "Timber",
    },
})
  • findOneByOrFail - Encuentra la primera entidad que coincide con las opciones FindOptions. Rechaza la promesa devuelta si no se encuentra ninguna coincidencia.
const timber = await manager.findOneByOrFail(User, { firstName: "Timber" })
  • clear - Limpia todos los datos de (trunca) la tabla dada. Soporta la opción cascade para también limpiar todos los datos de las tablas que tienen claves foráneas a esta tabla (soportada únicamente por PostgreSQL/CockroachDB y Oracle; otras bases de datos lanzarán un error si la opción cascade se establece en true).
await manager.clear(User)

// With cascade option (PostgreSQL/CockroachDB and Oracle only)
await manager.clear(User, { cascade: true })
  • getRepository - Obtiene un Repository para operar sobre una entidad específica. Más información sobre Repositorios.
const userRepository = manager.getRepository(User)
  • getTreeRepository - Obtiene un TreeRepository para operar sobre una entidad con estructura arbórea. Más información sobre Repositorios.
const categoryRepository = manager.getTreeRepository(Category)
  • getMongoRepository - Obtiene un MongoRepository para operar sobre una entidad MongoDB. Más información sobre MongoDB.
const userRepository = manager.getMongoRepository(User)
  • withRepository - Obtiene una instancia de repositorio personalizado usado en transacciones. Más información sobre Repositorios personalizados.
const myUserRepository = manager.withRepository(UserRepository)
  • release - Libera el query runner asociado al EntityManager. Se usa solo cuando el query runner fue creado y gestionado manualmente.
await manager.release()