kysely 0.27.3 → 0.27.5

package/dist/cjs/kysely.d.ts

@@ -20,37 +20,27 @@ import { DrainOuterGeneric } from './util/type-utils.js';
  * The main Kysely class.
  *
  * You should create one instance of `Kysely` per database using the {@link Kysely}
- * constructor. Each `Kysely` instance maintains it's own connection pool.
+ * constructor. Each `Kysely` instance maintains its own connection pool.
  *
  * ### Examples
  *
- * This example assumes your database has tables `person` and `pet`:
+ * This example assumes your database has a "person" table:
  *
  * ```ts
- * import { Kysely, Generated, PostgresDialect } from 'kysely'
- *
- * interface PersonTable {
- *   id: Generated<number>
- *   first_name: string
- *   last_name: string
- * }
- *
- * interface PetTable {
- *   id: Generated<number>
- *   owner_id: number
- *   name: string
- *   species: 'cat' | 'dog'
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { type Generated, Kysely, SqliteDialect } from 'kysely'
  *
  * interface Database {
- *   person: PersonTable,
- *   pet: PetTable
+ *   person: {
+ *     id: Generated<number>
+ *     first_name: string
+ *     last_name: string | null
+ *   }
  * }
  *
  * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     host: 'localhost',
- *     database: 'kysely_test',
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   })
  * })
  * ```
@@ -86,30 +76,52 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
     case(): CaseBuilder<DB, keyof DB>;
     case<V>(value: Expression<V>): CaseBuilder<DB, keyof DB, V>;
     /**
-     * Returns a {@link FunctionModule} that can be used to write type safe function
+     * Returns a {@link FunctionModule} that can be used to write somewhat type-safe function
      * calls.
      *
      * ```ts
+     * const { count } = db.fn
+     *
      * await db.selectFrom('person')
      *   .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *   .select((eb) => [
-     *     'person.id',
-     *     eb.fn.count('pet.id').as('pet_count')
+     *   .select([
+     *     'id',
+     *     count('pet.id').as('person_count'),
      *   ])
      *   .groupBy('person.id')
-     *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
+     *   .having(count('pet.id'), '>', 10)
      *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select "person"."id", count("pet"."id") as "pet_count"
+     * select "person"."id", count("pet"."id") as "person_count"
      * from "person"
      * inner join "pet" on "pet"."owner_id" = "person"."id"
      * group by "person"."id"
      * having count("pet"."id") > $1
      * ```
+     *
+     * Why "somewhat" type-safe? Because the function calls are not bound to the
+     * current query context. They allow you to reference columns and tables that
+     * are not in the current query. E.g. remove the `innerJoin` from the previous
+     * query and TypeScript won't even complain.
+     *
+     * If you want to make the function calls fully type-safe, you can use the
+     * {@link ExpressionBuilder.fn} getter for a query context-aware, stricter {@link FunctionModule}.
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select((eb) => [
+     *     'person.id',
+     *     eb.fn.count('pet.id').as('pet_count')
+     *   ])
+     *   .groupBy('person.id')
+     *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
+     *   .execute()
+     * ```
      */
     get fn(): FunctionModule<DB, keyof DB>;
     /**
@@ -118,8 +130,11 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * The returned {@link TransactionBuilder} can be used to configure the transaction. The
      * {@link TransactionBuilder.execute} method can then be called to run the transaction.
      * {@link TransactionBuilder.execute} takes a function that is run inside the
-     * transaction. If the function throws, the transaction is rolled back. Otherwise
-     * the transaction is committed.
+     * transaction. If the function throws an exception,
+     * 1. the exception is caught,
+     * 2. the transaction is rolled back, and
+     * 3. the exception is thrown again.
+     * Otherwise the transaction is committed.
      *
      * The callback function passed to the {@link TransactionBuilder.execute | execute}
      * method gets the transaction object as its only argument. The transaction is
@@ -130,9 +145,12 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      *
      * <!-- siteExample("transactions", "Simple transaction", 10) -->
      *
-     * This example inserts two rows in a transaction. If an error is thrown inside
-     * the callback passed to the `execute` method, the transaction is rolled back.
-     * Otherwise it's committed.
+     * This example inserts two rows in a transaction. If an exception is thrown inside
+     * the callback passed to the `execute` method,
+     * 1. the exception is caught,
+     * 2. the transaction is rolled back, and
+     * 3. the exception is thrown again.
+     * Otherwise the transaction is committed.
      *
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
@@ -160,12 +178,18 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * Setting the isolation level:
      *
      * ```ts
+     * import type { Kysely } from 'kysely'
+     *
      * await db
      *   .transaction()
      *   .setIsolationLevel('serializable')
      *   .execute(async (trx) => {
      *     await doStuff(trx)
      *   })
+     *
+     * async function doStuff(kysely: typeof db) {
+     *   // ...
+     * }
      * ```
      */
     transaction(): TransactionBuilder<DB>;
@@ -183,6 +207,10 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      *     // the same connection.
      *     await doStuff(db)
      *   })
+     *
+     * async function doStuff(kysely: typeof db) {
+     *   // ...
+     * }
      * ```
      */
     connection(): ConnectionBuilder<DB>;
@@ -209,7 +237,6 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      *
      * The following example adds and uses a temporary table:
      *
-     * @example
      * ```ts
      * await db.schema
      *   .createTable('temp_table')
@@ -250,7 +277,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
     /**
      * Executes a given compiled query or query builder.
      *
-     * See {@link https://github.com/koskimas/kysely/blob/master/site/docs/recipes/splitting-build-compile-and-execute-code.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
+     * See {@link https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0004-splitting-query-building-and-execution.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
      */
     executeQuery<R>(query: CompiledQuery<R> | Compilable<R>, queryId?: QueryId): Promise<QueryResult<R>>;
 }
@@ -269,8 +296,11 @@ export declare class Transaction<DB> extends Kysely<DB> {
      * The returned {@link TransactionBuilder} can be used to configure the transaction. The
      * {@link TransactionBuilder.execute} method can then be called to run the transaction.
      * {@link TransactionBuilder.execute} takes a function that is run inside the
-     * transaction. If the function throws, the transaction is rolled back. Otherwise
-     * the transaction is committed.
+     * transaction. If the function throws an exception,
+     * 1. the exception is caught,
+     * 2. the transaction is rolled back, and
+     * 3. the exception is thrown again.
+     * Otherwise the transaction is committed.
      *
      * The callback function passed to the {@link TransactionBuilder.execute | execute}
      * method gets the transaction object as its only argument. The transaction is
@@ -281,9 +311,12 @@ export declare class Transaction<DB> extends Kysely<DB> {
      *
      * <!-- siteExample("transactions", "Simple transaction", 10) -->
      *
-     * This example inserts two rows in a transaction. If an error is thrown inside
-     * the callback passed to the `execute` method, the transaction is rolled back.
-     * Otherwise it's committed.
+     * This example inserts two rows in a transaction. If an exception is thrown inside
+     * the callback passed to the `execute` method,
+     * 1. the exception is caught,
+     * 2. the transaction is rolled back, and
+     * 3. the exception is thrown again.
+     * Otherwise the transaction is committed.
      *
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
@@ -311,12 +344,18 @@ export declare class Transaction<DB> extends Kysely<DB> {
      * Setting the isolation level:
      *
      * ```ts
+     * import type { Kysely } from 'kysely'
+     *
      * await db
      *   .transaction()
      *   .setIsolationLevel('serializable')
      *   .execute(async (trx) => {
      *     await doStuff(trx)
      *   })
+     *
+     * async function doStuff(kysely: typeof db) {
+     *   // ...
+     * }
      * ```
      */
     transaction(): TransactionBuilder<DB>;
@@ -334,6 +373,10 @@ export declare class Transaction<DB> extends Kysely<DB> {
      *     // the same connection.
      *     await doStuff(db)
      *   })
+     *
+     * async function doStuff(kysely: typeof db) {
+     *   // ...
+     * }
      * ```
      */
     connection(): ConnectionBuilder<DB>;
@@ -366,7 +409,6 @@ export declare class Transaction<DB> extends Kysely<DB> {
      *
      * The following example adds and uses a temporary table:
      *
-     * @example
      * ```ts
      * await db.schema
      *   .createTable('temp_table')
@@ -406,16 +448,32 @@ export interface KyselyConfig {
      *
      * ### Examples
      *
+     * Setting up built-in logging for preferred log levels:
+     *
      * ```ts
+     * import * as Sqlite from 'better-sqlite3'
+     * import { Kysely, SqliteDialect } from 'kysely'
+     * import type { Database } from 'type-editor' // imaginary module
+     *
      * const db = new Kysely<Database>({
-     *   dialect: new PostgresDialect(postgresConfig),
+     *   dialect: new SqliteDialect({
+     *     database: new Sqlite(':memory:'),
+     *   }),
      *   log: ['query', 'error']
      * })
      * ```
      *
+     * Setting up custom logging:
+     *
      * ```ts
+     * import * as Sqlite from 'better-sqlite3'
+     * import { Kysely, SqliteDialect } from 'kysely'
+     * import type { Database } from 'type-editor' // imaginary module
+     *
      * const db = new Kysely<Database>({
-     *   dialect: new PostgresDialect(postgresConfig),
+     *   dialect: new SqliteDialect({
+     *     database: new Sqlite(':memory:'),
+     *   }),
      *   log(event): void {
      *     if (event.level === 'query') {
      *       console.log(event.query.sql)

package/dist/cjs/kysely.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionBuilder = exports.ConnectionBuilder = exports.isKyselyProps = exports.Transaction = exports.Kysely = void 0;
+exports.TransactionBuilder = exports.ConnectionBuilder = exports.Transaction = exports.Kysely = void 0;
+exports.isKyselyProps = isKyselyProps;
 const schema_js_1 = require("./schema/schema.js");
 const dynamic_js_1 = require("./dynamic/dynamic.js");
 const default_connection_provider_js_1 = require("./driver/default-connection-provider.js");
@@ -23,37 +24,27 @@ const with_schema_plugin_js_1 = require("./plugin/with-schema/with-schema-plugin
  * The main Kysely class.
  *
  * You should create one instance of `Kysely` per database using the {@link Kysely}
- * constructor. Each `Kysely` instance maintains it's own connection pool.
+ * constructor. Each `Kysely` instance maintains its own connection pool.
  *
  * ### Examples
  *
- * This example assumes your database has tables `person` and `pet`:
+ * This example assumes your database has a "person" table:
  *
  * ```ts
- * import { Kysely, Generated, PostgresDialect } from 'kysely'
- *
- * interface PersonTable {
- *   id: Generated<number>
- *   first_name: string
- *   last_name: string
- * }
- *
- * interface PetTable {
- *   id: Generated<number>
- *   owner_id: number
- *   name: string
- *   species: 'cat' | 'dog'
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { type Generated, Kysely, SqliteDialect } from 'kysely'
  *
  * interface Database {
- *   person: PersonTable,
- *   pet: PetTable
+ *   person: {
+ *     id: Generated<number>
+ *     first_name: string
+ *     last_name: string | null
+ *   }
  * }
  *
  * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     host: 'localhost',
- *     database: 'kysely_test',
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   })
  * })
  * ```
@@ -118,30 +109,52 @@ class Kysely extends query_creator_js_1.QueryCreator {
         });
     }
     /**
-     * Returns a {@link FunctionModule} that can be used to write type safe function
+     * Returns a {@link FunctionModule} that can be used to write somewhat type-safe function
      * calls.
      *
      * ```ts
+     * const { count } = db.fn
+     *
      * await db.selectFrom('person')
      *   .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *   .select((eb) => [
-     *     'person.id',
-     *     eb.fn.count('pet.id').as('pet_count')
+     *   .select([
+     *     'id',
+     *     count('pet.id').as('person_count'),
      *   ])
      *   .groupBy('person.id')
-     *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
+     *   .having(count('pet.id'), '>', 10)
      *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select "person"."id", count("pet"."id") as "pet_count"
+     * select "person"."id", count("pet"."id") as "person_count"
      * from "person"
      * inner join "pet" on "pet"."owner_id" = "person"."id"
      * group by "person"."id"
      * having count("pet"."id") > $1
      * ```
+     *
+     * Why "somewhat" type-safe? Because the function calls are not bound to the
+     * current query context. They allow you to reference columns and tables that
+     * are not in the current query. E.g. remove the `innerJoin` from the previous
+     * query and TypeScript won't even complain.
+     *
+     * If you want to make the function calls fully type-safe, you can use the
+     * {@link ExpressionBuilder.fn} getter for a query context-aware, stricter {@link FunctionModule}.
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select((eb) => [
+     *     'person.id',
+     *     eb.fn.count('pet.id').as('pet_count')
+     *   ])
+     *   .groupBy('person.id')
+     *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
+     *   .execute()
+     * ```
      */
     get fn() {
         return (0, function_module_js_1.createFunctionModule)();
@@ -152,8 +165,11 @@ class Kysely extends query_creator_js_1.QueryCreator {
      * The returned {@link TransactionBuilder} can be used to configure the transaction. The
      * {@link TransactionBuilder.execute} method can then be called to run the transaction.
      * {@link TransactionBuilder.execute} takes a function that is run inside the
-     * transaction. If the function throws, the transaction is rolled back. Otherwise
-     * the transaction is committed.
+     * transaction. If the function throws an exception,
+     * 1. the exception is caught,
+     * 2. the transaction is rolled back, and
+     * 3. the exception is thrown again.
+     * Otherwise the transaction is committed.
      *
      * The callback function passed to the {@link TransactionBuilder.execute | execute}
      * method gets the transaction object as its only argument. The transaction is
@@ -164,9 +180,12 @@ class Kysely extends query_creator_js_1.QueryCreator {
      *
      * <!-- siteExample("transactions", "Simple transaction", 10) -->
      *
-     * This example inserts two rows in a transaction. If an error is thrown inside
-     * the callback passed to the `execute` method, the transaction is rolled back.
-     * Otherwise it's committed.
+     * This example inserts two rows in a transaction. If an exception is thrown inside
+     * the callback passed to the `execute` method,
+     * 1. the exception is caught,
+     * 2. the transaction is rolled back, and
+     * 3. the exception is thrown again.
+     * Otherwise the transaction is committed.
      *
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
@@ -194,12 +213,18 @@ class Kysely extends query_creator_js_1.QueryCreator {
      * Setting the isolation level:
      *
      * ```ts
+     * import type { Kysely } from 'kysely'
+     *
      * await db
      *   .transaction()
      *   .setIsolationLevel('serializable')
      *   .execute(async (trx) => {
      *     await doStuff(trx)
      *   })
+     *
+     * async function doStuff(kysely: typeof db) {
+     *   // ...
+     * }
      * ```
      */
     transaction() {
@@ -219,6 +244,10 @@ class Kysely extends query_creator_js_1.QueryCreator {
      *     // the same connection.
      *     await doStuff(db)
      *   })
+     *
+     * async function doStuff(kysely: typeof db) {
+     *   // ...
+     * }
      * ```
      */
     connection() {
@@ -262,7 +291,6 @@ class Kysely extends query_creator_js_1.QueryCreator {
      *
      * The following example adds and uses a temporary table:
      *
-     * @example
      * ```ts
      * await db.schema
      *   .createTable('temp_table')
@@ -311,7 +339,7 @@ class Kysely extends query_creator_js_1.QueryCreator {
     /**
      * Executes a given compiled query or query builder.
      *
-     * See {@link https://github.com/koskimas/kysely/blob/master/site/docs/recipes/splitting-build-compile-and-execute-code.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
+     * See {@link https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0004-splitting-query-building-and-execution.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
      */
     executeQuery(query, queryId = (0, query_id_js_1.createQueryId)()) {
         const compiledQuery = (0, compilable_js_1.isCompilable)(query) ? query.compile() : query;
@@ -352,9 +380,6 @@ class Transaction extends Kysely {
             executor: this.#props.executor.withoutPlugins(),
         });
     }
-    /**
-     * @override
-     */
     withSchema(schema) {
         return new Transaction({
             ...this.#props,
@@ -373,7 +398,6 @@ function isKyselyProps(obj) {
         (0, object_utils_js_1.isObject)(obj.executor) &&
         (0, object_utils_js_1.isObject)(obj.dialect));
 }
-exports.isKyselyProps = isKyselyProps;
 class ConnectionBuilder {
     #props;
     constructor(props) {

package/dist/cjs/migration/file-migration-provider.d.ts

@@ -5,8 +5,8 @@ import { Migration, MigrationProvider } from './migrator.js';
  * ### Examples
  *
  * ```ts
- * import { promises as fs } from 'fs'
- * import path from 'path'
+ * import { promises as fs } from 'node:fs'
+ * import path from 'node:path'
  *
  * new FileMigrationProvider({
  *   fs,

package/dist/cjs/migration/file-migration-provider.js

@@ -8,8 +8,8 @@ const object_utils_js_1 = require("../util/object-utils.js");
  * ### Examples
  *
  * ```ts
- * import { promises as fs } from 'fs'
- * import path from 'path'
+ * import { promises as fs } from 'node:fs'
+ * import path from 'node:path'
  *
  * new FileMigrationProvider({
  *   fs,

package/dist/cjs/migration/migrator.d.ts

@@ -25,16 +25,29 @@ export interface Migration {
  * other way.
  *
  * ```ts
- * import { promises as fs } from 'fs'
- * import path from 'path'
+ * import { promises as fs } from 'node:fs'
+ * import path from 'node:path'
+ * import * as Sqlite from 'better-sqlite3'
+ * import {
+ *   FileMigrationProvider,
+ *   Kysely,
+ *   Migrator,
+ *   SqliteDialect
+ * } from 'kysely'
+ *
+ * const db = new Kysely<any>({
+ *   dialect: new SqliteDialect({
+ *     database: Sqlite(':memory:')
+ *   })
+ * })
  *
  * const migrator = new Migrator({
  *   db,
  *   provider: new FileMigrationProvider({
  *     fs,
- *     path,
  *     // Path to the folder that contains all your migrations.
- *     migrationFolder: 'some/path/to/migrations'
+ *     migrationFolder: 'some/path/to/migrations',
+ *     path,
  *   })
  * })
  * ```
@@ -64,19 +77,18 @@ export declare class Migrator {
      * ### Examples
      *
      * ```ts
-     * const db = new Kysely<Database>({
-     *   dialect: new PostgresDialect({
-     *     host: 'localhost',
-     *     database: 'kysely_test',
-     *   }),
-     * })
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import * as Sqlite from 'better-sqlite3'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
      *
      * const migrator = new Migrator({
      *   db,
-     *   provider: new FileMigrationProvider(
-     *     // Path to the folder that contains all your migrations.
-     *     'some/path/to/migrations'
-     *   )
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
      * })
      *
      * const { error, results } = await migrator.migrateToLatest()
@@ -107,6 +119,20 @@ export declare class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateTo('some_migration')
      * ```
      *
@@ -116,6 +142,20 @@ export declare class Migrator {
      * you can use a special constant `NO_MIGRATIONS`:
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator, NO_MIGRATIONS } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateTo(NO_MIGRATIONS)
      * ```
      */
@@ -131,6 +171,20 @@ export declare class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateUp()
      * ```
      */
@@ -146,6 +200,20 @@ export declare class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateDown()
      * ```
      */