Vai al contenuto principale

API dei Repository

Traduzione Beta Non Ufficiale

Questa pagina è stata tradotta da PageTurner AI (beta). Non ufficialmente approvata dal progetto. Hai trovato un errore? Segnala problema →

API Repository​

  • manager - L'EntityManager utilizzato da questo repository.
const manager = repository.manager
  • metadata - I metadati EntityMetadata dell'entità gestita da questo repository.
const metadata = repository.metadata
  • queryRunner - Il query runner utilizzato da EntityManager. Usato solo nelle istanze transazionali di EntityManager.
const queryRunner = repository.queryRunner
  • target - La classe di entità target gestita da questo repository. Usato solo nelle istanze transazionali di EntityManager.
const target = repository.target
  • createQueryBuilder - Crea un query builder utilizzato per costruire query SQL. Scopri di più sul QueryBuilder.
const users = await repository
    .createQueryBuilder("user")
    .where("user.name = :name", { name: "John" })
    .getMany()
  • hasId - Verifica se la proprietà della colonna primaria dell'entità specificata è definita.
if (repository.hasId(user)) {
    // ... do something
}
  • getId - Ottiene i valori delle proprietà della colonna primaria dell'entità specificata. Se l'entità ha chiavi primarie composite, il valore restituito sarà un oggetto con nomi e valori delle colonne primarie.
const userId = repository.getId(user) // userId === 1
  • create - Crea una nuova istanza di User. Accetta opzionalmente un oggetto con proprietà utente che verranno scritte nel nuovo oggetto utente.
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 - Combina più entità in una singola entità.
const user = new User()
repository.merge(user, { firstName: "Timber" }, { lastName: "Saw" }) // same as user.firstName = "Timber"; user.lastName = "Saw";

  • preload - Crea una nuova entità dall'oggetto JavaScript plain specificato. Se l'entità esiste già nel database, la carica (e tutto ciò che è correlato), sostituisce tutti i valori con quelli nuovi dall'oggetto fornito, e restituisce la nuova entità. La nuova entità è in realtà un'entità caricata dal database con tutte le proprietà sostituite dal nuovo oggetto.

    Nota: l'oggetto simile a un'entità deve avere un id/primary key per trovare l'entità. Restituisce undefined se non viene trovata nessuna entità con l'id specificato.

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 - Salva una singola entità o un array di entità. Se l'entità esiste già nel database, viene aggiornata. Se l'entità non esiste nel database, viene inserita. Salva tutte le entità specificate in una singola transazione (nel caso di entità singola, il manager non è transazionale). Supporta anche l'aggiornamento parziale poiché tutte le proprietà undefined vengono saltate. Restituisce l'entità/le entità salvate.
await repository.save(user)
await repository.save([category1, category2, category3])
  • remove - Rimuove una singola entità o un array di entità. Rimuove tutte le entità specificate in una singola transazione (nel caso di entità singola, il manager non è transazionale). Restituisce l'entità/le entità rimosse.
await repository.remove(user)
await repository.remove([category1, category2, category3])
  • insert - Inserisce una nuova entità o un array di entità.
await repository.insert({
    firstName: "Timber",
    lastName: "Timber",
})

await repository.insert([
    {
        firstName: "Foo",
        lastName: "Bar",
    },
    {
        firstName: "Rizz",
        lastName: "Rak",
    },
])
  • update - Aggiorna entità per id entità, ids o condizioni specificate. Imposta i campi dall'entità parziale fornita.
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 - Aggiorna tutte le entità del tipo target (senza clausola WHERE). Imposta i campi dall'entità parziale fornita.
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 - Inserisce una nuova entità o array di entità a meno che non esistano già, nel qual caso vengono invece aggiornate. Supportato dai driver AuroraDataApi, Cockroach, Mysql, Postgres e Sqlite.

Quando un'operazione upsert risulta in un aggiornamento (a causa di un conflitto), colonne speciali come @UpdateDateColumn e @VersionColumn vengono automaticamente aggiornate ai valori correnti.

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
 **/

Si può anche richiedere che i valori vengano restituiti da un'operazione upsert (supportato dai driver con 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 entità tramite id entità, ids o condizioni specificate:
await repository.delete(1)
await repository.delete([1, 2, 3])
await repository.delete({ firstName: "Timber" })
  • deleteAll - Elimina tutte le entità del tipo target (senza clausola WHERE).
await repository.deleteAll()
// executes DELETE FROM user

Vedi anche il metodo clear, che esegue un'operazione TRUNCATE TABLE sul database.

  • softDelete e restore - Eliminazione soft e ripristino di una riga tramite id, ids o condizioni specificate:
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 e recover - Alternativa a softDelete e 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 colonna di un valore fornito per le entità che corrispondono alle opzioni specificate.
await repository.increment({ firstName: "Timber" }, "age", 3)
  • decrement - Decrementa una colonna di un valore fornito per le entità che corrispondono alle opzioni specificate.
await repository.decrement({ firstName: "Timber" }, "age", 3)
  • exists - Verifica se esiste almeno un'entità che corrisponde alle FindOptions.
const exists = await repository.exists({
    where: {
        firstName: "Timber",
    },
})
  • existsBy - Verifica se esiste almeno un'entità che corrisponde a FindOptionsWhere.
const exists = await repository.existsBy({ firstName: "Timber" })
  • count - Conta le entità che corrispondono a FindOptions. Utile per l'impaginazione.
const count = await repository.count({
    where: {
        firstName: "Timber",
    },
})
  • countBy - Conta le entità che corrispondono a FindOptionsWhere. Utile per l'impaginazione.
const count = await repository.countBy({ firstName: "Timber" })
  • sum - Restituisce la somma di un campo numerico per tutte le entità che corrispondono alle FindOptionsWhere.
const sum = await repository.sum("age", { firstName: "Timber" })
  • average - Restituisce la media di un campo numerico per tutte le entità che corrispondono a FindOptionsWhere.
const average = await repository.average("age", { firstName: "Timber" })
  • minimum - Restituisce il valore minimo di un campo numerico per tutte le entità che corrispondono a FindOptionsWhere.
const minimum = await repository.minimum("age", { firstName: "Timber" })
  • maximum - Restituisce il valore massimo di un campo numerico per tutte le entità che corrispondono a FindOptionsWhere.
const maximum = await repository.maximum("age", { firstName: "Timber" })
  • find - Trova le entità che corrispondono alle FindOptions specificate.
const timbers = await repository.find({
    where: {
        firstName: "Timber",
    },
})
  • findBy - Trova le entità che corrispondono alle FindWhereOptions specificate.
const timbers = await repository.findBy({
    firstName: "Timber",
})
  • findAndCount - Trova le entità che corrispondono alle FindOptions specificate. Conta inoltre tutte le entità che corrispondono alle condizioni fornite, ignorando le impostazioni di impaginazione (opzioni from e take).
const [timbers, timbersCount] = await repository.findAndCount({
    where: {
        firstName: "Timber",
    },
})
  • findAndCountBy - Trova le entità che corrispondono a FindOptionsWhere specificate. Conta anche tutte le entità che corrispondono alle condizioni date, ignorando le impostazioni di paginazione (opzioni from e take).
const [timbers, timbersCount] = await repository.findAndCountBy({
    firstName: "Timber",
})
  • findOne - Trova la prima entità che corrisponde alle FindOptions specificate.
const timber = await repository.findOne({
    where: {
        firstName: "Timber",
    },
})
  • findOneBy - Trova la prima entità che corrisponde alle FindOptionsWhere specificate.
const timber = await repository.findOneBy({ firstName: "Timber" })
  • findOneOrFail - Trova la prima entità che corrisponde a un ID o opzioni di ricerca. Respinge la promise restituita se non viene trovata alcuna corrispondenza.
const timber = await repository.findOneOrFail({
    where: {
        firstName: "Timber",
    },
})
  • findOneByOrFail - Trova la prima entità che corrisponde alle FindOptions specificate. Respinge la promise restituita se non viene trovata alcuna corrispondenza.
const timber = await repository.findOneByOrFail({ firstName: "Timber" })
  • query - Esegue una query SQL raw.
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 - Svuota tutti i dati dalla tabella specificata (la tronca o elimina).
await repository.clear()

Opzioni Aggiuntive​

Le SaveOptions opzionali possono essere passate come parametro per save.

  • data - Dati aggiuntivi da passare con il metodo persist. Possono essere utilizzati nei subscriber.

  • listeners: boolean - Indica se i listener e i subscriber devono essere chiamati per questa operazione. Abilitati di default, possono essere disattivati con { listeners: false } nelle opzioni save/remove.

  • transaction: boolean - Di default le transazioni sono abilitate e tutte le query vengono raggruppate in transazioni. Disattivabile con { transaction: false } nelle opzioni di persistenza.

  • chunk: number - Suddivide l'operazione di salvataggio in gruppi di dimensione specificata. Esempio: per salvare 100.000 oggetti problematici, impostare { chunk: 10000 } per processarli in 10 gruppi da 10.000. Utile per superare limiti di parametri nei driver.

  • reload: boolean - Determina se l'entità persistita debba essere ricaricata durante l'operazione. Funziona solo su database senza supporto RETURNING/OUTPUT. Abilitato di default.

Esempio:

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

Le RemoveOptions opzionali possono essere passate come parametro per remove e delete.

  • data - Dati aggiuntivi da passare con il metodo remove. Possono essere utilizzati nei subscriber.

  • listeners: boolean - Indica se i listener e i subscriber devono essere chiamati per questa operazione. Abilitati di default, possono essere disattivati con { listeners: false } nelle opzioni save/remove.

  • transaction: boolean - Di default le transazioni sono abilitate e tutte le query vengono raggruppate in transazioni. Disattivabile con { transaction: false } nelle opzioni di persistenza.

  • chunk: number - Suddivide l'operazione di rimozione in gruppi di dimensione specificata. Esempio: per eliminare 100.000 oggetti problematici, impostare { chunk: 10000 } per processarli in 10 gruppi da 10.000. Utile per superare limiti di parametri nei driver.

Esempio:

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

API TreeRepository​

Per l'API TreeRepository consultare la documentazione sulle entità ad albero.

API MongoRepository​

Per l'API MongoRepository consultare la documentazione MongoDB.