---
title: "Référence d'API — @nodefony/drizzle — entity"
source: docs/api/drizzle/entity.md
url: https://nodefony.github.io/nodefony-core/docs/api/drizzle/entity/
---


[Documentation](../../../) › [Référence d'API](../../) › [`@nodefony/drizzle`](../) › entity

> Générée depuis les déclarations de types publiées de `@nodefony/drizzle` **10.0.0-beta.6** : 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/drizzle`

`import { … } from "@nodefony/drizzle"` — 97 symboles.

### Classes (1)

#### `ColumnValueError`

```ts
class ColumnValueError extends Error
```

Valeur qu'une colonne du kit REFUSE avant la base — là où PostgreSQL la refuserait lui-même (`22P02`).

- `readonly name = "ColumnValueError"`
- `readonly kind: ColumnValueKind` — Genre de la colonne.
- `readonly value: string` — Valeur refusée, telle que reçue.
- `readonly column: string` — `table.colonne`.
- `constructor(kind: ColumnValueKind, value: string, column: string, message: string)`

### Fonctions (22)

#### `assertTableSpec`

```ts
function assertTableSpec(spec: ITableSpec): void
```

Refuse une spec que le kit fabriquerait mal — à la DÉCLARATION, donc au chargement du module, plutôt qu'au premier DDL.

#### `canonicalIntegerKey`

```ts
function canonicalIntegerKey(value: unknown, label: string): number
```

Rend la valeur d'une clé ENTIÈRE (`serial`, ou référence vers une clé `serial`) sous la forme d'un nombre, ou la refuse comme PostgreSQL le ferait.

#### `columnName`

```ts
function columnName(key: string, column: ColumnSpec): string
```

Nom en base d'une colonne : son nom stocké s'il est déclaré, sinon sa propriété.

#### `createAuditEntities`

```ts
function createAuditEntities(connector: string, dialect?: SqlDialect): IEntity[]
```

Construit les descripteurs d'entités du journal d'audit pour un ORM nommé.

#### `createIdempotencyEntities`

```ts
function createIdempotencyEntities(connector: string, dialect?: SqlDialect): IEntity[]
```

Construit le descripteur d'entité du store d'idempotence pour un ORM nommé.

#### `createSessionEntity`

```ts
function createSessionEntity(connector: string, dialect?: SqlDialect): IEntity[]
```

Construit le descripteur d'entité session pour un ORM nommé.

#### `createTokenEntities`

```ts
function createTokenEntities(connector: string, dialect?: SqlDialect): IEntity[]
```

Construit les descripteurs d'entités du store de jetons pour un ORM nommé.

#### `createTotpSecretEntity`

```ts
function createTotpSecretEntity(connector: string, dialect?: SqlDialect): IEntity
```

Construit le descripteur d'entité du store de secrets TOTP pour un ORM nommé. Le `connector` est **dynamique** (nom du connecteur de l'app) et la variante de table suit le dialecte du connecteur (auto-register `registerStores.ts`). À enregistrer **avant** `orm.connect()`. `module: "security"` → regroupé sous

#### `createUserEntity`

```ts
function createUserEntity(connector: string, dialect?: SqlDialect): IEntity
```

Construit le descripteur d'entité `User` Drizzle pour un ORM nommé.

#### `createWebAuthnCredentialEntity`

```ts
function createWebAuthnCredentialEntity(connector: string, dialect?: SqlDialect): IEntity
```

Construit le descripteur d'entité du store de credentials pour un ORM nommé.

#### `createWebhookEndpointEntity`

```ts
function createWebhookEndpointEntity(connector: string, dialect?: SqlDialect): IEntity
```

Construit le descripteur d'entité du store webhook pour un ORM nommé.

#### `defineTable`

```ts
function defineTable<const S extends ITableSpec>(spec: S): IPortableTable<S>
```

Déclare une table PORTABLE : une spec logique, une table Drizzle par dialecte, construite au premier usage puis mémoïsée (le DDL, le registre d'entités et les stores voient le même objet).

#### `isPortableTable`

```ts
function isPortableTable(target: ITableDescription): target is IPortableTableBase
```

La description visée par une référence sait-elle fabriquer sa table Drizzle ? Une `ref` vise une description NEUTRE (`ITableDescription`) ; l'adaptateur exige une table déclarée par `defineTable`.

#### `jsonType`

```ts
function jsonType<T>(): IJsonType<T>
```

Déclare la forme d'une colonne JSON dans une spec.

#### `registerAuditEntities`

```ts
function registerAuditEntities(connector: string, dialect?: SqlDialect): void
```

Enregistre les entités du journal d'audit dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (l'adapter crée les tables au connect).

#### `registerIdempotencyEntities`

```ts
function registerIdempotencyEntities(connector: string, dialect?: SqlDialect): void
```

Enregistre l'entité du store d'idempotence dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).

#### `registerSessionEntity`

```ts
function registerSessionEntity(connector: string, dialect?: SqlDialect): void
```

Enregistre l'entité session dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).

#### `registerTokenEntities`

```ts
function registerTokenEntities(connector: string, dialect?: SqlDialect): void
```

Enregistre les entités du store de jetons dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (l'adapter crée les tables au connect).

#### `registerTotpSecretEntity`

```ts
function registerTotpSecretEntity(connector: string, dialect?: SqlDialect): void
```

Enregistre l'entité du store de secrets TOTP dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).

#### `registerUserEntity`

```ts
function registerUserEntity(connector: string, dialect?: SqlDialect): void
```

Enregistre l'entité `User` Drizzle dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (l'adapter compile/crée les tables au connect).

#### `registerWebAuthnCredentialEntity`

```ts
function registerWebAuthnCredentialEntity(connector: string, dialect?: SqlDialect): void
```

Enregistre l'entité du store de credentials dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).

#### `registerWebhookEndpointEntity`

```ts
function registerWebhookEndpointEntity(connector: string, dialect?: SqlDialect): void
```

Enregistre l'entité du store webhook dans le `entityRegistry` pour un ORM donné. À appeler **avant** `orm.connect()` (l'adapter crée la table au connect).

### Constantes (29)

#### `AUDIT_ENTITY_NAMES`

```ts
const AUDIT_ENTITY_NAMES: { readonly events: "audit_event"; }
```

Noms logiques des entités du store (clés de lookup `getRepository`).

#### `IDEMPOTENCY_ENTITY_NAME`

```ts
const IDEMPOTENCY_ENTITY_NAME: "idempotency_key"
```

Nom logique de l'entité (clé de lookup `getRepository` / `entityRegistry`).

#### `SESSION_CONNECTOR`

```ts
const SESSION_CONNECTOR = "default"
```

ORM cible du stockage de session (connecteur par défaut du module).

#### `SESSION_ENTITY_NAME`

```ts
const SESSION_ENTITY_NAME = "session"
```

Nom logique de l'entité (clé de lookup `getRepository` / `entityRegistry`).

#### `TOKEN_ENTITY_NAMES`

```ts
const TOKEN_ENTITY_NAMES: { readonly records: "access_token"; readonly denied: "denied_jti"; readonly revocations: "subject_revocation"; }
```

Noms logiques des entités du store (clés de lookup `getRepository`).

#### `TOTP_SECRET_ENTITY`

```ts
const TOTP_SECRET_ENTITY = "totp_secret"
```

Nom logique de l'entité (clé de lookup `getRepository`).

#### `WEBAUTHN_CREDENTIAL_ENTITY`

```ts
const WEBAUTHN_CREDENTIAL_ENTITY = "webauthn_credential"
```

Nom logique de l'entité (clé de lookup `getRepository`).

#### `WEBHOOK_ENDPOINT_ENTITY`

```ts
const WEBHOOK_ENDPOINT_ENTITY = "webhook_endpoint"
```

Nom logique de l'entité (clé de lookup `getRepository`).

#### `accessTokenTable`

```ts
const accessTokenTable: SQLiteTable
```

Variantes SQLite des trois tables (dialecte par défaut) — exports conservés pour l'usage direct/banc-test.

#### `auditEventTable`

```ts
const auditEventTable: SQLiteTable
```

Variante SQLite de la table (dialecte par défaut) — export conservé pour l'usage direct/banc-test.

#### `createAccessTokenTable`

```ts
const createAccessTokenTable: import("./colKit").ITableFactory<{ readonly name: "access_token"; readonly columns: { readonly id: { readonly kind: "text"; readonly primaryKey: true; }; readonly kind: { readonly kind: "text"; readonly notNull: true; }; readonly name: { readonly kind: "text"; readonly notNull: true; }; readonly prefix: { readonly kind: "text"; }; readonly subjectId: { readonly kind: …
```

Factory de la table des records (mémoïsée — une instance par dialecte).

#### `createAuditEventTable`

```ts
const createAuditEventTable: import("./colKit").ITableFactory<{ readonly name: "audit_event"; readonly columns: { readonly id: { readonly kind: "text"; readonly primaryKey: true; }; readonly ts: { readonly kind: "int64"; readonly notNull: true; }; readonly category: { readonly kind: "text"; readonly notNull: true; }; readonly action: { readonly kind: "text"; readonly notNull: true; }; readonly out …
```

Factory de la table du journal (mémoïsée — une instance par dialecte).

#### `createDeniedJtiTable`

```ts
const createDeniedJtiTable: import("./colKit").ITableFactory<{ readonly name: "denied_jti"; readonly columns: { readonly jti: { readonly kind: "text"; readonly primaryKey: true; }; readonly expiresAt: { readonly kind: "int64"; readonly notNull: true; }; }; }>
```

Factory de la denylist `jti` (mémoïsée — une instance par dialecte).

#### `createIdempotencyTable`

```ts
const createIdempotencyTable: import("./colKit").ITableFactory<{ readonly name: "idempotency_key"; readonly columns: { readonly key: { readonly kind: "text"; readonly primaryKey: true; }; readonly fingerprint: { readonly kind: "text"; readonly notNull: true; }; readonly state: { readonly kind: "enum"; readonly values: readonly [ "if", "done" ]; readonly notNull: true; }; readonly response: { reado …
```

Factory de la table d'idempotence pour un dialecte donné — **premier maillon du chantier portabilité multi-dialecte** (un schéma logique → la table Drizzle du bon dialecte), migrée du switch manuel 2 tables vers le colKit (S4 : la variante mysql sort du kit). Le `DrizzleOrm` l'appelle selon `connector.dialect`.

#### `createSessionTable`

```ts
const createSessionTable: import("./colKit").ITableFactory<{ readonly name: "session"; readonly columns: { readonly session_id: { readonly kind: "text"; readonly primaryKey: true; }; readonly Attributes: { readonly kind: "json"; }; readonly flashBag: { readonly kind: "json"; }; readonly metaBag: { readonly kind: "json"; }; readonly user: { readonly kind: "text"; }; readonly createdAt: { readonly k …
```

Factory de la table de session pour un dialecte donné (mémoïsée — une instance par dialecte). `sqlite` (défaut) et `postgres` sont portés ; `mysql` jette (S4).

#### `createSubjectRevocationTable`

```ts
const createSubjectRevocationTable: import("./colKit").ITableFactory<{ readonly name: "subject_revocation"; readonly columns: { readonly subjectId: { readonly kind: "text"; readonly primaryKey: true; }; readonly invalidBefore: { readonly kind: "int64"; readonly notNull: true; }; }; }>
```

Factory des seuils de révocation (mémoïsée — une instance par dialecte).

#### `createTotpSecretTable`

```ts
const createTotpSecretTable: import("./colKit").ITableFactory<{ readonly name: "totp_secret"; readonly columns: { readonly userId: { readonly kind: "text"; readonly primaryKey: true; }; readonly secretEnc: { readonly kind: "text"; readonly notNull: true; }; readonly algorithm: { readonly kind: "text"; readonly notNull: true; }; readonly digits: { readonly kind: "int"; readonly notNull: true; }; re …
```

Factory de la table de secrets TOTP pour un dialecte donné (mémoïsée — une instance par dialecte). **Les trois dialectes sont portés** (`TOTP_PORTED = ALL_DIALECTS`, `registerStores.ts:92`) : sqlite, postgres et mysql.

#### `createUserTable`

```ts
const createUserTable: UserTableFactory
```

#### `createWebAuthnCredentialTable`

```ts
const createWebAuthnCredentialTable: import("./colKit").ITableFactory<{ readonly name: "webauthn_credential"; readonly columns: { readonly id: { readonly kind: "text"; readonly primaryKey: true; }; readonly userId: { readonly kind: "text"; readonly notNull: true; }; readonly publicKey: { readonly kind: "text"; readonly notNull: true; }; readonly signCount: { readonly kind: "int64"; readonly notNul …
```

Factory de la table de credentials pour un dialecte donné (mémoïsée — une instance par dialecte). `sqlite` (défaut) et `postgres` sont portés ; `mysql` jette (S4).

#### `createWebhookEndpointTable`

```ts
const createWebhookEndpointTable: import("./colKit").ITableFactory<{ readonly name: "webhook_endpoint"; readonly columns: { readonly id: { readonly kind: "text"; readonly primaryKey: true; }; readonly url: { readonly kind: "text"; readonly notNull: true; }; readonly secretEnc: { readonly kind: "text"; readonly notNull: true; }; readonly events: { readonly kind: "json"; readonly notNull: true; read …
```

Factory de la table des endpoints (mémoïsée — une instance par dialecte).

#### `deniedJtiTable`

```ts
const deniedJtiTable: SQLiteTable
```

#### `idempotencyKeyTable`

```ts
const idempotencyKeyTable: SQLiteTable
```

Variante SQLite mémoïsée (dialecte par défaut) — export statique de compat (bancs, typage du store `DrizzleIdempotencyStore`).

#### `portableUserTable`

```ts
const portableUserTable: IPortableUserTable
```

Description PORTABLE de la table `User` — le `schema` de l'entité `User` d'une application, et la cible de ses références (`{ kind: "ref", target: () => userTable }`).

#### `sessionTable`

```ts
const sessionTable: SQLiteTable
```

Variante SQLite de la table de session (dialecte par défaut) — export conservé pour l'usage direct/banc-test.

#### `subjectRevocationTable`

```ts
const subjectRevocationTable: SQLiteTable
```

#### `totpSecretTable`

```ts
const totpSecretTable: SQLiteTable
```

Variante SQLite de la table de secrets TOTP (dialecte par défaut) — export conservé pour l'usage direct/banc-test.

#### `userTable`

```ts
const userTable: SQLiteTable<import("drizzle-orm/sqlite-core").TableConfig> & { readonly id: AnySQLiteColumn; }
```

Variante SQLite de la table `User` (dialecte par défaut) — export conservé pour l'usage direct/banc-test (ex. module mediasoup).

#### `webAuthnCredentialTable`

```ts
const webAuthnCredentialTable: SQLiteTable
```

Variante SQLite de la table de credentials (dialecte par défaut) — export conservé pour l'usage direct/banc-test.

#### `webhookEndpointTable`

```ts
const webhookEndpointTable: SQLiteTable
```

Variante SQLite de la table (dialecte par défaut) — export conservé pour l'usage direct/banc-test.

### Interfaces (38)

#### `AuditEventRow`

```ts
interface AuditEventRow
```

Forme plate d'une ligne du journal d'audit. Miroir d'`IAuditEvent` avec les champs optionnels rendus explicitement `| null` (colonnes NULLABLE SQL). Le store mappe `null` ↔ `undefined` aux frontières.

- `id: string`
- `ts: number`
- `category: AuditCategory`
- `action: string`
- `outcome: AuditOutcome`
- `actor: string | null`
- `resource: string | null`
- `reason: string | null`
- `ip: string | null`
- `userAgent: string | null`
- `requestId: string | null`
- `flags: IAuditEventFlags | null`
- `metadata: Record<string, unknown> | null`

#### `DeniedJtiRow`

```ts
interface DeniedJtiRow
```

Forme plate d'une ligne de la denylist `jti`.

- `jti: string`
- `expiresAt: number`

#### `IBoolColumn`

```ts
interface IBoolColumn extends IValueColumnMods<boolean>
```

Booléen.

- `readonly kind: "bool"`

#### `ICharColumn`

```ts
interface ICharColumn extends IKeyColumnMods<string>
```

Chaîne de longueur EXACTE `n` — `char(n)` + `CHECK` de longueur, partout.

- `readonly kind: "char"`
- `readonly length: number`

#### `IColumnMods`

```ts
interface IColumnMods<TData> extends IStoredName
```

Modificateurs communs ; `TData` borne un défaut au type de la colonne.

- `readonly notNull?: true` — La colonne refuse `NULL`.
- `readonly unique?: true` — Contrainte d'unicité de colonne.
- `readonly defaultFn?: () => TData` — Défaut calculé en JavaScript à l'insertion (jamais de `DEFAULT` SQL).
- `readonly default?: TData` — Valeur par défaut LITTÉRALE — posée deux fois, et chaque pose couvre ce que l'autre ne peut pas : un `DEFAULT` SQL dans la migration (seul à remplir les lignes existantes quand la colonne est AJOUTÉE …
- `readonly onUpdateFn?: () => TData` — Valeur recalculée à chaque `UPDATE` (pendant SQL d'`updatedAt`).

#### `IDateColumn`

```ts
interface IDateColumn extends IValueColumnMods<string>
```

Jour calendaire SANS heure ni fuseau — rendu `"YYYY-MM-DD"` partout.

- `readonly kind: "date"`

#### `IDatetimeColumn`

```ts
interface IDatetimeColumn extends IValueColumnMods<Date>
```

Instant (UTC, précision milliseconde) — rendu `Date` partout.

- `readonly kind: "datetime"`

#### `IDecimalColumn`

```ts
interface IDecimalColumn extends IValueColumnMods<string>
```

Décimal exact, rendu en chaîne (`"12.50"`) — `numeric(p,s)` / `decimal(p,s)`.

- `readonly kind: "decimal"`
- `readonly precision: number` — Nombre total de chiffres (1 à 65).
- `readonly scale: number` — Chiffres après la virgule (0 à 30, au plus `precision`).

#### `IEnumColumn`

```ts
interface IEnumColumn<V extends readonly [ string, ...string[] ] = readonly [ string, ...string[] ]> extends IValueColumnMods<V[number]>
```

Valeurs énumérées, bornées en base par un `CHECK` (pas seulement au type).

- `readonly kind: "enum"`
- `readonly values: V` — Valeurs admises (64 caractères au plus chacune).

#### `IFloatColumn`

```ts
interface IFloatColumn extends IValueColumnMods<number>
```

Flottant IEEE 754 double précision.

- `readonly kind: "float"`

#### `IIndexSpec`

```ts
interface IIndexSpec
```

Index déclaratif — émis par le DDL dérivé (dev) et par drizzle-kit (prod).

- `readonly name: string`
- `readonly on: readonly [ string, ...string[] ]` — Noms de colonnes de la spec (validés à la déclaration).
- `readonly unique?: true`

#### `IInt64Column`

```ts
interface IInt64Column extends IValueColumnMods<number>
```

Entier 64 bits, exact jusqu'à 2⁵³−1 — compteurs, horodatages epoch ms.

- `readonly kind: "int64"`

#### `IIntColumn`

```ts
interface IIntColumn extends IValueColumnMods<number>
```

Entier 32 bits signé — réservé aux valeurs bornées par le domaine.

- `readonly kind: "int"`

#### `IJsonColumn`

```ts
interface IJsonColumn<T = unknown> extends IValueColumnMods<T>
```

JSON — `type: jsonType<T>()` pour une forme connue, sinon `unknown`.

- `readonly kind: "json"`
- `readonly type?: IJsonType<T>`

#### `IJsonType`

```ts
interface IJsonType<T>
```

Marqueur du type d'une colonne JSON : `T` est FANTÔME (l'objet est vide à l'exécution). C'est la seule façon de porter un type dans un littéral de spec sans perdre les modificateurs littéraux (`notNull: true`) qu'un helper `json<T>(mods)` effacerait de son type de retour.

- `readonly __type?: T`

#### `IKeyColumnMods`

```ts
interface IKeyColumnMods<TData> extends IColumnMods<TData>
```

Modificateurs d'une colonne qui peut être CLÉ PRIMAIRE (chaîne ou uuid).

- `readonly primaryKey?: true` — Clé primaire de la table — une seule par spec.

#### `IPortableTable`

```ts
interface IPortableTable<S extends ITableSpec> extends IPortableTableBase
```

Ce que rend `defineTable` : la spec et la fabrique par dialecte.

- `readonly spec: S`
- `readonly table: ITableFactory<S>`

#### `IPortableTableBase`

```ts
interface IPortableTableBase
```

Vue LARGE d'une table portable — ce qu'une référence (`ref`) accepte pour cible, et ce qu'un consommateur qui ne connaît pas la spec manipule.

- `readonly spec: ITableSpec`
- `readonly table: ITableFactoryBase`

#### `IPortableUserTable`

```ts
interface IPortableUserTable extends IPortableTableBase
```

Description portable de `User` : la spec vue par sa clé, la fabrique par dialecte.

- `readonly spec: IUserKeySpec`
- `readonly table: UserTableFactory`

#### `IRefColumn`

```ts
interface IRefColumn extends IStoredName
```

Clé étrangère — la colonne prend le type de la clé primaire VISÉE.

- `readonly kind: "ref"`
- `readonly primaryKey?: never`
- `readonly target: "self" | () => ITableDescription`
- `readonly notNull?: true`
- `readonly unique?: true`
- `readonly onDelete?: OnDeleteAction`

#### `ISerialColumn`

```ts
interface ISerialColumn extends IStoredName
```

Clé primaire entière auto-incrémentée — `serial` PostgreSQL.

- `readonly kind: "serial"`
- `readonly primaryKey: true`

#### `IStoredName`

```ts
interface IStoredName
```

Nom STOCKÉ d'une colonne, quand il diffère de la propriété.

- `readonly column?: string` — Nom en base (identifiant SQL simple) ; défaut : la propriété.

#### `IStringColumn`

```ts
interface IStringColumn extends IKeyColumnMods<string>
```

Chaîne bornée — `varchar(n)` ; en SQLite, la borne est un `CHECK`.

- `readonly kind: "string"`
- `readonly length?: number` — Longueur maximale en caractères (défaut 255).

#### `ITableDescription`

```ts
interface ITableDescription
```

Ce qu'une référence (`ref`) vise : une description de table, quel que soit l'adaptateur qui la fabriquera. Le type précis de la cible est retrouvé par `infer` sur `spec`.

- `readonly spec: ITableSpec`

#### `ITableFactory`

```ts
interface ITableFactory<S extends ITableSpec>
```

Fabrique de table par dialecte, typée par la spec.

- `(dialect: "sqlite"): SqliteTableOf<S>`
- `(dialect: "postgres"): PgTableOf<S>`
- `(dialect: "mysql"): MySqlTableOf<S>`
- `(dialect: SqlDialect): SqliteTableOf<S> | PgTableOf<S> | MySqlTableOf<S>`

#### `ITableFactoryBase`

```ts
interface ITableFactoryBase
```

Fabrique de table par dialecte, vue LARGE.

- `(dialect: "sqlite"): SQLiteTable`
- `(dialect: "postgres"): PgTable`
- `(dialect: "mysql"): MySqlTable`
- `(dialect: SqlDialect): SQLiteTable | PgTable | MySqlTable`

#### `ITableSpec`

```ts
interface ITableSpec
```

Spec logique d'une table.

- `readonly name: string`
- `readonly columns: Readonly<Record<string, ColumnSpec>>`
- `readonly indexes?: readonly IIndexSpec[]`

#### `ITextColumn`

```ts
interface ITextColumn extends IKeyColumnMods<string>
```

Texte non borné — `varchar(512)` en MySQL s'il est indexé (InnoDB).

- `readonly kind: "text"`

#### `IUserKeySpec`

```ts
interface IUserKeySpec extends ITableSpec
```

Spec de `User` telle qu'une RÉFÉRENCE la voit : sa clé, un `text`.

- `readonly columns: { readonly id: { readonly kind: "text"; readonly primaryKey: true; }; }`

#### `IUuidColumn`

```ts
interface IUuidColumn extends IKeyColumnMods<string>
```

UUID, rendu en minuscules canoniques — `uuid` natif PostgreSQL.

- `readonly kind: "uuid"`

#### `IValueColumnMods`

```ts
interface IValueColumnMods<TData> extends IColumnMods<TData>
```

Modificateurs d'une colonne de VALEUR — jamais clé primaire : une clé est une chaîne, un uuid ou un `serial` (une clé entière non auto-incrémentée diverge entre moteurs — SQLite en fait un alias de `rowid` qu'il remplit seul).

- `readonly primaryKey?: never`

#### `IVectorColumn`

```ts
interface IVectorColumn extends IValueColumnMods<number[]>
```

Vecteur pgvector — PostgreSQL seulement, refusé ailleurs en le nommant.

- `readonly kind: "vector"`
- `readonly dimensions: number`

#### `IdempotencyKeyRow`

```ts
interface IdempotencyKeyRow
```

Forme plate d'une ligne du store d'idempotence (telle que renvoyée par le repository / `SELECT`). Identique aux colonnes de `idempotencyKeyTable` → zéro mapping store ↔ entité.

- `key: string`
- `fingerprint: string`
- `state: "if" | "done"`
- `response: IdempotentResponse | null`
- `expiresAt: number`

#### `SessionRow`

```ts
interface SessionRow
```

Forme plate d'une ligne de session telle que renvoyée par le repository.

- `session_id: string`
- `Attributes: unknown`
- `flashBag: unknown`
- `metaBag: unknown`
- `user: string | null`
- `createdAt: number`
- `updatedAt: number`

#### `SubjectRevocationRow`

```ts
interface SubjectRevocationRow
```

Forme plate d'une ligne de révocation par porteur.

- `subjectId: string`
- `invalidBefore: number`

#### `TotpSecretRow`

```ts
interface TotpSecretRow
```

Forme **plate** d'une ligne de secret renvoyée par le repository ORM. Structure identique à `ITotpSecret` (tout `| null` déjà présent côté contrat) → mapping quasi-identité dans `DrizzleTotpSecretStore` (≠ `webAuthnCredentialEntity` qui a un `nickname?` à normaliser).

- `userId: string`
- `secretEnc: string`
- `algorithm: TotpAlgorithm`
- `digits: number`
- `period: number`
- `recoveryCodes: string[]`
- `confirmedAt: number | null`
- `lastUsedStep: number | null`
- `createdAt: number`
- `lastUsedAt: number | null`

#### `WebAuthnCredentialRow`

```ts
interface WebAuthnCredentialRow
```

Forme **plate** d'une ligne de credentials renvoyée par le repository ORM — `nickname: string | null` (≠ `nickname?: string` du contrat) et `transports` mutable. `DrizzleWebAuthnCredentialStore` mappe `Row ↔ IWebAuthnCredential`.

- `id: string`
- `userId: string`
- `publicKey: string`
- `signCount: number`
- `transports: string[]`
- `backupEligible: boolean`
- `backupState: boolean`
- `uvInitialized: boolean`
- `nickname: string | null`
- `createdAt: number`
- `lastUsedAt: number | null`

#### `WebhookEndpointRow`

```ts
interface WebhookEndpointRow
```

Forme **plate** d'une ligne d'endpoint renvoyée par le repository ORM — `events` mutable (le contrat porte `readonly string[]`). Tous les autres champs sont identiques à `IWebhookEndpoint` (déjà « plat tout `| null` »). `DrizzleWebhookStore` mappe `Row ↔ IWebhookEndpoint`.

- `id: string`
- `url: string`
- `secretEnc: string`
- `events: string[]`
- `enabled: boolean`
- `description: string | null`
- `tenantId: string | null`
- `createdBy: string | null`
- `createdAt: number`
- `updatedAt: number`
- `lastDeliveryAt: number | null`
- `lastDeliveryStatus: number | null`
- `lastDeliveryError: string | null`
- `failureCount: number`
- `metadata: Record<string, unknown>`

### Types (7)

#### `ColumnKind`

```ts
type ColumnKind = ColumnSpec["kind"]
```

Genre logique d'une colonne.

#### `ColumnSpec`

```ts
type ColumnSpec = IStringColumn | ICharColumn | ITextColumn | IIntColumn | IInt64Column | ISerialColumn | IFloatColumn | IDecimalColumn | IBoolColumn | IJsonColumn | IDateColumn | IDatetimeColumn | IUuidColumn | IEnumColumn | IVectorColumn | IRefColumn
```

Spec logique d'une colonne.

#### `ColumnValueKind`

```ts
type ColumnValueKind = "decimal" | "uuid" | "date" | "integer"
```

Genre de colonne dont un codec refuse la valeur.

#### `DataOf`

```ts
type DataOf<S extends ITableSpec, C extends ColumnSpec> = C extends { kind: "json"; } ? C extends { type: IJsonType<infer T>; } ? T : unknown : C extends IEnumColumn<infer V> ? V[number] : C extends IRefColumn ? RefTargetKey<S, C> extends infer P extends ColumnSpec ? DataOf<RefTargetSpec<S, C>, P> : never : C extends { kind: "string" | "char" | "text" | "decimal" | "date" | "uuid"; } ? string : C …
```

Type JavaScript rendu à la LECTURE pour une colonne — identique sur les trois dialectes.

#### `InsertOf`

```ts
type InsertOf<S extends ITableSpec> = IsWideSpec<S> extends true ? Record<string, unknown> : Simplify<{ -readonly [K in keyof S["columns"] as OptionalOnInsert<S["columns"][K]> extends true ? never : K]: DataOf<S, S["columns"][K]>; } & { -readonly [K in keyof S["columns"] as OptionalOnInsert<S["columns"][K]> extends true ? K : never]?: DataOf<S, S["columns"][K]> | (IsNullable<S["columns"][K]> exten …
```

Données d'insertion — égales à `$inferInsert` des trois tables.

#### `OnDeleteAction`

```ts
type OnDeleteAction = "restrict" | "cascade" | "set null" | "no action"
```

Action d'une clé étrangère à la suppression de la ligne visée.

#### `RowOf`

```ts
type RowOf<S extends ITableSpec> = IsWideSpec<S> extends true ? Record<string, unknown> : Simplify<{ -readonly [K in keyof S["columns"]]: DataOf<S, S["columns"][K]> | (IsNullable<S["columns"][K]> extends true ? null : never); }>
```

Ligne telle que le repository la rend — égale à `$inferSelect` des trois tables.

---

[← Toutes les références d'API](../../)