kysely 0.25.0 → 0.26.0

package/dist/cjs/schema/create-table-builder.js

@@ -307,12 +307,6 @@ class CreateTableBuilder {
     $call(func) {
         return func(this);
     }
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call(func) {
-        return this.$call(func);
-    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }

package/dist/cjs/schema/schema.d.ts

@@ -139,8 +139,7 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .alterTable('person')
-     *   .alterColumn('first_name')
-     *   .setDataType('text')
+     *   .alterColumn('first_name', (ac) => ac.setDataType('text'))
      *   .execute()
      * ```
      */

package/dist/cjs/schema/schema.js

@@ -193,8 +193,7 @@ class SchemaModule {
      * ```ts
      * await db.schema
      *   .alterTable('person')
-     *   .alterColumn('first_name')
-     *   .setDataType('text')
+     *   .alterColumn('first_name', (ac) => ac.setDataType('text'))
      *   .execute()
      * ```
      */

package/dist/cjs/util/column-type.d.ts

@@ -1,4 +1,3 @@
-import { DrainOuterGeneric } from './type-utils.js';
 /**
  * This type can be used to specify a different type for
  * select, insert and update operations.
@@ -34,7 +33,7 @@ import { DrainOuterGeneric } from './type-utils.js';
  * ColumnType<Date, string, never>
  * ```
  */
-export declare type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectType> = {
+export type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectType> = {
     readonly __select__: SelectType;
     readonly __insert__: InsertType;
     readonly __update__: UpdateType;
@@ -52,50 +51,55 @@ export declare type ColumnType<SelectType, InsertType = SelectType, UpdateType =
  * type Generated<S> = ColumnType<S, S | undefined, S>
  * ```
  */
-export declare type Generated<S> = ColumnType<S, S | undefined, S>;
+export type Generated<S> = ColumnType<S, S | undefined, S>;
 /**
  * A shortcut for defining columns that are only database-generated
  * (like postgres GENERATED ALWAYS AS IDENTITY). No insert/update
  * is allowed.
  */
-export declare type GeneratedAlways<S> = ColumnType<S, never, never>;
+export type GeneratedAlways<S> = ColumnType<S, never, never>;
+/**
+ * A shortcut for defining JSON columns, which are by default inserted/updated
+ * as stringified JSON strings.
+ */
+export type JSONColumnType<SelectType extends object | null, InsertType = string, UpdateType = string> = ColumnType<SelectType, InsertType, UpdateType>;
 /**
  * Evaluates to `K` if `T` can be `null` or `undefined`.
  */
-declare type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
+type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
 /**
  * Evaluates to `K` if `T` can't be `null` or `undefined`.
  */
-declare type IfNotNullable<T, K> = undefined extends T ? never : null extends T ? never : T extends never ? never : K;
+type IfNotNullable<T, K> = undefined extends T ? never : null extends T ? never : T extends never ? never : K;
 /**
  * Evaluates to `K` if `T` isn't `never`.
  */
-declare type IfNotNever<T, K> = T extends never ? never : K;
-export declare type SelectType<T> = T extends ColumnType<infer S, any, any> ? S : T;
-export declare type InsertType<T> = T extends ColumnType<any, infer I, any> ? I : T;
-export declare type UpdateType<T> = T extends ColumnType<any, any, infer U> ? U : T;
+type IfNotNever<T, K> = T extends never ? never : K;
+export type SelectType<T> = T extends ColumnType<infer S, any, any> ? S : T;
+export type InsertType<T> = T extends ColumnType<any, infer I, any> ? I : T;
+export type UpdateType<T> = T extends ColumnType<any, any, infer U> ? U : T;
 /**
  * Keys of `R` whose `InsertType` values can be `null` or `undefined`.
  */
-export declare type NullableInsertKeys<R> = {
+export type NullableInsertKeys<R> = {
     [K in keyof R]: IfNullable<InsertType<R[K]>, K>;
 }[keyof R];
 /**
  * Keys of `R` whose `InsertType` values can't be `null` or `undefined`.
  */
-export declare type NonNullableInsertKeys<R> = {
+export type NonNullableInsertKeys<R> = {
     [K in keyof R]: IfNotNullable<InsertType<R[K]>, K>;
 }[keyof R];
 /**
  * Keys of `R` whose `SelectType` values are not `never`
  */
-declare type NonNeverSelectKeys<R> = {
+type NonNeverSelectKeys<R> = {
     [K in keyof R]: IfNotNever<SelectType<R[K]>, K>;
 }[keyof R];
 /**
  * Keys of `R` whose `UpdateType` values are not `never`
  */
-export declare type UpdateKeys<R> = {
+export type UpdateKeys<R> = {
     [K in keyof R]: IfNotNever<UpdateType<R[K]>, K>;
 }[keyof R];
 /**
@@ -119,9 +123,9 @@ export declare type UpdateKeys<R> = {
  * // }
  * ```
  */
-export declare type Selectable<R> = DrainOuterGeneric<{
+export type Selectable<R> = {
     [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
-}>;
+};
 /**
  * Given a table interface, extracts the insert type from all
  * {@link ColumnType} types.
@@ -143,7 +147,7 @@ export declare type Selectable<R> = DrainOuterGeneric<{
  * // }
  * ```
  */
-export declare type Insertable<R> = {
+export type Insertable<R> = {
     [K in NonNullableInsertKeys<R>]: InsertType<R[K]>;
 } & {
     [K in NullableInsertKeys<R>]?: InsertType<R[K]>;
@@ -168,7 +172,7 @@ export declare type Insertable<R> = {
  * // }
  * ```
  */
-export declare type Updateable<R> = {
+export type Updateable<R> = {
     [K in UpdateKeys<R>]?: UpdateType<R[K]>;
 };
 export {};

package/dist/cjs/util/explainable.d.ts

@@ -1,5 +1,5 @@
 import { Expression } from '../expression/expression.js';
-export declare type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
+export type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
 export interface Explainable {
     /**
      * Executes query with `explain` statement before the main query.

package/dist/cjs/util/infer-result.d.ts

@@ -41,6 +41,6 @@ import { Compilable } from './compilable.js';
  * type QueryResult = InferResult<typeof compiledQuery> // Selectable<Person>[]
  * ```
  */
-export declare type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
-declare type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult ? O : O[];
+export type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
+type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult ? O : O[];
 export {};

package/dist/cjs/util/log.d.ts

@@ -1,7 +1,7 @@
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { ArrayItemType } from './type-utils.js';
 export declare const LOG_LEVELS: readonly ["query", "error"];
-export declare type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
+export type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
 export interface QueryLogEvent {
     readonly level: 'query';
     readonly query: CompiledQuery;
@@ -13,9 +13,9 @@ export interface ErrorLogEvent {
     readonly query: CompiledQuery;
     readonly queryDurationMillis: number;
 }
-export declare type LogEvent = QueryLogEvent | ErrorLogEvent;
-export declare type Logger = (event: LogEvent) => void | Promise<void>;
-export declare type LogConfig = ReadonlyArray<LogLevel> | Logger;
+export type LogEvent = QueryLogEvent | ErrorLogEvent;
+export type Logger = (event: LogEvent) => void | Promise<void>;
+export type LogConfig = ReadonlyArray<LogLevel> | Logger;
 export declare class Log {
     #private;
     constructor(config: LogConfig);

package/dist/cjs/util/require-all-props.d.ts

@@ -3,7 +3,7 @@
  *
  * Similar to Required<T> build-in type, but allows `undefined` values.
  */
-declare type AllProps<T> = T & {
+type AllProps<T> = T & {
     [P in keyof T]-?: unknown;
 };
 /**

package/dist/cjs/util/type-utils.d.ts

@@ -34,13 +34,13 @@ import { KyselyTypeError } from './type-error.js';
  * // Columns == 'id' | 'name' | 'species'
  * ```
  */
-export declare type AnyColumn<DB, TB extends keyof DB> = DrainOuterGeneric<{
+export type AnyColumn<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [T in TB]: keyof DB[T];
 }[TB] & string>;
 /**
  * Extracts a column type.
  */
-export declare type ExtractColumnType<DB, TB extends keyof DB, C> = {
+export type ExtractColumnType<DB, TB extends keyof DB, C> = {
     [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
 }[TB];
 /**
@@ -74,60 +74,60 @@ export declare type ExtractColumnType<DB, TB extends keyof DB, C> = {
  * // Columns == 'person.id' | 'pet.name' | 'pet.species'
  * ```
  */
-export declare type AnyColumnWithTable<DB, TB extends keyof DB> = {
+export type AnyColumnWithTable<DB, TB extends keyof DB> = {
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${T}.${keyof DB[T]}` : never : never;
 }[TB];
 /**
  * Just like {@link AnyColumn} but with a ` as <string>` suffix.
  */
-export declare type AnyAliasedColumn<DB, TB extends keyof DB> = {
+export type AnyAliasedColumn<DB, TB extends keyof DB> = {
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${keyof DB[T]} as ${string}` : never : never;
 }[TB];
 /**
  * Just like {@link AnyColumnWithTable} but with a ` as <string>` suffix.
  */
-export declare type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
+export type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${T}.${keyof DB[T]} as ${string}` : never : never;
 }[TB];
 /**
  * Extracts the item type of an array.
  */
-export declare type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
+export type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
 /**
  * Any select query builder.
  */
-export declare type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
-export declare type SimplifySingleResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O> | undefined;
-export declare type SimplifyResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O>;
-export declare type Simplify<T> = DrainOuterGeneric<{
+export type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
+export type SimplifySingleResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O> | undefined;
+export type SimplifyResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O>;
+export type Simplify<T> = DrainOuterGeneric<{
     [K in keyof T]: T[K];
 } & {}>;
 /**
  * Represents a database row whose column names and their types are unknown.
  */
-export declare type UnknownRow = Record<string, unknown>;
+export type UnknownRow = Record<string, unknown>;
 /**
  * Makes all properties of object type `T` nullable.
  */
-export declare type Nullable<T> = {
+export type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
 /**
  * Evaluates to `true` if `T` is `never`.
  */
-export declare type IsNever<T> = [T] extends [never] ? true : false;
+export type IsNever<T> = [T] extends [never] ? true : false;
 /**
  * Evaluates to `true` if `T` is `any`.
  */
-export declare type IsAny<T> = 0 extends T & 1 ? true : false;
+export type IsAny<T> = 0 extends T & 1 ? true : false;
 /**
  * Evaluates to `true` if the types `T` and `U` are equal.
  */
-export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
-export declare type NarrowPartial<S, T> = DrainOuterGeneric<{
+export type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+export type NarrowPartial<S, T> = DrainOuterGeneric<{
     [K in keyof S & string]: K extends keyof T ? T[K] extends S[K] ? T[K] : KyselyTypeError<`$narrowType() call failed: passed type does not exist in '${K}'s type union`> : S[K];
 }>;
-export declare type SqlBool = boolean | 0 | 1;
+export type SqlBool = boolean | 0 | 1;
 /**
  * Utility to reduce depth of TypeScript's internal type instantiation stack.
  *
@@ -155,7 +155,7 @@ export declare type SqlBool = boolean | 0 | 1;
  * type Ok = Test<number> // Ok
  * ```
  */
-export declare type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
-export declare type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
     [P in K]: T;
 }>;

package/dist/esm/dialect/database-introspector.d.ts

@@ -30,7 +30,7 @@ export interface SchemaMetadata {
 export interface DatabaseMetadata {
     /**
      * The tables and views found in the database.
-  *  * The propery isView can be used to tell them apart.
+     * The propery isView can be used to tell them apart.
      */
     readonly tables: TableMetadata[];
 }

package/dist/esm/dialect/mysql/mysql-dialect-config.d.ts

@@ -1,5 +1,4 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
-import { ShallowRecord } from '../../util/type-utils.js';
 /**
  * Config for the MySQL dialect.
  *
@@ -47,6 +46,7 @@ export interface MysqlStream<T> {
 }
 export interface MysqlOkPacket {
     affectedRows: number;
+    changedRows: number;
     insertId: number;
 }
-export declare type MysqlQueryResult = MysqlOkPacket | ShallowRecord<string, unknown>[];
+export type MysqlQueryResult = MysqlOkPacket | Record<string, unknown>[];

package/dist/esm/dialect/mysql/mysql-driver.js

@@ -83,10 +83,13 @@ class MysqlConnection {
         try {
             const result = await this.#executeQuery(compiledQuery);
             if (isOkPacket(result)) {
-                const { insertId, affectedRows } = result;
+                const { insertId, affectedRows, changedRows } = result;
                 const numAffectedRows = affectedRows !== undefined && affectedRows !== null
                     ? BigInt(affectedRows)
                     : undefined;
+                const numChangedRows = changedRows !== undefined && changedRows !== null
+                    ? BigInt(changedRows)
+                    : undefined;
                 return {
                     insertId: insertId !== undefined &&
                         insertId !== null &&
@@ -96,6 +99,7 @@ class MysqlConnection {
                     // TODO: remove.
                     numUpdatedOrDeletedRows: numAffectedRows,
                     numAffectedRows,
+                    numChangedRows,
                     rows: [],
                 };
             }

package/dist/esm/dialect/postgres/postgres-dialect-config.d.ts

@@ -50,7 +50,7 @@ export interface PostgresCursor<T> {
     read(rowsCount: number): Promise<T[]>;
     close(): Promise<void>;
 }
-export declare type PostgresCursorConstructor = new <T>(sql: string, parameters: unknown[]) => PostgresCursor<T>;
+export type PostgresCursorConstructor = new <T>(sql: string, parameters: unknown[]) => PostgresCursor<T>;
 export interface PostgresQueryResult<R> {
     command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT';
     rowCount: number;

package/dist/esm/dialect/postgres/postgres-introspector.js

@@ -48,10 +48,7 @@ export class PostgresIntrospector {
                 .as('auto_incrementing'),
         ])
             // r == normal table
-            .where(({ cmpr, or }) => or([
-            cmpr('c.relkind', '=', 'r'),
-            cmpr('c.relkind', '=', 'v'),
-        ]))
+            .where((eb) => eb.or([eb('c.relkind', '=', 'r'), eb('c.relkind', '=', 'v')]))
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -12,7 +12,7 @@ export class SqliteIntrospector {
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
-            .selectFrom('sqlite_schema')
+            .selectFrom('sqlite_master')
             .where('type', 'in', ['table', 'view'])
             .where('name', 'not like', 'sqlite_%')
             .select('name')

package/dist/esm/driver/database-connection.d.ts

@@ -18,6 +18,12 @@ export interface QueryResult<O> {
      * the number of rows the query inserted/updated/deleted.
      */
     readonly numAffectedRows?: bigint;
+    /**
+     * This is defined for update queries and contains the number of rows
+     * the query changed.
+     * This is optional and only provided by some drivers like node-mysql2.
+     */
+    readonly numChangedRows?: bigint;
     /**
      * This is defined for insert queries on dialects that return
      * the auto incrementing primary key from an insert.

package/dist/esm/driver/driver.d.ts

@@ -41,4 +41,4 @@ export interface TransactionSettings {
     readonly isolationLevel?: IsolationLevel;
 }
 export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable"];
-export declare type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;
+export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;