Référence d'API — @nodefony/orm-core — interfaces

stable

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#

function isMigrationFailure(reply: IOrmMigrationReply | IOrmMigrationPlanReply | IOrmMigrationApplyReply): reply is IOrmMigrationFailure

Y a-t-il un empêchement plutôt qu’un état ?

Interfaces (35)#

FieldOperators#

interface FieldOperators<V>

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#

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#

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#

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#

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<string, string | number | boolean> — Métriques driver libres (clé→valeur).

IConnectionInfo#

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#

interface IEntity<S = unknown, M = unknown>

• 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<IEntityRelation> — Relations déclarées vers d’autres entités (par nom logique).
• readonly indexes?: ReadonlyArray<IEntityIndex> — Index composites, appliqués par l’adapter qui les exprime hors schéma (Mongoose schema.index()).

IEntityGraphNode#

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#

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<Record<string, 1 | -1>> — 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#

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#

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#

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<void> — Établit la connexion sous-jacente et compile les entités enregistrées.
• disconnect(): Promise<void> — Ferme proprement la connexion et libère le pool.
• isConnected(): boolean — Indique si la connexion est actuellement active.
• getRepository<T = unknown>(name: string): IRepository<T> — Retourne le repository typé d’une entité enregistrée.
• transaction<R>(work: (tx: ITransaction) => Promise<R>): Promise<R> — Exécute un travail dans une transaction : commit si résolu, rollback si rejeté.
• getNativeConnection<C = unknown>(): 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<void> — Ping bas-coût de la connexion (round-trip réel vers la base) pour le diagnostic du data plane.
• probe?(): Promise<IOrmProbe> — Sonde profonde driver-spécifique (stockage, pool…) pour le contrôle total des ORM via le hub temps réel.
• migrationStatus?(): Promise<IOrmMigrationReply> — État des migrations de ce connecteur — capacité optionnelle, et son ABSENCE est une réponse.
• migrationPlan?(): Promise<IOrmMigrationPlanReply> — Ce qui S’APPLIQUERAIT, avec son SQL — capacité optionnelle, lecture seule.
• applyMigrations?(): Promise<IOrmMigrationApplyReply> — Applique les migrations en attente — capacité optionnelle, et ÉCRIVANTE.

IOrmFlowReport#

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#

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#

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#

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#

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#

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#

interface IOrmMigrationPlan

Ce qui S’APPLIQUERAIT — le plan, avec son SQL.

• formatVersion: number
• connector: string
• pending: IOrmPendingMigration[]

IOrmMigrationSource#

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#

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#

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#

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#

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<string, string | number | boolean> — Métriques libres clé→valeur (extensible par adapter, jamais de credential).

IOrmResilience#

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#

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#

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#

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#

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#

interface IRepository<T = unknown>

Contrat CRUD minimal exposé par un repository, indépendant de l’ORM sous-jacent.

• find(criteria?: Criteria<T>, options?: RepositoryReadOptions): Promise<T[]> — Retourne toutes les entités correspondant au critère (toutes si omis).
• findOne(criteria: Criteria<T>, options?: RepositoryReadOptions): Promise<T | null> — Retourne la première entité correspondant au critère, ou null.
• create(data: Partial<T>): Promise<T> — Persiste une nouvelle entité et retourne sa version persistée (id généré, valeurs par défaut).
• createMany(data: Partial<T>[]): Promise<T[]> — 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<T>, data: Partial<T>): Promise<T | null> — 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<T>, update: UpdateData<T>, insertOnly?: Partial<T>): Promise<T> — 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<T>, data: Partial<T>): Promise<number> — 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<T>, changes: Partial<Record<keyof T, number>>): Promise<T | null> — 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<T>): Promise<number> — Supprime les entités correspondant au critère.
• deleteOne(criteria: Criteria<T>): Promise<boolean> — Supprime au plus une entité de façon atomique (symétrique d’IRepository.updateOne ; DELETE … LIMIT 1 SQL / deleteOne Mongo).
• findOneAndDelete(criteria: Criteria<T>): Promise<T | null> — 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<T>): Promise<number> — Compte les entités correspondant au critère (toutes si omis).
• countDistinct(field: keyof T & string, criteria?: Criteria<T>): Promise<number> — 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<T>): Promise<boolean> — 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<T> — 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#

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#

interface ITransaction

Unité de travail transactionnelle abstraite (commit / rollback / savepoint).

• commit(): Promise<void> — Valide définitivement les opérations de la transaction.
• rollback(): Promise<void> — Annule toutes les opérations depuis le début de la transaction.
• savepoint(name: string): Promise<void> — Crée un point de sauvegarde nommé pour un rollback partiel ultérieur.
• rollbackTo(name: string): Promise<void> — Annule jusqu’à un savepoint sans terminer la transaction.
• getNative<C = unknown>(): C — Expose l’objet transaction natif du driver (trappe bas niveau).

PageQuery#

interface PageQuery<T = unknown> 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<T> — Filtre typé optionnel appliqué avant la pagination (toutes les lignes si omis).

RepositoryReadOptions#

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#

interface UpdateOperators<V>

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#

type Criteria<T> = { [K in keyof T]?: FieldCriteria<T[K]>; } & { $or?: ReadonlyArray<Criteria<T>>; } & OrmCriteria

Critère typé par champ d’une entité T.

FieldCriteria#

type FieldCriteria<V> = V | FieldOperators<NonNullable<V>>

Valeur de critère pour un champ : soit l’égalité directe (valeur nue), soit un objet d’FieldOperators riche.

IOrmMigrationApplyReply#

type IOrmMigrationApplyReply = IOrmMigrationApplied | IOrmMigrationFailure

Le compte rendu d’application, ou l’empêchement.

IOrmMigrationPlanReply#

type IOrmMigrationPlanReply = IOrmMigrationPlan | IOrmMigrationFailure

Le plan, ou l’empêchement.

IOrmMigrationReply#

type IOrmMigrationReply = IOrmMigrationStatus | IOrmMigrationFailure

L’état, ou l’empêchement — jamais les deux.

OrmCriteria#

type OrmCriteria = Record<string, unknown>

Critère de filtre brut passé aux opérations d’un repository.

UpdateData#

type UpdateData<T> = { [K in keyof T]?: T[K] | UpdateOperators<NonNullable<T[K]>>; }

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