--- title: "Référence d'API — @nodefony/orm-core — interfaces" source: docs/api/orm-core/interfaces.md url: https://nodefony.github.io/nodefony-core/docs/api/orm-core/interfaces/ --- [Documentation](../../../) › [Référence d'API](../../) › [`@nodefony/orm-core`](../) › interfaces > Générée depuis les déclarations de types publiées de `@nodefony/orm-core` **10.0.0-beta.5** : exactement ce que reçoit une application qui l'installe. Cette page n'existe dans aucun dépôt — pour la corriger, on corrige le TSDoc du code. ## `@nodefony/orm-core` `import { … } from "@nodefony/orm-core"` — 43 symboles. ### Fonctions (1) #### `isMigrationFailure` ```ts function isMigrationFailure(reply: IOrmMigrationReply | IOrmMigrationPlanReply | IOrmMigrationApplyReply): reply is IOrmMigrationFailure ``` Y a-t-il un empêchement plutôt qu'un état ? ### Interfaces (35) #### `FieldOperators` ```ts interface FieldOperators ``` Opérateurs de comparaison riches applicables à **un** champ, façon MongoDB. - `$eq?: V` — Égalité stricte (équivalent à passer la valeur nue). - `$ne?: V` — Différent de. - `$gt?: V` — Strictement supérieur à. - `$gte?: V` — Supérieur ou égal à. - `$lt?: V` — Strictement inférieur à. - `$lte?: V` — Inférieur ou égal à. - `$in?: readonly V[]` — Appartient à l'ensemble. - `$nin?: readonly V[]` — N'appartient pas à l'ensemble. - `$like?: string` — Motif SQL `LIKE` (`%`/`_`) — pertinent pour les champs texte uniquement. - `$null?: boolean` — Teste l'**absence de valeur** : `true` → `IS NULL`, `false` → `IS NOT NULL` (Mongo : `$eq`/`$ne null`, qui couvre aussi le champ absent). #### `IColumnInfo` ```ts interface IColumnInfo ``` Colonne/champ normalisé d'une entité (extrait via `IOrm.describeEntity`). - `name: string` — Nom de la colonne. - `type: string` — Type natif tel que rapporté par le driver (ex. - `primaryKey: boolean` — `true` si clé primaire. - `nullable: boolean` — `true` si la colonne accepte `NULL`. - `unique: boolean` — `true` si contrainte d'unicité. #### `IConnectionError` ```ts interface IConnectionError ``` Erreur de connexion horodatée (message **redacté** — jamais de credential). - `message: string` — Message d'erreur (driver), credential déjà retiré. - `ts: number` — Horodatage epoch ms. #### `IConnectionEvent` ```ts interface IConnectionEvent ``` Un événement de vie de la connexion : une PERTE ou une REPRISE, constatée par l'adapter (événement du driver) ou par le battement de cœur. - `kind: "lost" | "restored"` — `lost` : la base a cessé de répondre ; `restored` : elle répond à nouveau. - `ts: number` — Horodatage epoch ms. - `reason?: string` — Cause de la perte (credential déjà retiré) — absente pour une reprise. #### `IConnectionHealth` ```ts interface IConnectionHealth ``` Diagnostic d'un connecteur — réponse de `/nodefony/orm/api/connection/health`. Combine l'état figé (`IConnectionInfo`), les compteurs de cycle de vie (connexions, **reconnexions**, **erreurs**) du moniteur, et un **ping live** (round-trip réel mesuré à la requête). - `instanceId: string` — Identité de l'**instance** (process) qui rapporte — cloud-native : le diagnostic est per-pod (pool DB local au process). - `name: string` — Clé du connecteur. - `vendor: string` — Vendor ORM (`drizzle`, `mongoose`…). - `driver: string` — Base/driver (`sqlite`, `mongodb`…). - `target?: string` — Cible lisible (chemin relatif / host:port), jamais de credential. - `version?: string` — Version moteur. - `ormVersion?: string` — Version lib ORM. - `connected: boolean` — État courant (`isConnected`). - `connectedSince: number | null` — Connecté depuis (epoch ms), `null` si jamais connecté. - `uptimeMs: number | null` — Durée depuis la dernière connexion réussie (ms), `null` si jamais. - `connectCount: number` — Nombre total de connexions réussies. - `reconnectCount: number` — Reprises CONSTATÉES après une perte (jamais déduites des connexions). - `lostCount: number` — Pertes constatées depuis le démarrage du process. - `lastLostAt: number | null` — Dernière perte (epoch ms), `null` si aucune. - `lastRestoredAt: number | null` — Dernière reprise (epoch ms), `null` si aucune. - `events: IConnectionEvent[]` — Pertes et reprises récentes (ring borné, plus récentes d'abord). - `resilience?: IOrmResilience` — Mécanisme de détection et de reprise, si l'ORM le décrit. - `errorCount: number` — Nombre total d'erreurs enregistrées (connexion + ping). - `lastError: IConnectionError | null` — Dernière erreur, `null` si aucune. - `recentErrors: IConnectionError[]` — Erreurs récentes (ring borné, plus récentes d'abord). - `lastConnectMs: number | null` — Latence de la dernière connexion réussie (ms), `null` si inconnue. - `pingMs: number | null` — Latence du ping live (ms), `null` si non pingable / déconnecté. - `pingOk: boolean` — `true` si le ping live a réussi. - `pingError: string | null` — Message d'erreur du ping live, `null` si OK. - `latency: ILatencyWindow` — Fenêtre glissante de latence (min/moy/max sur les N derniers pings). - `storage?: IOrmStorageProbe` — Sonde de stockage (driver), si l'adapter l'expose. - `pool?: IOrmPoolProbe` — Sonde de pool de connexions (driver), si l'adapter l'expose. - `extra?: Record` — Métriques driver libres (clé→valeur). #### `IConnectionInfo` ```ts interface IConnectionInfo ``` Connexion sous-jacente d'un ORM (extrait via `IOrm.describeConnection`). - `driver: string` — Base/driver sous-jacent en minuscules (`sqlite`, `postgres`, `mysql`, `mariadb`, `mongodb`…) — sert à choisir le logo et qualifier le connecteur. - `target?: string` — Cible lisible : chemin du fichier (SQLite, **relatif** — jamais d'absolu), `host:port/base` (serveur) ou URI redactée. - `version?: string` — Version du moteur/base (ex. - `ormVersion?: string` — Version de la lib ORM elle-même (ex. #### `IEntity` ```ts interface IEntity ``` - `readonly name: string` — Nom logique de l'entité (clé de lookup, ex. - `readonly connector: string` — Connexion nommée cible, telle que déclarée en config (ex. - `readonly module?: string` — Module Nodefony propriétaire de l'entité (ex. - `readonly domain?: string` — **Classification** de l'entité (ex. - `readonly schema: S` — Définition de schéma propre au driver (forme libre). - `model?: M` — Modèle compilé natif, renseigné après connexion de l'ORM. - `readonly timestamps?: boolean` — Active la gestion **automatique** des horodatages `createdAt`/`updatedAt` par l'adapter qui la supporte nativement (Mongoose `timestamps: true`). - `readonly relations?: ReadonlyArray` — Relations déclarées vers d'autres entités (par nom logique). - `readonly indexes?: ReadonlyArray` — Index composites, appliqués par l'adapter qui les exprime hors schéma (Mongoose `schema.index()`). #### `IEntityGraphNode` ```ts interface IEntityGraphNode ``` Nœud du graphe : une entité avec ses colonnes et ses relations. - `name: string` — Nom logique de l'entité. - `connector: string` — Connexion nommée qui porte l'entité (clé de `connectors` en config). - `module: string` — Module Nodefony propriétaire (regroupement ERD), `""` si non rattaché. - `domain: string` — Classification (domaine fonctionnel) — axe de regroupement ERD distinct du `module`, `""` si non renseigné. - `columns: IColumnInfo[]` — Colonnes normalisées (vide si l'adapter n'implémente pas `describeEntity`). - `relations: IRelationInfo[]` — Relations déclarées. #### `IEntityIndex` ```ts interface IEntityIndex ``` Index COMPOSITE déclaré par une entité, pour l'adapter qui ne sait pas l'exprimer dans son schéma (Mongoose : un `SchemaDefinition` plat n'a d'index que par champ). - `readonly fields: Readonly>` — Champs et sens, dans l'ORDRE de l'index (`1` croissant, `-1` décroissant). - `readonly unique?: boolean` — Contrainte d'unicité sur la combinaison. - `readonly name?: string` — Nom de l'index en base (sinon celui que le driver dérive des champs). #### `IEntityRelation` ```ts interface IEntityRelation ``` Relation déclarative entre deux entités, indépendante du driver ORM. - `readonly type: "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many"` — Cardinalité de la relation. - `readonly target: string` — Nom logique de l'entité cible (clé de lookup dans le registre). - `readonly field: string` — Champ portant la relation côté entité courante. - `readonly foreignKey?: string` — Clé étrangère explicite. #### `ILatencyWindow` ```ts interface ILatencyWindow ``` Fenêtre glissante de latence de ping — `min`/`avg`/`max` sur les N derniers échantillons (révèle les pics, pas seulement l'instantané). `null` tant qu'aucun ping n'a été mesuré. - `last: number | null` — Dernière latence mesurée (ms). - `min: number | null` — Minimum sur la fenêtre (ms). - `avg: number | null` — Moyenne sur la fenêtre (ms). - `max: number | null` — Maximum sur la fenêtre (ms). - `samples: number` — Nombre d'échantillons dans la fenêtre. #### `IOrm` ```ts interface IOrm ``` Contrat d'une instance ORM gérée par le framework (une par connexion logique). - `readonly name: string` — Nom unique de l'instance dans le registre (clé `OrmRegistry.get`). - `connect(): Promise` — Établit la connexion sous-jacente et compile les entités enregistrées. - `disconnect(): Promise` — Ferme proprement la connexion et libère le pool. - `isConnected(): boolean` — Indique si la connexion est actuellement active. - `getRepository(name: string): IRepository` — Retourne le repository typé d'une entité enregistrée. - `transaction(work: (tx: ITransaction) => Promise): Promise` — Exécute un travail dans une transaction : commit si résolu, rollback si rejeté. - `getNativeConnection(): C` — Expose la connexion native du driver (trappe SQL/commandes brutes). - `describeEntity?(name: string): IColumnInfo[]` — Décrit les colonnes normalisées d'une entité pour le graphe canonique (data plane ORM / ERD / contexte IA). - `describeConnection?(): IConnectionInfo` — Décrit la connexion sous-jacente (driver + cible lisible) pour le data plane ORM / dashboard. - `describeResilience?(): IOrmResilience` — Décrit le mécanisme de résilience tel qu'il tourne (battement, perte en souffrance) pour le data plane. - `ping?(): Promise` — Ping bas-coût de la connexion (round-trip réel vers la base) pour le diagnostic du data plane. - `probe?(): Promise` — Sonde profonde driver-spécifique (stockage, pool…) pour le contrôle total des ORM via le hub temps réel. - `migrationStatus?(): Promise` — État des migrations de ce connecteur — **capacité optionnelle**, et son ABSENCE est une réponse. - `migrationPlan?(): Promise` — Ce qui S'APPLIQUERAIT, avec son SQL — **capacité optionnelle**, lecture seule. - `applyMigrations?(): Promise` — Applique les migrations en attente — **capacité optionnelle, et ÉCRIVANTE**. #### `IOrmFlowReport` ```ts interface IOrmFlowReport ``` Rapport de flux complet — un par instance (cloud-native : per-process). Le débit/s n'y figure pas (dérivé du delta de `total` entre deux `ts`). - `enabled: boolean` — La sonde est-elle active ? - `ts: number` — Horodatage du rapport (ms epoch) — sert au calcul du débit (Δts). - `instanceId: string` — Identifiant de l'instance (pid, ou `NF_INSTANCE_ID`). - `slowMs: number` — Seuil « lent » courant (ms) — au-delà, la requête est capturée. - `connectors: IQueryFlow[]` — Flux par connecteur ORM enregistré. #### `IOrmGraph` ```ts interface IOrmGraph ``` Graphe complet du modèle de données — réponse de `/nodefony/orm/api/graph`. - `orms: IOrmSummary[]` — ORMs/connecteurs enregistrés. - `entities: IEntityGraphNode[]` — Entités (colonnes + relations), éventuellement filtrées par ORM. #### `IOrmMigrationAction` ```ts interface IOrmMigrationAction ``` Une commande à taper, telle que le produit la propose. - `command: string` — La ligne complète, prête à copier. - `args: string[]` — Ses arguments, pour qui l'exécute au lieu de l'afficher. #### `IOrmMigrationApplied` ```ts interface IOrmMigrationApplied ``` Ce qu'une application a fait — ou l'empêchement qui l'a arrêtée. - `formatVersion: number` - `connector: string` - `runId: string` — Identifiant du passage — groupe les migrations d'un même déploiement. - `applied: { source: string; tag: string; executionMs: number; }[]` — Ce qui a été appliqué, dans l'ordre. #### `IOrmMigrationEntry` ```ts interface IOrmMigrationEntry ``` Une migration, telle que l'historique et les fichiers la décrivent. - `tag: string` — Identifiant immuable une fois publié. - `status: string` — Où en est cette migration pour CE connecteur. - `runId?: string` — Déploiement qui l'a portée — groupe les migrations d'un même passage. - `appliedAt?: number` — Quand elle a été appliquée — absent tant qu'elle ne l'est pas. - `appliedBy?: string` — Ce qui l'a appliquée, tel que l'historique l'a retenu. - `durationMs?: number` — Durée d'application, en millisecondes. - `error?: string` — Motif de l'échec, quand elle a échoué. #### `IOrmMigrationFailure` ```ts interface IOrmMigrationFailure ``` Ce qu'un ORM répond quand il ne PEUT pas rendre d'état. - `formatVersion: number` - `connector: string` - `error: { code: string; summary: string; meaning: string; nextActions: IOrmMigrationAction[]; }` #### `IOrmMigrationPlan` ```ts interface IOrmMigrationPlan ``` Ce qui S'APPLIQUERAIT — le plan, avec son SQL. - `formatVersion: number` - `connector: string` - `pending: IOrmPendingMigration[]` #### `IOrmMigrationSource` ```ts interface IOrmMigrationSource ``` Les migrations d'une origine — le framework, l'application, un module. - `name: string` — Nom de l'origine, tel qu'il s'affiche. - `applied: number` — Combien sont passées. - `pending: number` — Combien restent à appliquer. - `failed: number` — Combien ont échoué. - `entries: IOrmMigrationEntry[]` — Ses migrations, dans l'ordre d'application. #### `IOrmMigrationStatus` ```ts interface IOrmMigrationStatus ``` L'état complet, cœur neutre — la charge utile de l'écran et de `--json`. - `formatVersion: number` — Version du format, pour qu'un lecteur sache ce qu'il lit — un ENTIER, qui ne s'incrémente que sur une rupture. - `connector: string` — Connecteur observé. - `verdict: string` — Situation d'ensemble (`ok`, `pending`, `divergent`, `failed`…). - `summary: string` — Le fait constaté, en une phrase. - `nextActions: IOrmMigrationAction[]` — Ce qu'il faut faire, du plus direct au plus assumé. - `sources: IOrmMigrationSource[]` — Une origine par entrée. - `driver: { kind: string; [key: string]: unknown; }` — Tout ce qui est propre au pilote, et rien d'autre ailleurs. #### `IOrmPendingMigration` ```ts interface IOrmPendingMigration ``` Une migration en attente, avec le SQL qu'elle exécuterait. - `source: string` — Origine — le framework, l'application, un module. - `tag: string` — Identité immuable une fois publiée. - `statements: string[]` — Les instructions, dans l'ordre d'exécution. #### `IOrmPoolProbe` ```ts interface IOrmPoolProbe ``` Sonde de pool de connexions — pertinente pour les bases serveur (Mongo, Postgres, MySQL). SQLite (better-sqlite3) = mono-connexion → non renseigné. - `size?: number` — Taille max configurée du pool. - `available?: number` — Connexions disponibles (idle). - `borrowed?: number` — Connexions en cours d'utilisation. - `pending?: number` — Demandes en attente d'une connexion. #### `IOrmProbe` ```ts interface IOrmProbe ``` Sonde profonde driver-spécifique retournée par `IOrm.probe`. Tous les champs sont optionnels : un adapter ne rapporte que ce qu'il sait mesurer. - `storage?: IOrmStorageProbe` — Métriques de stockage (taille, pages, journal…). - `pool?: IOrmPoolProbe` — Métriques de pool de connexions (serveurs). - `extra?: Record` — Métriques libres clé→valeur (extensible par adapter, jamais de credential). #### `IOrmResilience` ```ts interface IOrmResilience ``` Le mécanisme de résilience d'un connecteur, TEL QU'IL TOURNE dans ce process. - `heartbeatMs: number` — Période du battement (ms) ; `0` = désactivé (`NF_ORM_HEARTBEAT_MS=0`). - `heartbeatTimeoutMs: number` — Délai au-delà duquel un battement sans réponse vaut une perte (ms). - `heartbeatActive: boolean` — Le battement tourne-t-il en ce moment ? - `pingable: boolean` — L'adapter sait-il répondre à `ping()` (condition du battement) ? - `lostPending: boolean` — Une perte est-elle constatée et PAS ENCORE réparée ? #### `IOrmStorageProbe` ```ts interface IOrmStorageProbe ``` Sonde de stockage — driver-spécifique. Pour SQLite : dérivée des PRAGMA (`page_count`, `page_size`, `journal_mode`, `freelist_count`). Pour un serveur : taille logique de la base si l'adapter sait l'obtenir. - `sizeBytes?: number` — Taille de la base (octets) — `pages × pageSize` (SQLite). - `pages?: number` — Nombre de pages allouées. - `pageSize?: number` — Taille d'une page (octets). - `journalMode?: string` — Mode de journalisation (SQLite : `wal`, `delete`, `memory`…). - `freePages?: number` — Pages libres (fragmentation / espace récupérable au VACUUM). #### `IOrmSummary` ```ts interface IOrmSummary ``` Résumé d'un ORM/connecteur enregistré. - `name: string` — Clé du connecteur dans le `OrmRegistry`. - `vendor: string` — Vendor de l'adapter en minuscules (`drizzle`, `mongoose`…), dérivé du nom de classe. - `default: boolean` — `true` pour le connecteur par défaut : celui qui porte les stores de l'application (un RÔLE constaté, pas le nom `"default"` — repli sur ce nom seulement quand aucun store n'est porté par un ORM). - `connected: boolean` — État de la connexion. - `entityCount: number` — Nombre d'entités rattachées à cet ORM. - `connection?: IConnectionInfo` — Connexion sous-jacente (driver + cible), si l'adapter l'expose. #### `IQueryFlow` ```ts interface IQueryFlow ``` Compteurs de flux d'UN connecteur ORM. Cumuls depuis le boot (le débit/s se dérive du delta de `total`). Latence en deux vues : moyenne sur la vie du process (`avgMs`) et EWMA lissée (`ewmaMs`, suit les variations récentes). - `connector: string` — Connecteur ORM (clé du registre, ex. - `vendor: string` — Vendor de l'adapter (`drizzle`, `mongoose`), `""` si inconnu. - `total: number` — Requêtes mesurées depuis le boot (le débit/s = Δtotal / Δts côté lecteur). - `avgMs: number | null` — Latence moyenne sur la vie du process (ms), `null` si aucune requête. - `ewmaMs: number | null` — Latence EWMA lissée (ms) — suit les variations récentes, `null` si aucune. - `lastMs: number | null` — Dernière latence mesurée (ms), `null` si aucune. - `maxMs: number` — Pire latence observée (ms), `0` si aucune. - `slowTotal: number` — Requêtes classées lentes depuis le boot (≥ seuil). - `slow: ISlowQuery[]` — Ring borné des requêtes lentes récentes (la plus récente en tête). #### `IRelationInfo` ```ts interface IRelationInfo ``` Relation projetée pour le graphe (sous-ensemble sérialisable de `IEntityRelation`). - `type: "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many"` — Cardinalité. - `target: string` — Entité cible (nom logique). - `field: string` — Champ portant la relation côté entité courante. - `foreignKey?: string` — Clé étrangère (explicite ou dérivée déterministe). #### `IRepository` ```ts interface IRepository ``` Contrat CRUD minimal exposé par un repository, indépendant de l'ORM sous-jacent. - `find(criteria?: Criteria, options?: RepositoryReadOptions): Promise` — Retourne toutes les entités correspondant au critère (toutes si omis). - `findOne(criteria: Criteria, options?: RepositoryReadOptions): Promise` — Retourne la première entité correspondant au critère, ou `null`. - `create(data: Partial): Promise` — Persiste une nouvelle entité et retourne sa version persistée (id généré, valeurs par défaut). - `createMany(data: Partial[]): Promise` — Insère **plusieurs** entités en **une seule** requête (`INSERT … VALUES (…),(…)` SQL / `insertMany` Mongo) et retourne leurs versions persistées (ids générés, défauts appliqués), dans l'ordre. - `updateOne(criteria: Criteria, data: Partial): Promise` — Met à jour **au plus une** entité correspondant au critère, de façon **atomique**, et retourne sa version persistée (ou `null` si aucune ne correspond). - `upsert(criteria: Criteria, update: UpdateData, insertOnly?: Partial): Promise` — Insère **ou** met à jour atomiquement l'entité identifiée par `criteria` (clé unique), en **une seule** requête (`INSERT … ON CONFLICT DO UPDATE … RETURNING` SQL / `findOneAndUpdate({ upsert })` Mongo … - `updateMany(criteria: Criteria, data: Partial): Promise` — Met à jour **toutes** les entités correspondant au critère et retourne le **nombre** de lignes modifiées (parité de signature avec `IRepository.delete`). - `increment(criteria: Criteria, changes: Partial>): Promise` — Incrémente **atomiquement** des champs numériques d'**au plus une** entité (`SET f = f + ?` SQL / `$inc` Mongo), sans read-modify-write (donc sans race) — pour les compteurs (stats, usage/tokens, rate … - `delete(criteria: Criteria): Promise` — Supprime les entités correspondant au critère. - `deleteOne(criteria: Criteria): Promise` — Supprime **au plus une** entité de façon **atomique** (symétrique d'`IRepository.updateOne` ; `DELETE … LIMIT 1` SQL / `deleteOne` Mongo). - `findOneAndDelete(criteria: Criteria): Promise` — Supprime **au plus une** entité et **retourne** sa valeur supprimée (ou `null`), de façon atomique (`DELETE … RETURNING` SQL / `findOneAndDelete` Mongo) — claim-and-remove (file de jobs, outbox, pop a … - `count(criteria?: Criteria): Promise` — Compte les entités correspondant au critère (toutes si omis). - `countDistinct(field: keyof T & string, criteria?: Criteria): Promise` — Compte les **valeurs distinctes** d'un champ parmi les entités qui correspondent au critère (`COUNT(DISTINCT col)` SQL / agrégation Mongo). - `exists(criteria: Criteria): Promise` — Indique si **au moins une** entité correspond au critère, sans rapatrier la ligne (`SELECT 1 … LIMIT 1` SQL / `exists` Mongo). - `withTransaction(tx: ITransaction): IRepository` — Retourne une **vue de ce repository liée à une transaction** : toutes ses opérations s'exécutent dans `tx` (commit/rollback gérés par `IOrm.transaction()`). #### `ISlowQuery` ```ts interface ISlowQuery ``` Une requête « lente » capturée (au-delà du seuil). Le SQL est **paramétré** (placeholders, jamais les valeurs) et redacté → 0 credential. Capturé uniquement sur le chemin lent (rare) pour ne rien coûter au cas nominal. - `ts: number` — Horodatage de la requête (ms epoch). - `durationMs: number` — Durée mesurée (ms). - `connector: string` — Connecteur ORM (clé du registre). - `sql?: string` — SQL paramétré et redacté (absent si l'adapter ne sait pas l'extraire). #### `ITransaction` ```ts interface ITransaction ``` Unité de travail transactionnelle abstraite (commit / rollback / savepoint). - `commit(): Promise` — Valide définitivement les opérations de la transaction. - `rollback(): Promise` — Annule toutes les opérations depuis le début de la transaction. - `savepoint(name: string): Promise` — Crée un point de sauvegarde nommé pour un rollback partiel ultérieur. - `rollbackTo(name: string): Promise` — Annule jusqu'à un savepoint sans terminer la transaction. - `getNative(): C` — Expose l'objet transaction natif du driver (trappe bas niveau). #### `PageQuery` ```ts interface PageQuery extends IPageQuery ``` Requête de page pour un `IRepository` — le contrat de page core (`IPageQuery`) enrichi du `criteria` typé de l'ORM. C'est la forme que `paginate` consomme. - `criteria?: Criteria` — Filtre typé optionnel appliqué avant la pagination (toutes les lignes si omis). #### `RepositoryReadOptions` ```ts interface RepositoryReadOptions ``` Options de lecture (`find`/`findOne`) portables cross-ORM. - `relations?: string[]` — Noms logiques des relations déclarées à charger (eager-load). - `limit?: number` — Nombre maximum de lignes. - `offset?: number` — Décalage (pagination). - `order?: Array<[ string, "ASC" | "DESC" ]>` — Tri : couples `[champ, sens]`, ex. #### `UpdateOperators` ```ts interface UpdateOperators ``` Opérateurs d'**écriture** applicables à un champ dans le `update` d'un `IRepository.upsert` — par opposition aux `FieldOperators`, qui filtrent en lecture. - `$max?: V` — Écrit la valeur seulement si elle est **supérieure** à celle en base. - `$min?: V` — Écrit la valeur seulement si elle est **inférieure** à celle en base. ### Types (7) #### `Criteria` ```ts type Criteria = { [K in keyof T]?: FieldCriteria; } & { $or?: ReadonlyArray>; } & OrmCriteria ``` Critère **typé par champ** d'une entité `T`. #### `FieldCriteria` ```ts type FieldCriteria = V | FieldOperators> ``` Valeur de critère pour un champ : soit l'**égalité** directe (valeur nue), soit un objet d'`FieldOperators` riche. #### `IOrmMigrationApplyReply` ```ts type IOrmMigrationApplyReply = IOrmMigrationApplied | IOrmMigrationFailure ``` Le compte rendu d'application, ou l'empêchement. #### `IOrmMigrationPlanReply` ```ts type IOrmMigrationPlanReply = IOrmMigrationPlan | IOrmMigrationFailure ``` Le plan, ou l'empêchement. #### `IOrmMigrationReply` ```ts type IOrmMigrationReply = IOrmMigrationStatus | IOrmMigrationFailure ``` L'état, ou l'empêchement — jamais les deux. #### `OrmCriteria` ```ts type OrmCriteria = Record ``` Critère de filtre brut passé aux opérations d'un repository. #### `UpdateData` ```ts type UpdateData = { [K in keyof T]?: T[K] | UpdateOperators>; } ``` Données d'écriture d'un `IRepository.upsert` : chaque champ accepte soit sa valeur nue (écriture directe), soit un objet d'`UpdateOperators`. --- [← Toutes les références d'API](../../)