Saltar al contenido principal

APIs del Repositorio

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 →

API de Repository​

  • manager - El EntityManager utilizado por este repositorio.
const manager = repository.manager
  • metadata - Los EntityMetadata de la entidad gestionada por este repositorio.
const metadata = repository.metadata
  • queryRunner - El ejecutor de consultas utilizado por EntityManager. Se usa únicamente en instancias transaccionales de EntityManager.
const queryRunner = repository.queryRunner
  • target - La clase de entidad objetivo gestionada por este repositorio. Se usa solo en instancias transaccionales de EntityManager.
const target = repository.target
  • createQueryBuilder - Crea un constructor de consultas para construir consultas SQL. Más información sobre QueryBuilder.
const users = await repository
    .createQueryBuilder("user")
    .where("user.name = :name", { name: "John" })
    .getMany()
  • hasId - Verifica si la propiedad de columna primaria de la entidad dada está definida.
if (repository.hasId(user)) {
    // ... do something
}
  • getId - Obtiene los valores de propiedad de la columna primaria de la entidad dada. Si la entidad tiene claves primarias compuestas, el valor devuelto será un objeto con nombres y valores de las columnas primarias.
const userId = repository.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 = repository.create() // same as const user = new User();
const user = repository.create({
    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()
repository.merge(user, { firstName: "Timber" }, { lastName: "Saw" }) // same as user.firstName = "Timber"; user.lastName = "Saw";

  • preload - Crea una nueva entidad a partir del objeto plano de JavaScript 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 es en realidad una entidad cargada desde la base de datos con todas las propiedades reemplazadas por las del nuevo objeto.

    Nota: El objeto similar a entidad debe tener un id / clave primaria para encontrar la entidad. Devuelve undefined si no se encuentra la entidad con el id dado.

const partialUser = {
    id: 1,
    firstName: "Rizzrak",
    profile: {
        id: 1,
    },
}
const user = await repository.preload(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 array de entidades dada. Si la entidad ya existe en la base de datos, se actualiza. Si no existe, se inserta. Guarda todas las entidades dadas en una sola transacción (si el manager no es transaccional). Soporta actualización parcial ya que se omiten todas las propiedades no definidas. Devuelve la(s) entidad(es) guardada(s).
await repository.save(user)
await repository.save([category1, category2, category3])
  • remove - Elimina una entidad o array de entidades dada. Elimina todas las entidades dadas en una sola transacción (si el manager no es transaccional). Devuelve la(s) entidad(es) eliminada(s).
await repository.remove(user)
await repository.remove([category1, category2, category3])
  • insert - Inserta una nueva entidad o un arreglo de entidades.
await repository.insert({
    firstName: "Timber",
    lastName: "Timber",
})

await repository.insert([
    {
        firstName: "Foo",
        lastName: "Bar",
    },
    {
        firstName: "Rizz",
        lastName: "Rak",
    },
])
  • update - Actualiza entidades por su id, ids o condiciones dadas. Establece campos desde una entidad parcial proporcionada.
await repository.update({ age: 18 }, { category: "ADULT" })
// executes UPDATE user SET category = ADULT WHERE age = 18

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

// optionally request RETURNING / OUTPUT values (supported drivers only)
const result = await repository.update(
    1,
    { firstName: "Rizzrak" },
    { returning: ["id", "firstName"] },
)
console.log(result.raw) // [{ id: 1, firstName: "Rizzrak" }]
  • updateAll - Actualiza todas las entidades del tipo objetivo (sin cláusula WHERE). Establece campos desde una entidad parcial proporcionada.
await repository.updateAll({ category: "ADULT" })
// executes UPDATE user SET category = ADULT

await repository.updateAll(
    { category: "ADULT" },
    { returning: "*" }, // limited to drivers that support returning clauses
)
  • 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.

await repository.upsert(
    [
        { 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
 *  SET firstName = EXCLUDED.firstName,
 *      updatedDate = CURRENT_TIMESTAMP,
 *      version = version + 1
 **/

También puedes solicitar que se devuelvan valores de un upsert (compatible con controladores que admiten RETURNING / OUTPUT):

const { raw } = await repository.upsert(
    { externalId: "abc123", firstName: "Rizzrak" },
    {
        conflictPaths: ["externalId"],
        returning: ["externalId", "firstName"],
    },
)
console.log(raw) // [{ externalId: "abc123", firstName: "Rizzrak" }]
await repository.upsert(
    [
        { externalId: "abc123", firstName: "Rizzrak" },
        { externalId: "bca321", firstName: "Karzzir" },
    ],
    {
        conflictPaths: ["externalId"],
        skipUpdateIfNoValuesChanged: true, // supported by postgres, skips update if it would not change row values
        upsertType: "upsert", //  "on-conflict-do-update" | "on-duplicate-key-update" | "upsert" - optionally provide an UpsertType - 'upsert' is currently only supported by CockroachDB
    },
)
/** executes
 *  INSERT INTO user
 *  VALUES
 *      (externalId = abc123, firstName = Rizzrak),
 *      (externalId = cba321, firstName = Karzzir),
 *  ON CONFLICT (externalId) DO UPDATE
 *  SET firstName = EXCLUDED.firstName
 *  WHERE user.firstName IS DISTINCT FROM EXCLUDED.firstName
 **/
await repository.upsert(
    [
        { externalId: "abc123", firstName: "Rizzrak", dateAdded: "2020-01-01" },
        { externalId: "bca321", firstName: "Karzzir", dateAdded: "2022-01-01" },
    ],
    {
        conflictPaths: ["externalId"],
        skipUpdateIfNoValuesChanged: true, // supported by postgres, skips update if it would not change row values
        indexPredicate: "dateAdded > 2020-01-01", // supported by postgres, allows for partial indexes
    },
)
/** executes
 *  INSERT INTO user
 *  VALUES
 *      (externalId = abc123, firstName = Rizzrak, dateAdded = 2020-01-01),
 *      (externalId = cba321, firstName = Karzzir, dateAdded = 2022-01-01),
 *  ON CONFLICT (externalId) WHERE ( dateAdded > 2021-01-01 ) DO UPDATE
 *  SET firstName = EXCLUDED.firstName,
 *  SET dateAdded = EXCLUDED.dateAdded,
 *  WHERE user.firstName IS DISTINCT FROM EXCLUDED.firstName OR user.dateAdded IS DISTINCT FROM EXCLUDED.dateAdded
 **/
  • delete - Elimina entidades por id de entidad, ids o condiciones dadas:
await repository.delete(1)
await repository.delete([1, 2, 3])
await repository.delete({ firstName: "Timber" })
  • deleteAll - Elimina todas las entidades del tipo objetivo (sin cláusula WHERE).
await repository.deleteAll()
// executes DELETE FROM user

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

  • softDelete y restore - Eliminación suave y restauración de una fila por id, ids o condiciones dadas:
const repository = dataSource.getRepository(Entity)
// Soft delete an entity
await repository.softDelete(1)
// And you can restore it using restore;
await repository.restore(1)
// Soft delete multiple entities
await repository.softDelete([1, 2, 3])
// Or soft delete by other attribute
await repository.softDelete({ firstName: "Jake" })
  • softRemove y recover - Alternativa a softDelete y restore.
// You can soft-delete them using softRemove
const entities = await repository.find()
const entitiesAfterSoftRemove = await repository.softRemove(entities)

// And You can recover them using recover;
await repository.recover(entitiesAfterSoftRemove)
  • increment - Incrementa una columna en el valor proporcionado para entidades que coinciden con las opciones dadas.
await repository.increment({ firstName: "Timber" }, "age", 3)
  • decrement - Decrementa una columna en el valor proporcionado para entidades que coinciden con las opciones dadas.
await repository.decrement({ firstName: "Timber" }, "age", 3)
  • exists - Verifica si existe alguna entidad que coincida con FindOptions.
const exists = await repository.exists({
    where: {
        firstName: "Timber",
    },
})
  • existsBy - Verifica si existe alguna entidad que coincida con FindOptionsWhere.
const exists = await repository.existsBy({ firstName: "Timber" })
  • count - Cuenta las entidades que coinciden con FindOptions. Útil para paginación.
const count = await repository.count({
    where: {
        firstName: "Timber",
    },
})
  • countBy - Cuenta las entidades que coinciden con FindOptionsWhere. Útil para paginación.
const count = await repository.countBy({ firstName: "Timber" })
  • sum - Devuelve la suma de un campo numérico para todas las entidades que coinciden con FindOptionsWhere.
const sum = await repository.sum("age", { firstName: "Timber" })
  • average - Devuelve el promedio de un campo numérico para todas las entidades que coinciden con FindOptionsWhere.
const average = await repository.average("age", { firstName: "Timber" })
  • minimum - Devuelve el valor mínimo de un campo numérico para todas las entidades que coinciden con FindOptionsWhere.
const minimum = await repository.minimum("age", { firstName: "Timber" })
  • maximum - Devuelve el valor máximo de un campo numérico para todas las entidades que coinciden con FindOptionsWhere.
const maximum = await repository.maximum("age", { firstName: "Timber" })
  • find - Busca entidades que coincidan con FindOptions.
const timbers = await repository.find({
    where: {
        firstName: "Timber",
    },
})
  • findBy - Busca entidades que coincidan con FindWhereOptions.
const timbers = await repository.findBy({
    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 repository.findAndCount({
    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 repository.findAndCountBy({
    firstName: "Timber",
})
  • findOne - Encuentra la primera entidad que coincide con las opciones FindOptions.
const timber = await repository.findOne({
    where: {
        firstName: "Timber",
    },
})
  • findOneBy - Encuentra la primera entidad que coincide con las opciones FindOptionsWhere.
const timber = await repository.findOneBy({ 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 repository.findOneOrFail({
    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 repository.findOneByOrFail({ firstName: "Timber" })
  • query - Ejecuta una consulta SQL en bruto.
const rawData = await repository.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 repository.query(
    "SELECT * FROM USERS WHERE name = ? and age = ?",
    ["John", 24],
)

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

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

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

// mssql
const rawData = await repository.query(
    "SELECT * FROM USERS WHERE name = @0 and age = @1",
    ["John", 24],
)
  • clear - Limpia todos los datos de la tabla especificada (la trunca o elimina).
await repository.clear()

Opciones Adicionales​

Se puede pasar SaveOptions opcional como parámetro para save.

  • data - Datos adicionales para pasar con el método persist. Pueden usarse luego en suscriptores.

  • listeners: booleano - Indica si se llaman oyentes y suscriptores para esta operación. Por defecto están habilitados, puedes desactivarlos con { listeners: false } en opciones de save/remove.

  • transaction: booleano - Por defecto las transacciones están habilitadas y todas las consultas se envuelven en transacción. Puedes deshabilitarlo con { transaction: false } en opciones de persistencia.

  • chunk: número - Divide la ejecución de save en grupos de fragmentos. Ejemplo: para guardar 100.000 objetos con problemas, divídelos en 10 grupos de 10.000 (configurando { chunk: 10000 }). Necesario para inserciones masivas con límites de parámetros del controlador.

  • reload: booleano - Determina si la entidad persistida debe recargarse durante la operación. Solo funciona en bases sin soporte RETURNING/OUTPUT. Habilitado por defecto.

Métodos Útiles de QueryRunner​

userRepository.save(users, { chunk: 1000 })

Se puede pasar RemoveOptions opcional como parámetro para remove y delete.

  • data - Datos adicionales para pasar con el método remove. Pueden usarse luego en suscriptores.

  • listeners: booleano - Indica si se llaman oyentes y suscriptores para esta operación. Por defecto están habilitados, puedes desactivarlos con { listeners: false } en opciones de save/remove.

  • transaction: booleano - Por defecto las transacciones están habilitadas y todas las consultas se envuelven en transacción. Puedes deshabilitarlo con { transaction: false } en opciones de persistencia.

  • chunk: número - Divide la ejecución de remove en grupos de fragmentos. Ejemplo: para eliminar 100.000 objetos con problemas, divídelos en 10 grupos de 10.000 (configurando { chunk: 10000 }). Necesario para eliminaciones masivas con límites de parámetros del controlador.

Métodos Útiles de QueryRunner​

userRepository.remove(users, { chunk: 1000 })

API de TreeRepository​

Para la API de TreeRepository, consulta la documentación de Entidades en Árbol.

API de MongoRepository​

Para la API de MongoRepository, consulta la documentación de MongoDB.