kysely 0.27.3 → 0.27.5

package/.renovaterc.json

@@ -0,0 +1,3 @@
+{
+  "rangeStrategy": "bump"  
+}

package/CONTRIBUTING.md

@@ -15,7 +15,7 @@ There are quite a few guidelines to keep in mind:
 
 * Kysely should have zero dependencies.
 
-* Kysely should work in all javascript environments (node.js, deno & modern browsers), 
+* Kysely should work in all JavaScript environments (node.js, deno & modern browsers), 
 even though the main focus is node.js.
 
 * Everything is immutable.
@@ -52,7 +52,7 @@ for all cases, are best left for consumers to implement.
 
 5. create a branch.
 
-6. create a draft pull request. link the relevant issue by refering to it in the 
+6. create a draft pull request. link the relevant issue by referring to it in the 
 PR's description. E.g. `closes #123` will link the PR to issue/pull request #123.
 
 7. implement your changes.

package/README.md

@@ -5,16 +5,16 @@
 [![License](https://img.shields.io/github/license/kysely-org/kysely?style=flat)](https://github.com/kysely-org/kysely/blob/master/LICENSE)
 [![Issues](https://img.shields.io/github/issues-closed/kysely-org/kysely?logo=github)](https://github.com/kysely-org/kysely/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)
 [![Pull Requests](https://img.shields.io/github/issues-pr-closed/kysely-org/kysely?label=PRs&logo=github&style=flat)](https://github.com/kysely-org/kysely/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc)
-[![Vulnerabilities](https://img.shields.io/snyk/vulnerabilities/github/kysely-org/kysely?style=flat&logo=snyk)](https://snyk.io/advisor/npm-package/kysely)
 [![Downloads](https://img.shields.io/npm/dw/kysely?logo=npm)](https://www.npmjs.com/package/kysely)
 [![Bundle Size](https://img.shields.io/bundlephobia/minzip/kysely?label=size&logo=npm)](https://bundlephobia.com/package/kysely)
 [![Social](https://img.shields.io/twitter/follow/kysely_?style=social)](https://twitter.com/kysely_)
 
 # [Kysely](https://kysely.dev)
 
-Kysely (pronounce “Key-Seh-Lee”) is a type-safe and autocompletion-friendly typescript SQL query builder.
-Inspired by [knex](http://knexjs.org/). Mainly developed for [node.js](https://nodejs.org/en/) but also
-runs on all other javascript environments like [deno](https://deno.land/).
+Kysely (pronounce “Key-Seh-Lee”) is a type-safe and autocompletion-friendly [TypeScript](https://www.typescriptlang.org/) [SQL](https://en.wikipedia.org/wiki/SQL) query builder.
+Inspired by [Knex.js](http://knexjs.org/). Mainly developed for [Node.js](https://nodejs.org/en/) but also
+runs on all other [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript) environments like [Deno](https://deno.com/), [Bun](https://bun.sh/), [Cloudflare Workers](https://workers.cloudflare.com/)
+and web browsers.
 
 ![](https://github.com/kysely-org/kysely/blob/master/assets/demo.gif)
 
@@ -22,7 +22,7 @@ Kysely makes sure you only refer to tables and columns that are visible to the p
 you're writing. The result type only has the selected columns with correct types and aliases. As an
 added bonus you get autocompletion for all that stuff.
 
-As shown in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
+As shown in the gif above, through the pure magic of modern TypeScript, Kysely is even able to parse
 the alias given to `pet.name` and add the `pet_name` column to the result row type. Kysely is able to infer
 column names, aliases and types from selected subqueries, joined subqueries, `with` statements and pretty
 much anything you can think of.
@@ -35,12 +35,12 @@ All API documentation is written in the typing files and you can simply hover ov
 or method you're using to see it in your IDE. The same documentation is also hosted [here](https://kysely-org.github.io/kysely-apidoc/).
 
 If you start using Kysely and can't find something you'd want to use, please open an issue or join our
-[discord server](https://discord.gg/xyBJ3GwvAm).
+[Discord server](https://discord.gg/xyBJ3GwvAm).
 
 # Getting started
 
 Please visit our documentation site [kysely.dev](https://kysely.dev) to get started. We also have a comprehensive
-API documentation hosted [here](https://kysely-org.github.io/kysely-apidoc/) but you can access the same
+API documentation hosted [here](https://kysely-org.github.io/kysely-apidoc/), but you can access the same
 documentation in your IDE by hovering over a class/method/property/whatever.
 
 # Contributors

package/deno.check.d.ts

@@ -0,0 +1,86 @@
+import type {
+  ColumnType,
+  Generated,
+  GeneratedAlways,
+  Insertable,
+  Kysely,
+  Selectable,
+  SqlBool,
+  Updateable,
+} from './dist/esm'
+
+export interface Database {
+  person: PersonTable
+  pet: PetTable
+  toy: ToyTable
+  wine: WineTable
+  wine_stock_change: WineStockChangeTable
+}
+
+interface PersonTable {
+  id: Generated<number>
+  address: { city: string } | null
+  age: number | null
+  birthdate: ColumnType<Date | null, string | null | undefined, string | null>
+  created_at: GeneratedAlways<Date>
+  deleted_at: ColumnType<Date | null, string | null | undefined, string | null>
+  experience: { role: string }[] | null
+  first_name: string
+  gender: 'male' | 'female' | 'other' | null
+  has_pets: Generated<'Y' | 'N'>
+  last_name: string | null
+  middle_name: string | null
+  nicknames: string[] | null
+  nullable_column: string | null
+  profile: {
+    addresses: { city: string }[]
+    website: { url: string }
+  } | null
+  updated_at: ColumnType<Date | null, string | null | undefined, string | null>
+  marital_status: 'single' | 'married' | 'divorced' | 'widowed' | null
+}
+
+interface PetTable {
+  id: Generated<number>
+  created_at: GeneratedAlways<Date>
+  is_favorite: Generated<SqlBool>
+  name: string
+  owner_id: number
+  species: Species
+}
+
+interface ToyTable {
+  id: Generated<number>
+  pet_id: number
+  price: number
+}
+
+interface WineTable {
+  name: string
+  stock: number
+}
+
+interface WineStockChangeTable {
+  stock_delta: number
+  wine_name: string
+}
+
+export type Person = Selectable<PersonTable>
+export type NewPerson = Insertable<PersonTable>
+export type PersonUpdate = Updateable<PersonTable>
+export type Pet = Selectable<PetTable>
+export type NewPet = Insertable<PetTable>
+export type PetUpdate = Updateable<PetTable>
+export type Species = 'dog' | 'cat' | 'hamster'
+
+declare global {
+  // @ts-ignore
+  export class Buffer {
+    static isBuffer(obj: unknown): obj is { length: number }
+    static compare(a: Buffer, b: Buffer): number
+  }
+  export const db: Kysely<Database>
+  export function functionThatExpectsPersonWithNonNullValue(
+    person: Person & { nullable_column: string },
+  ): void
+}

package/deno.check.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://deno.land/x/deno/cli/schemas/config-file.v1.json",
+  "compilerOptions": {
+    "types": ["./deno.check.d.ts"]
+  },
+  "imports": {
+    "better-sqlite3": "npm:better-sqlite3",
+    "kysely": "./dist/esm",
+    "kysely/helpers/mssql": "./dist/esm/helpers/mssql.js",
+    "kysely/helpers/mysql": "./dist/esm/helpers/mysql.js",
+    "kysely/helpers/postgres": "./dist/esm/helpers/postgres.js",
+    "kysely/helpers/sqlite": "./dist/esm/helpers/sqlite.js",
+    "lodash/snakeCase": "npm:lodash/snakeCase",
+    "mysql2": "npm:mysql2",
+    "pg": "npm:pg",
+    "pg-cursor": "npm:pg-cursor",
+    "tarn": "npm:tarn",
+    "tedious": "npm:tedious",
+    "type-editor": "./deno.check.d.ts"
+  }
+}

package/dist/cjs/dialect/dialect-adapter-base.d.ts

@@ -2,7 +2,7 @@ import { Kysely } from '../kysely.js';
 import { DialectAdapter, MigrationLockOptions } from './dialect-adapter.js';
 /**
  * A basic implementation of `DialectAdapter` with sensible default values.
- * 3rd party dialects can extend this instead of implementing the `DialectAdapter`
+ * Third-party dialects can extend this instead of implementing the `DialectAdapter`
  * interface from scratch. That way all new settings will get default values when
  * they are added and there will be less breaking changes.
  */
@@ -26,6 +26,7 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * updates and deletes.
      */
     get supportsReturning(): boolean;
+    get supportsOutput(): boolean;
     /**
      * This method is used to acquire a lock for the migrations so that
      * it's not possible for two migration operations to run in parallel.
@@ -46,8 +47,13 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * import { DialectAdapterBase, type MigrationLockOptions, Kysely } from 'kysely'
+     *
+     * export class MyAdapter extends DialectAdapterBase {
+     *   override async acquireMigrationLock(
+     *     db: Kysely<any>,
+     *     options: MigrationLockOptions
+     *   ): Promise<void> {
      *     const queryDb = options.lockTableSchema
      *       ? db.withSchema(options.lockTableSchema)
      *       : db
@@ -63,6 +69,10 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

package/dist/cjs/dialect/dialect-adapter-base.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DialectAdapterBase = void 0;
 /**
  * A basic implementation of `DialectAdapter` with sensible default values.
- * 3rd party dialects can extend this instead of implementing the `DialectAdapter`
+ * Third-party dialects can extend this instead of implementing the `DialectAdapter`
  * interface from scratch. That way all new settings will get default values when
  * they are added and there will be less breaking changes.
  */
@@ -17,5 +17,8 @@ class DialectAdapterBase {
     get supportsReturning() {
         return false;
     }
+    get supportsOutput() {
+        return false;
+    }
 }
 exports.DialectAdapterBase = DialectAdapterBase;

package/dist/cjs/dialect/dialect-adapter.d.ts

@@ -27,6 +27,11 @@ export interface DialectAdapter {
      * updates and deletes.
      */
     readonly supportsReturning: boolean;
+    /**
+     * Whether or not this dialect supports the `output` clause in inserts
+     * updates and deletes.
+     */
+    readonly supportsOutput?: boolean;
     /**
      * This method is used to acquire a lock for the migrations so that
      * it's not possible for two migration operations to run in parallel.
@@ -47,8 +52,13 @@ export interface DialectAdapter {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * import { DialectAdapterBase, type MigrationLockOptions, Kysely } from 'kysely'
+     *
+     * export class MyAdapter extends DialectAdapterBase {
+     *   override async acquireMigrationLock(
+     *     db: Kysely<any>,
+     *     options: MigrationLockOptions
+     *   ): Promise<void> {
      *     const queryDb = options.lockTableSchema
      *       ? db.withSchema(options.lockTableSchema)
      *       : db
@@ -64,6 +74,10 @@ export interface DialectAdapter {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

package/dist/cjs/dialect/mssql/mssql-adapter.d.ts

@@ -15,11 +15,7 @@ export declare class MssqlAdapter extends DialectAdapterBase {
      * If this is true, migrations are executed inside a transaction.
      */
     get supportsTransactionalDdl(): boolean;
-    /**
-     * Whether or not this dialect supports the `returning` in inserts
-     * updates and deletes.
-     */
-    get supportsReturning(): boolean;
+    get supportsOutput(): boolean;
     /**
      * This method is used to acquire a lock for the migrations so that
      * it's not possible for two migration operations to run in parallel.
@@ -40,8 +36,13 @@ export declare class MssqlAdapter extends DialectAdapterBase {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * import { DialectAdapterBase, type MigrationLockOptions, Kysely } from 'kysely'
+     *
+     * export class MyAdapter extends DialectAdapterBase {
+     *   override async acquireMigrationLock(
+     *     db: Kysely<any>,
+     *     options: MigrationLockOptions
+     *   ): Promise<void> {
      *     const queryDb = options.lockTableSchema
      *       ? db.withSchema(options.lockTableSchema)
      *       : db
@@ -57,6 +58,10 @@ export declare class MssqlAdapter extends DialectAdapterBase {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

package/dist/cjs/dialect/mssql/mssql-adapter.js

@@ -11,10 +11,8 @@ class MssqlAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
     get supportsTransactionalDdl() {
         return true;
     }
-    get supportsReturning() {
-        // mssql should support returning with the `output` clause.
-        // we need to figure this out when we'll introduce support for it.
-        return false;
+    get supportsOutput() {
+        return true;
     }
     async acquireMigrationLock(db) {
         // Acquire a transaction-level exclusive lock on the migrations table.

package/dist/cjs/dialect/mssql/mssql-dialect-config.d.ts

@@ -6,21 +6,23 @@ export interface MssqlDialectConfig {
      * (excluding `create`, `destroy` and `validate` functions which are controlled by this dialect),
      * `min` & `max` connections at the very least.
      *
-     * Example:
+     * ### Examples
      *
      * ```ts
+     * import { MssqlDialect } from 'kysely'
      * import * as Tarn from 'tarn'
+     * import * as Tedious from 'tedious'
      *
      * const dialect = new MssqlDialect({
-     *   // ...
-     *   tarn: {
-     *     ...Tarn,
-     *     options: {
+     *   tarn: { ...Tarn, options: { max: 10, min: 0 } },
+     *   tedious: {
+     *     ...Tedious,
+     *     connectionFactory: () => new Tedious.Connection({
      *       // ...
-     *       min: 0,
-     *       max: 10,
-     *     },
-     *   },
+     *       server: 'localhost',
+     *       // ...
+     *     }),
+     *   }
      * })
      * ```
      */
@@ -31,17 +33,23 @@ export interface MssqlDialectConfig {
      * you need to pass the `tedious` package itself. You also need to pass a factory
      * function that creates new `tedious` `Connection` instances on demand.
      *
-     * Example:
+     * ### Examples
      *
      * ```ts
+     * import { MssqlDialect } from 'kysely'
+     * import * as Tarn from 'tarn'
      * import * as Tedious from 'tedious'
      *
      * const dialect = new MssqlDialect({
-     *   // ...
+     *   tarn: { ...Tarn, options: { max: 10, min: 0 } },
      *   tedious: {
      *     ...Tedious,
-     *     connectionFactory: () => new Tedious.Connection({ ... }),
-     *   },
+     *     connectionFactory: () => new Tedious.Connection({
+     *       // ...
+     *       server: 'localhost',
+     *       // ...
+     *     }),
+     *   }
      * })
      * ```
      */
@@ -50,39 +58,66 @@ export interface MssqlDialectConfig {
 export interface Tedious {
     connectionFactory: () => TediousConnection | Promise<TediousConnection>;
     ISOLATION_LEVEL: TediousIsolationLevel;
-    Request: typeof TediousRequest;
+    Request: TediousRequestClass;
     TYPES: TediousTypes;
-}
-export type TediousIsolationLevel = Record<'NO_CHANGE' | 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE' | 'SNAPSHOT', number>;
-export type TediousTypes = Record<'BigInt' | 'Binary' | 'Bit' | 'Char' | 'Date' | 'DateTime' | 'DateTime2' | 'DateTimeOffset' | 'Decimal' | 'Float' | 'Image' | 'Int' | 'Money' | 'NChar' | 'NText' | 'Null' | 'Numeric' | 'NVarChar' | 'Real' | 'SmallDateTime' | 'SmallInt' | 'SmallMoney' | 'Text' | 'Time' | 'TinyInt' | 'TVP' | 'UDT' | 'UniqueIdentifier' | 'VarBinary' | 'VarChar' | 'Xml', {
-    name: string;
-    type: string;
-}>;
-export interface TediousType {
-    name: string;
-    type: string;
+    /**
+     * Controls whether connections are reset to their initial states when released back to the pool. Resetting a connection performs additional requests to the database.
+     * See {@link https://tediousjs.github.io/tedious/api-connection.html#function_reset | connection.reset}.
+     *
+     * Defaults to `true`.
+     */
+    resetConnectionOnRelease?: boolean;
 }
 export interface TediousConnection {
-    beginTransaction(callback: (error?: Error) => void, transactionId?: string | undefined, isolationLevel?: number | undefined): void;
-    cancel(): void;
+    beginTransaction(callback: (error?: Error | null, transactionDescriptor?: any) => void, name?: string, isolationLevel?: number): void;
+    cancel(): boolean;
     close(): void;
-    commitTransaction(callback: (error?: Error) => void): void;
-    connect(callback: (error?: Error) => void): void;
+    commitTransaction(callback: (error?: Error | null) => void, name?: string): void;
+    connect(callback?: (error?: Error) => void): void;
     execSql(request: TediousRequest): void;
-    reset(callback: (error?: Error) => void): void;
-    rollbackTransaction(callback: (error?: Error) => void): void;
-    once(event: 'end', listener: () => void): void;
+    off(event: 'error', listener: (error: unknown) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    on(event: 'error', listener: (error: unknown) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: 'end', listener: () => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    reset(callback: (error?: Error | null) => void): void;
+    rollbackTransaction(callback: (error?: Error | null) => void, name?: string): void;
+    saveTransaction(callback: (error?: Error | null) => void, name: string): void;
+}
+export type TediousIsolationLevel = Record<string, number>;
+export interface TediousRequestClass {
+    new (sqlTextOrProcedure: string | undefined, callback: (error?: Error | null, rowCount?: number, rows?: any) => void, options?: {
+        statementColumnEncryptionSetting?: any;
+    }): TediousRequest;
 }
 export declare class TediousRequest {
-    constructor(sql: string, callback: (error: Error, rowCount: number, rows: any[]) => void);
-    addParameter(name: string, type: TediousType, value: any, options?: {
-        length?: number | 'max' | undefined;
-        precision?: number | undefined;
-        scale?: number | undefined;
-    }): void;
-    off(event: 'row', listener: (...args: any[]) => void): void;
-    on(event: 'row', listener: (columns: TediousColumnValue[]) => void): void;
-    once(event: 'requestCompleted', listener: (...args: any[]) => void): void;
+    addParameter(name: string, dataType: TediousDataType, value?: unknown, options?: Readonly<{
+        output?: boolean;
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }> | null): void;
+    off(event: 'row', listener: (columns: any) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    on(event: 'row', listener: (columns: any) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: 'requestCompleted', listener: () => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    pause(): void;
+    resume(): void;
+}
+export interface TediousTypes {
+    NVarChar: TediousDataType;
+    BigInt: TediousDataType;
+    Int: TediousDataType;
+    Float: TediousDataType;
+    Bit: TediousDataType;
+    DateTime: TediousDataType;
+    VarBinary: TediousDataType;
+    [x: string]: TediousDataType;
+}
+export interface TediousDataType {
 }
 export interface TediousColumnValue {
     metadata: {
@@ -95,23 +130,16 @@ export interface Tarn {
      * Tarn.js' pool options, excluding `create`, `destroy` and `validate` functions,
      * which must be implemented by this dialect.
      */
-    options: Omit<TarnPoolOptions<any>, 'create' | 'destroy' | 'validate'>;
+    options: Omit<TarnPoolOptions<any>, 'create' | 'destroy' | 'validate'> & {
+        /**
+         * Controls whether connections are validated before being acquired from the pool. Connection validation performs additional requests to the database.
+         *
+         * Defaults to `true`.
+         */
+        validateConnections?: boolean;
+    };
     /**
      * Tarn.js' Pool class.
-     *
-     * Example:
-     *
-     * ```ts
-     * import { Pool } from 'tarn'
-     *
-     * const dialect = new MssqlDialect({
-     *   // ...
-     *   tarn: {
-     *     // ...
-     *     Pool,
-     *   },
-     * })
-     * ```
      */
     Pool: typeof TarnPool;
 }
@@ -134,7 +162,7 @@ export interface TarnPoolOptions<R> {
     min: number;
     propagateCreateError?: boolean;
     reapIntervalMillis?: number;
-    validate(resource: R): boolean;
+    validate?(resource: R): boolean;
 }
 export interface TarnPendingRequest<R> {
     promise: Promise<R>;

package/dist/cjs/dialect/mssql/mssql-driver.d.ts

@@ -44,6 +44,7 @@ declare class MssqlConnection implements DatabaseConnection {
     constructor(connection: TediousConnection, tedious: Tedious);
     beginTransaction(settings: TransactionSettings): Promise<void>;
     commitTransaction(): Promise<void>;
+    connect(): Promise<this>;
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
     rollbackTransaction(): Promise<void>;
     streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;