kysely 0.24.2 → 0.26.0

package/dist/esm/schema/create-index-builder.js

@@ -1,12 +1,11 @@
 /// <reference types="./create-index-builder.d.ts" />
 import { CreateIndexNode, } from '../operation-node/create-index-node.js';
-import { ListNode } from '../operation-node/list-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { parseColumnName } from '../parser/reference-parser.js';
+import { parseOrderedColumnName, } from '../parser/reference-parser.js';
 import { parseTable } from '../parser/table-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
-import { parseWhere, } from '../parser/binary-operation-parser.js';
+import { parseFilter, } from '../parser/binary-operation-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { ImmediateValueTransformer } from '../plugin/immediate-value/immediate-value-transformer.js';
 export class CreateIndexBuilder {
@@ -50,29 +49,62 @@ export class CreateIndexBuilder {
         });
     }
     /**
-     * Specifies the column for the index.
+     * Adds a column to the index.
      *
-     * Also see the `expression` for specifying an arbitrary expression.
+     * Also see {@link columns} for adding multiple columns at once or {@link expression}
+     * for specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .createIndex('person_first_name_and_age_index')
+     *         .on('person')
+     *         .column('first_name')
+     *         .column('age desc')
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+     * ```
      */
     column(column) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: CreateIndexNode.cloneWith(this.#props.node, {
-                expression: parseColumnName(column),
-            }),
+            node: CreateIndexNode.cloneWithColumns(this.#props.node, [
+                parseOrderedColumnName(column),
+            ]),
         });
     }
     /**
      * Specifies a list of columns for the index.
      *
-     * Also see the `expression` for specifying an arbitrary expression.
+     * Also see {@link column} for adding a single column or {@link expression} for
+     * specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .createIndex('person_first_name_and_age_index')
+     *         .on('person')
+     *         .columns(['first_name', 'age desc'])
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+     * ```
      */
     columns(columns) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: CreateIndexNode.cloneWith(this.#props.node, {
-                expression: ListNode.create(columns.map(parseColumnName)),
-            }),
+            node: CreateIndexNode.cloneWithColumns(this.#props.node, columns.map(parseOrderedColumnName)),
         });
     }
     /**
@@ -89,13 +121,19 @@ export class CreateIndexBuilder {
      *   .expression(sql`first_name COLLATE "fi_FI"`)
      *   .execute()
      * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_index" on "person" (first_name COLLATE "fi_FI")
+     * ```
      */
     expression(expression) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: CreateIndexNode.cloneWith(this.#props.node, {
-                expression: expression.toOperationNode(),
-            }),
+            node: CreateIndexNode.cloneWithColumns(this.#props.node, [
+                expression.toOperationNode(),
+            ]),
         });
     }
     using(indexType) {
@@ -110,7 +148,7 @@ export class CreateIndexBuilder {
         const transformer = new ImmediateValueTransformer();
         return new CreateIndexBuilder({
             ...this.#props,
-            node: QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode(parseWhere(args))),
+            node: QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode(parseFilter(args))),
         });
     }
     /**

package/dist/esm/schema/create-table-builder.d.ts

@@ -238,10 +238,6 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```
      */
     $call<T>(func: (qb: this) => T): T;
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call<T>(func: (qb: this) => T): T;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
@@ -251,5 +247,5 @@ export interface CreateTableBuilderProps {
     readonly executor: QueryExecutor;
     readonly node: CreateTableNode;
 }
-export declare type ColumnBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
-export declare type ForeignKeyConstraintBuilderCallback = (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder;
+export type ColumnBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
+export type ForeignKeyConstraintBuilderCallback = (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder;

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

@@ -305,12 +305,6 @@ export 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/esm/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/esm/schema/schema.js

@@ -191,8 +191,7 @@ export class SchemaModule {
      * ```ts
      * await db.schema
      *   .alterTable('person')
-     *   .alterColumn('first_name')
-     *   .setDataType('text')
+     *   .alterColumn('first_name', (ac) => ac.setDataType('text'))
      *   .execute()
      * ```
      */
@@ -200,7 +199,7 @@ export class SchemaModule {
         return new AlterTableBuilder({
             queryId: createQueryId(),
             executor: this.#executor,
-            node: AlterTableNode.create(table),
+            node: AlterTableNode.create(parseTable(table)),
         });
     }
     /**

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

@@ -33,7 +33,7 @@
  * 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;
@@ -51,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];
 /**
@@ -118,7 +123,7 @@ export declare type UpdateKeys<R> = {
  * // }
  * ```
  */
-export declare type Selectable<R> = {
+export type Selectable<R> = {
     [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
 };
 /**
@@ -142,7 +147,7 @@ export declare type Selectable<R> = {
  * // }
  * ```
  */
-export declare type Insertable<R> = {
+export type Insertable<R> = {
     [K in NonNullableInsertKeys<R>]: InsertType<R[K]>;
 } & {
     [K in NullableInsertKeys<R>]?: InsertType<R[K]>;
@@ -167,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/esm/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/esm/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/esm/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,13 +13,13 @@ export interface ErrorLogEvent {
     readonly query: CompiledQuery;
     readonly queryDurationMillis: number;
 }
-export declare type LogEvent = QueryLogEvent | ErrorLogEvent;
-export declare type Logger = (event: LogEvent) => 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);
     isLevelEnabled(level: LogLevel): boolean;
-    query(getEvent: () => QueryLogEvent): void;
-    error(getEvent: () => ErrorLogEvent): void;
+    query(getEvent: () => QueryLogEvent): Promise<void>;
+    error(getEvent: () => ErrorLogEvent): Promise<void>;
 }

package/dist/esm/util/log.js

@@ -23,14 +23,14 @@ export class Log {
     isLevelEnabled(level) {
         return this.#levels[level];
     }
-    query(getEvent) {
+    async query(getEvent) {
         if (this.#levels.query) {
-            this.#logger(getEvent());
+            await this.#logger(getEvent());
         }
     }
-    error(getEvent) {
+    async error(getEvent) {
         if (this.#levels.error) {
-            this.#logger(getEvent());
+            await this.#logger(getEvent());
         }
     }
 }

package/dist/esm/util/object-utils.d.ts

@@ -1,3 +1,4 @@
+import { ShallowRecord } from './type-utils.js';
 export declare function isEmpty(obj: ArrayLike<unknown> | string | object): boolean;
 export declare function isUndefined(obj: unknown): obj is undefined;
 export declare function isString(obj: unknown): obj is string;
@@ -10,7 +11,7 @@ export declare function isBuffer(obj: unknown): obj is {
     length: number;
 };
 export declare function isFunction(obj: unknown): obj is Function;
-export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+export declare function isObject(obj: unknown): obj is ShallowRecord<string, unknown>;
 export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;

package/dist/esm/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/esm/util/type-utils.d.ts

@@ -2,10 +2,7 @@ import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { InsertResult } from '../query-builder/insert-result.js';
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
-/**
- * Given an object type, extracts the union of all value types.
- */
-export declare type ValueType<T> = T[keyof T];
+import { KyselyTypeError } from './type-error.js';
 /**
  * Given a database type and a union of table names in that db, returns
  * a union type with all possible column names.
@@ -37,13 +34,13 @@ export declare type ValueType<T> = T[keyof T];
  * // Columns == 'id' | 'name' | 'species'
  * ```
  */
-export declare type AnyColumn<DB, TB extends keyof DB> = {
+export type AnyColumn<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [T in TB]: keyof DB[T];
-}[TB] & string;
+}[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];
 /**
@@ -77,71 +74,88 @@ 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> = {
+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;
 };
 /**
- * Takes all properties from T1 and merges all properties from T2
- * that don't exist in T1 as optional properties.
+ * Evaluates to `true` if `T` is `never`.
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Evaluates to `true` if `T` is `any`.
+ */
+export type IsAny<T> = 0 extends T & 1 ? true : false;
+/**
+ * Evaluates to `true` if the types `T` and `U` are equal.
+ */
+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 type SqlBool = boolean | 0 | 1;
+/**
+ * Utility to reduce depth of TypeScript's internal type instantiation stack.
  *
  * Example:
  *
- * interface Person {
- *   name: string
- *   age: number
- * }
+ * ```ts
+ * type A<T> = { item: T }
  *
- * interface Pet {
- *   name: string
- *   species: 'cat' | 'dog'
- * }
+ * type Test<T> = A<
+ *   A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
  *
- * type Merged = MergePartial<Person, Pet>
+ * type Error = Test<number> // Type instantiation is excessively deep and possibly infinite.ts (2589)
+ * ```
  *
- * // { name: string, age: number, species?: 'cat' | 'dog' }
- */
-export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;
-/**
- * Evaluates to `true` if `T` is `never`.
- */
-export declare type IsNever<T> = [T] extends [never] ? true : false;
-/**
- * Evaluates to `true` if the types `T` and `U` are equal.
+ * To fix this, we can use `DrainOuterGeneric`:
+ *
+ * ```ts
+ * type A<T> = DrainOuterGeneric<{ item: T }>
+ *
+ * type Test<T> = A<
+ *  A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
+ *
+ * type Ok = Test<number> // Ok
+ * ```
  */
-export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
-export declare type SqlBool = boolean | 0 | 1;
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
+    [P in K]: T;
+}>;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "kysely",
-  "version": "0.24.2",
+  "version": "0.26.0",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
-    "url": "git://github.com/koskimas/kysely.git"
+    "url": "git://github.com/kysely-org/kysely.git"
   },
   "engines": {
     "node": ">=14.0.0"
@@ -36,10 +36,11 @@
     "test:node:postgres": "DIALECT=postgres npm run test:node:run",
     "test:node:mysql": "DIALECT=mysql npm run test:node:run",
     "test:node:sqlite": "DIALECT=sqlite npm run test:node:run",
-    "test:node:run": "mocha --timeout 15000 test/node/dist/**/*.test.js",
+    "test:node:run": "mocha --reporter min --timeout 15000 test/node/dist/**/*.test.js",
     "test:browser:build": "rm -rf test/browser/bundle.js && esbuild test/browser/main.ts --bundle --outfile=test/browser/bundle.js",
     "test:browser": "npm run build && npm run test:browser:build && node test/browser/test.js",
-    "test:deno": "npm run build && deno run test/deno/local.test.ts && deno run test/deno/cdn.test.ts",
+    "test:bun": "npm run build && cd test/bun && bun install && bun run test",
+    "test:deno": "npm run build && deno run --allow-env --allow-read --allow-net test/deno/local.test.ts && deno run --allow-env --allow-read --allow-net test/deno/cdn.test.ts",
     "test:typings": "tsd test/typings",
     "test:esmimports": "node scripts/check-esm-imports.js",
     "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/esm/index.js --outfile=/dev/null",
@@ -52,6 +53,7 @@
     "script:module-fixup": "node scripts/module-fixup.js",
     "script:copy-interface-doc": "node scripts/copy-interface-documentation.js",
     "script:add-deno-type-references": "node scripts/add-deno-type-references.js",
+    "script:align-site-version": "node scripts/align-site-version.js",
     "prepublishOnly": "npm run build"
   },
   "author": "Sami Koskimäki <sami@jakso.me>",
@@ -60,30 +62,30 @@
     "Igal Klebanov <igalklebanov@gmail.com>"
   ],
   "devDependencies": {
-    "@types/better-sqlite3": "^7.5.0",
-    "@types/chai": "^4.3.1",
+    "@types/better-sqlite3": "^7.6.4",
+    "@types/chai": "^4.3.5",
     "@types/chai-as-promised": "^7.1.5",
     "@types/chai-subset": "^1.3.3",
-    "@types/mocha": "^9.1.1",
+    "@types/mocha": "^10.0.1",
     "@types/node": "^18.15.11",
-    "@types/pg": "^8.6.5",
+    "@types/pg": "^8.10.2",
     "@types/pg-cursor": "^2.7.0",
-    "@types/sinon": "^10.0.13",
-    "better-sqlite3": "^7.5.3",
-    "chai": "^4.3.6",
+    "@types/sinon": "^10.0.15",
+    "better-sqlite3": "^8.4.0",
+    "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "chai-subset": "^1.6.0",
-    "concurrently": "^7.6.0",
-    "esbuild": "^0.14.47",
-    "mocha": "^10.0.0",
-    "mysql2": "^2.3.3",
-    "pg": "^8.7.3",
-    "pg-cursor": "^2.7.3",
-    "playwright": "^1.22.2",
-    "prettier": "^2.7.1",
-    "sinon": "^14.0.0",
-    "tsd": "^0.21.0",
-    "typedoc": "^0.23.28",
-    "typescript": "5.0.2"
+    "concurrently": "^8.1.0",
+    "esbuild": "^0.17.19",
+    "mocha": "^10.2.0",
+    "mysql2": "^3.3.3",
+    "pg": "^8.11.0",
+    "pg-cursor": "^2.10.0",
+    "playwright": "^1.34.3",
+    "prettier": "^2.8.8",
+    "sinon": "^15.1.0",
+    "tsd": "^0.28.1",
+    "typedoc": "^0.24.8",
+    "typescript": "^5.1.6"
   }
 }