Guide

Kysely, un query builder SQL typé pour TypeScript

Kysely est un query builder SQL typé pour TypeScript : schéma de types, requêtes, transactions, migrations, coût pour le compilateur et comparaison avec Drizzle.

L'équipe CodeWorlds20 min de lecture ·

Pratique HTML et CSS dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article9

Kysely est une bibliothèque pour construire des requêtes SQL en TypeScript qui complète automatiquement les noms de tables et de colonnes et infère le type du résultat, sans chercher à te cacher le SQL. La version actuelle est la 0.29.5, publiée le 10 août 2026, la licence est MIT, le dépôt kysely-org/kysely compte environ 14,1 mille étoiles, et le paquet n'a aucune dépendance à l'exécution.

Ce que fait réellement Kysely

Tu commences avec une instance de la classe Kysely paramétrée par une interface décrivant ta base de données, puis tu appelles des méthodes qui reflètent les parties d'une requête : selectFrom, innerJoin, where, orderBy, limit. À la fin, tu appelles execute ou executeTakeFirstOrThrow et tu reçois un tableau d'objets typés d'après ce que tu as passé à select. Il n'y a ici ni session, ni chargement paresseux, ni requête qui atteigne la base de données à ton insu.

Cette distinction est le cœur de la bibliothèque. Dans un ORM typique, tu écris user.projects et tu ne peux pas savoir si tu viens de lire un champ en mémoire ou d'émettre une requête. Dans Kysely, chaque requête est visible dans le code sous la forme d'une chaîne d'appels qui se lit comme du SQL, car les noms de méthodes sont les noms des clauses. Le problème classique des requêtes répétées dans une boucle ne disparaît pas tout seul, mais au moins tu le vois dans le code au lieu de le découvrir dans le journal de la base de données.

Au lieu de types de résultat écrits à la main, tu obtiens des types inférés. Passe ['projects.id', 'users.email'] à select et le résultat est un tableau d'objets avec exactement ces deux champs, tandis que lire autre chose est une erreur de compilation. Si une colonne du schéma est décrite comme string | null, ce null apparaît dans le type du résultat et le compilateur t'oblige à le gérer. Rattache une table avec leftJoin et ses colonnes deviennent optionnelles, car la correspondance peut ne pas avoir été trouvée.

Les dialectes intégrés sont PostgreSQL, MySQL, SQLite, MS SQL Server et PGlite, ce dernier ajouté dans la version 0.29.0. Un dialecte est la couche qui traduit l'arbre de requête vers une variante précise de SQL et gère les connexions, tandis que le driver se branche de l'extérieur : pour PostgreSQL, c'est généralement le paquet pg avec son propre pool de connexions. Le paquet lui-même ne déclare aucune dépendance à l'exécution, pèse 323 kilo-octets en archive et contient 610 fichiers.

La table exports de package.json expose six points d'entrée en plus du principal : kysely/migration, kysely/readonly et quatre ensembles d'aides pour des bases précises. Les aides PostgreSQL sont jsonArrayFrom, jsonObjectFrom, jsonBuildObject et mergeAction, des fonctions pour assembler des résultats imbriqués en une seule requête plutôt qu'en plusieurs. Il existe une poignée de plugins, activés à la création de l'instance : CamelCasePlugin traduit les noms entre le style avec underscores de la base et le style camel du code, ParseJSONResultsPlugin analyse les colonnes JSON que le driver renvoie sous forme de texte, DeduplicateJoinsPlugin supprime les jointures répétées.

Ce que Kysely ne fait pas compte ici plus que la liste de fonctionnalités. Il ne connaît pas ta base de données. Il ne se connecte pas pour lire le schéma. Il ne génère pas de migrations à partir de la différence entre un modèle et la réalité. Il n'a pas de studio pour parcourir les données. Tout ce qu'il sait de tes tables vient d'une interface TypeScript que tu dois fournir.

Version, licence et santé du projet

Le paquet kysely compte actuellement 187 versions publiées, la première de février 2021 et l'actuelle 0.29.5 du 10 août 2026. Le numéro majeur est toujours zéro, après plus de cinq ans de développement et avec un usage clairement en production. Le dépôt compte 432 forks, 172 issues ouvertes et 158 pages de liste de contributeurs à une entrée par page, il n'est pas archivé, et la dernière modification date du 17 août 2026.

J'ai vérifié la licence à trois endroits, car c'est exactement là que les surprises ont l'habitude de se cacher. Le fichier LICENSE de la branche principale contient le texte MIT avec la ligne « Copyright (c) 2022 Sami Koskimäki ». Le champ license du registre npm pour la 0.29.5 indique MIT. L'archive publiée contient package/LICENSE avec exactement le même texte. L'interface de programmation de GitHub renvoie MIT. Quatre sources, une seule réponse, aucune divergence. Cela paraît évident et ne l'est pas : cette même collection couvre des paquets où le dépôt dit une chose, le registre une autre, et où l'archive publiée ne contient aucun fichier de licence. Kysely s'en sort ici de façon exemplaire, et un audit de dépendances peut clore le sujet dès la première vérification.

Il n'existe pas de variante payante. Il n'y a pas non plus d'entreprise qui vende du support ni de plan avec un temps de réponse garanti, ce qui distingue le projet de ceux qui ont derrière la bibliothèque une société et un service hébergé. Le gain est que rien ne te lie à un fournisseur et que personne ne changera tes conditions tarifaires. Le coût est qu'un bug sérieux te laisse avec une issue GitHub et un canal Discord plutôt qu'un contrat.

Deux contraintes d'environnement ressortent lors des mises à jour. La première est Node : le champ engines exige au minimum la version 22, alors que la 0.28.17 demandait la 20, la 0.28.0 la dix-huit, et la 0.27.0 la quatorze. Le plancher monte dans des versions mineures, car avec un majeur à zéro chaque version est formellement mineure. La seconde est TypeScript. La table exports contient une entrée types@<5.4 pointant vers outdated-typescript.d.ts, qui, au lieu de vrais types, exporte Kysely, RawBuilder et sql comme un type d'erreur spécial portant un message sur la mise à niveau vers 5.4 ou plus récent. Tu n'obtiens donc pas un échec d'inférence cryptique, mais une phrase lisible sur ce qui ne va pas, et il te faut quand même monter la version du compilateur.

D'où vient le schéma de types

C'est la décision la plus importante lors de l'adoption de Kysely et en même temps sa plus grande faiblesse. La bibliothèque ne sait rien de ta base de données, donc tu dois lui fournir toi-même les descriptions des tables. Cela ressemble à ceci.

TypeScript
import { Pool } from 'pg'
import {
  Kysely,
  PostgresDialect,
  type ColumnType,
  type Generated,
  type Insertable,
  type Selectable,
  type Updateable
} from 'kysely'

interface UserTable {
  id: Generated<number>
  email: string
  display_name: string | null
  plan: 'free' | 'pro'
  created_at: ColumnType<Date, string | undefined, never>
}

interface ProjectTable {
  id: Generated<string>
  owner_id: number
  slug: string
  archived_at: Date | null
}

export interface Database {
  users: UserTable
  projects: ProjectTable
}

export type User = Selectable<UserTable>
export type NewUser = Insertable<UserTable>
export type UserUpdate = Updateable<UserTable>

export const db = new Kysely<Database>({
  dialect: new PostgresDialect({
    pool: new Pool({ connectionString: process.env.DATABASE_URL, max: 10 })
  })
})

Toute la puissance de cette notation se trouve dans le type ColumnType, qui prend trois paramètres : le type en lecture, le type à l'insertion et le type à la mise à jour. Une colonne created_at décrite comme ColumnType<Date, string | undefined, never> renvoie un objet date en lecture, accepte une chaîne ou rien à l'insertion, et ne peut pas être modifiée à la mise à jour. Le type Generated<number> est un raccourci pour une colonne que la base de données remplit elle-même, donc facultative à l'insertion. Il existe aussi GeneratedAlways pour les colonnes où l'on ne doit jamais écrire, et JSONColumnType pour les données que le driver renvoie sous forme de texte. Les aides Selectable, Insertable et Updateable transforment une description de table en trois formes d'objets distinctes, et ce sont elles que tu utilises dans les signatures de tes propres fonctions, jamais l'interface brute de la table.

Il existe trois voies pour obtenir ce schéma. La première est de l'écrire à la main, raisonnable sur une petite base et avec un contrôle total des migrations, fatigante sur soixante tables. La deuxième est kysely-codegen, actuellement en version 0.20.0 sous licence MIT, qui se connecte à une base en fonctionnement et écrit un fichier de types fini. La troisième est prisma-kysely en version 3.2.1, un générateur branché sur Prisma qui prend schema.prisma comme source de vérité et produit des types pour Kysely, ce qui a du sens si Prisma gère tes migrations alors que tu veux écrire des requêtes sans son moteur.

Bash
npx kysely-codegen \
  --dialect postgres \
  --url "$DATABASE_URL" \
  --out-file ./src/db/schema.d.ts \
  --camel-case \
  --exclude-pattern "public._prisma*" \
  --type-only-imports

npx kysely-codegen --dialect postgres --url "$DATABASE_URL" --verify

La deuxième commande est celle qu'on oublie le plus facilement et la pièce maîtresse du puzzle. Le flag --verify n'écrit aucun fichier, il vérifie seulement si l'existant correspond à l'état actuel de la base de données, et sort avec un code non nul en cas de divergence. Sans cette étape dans le pipeline d'intégration continue, tôt ou tard quelqu'un ajoute une colonne via une migration, saute la régénération des types, et le compilateur continue d'affirmer que tout va bien. Les types de Kysely ne sont pas vérifiés contre la base de données à l'exécution, donc si tu mens dans l'interface, la bibliothèque te croit sur parole et l'erreur apparaît comme une exception du driver en production.

Le générateur prend en charge les dialectes postgres, mysql, sqlite, mssql, libsql, bun-sqlite et worker-bun-sqlite, et au-delà des flags montrés, il propose entre autres --overrides, --type-mapping, --include-pattern, --singularize, --runtime-enums, --date-parser, --numeric-parser, --default-schema et --config-file. C'est un paquet séparé avec un mainteneur séparé, donc son rythme de versions n'est pas celui de Kysely, et après un changement important dans la bibliothèque, il peut prendre du retard pendant un temps.

Écrire des requêtes

Voici une lecture typique avec une condition optionnelle et une jointure, le genre de requête qui ressemble beaucoup à elle-même dans chaque application.

TypeScript
import { sql } from 'kysely'

async function findActiveProjects(ownerId: number, search?: string) {
  return db
    .selectFrom('projects')
    .innerJoin('users', 'users.id', 'projects.owner_id')
    .select([
      'projects.id',
      'projects.slug',
      'users.email',
      sql<number>`count(*) over ()`.as('total_count')
    ])
    .where('projects.owner_id', '=', ownerId)
    .where('projects.archived_at', 'is', null)
    .$if(search !== undefined, (qb) =>
      qb.where('projects.slug', 'like', `%${search}%`)
    )
    .orderBy('projects.slug', 'asc')
    .limit(50)
    .execute()
}

const owner = await db
  .selectFrom('users')
  .selectAll()
  .where((eb) =>
    eb.or([eb('users.email', '=', 'ada@example.com'), eb('users.id', '=', 1)])
  )
  .executeTakeFirstOrThrow()

La méthode $if résout un problème qui, dans les query builders, finit généralement en code ramifié et en type perdu. Tu passes la condition sous forme de booléen et l'extension de la requête sous forme de fonction, et le type du résultat est calculé correctement dans les deux cas. Les méthodes commençant par un signe dollar sont une convention cohérente pour les opérations qui agissent au niveau des types plutôt qu'au niveau SQL : à côté de $if se trouvent $castTo, $narrowType, $assertType, $asScalar et $call.

La fonction passée à where reçoit un constructeur d'expressions, nommé conventionnellement eb. Il est lui-même appelable comme une comparaison à trois arguments, et propose en plus and, or, not, between, exists, ref, val, lit, cast, case, selectFrom et quelques autres. C'est le mécanisme pour composer des conditions imbriquées qu'une chaîne d'appels à plat ne peut pas exprimer.

Le tag de gabarit sql est l'échappatoire pour tout ce que la bibliothèque n'a pas encapsulé. Le paramètre de type dans sql<number> dit au compilateur ce que tu attends, et la responsabilité passe à toi à cet endroit, car personne ne le vérifiera. Les valeurs interpolées dans le gabarit deviennent des paramètres de requête plutôt que du texte, donc le cas de base est sûr. Le tag porte aussi des aides : sql.ref pour une référence de colonne, sql.table pour une table, sql.id pour un identifiant, sql.lit pour un littéral, sql.join pour une liste, et sql.raw pour du texte brut. Le dernier colle une chaîne dans la requête sans aucun traitement et c'est le seul endroit de toute l'interface où l'injection SQL est facile.

L'écriture de données est symétrique, la gestion des conflits étant exposée directement via l'équivalent de la clause on conflict.

TypeScript
const inserted = await db
  .insertInto('users')
  .values({ email: 'ada@example.com', display_name: 'Ada', plan: 'pro' })
  .onConflict((oc) =>
    oc.column('email').doUpdateSet({ display_name: 'Ada', plan: 'pro' })
  )
  .returningAll()
  .executeTakeFirstOrThrow()

const { sql: text, parameters } = db
  .selectFrom('users')
  .select('id')
  .where('plan', '=', 'pro')
  .compile()

Le constructeur de conflit propose column, columns, constraint, doNothing, doUpdateSet et where, l'ensemble complet nécessaire à une insertion avec mise à jour. La méthode compile termine la construction sans rien envoyer et renvoie un objet avec les champs sql, parameters, query et queryId. Elle aide dans deux situations : quand tu veux voir le texte généré dans un test plutôt que de le deviner, et quand tu as besoin d'une requête préparée une fois et exécutée plusieurs fois.

Transactions, migrations et limites de la bibliothèque

Une transaction est enfermée dans un callback, avec commit et rollback effectués automatiquement selon que la fonction a levé une exception ou non. L'objet passé à l'intérieur porte la même interface que l'instance principale, donc le code des requêtes ne peut pas savoir s'il s'exécute dans une transaction.

TypeScript
await db.transaction().execute(async (trx) => {
  const user = await trx
    .insertInto('users')
    .values({ email: 'ada@example.com', plan: 'free' })
    .returning('id')
    .executeTakeFirstOrThrow()

  await trx
    .insertInto('projects')
    .values({ owner_id: user.id, slug: 'default' })
    .execute()
})

Les migrations sont présentes dans la bibliothèque, mais sous une forme minimale et entièrement manuelle. Un fichier de migration est un module qui exporte deux fonctions, up et down, et la construction du schéma suit le même style chaîné que les requêtes.

TypeScript
import { Kysely, sql } from 'kysely'

export async function up(db: Kysely<any>): Promise<void> {
  await db.schema
    .createTable('projects')
    .addColumn('id', 'uuid', (col) => col.primaryKey().defaultTo(sql`gen_random_uuid()`))
    .addColumn('owner_id', 'integer', (col) =>
      col.notNull().references('users.id').onDelete('cascade')
    )
    .addColumn('slug', 'varchar(64)', (col) => col.notNull())
    .addColumn('archived_at', 'timestamptz')
    .execute()

  await db.schema
    .createIndex('projects_owner_id_index')
    .on('projects')
    .column('owner_id')
    .execute()
}

export async function down(db: Kysely<any>): Promise<void> {
  await db.schema.dropTable('projects').execute()
}

Leur exécution est le travail de la classe Migrator, à laquelle tu passes une instance de base de données et un fournisseur de fichiers.

TypeScript
import { promises as fs } from 'node:fs'
import path from 'node:path'
import { Migrator, FileMigrationProvider } from 'kysely'

const migrator = new Migrator({
  db,
  provider: new FileMigrationProvider({
    fs,
    path,
    migrationFolder: path.join(process.cwd(), 'migrations')
  }),
  migrationTableName: 'kysely_migration',
  allowUnorderedMigrations: true
})

const { error, results } = await migrator.migrateToLatest()

Au-delà de migrateToLatest, tu disposes de migrateUp, migrateDown, migrateTo et getMigrations, et la configuration te permet de changer le nom de la table de migrations, le nom de la table de verrou et le schéma dans lequel les deux sont créées. L'option allowUnorderedMigrations se justifie dans une équipe qui travaille sur plusieurs branches, car sans elle une migration avec un horodatage antérieur ajoutée après un merge est rejetée. L'appel renvoie un objet avec les champs error et results, tous deux optionnels, donc gère les deux plutôt que la seule exception.

C'est là que passe la frontière principale avec l'outillage complet. Kysely ne calculera pas la différence entre l'état de la base de données et ton modèle, et n'écrira pas la migration à ta place. Chaque changement de schéma est écrit à la main et les types sont régénérés séparément, donc un changement de colonne représente deux actions au lieu d'une. Il n'y a pas non plus d'interface en ligne de commande dans la bibliothèque, elle vit dans le paquet séparé kysely-ctl en version 0.21.0.

Le coût côté compilateur

Cette bibliothèque calcule presque tout au niveau des types et tu le paies. Le type du résultat d'une requête est produit en traitant l'interface de la base de données, la liste des jointures et la liste des colonnes sélectionnées, et chacun de ces éléments est du travail pour le compilateur, refait à chaque vérification du fichier dans l'éditeur. Avec une base de plusieurs dizaines de tables et des requêtes comportant quelques jointures, le temps de réponse du serveur de langage devient perceptible.

L'équipe le dit ouvertement. Les notes de version de la 0.29.5 s'ouvrent sur l'affirmation que TypeScript 7 autorise des calculs plus profonds, ce qui provoque beaucoup plus d'instanciations de types et des temps d'horloge plus longs dans divers scénarios, et l'un des correctifs de cette version concerne justement l'optimisation des vérifications d'assignabilité entre builders. Un autre correctif porte un titre sur la réparation d'une récursion infinie lors de la vérification de types. Ce ne sont pas des problèmes théoriques.

La version 0.29.0 a ajouté deux outils qui s'attaquent frontalement à ce coût : $pickTables et $omitTables. Les deux restreignent la vue de la base de données pour le reste de la chaîne, donc le compilateur traite la description de deux tables au lieu de cinquante. La même version a introduit le type ReadonlyKysely importé depuis kysely/readonly, qui retire les méthodes d'écriture d'une instance à la compilation, transformant insertInto, updateTable, deleteFrom et mergeInto en erreurs. C'est utile dans du code qui lit depuis une réplique.

La conclusion pratique est simple. Si la base est grande, garde le fichier de types hors de la vérification continue quand tu le peux, découpe la description de la base en modules et utilise la restriction de vue partout où l'éditeur commence à traîner. Sur une base petite ou moyenne, tu ne remarqueras rien.

Kysely face aux alternatives

CaractéristiqueKyselyDrizzle ORMPrismaLe driver pg sans surcouche
Modèle de travailméthodes reflétant les clauses SQLméthodes reflétant les clauses SQLson propre langage de requêtes et ses relationsSQL sous forme de chaîne
Origine du schéma de typesà la main ou un générateur séparéun fichier de schéma en TypeScriptun fichier schema.prismaaucun typage des résultats
Migrations à partir de différences de schémaaucuneoui, via drizzle-kitoui, via prisma migrateaucune
Dépendances à l'exécutionaucuneaucunesix paquets dans prismasix paquets dans pg
Version actuelle0.29.50.45.27.9.18.23.0
LicenceMITApache 2.0Apache 2.0MIT

Le choix se ramène à une question : veux-tu une source de vérité pour le schéma, ou deux. Drizzle et Prisma t'en donnent une, car les types et les migrations viennent de la même description, et c'est leur véritable avantage, que Kysely ne cherche même pas à contester. Kysely t'en donne deux et attend de toi que tu les gardes synchronisées, en échange de quoi il n'impose rien ni sur les migrations ni sur la façon d'écrire les requêtes.

Tu choisis Kysely quand la base existe déjà et que ce n'est pas à toi de la gouverner, quand les requêtes sont non triviales et que les écrire dans le langage de requêtes de quelqu'un d'autre serait un combat, ou quand tu veux la certitude que rien n'atteint la base à ton insu. Il fonctionne bien comme couche d'accès aux données au-dessus de PostgreSQL pur, et tout autant au-dessus de bases hébergées comme Supabase ou Neon, où tu te connectes de toute façon par un driver ordinaire. Tu ne le choisis pas quand l'équipe est petite, la base neuve et la priorité de monter rapidement un schéma avec ses migrations.

Erreurs fréquentes

La première est une description de tables qui ne correspond pas à la base de données. Les types ne sont pas vérifiés à l'exécution, donc une faute de frappe dans un nom de colonne ou une valeur nullable oubliée produit du code qui compile et ne casse qu'au moment de la requête. Mets kysely-codegen --verify dans le pipeline d'intégration continue.

La deuxième est d'utiliser l'interface brute de la table là où Selectable a sa place. Le type UserTable contient Generated et ColumnType, des descriptions de trois formes différentes à la fois, et ne convient pas comme type d'un objet renvoyé par la base. Décris les fonctions qui prennent et renvoient des données avec Selectable, Insertable et Updateable.

La troisième est executeTakeFirst là où un résultat manquant est une erreur. Cette méthode renvoie une valeur vide facile à négliger, car le type du résultat te laisse continuer. Si l'enregistrement doit exister, utilise executeTakeFirstOrThrow.

La quatrième est sql.raw avec des données fournies par l'utilisateur. L'interpolation dans le tag sql crée un paramètre et est sûre, mais sql.raw colle le texte littéralement. Pour un nom de colonne ou de table dynamique, il existe sql.ref, sql.table et sql.id.

La cinquième est d'activer CamelCasePlugin à mi-parcours d'un projet. Le plugin traduit les noms dans les deux sens, donc une fois activé, l'interface de la base doit être écrite en camel case plutôt qu'avec des underscores. Faire ce changement dans un projet en fonctionnement signifie réécrire chaque description de table et régénérer les types avec le flag --camel-case.

La sixième est de monter d'une version mineure sans lire les notes. Le numéro majeur est zéro, donc les changements non rétrocompatibles entrent dans les règles de versionnage. Le plancher de Node passant de 20 à 22 est arrivé dans une version de ce genre et peut bloquer le build d'un serveur.

La septième est de répéter des requêtes dans une boucle. L'absence de chargement paresseux ne signifie pas que le problème a disparu, seulement que tu le crées explicitement. Pour des résultats imbriqués, utilise jsonArrayFrom et jsonObjectFrom de kysely/helpers/postgres, ou une jointure avec agrégation.

FAQ

Kysely est-il un ORM ?

Non, et c'est voulu. Il lui manque tout ce qui définit le mapping objet-relationnel : pas de session, pas d'unité de travail, pas de chargement paresseux, pas d'objets entités avec identité. C'est une couche qui construit du SQL et type le résultat, donc tu continues de penser en tables et en clauses.

Où obtenir l'interface qui décrit la base de données ?

À l'un de trois endroits : l'écrire à la main, la générer depuis une base en fonctionnement avec kysely-codegen en version 0.20.0, ou depuis un fichier schema.prisma avec prisma-kysely en version 3.2.1. En cas de génération, ajoute l'étape --verify au pipeline pour qu'une divergence entre les types et la base arrête le build.

Kysely gérera-t-il les migrations à ma place ?

Il les exécutera et consignera l'historique dans une table, mais il ne les écrira pas. La classe Migrator exécute des fichiers qui exportent des fonctions up et down, et tu écris toi-même le corps de ces fonctions avec le constructeur de schéma. Personne ne calcule ici la différence entre l'état de la base et un modèle.

Pourquoi l'éditeur ralentit-il sur une grande base de données ?

Parce que les types des résultats sont calculés par le compilateur à chaque vérification, et que le coût croît avec la taille de l'interface de la base et le nombre de jointures. L'équipe travaille sur l'optimisation, comme l'indiquent clairement les notes de version de la 0.29.5. Comme remède immédiat, restreins la vue avec $pickTables ou $omitTables.

Kysely est-il payant, et la licence restreint-elle quelque chose ?

Non et non. Le paquet est sous licence MIT, confirmée de façon cohérente par le fichier du dépôt, le champ du registre npm et le fichier LICENSE à l'intérieur de l'archive publiée. Il n'y a pas d'offre payante, mais pas non plus d'entreprise qui vende du support, donc un bug sérieux te laisse avec une issue dans le dépôt.

Peut-on utiliser Kysely avec Prisma ?

Oui, et ce dispositif est assez courant. Prisma possède le schéma et les migrations, le générateur prisma-kysely transforme le fichier de schéma en types pour Kysely, et tu écris les requêtes plus difficiles avec le builder. Le coût est de maintenir deux bibliothèques dans le projet, donc cela a surtout du sens pendant une migration progressive.

La documentation et les exemples se trouvent sur le site du projet, le code source dans le dépôt GitHub, et les métadonnées de version dans le registre npm. Pour une vue complète, il est utile de lire ceci avec l'article sur TypeScript, car certaines limites de Kysely ne sont que des limites du compilateur.

À lire aussi