kysely 0.26.1 → 0.26.2

package/dist/esm/raw-builder/raw-builder.d.ts

@@ -1,38 +1,21 @@
 import { QueryResult } from '../driver/database-connection.js';
-import { AliasNode } from '../operation-node/alias-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
 import { QueryId } from '../util/query-id.js';
-import { AliasedExpression, Expression } from '../expression/expression.js';
+import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
  * You shouldn't need to create `RawBuilder` instances directly. Instead you should
  * use the {@link sql} template tag.
  */
-export declare class RawBuilder<O> implements Expression<O> {
-    #private;
-    constructor(props: RawBuilderProps);
-    /** @private */
+export interface RawBuilder<O> extends AliasableExpression<O> {
     /**
-     * All expressions need to have this getter for complicated type-related reasons.
-     * Simply add this getter for your expression and always return `undefined` from it:
-     *
-     * ```ts
-     * class SomeExpression<T> implements Expression<T> {
-     *   get expressionType(): T | undefined {
-     *     return undefined
-     *   }
-     * }
-     * ```
-     *
-     * The getter is needed to make the expression assignable to another expression only
-     * if the types `T` are assignable. Without this property (or some other property
-     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     * @private Without this SelectQueryBuilder extends RawBuilder and things break.
      */
-    get expressionType(): O | undefined;
+    get isRawBuilder(): true;
     /**
      * Returns an aliased version of the SQL expression.
      *
@@ -87,6 +70,62 @@ export declare class RawBuilder<O> implements Expression<O> {
      * ```
      */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * In addition to slapping `as "the_alias"` at the end of the expression,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     // `eb.fn<string>` returns an AliasableExpression<string>
+     *     eb.fn<string>('concat', ['first_name' eb.val(' '), 'last_name']).as('full_name')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `full_name: string` field exists in the result type.
+     * console.log(result.full_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select
+     *   concat("first_name", $1, "last_name") as "full_name"
+     * from
+     *   "person"
+     * ```
+     *
+     * You can also pass in a raw SQL snippet (or any expression) but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
+     */
     as<A extends string>(alias: Expression<any>): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
@@ -95,14 +134,31 @@ export declare class RawBuilder<O> implements Expression<O> {
      * returns a copy of this `RawBuilder` with a new output type.
      */
     $castTo<T>(): RawBuilder<T>;
-    /**
-     * @deprecated Use `$castTo` instead.
-     */
-    castTo<T>(): RawBuilder<T>;
     /**
      * Adds a plugin for this SQL snippet.
      */
     withPlugin(plugin: KyselyPlugin): RawBuilder<O>;
+    /**
+     * Compiles the builder to a `CompiledQuery`.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const { sql } = sql`select * from ${sql.table('person')}`.compile(db)
+     * console.log(sql)
+     * ```
+     */
+    compile(executorProvider: QueryExecutorProvider): CompiledQuery<O>;
+    /**
+     * Executes the raw query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await sql`select * from ${sql.table('person')}`.execute(db)
+     * ```
+     */
+    execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -118,33 +174,16 @@ export declare class RawBuilder<O> implements Expression<O> {
      * ```
      */
     toOperationNode(): RawNode;
-    compile(executorProvider: QueryExecutorProvider): CompiledQuery<O>;
-    execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>;
-}
-export declare function isRawBuilder(obj: unknown): obj is RawBuilder<unknown>;
-/**
- * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
- */
-export declare class AliasedRawBuilder<O = unknown, A extends string = never> implements AliasedExpression<O, A> {
-    #private;
-    constructor(rawBuilder: RawBuilder<O>, alias: A | Expression<unknown>);
-    /** @private */
-    /**
-     * Returns the aliased expression.
-     */
-    get expression(): Expression<O>;
-    /** @private */
-    /**
-     * Returns the alias.
-     */
-    get alias(): A | Expression<unknown>;
-    /**
-     * Creates the OperationNode that describes how to compile this expression into SQL.
-     */
-    toOperationNode(): AliasNode;
 }
 export interface RawBuilderProps {
     readonly queryId: QueryId;
     readonly rawNode: RawNode;
     readonly plugins?: ReadonlyArray<KyselyPlugin>;
 }
+export declare function createRawBuilder<O>(props: RawBuilderProps): RawBuilder<O>;
+/**
+ * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
+ */
+export interface AliasedRawBuilder<O = unknown, A extends string = never> extends AliasedExpression<O, A> {
+    get rawBuilder(): RawBuilder<O>;
+}

package/dist/esm/raw-builder/raw-builder.js

@@ -1,48 +1,29 @@
 /// <reference types="./raw-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
 import { preventAwait } from '../util/prevent-await.js';
-import { freeze, isFunction, isObject } from '../util/object-utils.js';
+import { freeze } from '../util/object-utils.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
-/**
- * An instance of this class can be used to create raw SQL snippets or queries.
- *
- * You shouldn't need to create `RawBuilder` instances directly. Instead you should
- * use the {@link sql} template tag.
- */
-export class RawBuilder {
+class RawBuilderImpl {
     #props;
     constructor(props) {
         this.#props = freeze(props);
     }
-    /** @private */
     get expressionType() {
         return undefined;
     }
+    get isRawBuilder() {
+        return true;
+    }
     as(alias) {
-        return new AliasedRawBuilder(this, alias);
-    }
-    /**
-     * Change the output type of the raw expression.
-     *
-     * This method call doesn't change the SQL in any way. This methods simply
-     * returns a copy of this `RawBuilder` with a new output type.
-     */
-    $castTo() {
-        return new RawBuilder({ ...this.#props });
+        return new AliasedRawBuilderImpl(this, alias);
     }
-    /**
-     * @deprecated Use `$castTo` instead.
-     */
-    castTo() {
-        return this.$castTo();
+    $castTo() {
+        return new RawBuilderImpl({ ...this.#props });
     }
-    /**
-     * Adds a plugin for this SQL snippet.
-     */
     withPlugin(plugin) {
-        return new RawBuilder({
+        return new RawBuilderImpl({
             ...this.#props,
             plugins: this.#props.plugins !== undefined
                 ? freeze([...this.#props.plugins, plugin])
@@ -74,36 +55,30 @@ export class RawBuilder {
         return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
     }
 }
-export function isRawBuilder(obj) {
-    return (isObject(obj) &&
-        isFunction(obj.as) &&
-        isFunction(obj.$castTo) &&
-        isFunction(obj.withPlugin) &&
-        isFunction(obj.toOperationNode) &&
-        isFunction(obj.execute));
+export function createRawBuilder(props) {
+    return new RawBuilderImpl(props);
 }
-preventAwait(RawBuilder, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
-/**
- * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
- */
-export class AliasedRawBuilder {
+preventAwait(RawBuilderImpl, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
+class AliasedRawBuilderImpl {
     #rawBuilder;
     #alias;
     constructor(rawBuilder, alias) {
         this.#rawBuilder = rawBuilder;
         this.#alias = alias;
     }
-    /** @private */
     get expression() {
         return this.#rawBuilder;
     }
-    /** @private */
     get alias() {
         return this.#alias;
     }
+    get rawBuilder() {
+        return this.#rawBuilder;
+    }
     toOperationNode() {
         return AliasNode.create(this.#rawBuilder.toOperationNode(), isOperationNodeSource(this.#alias)
             ? this.#alias.toOperationNode()
             : IdentifierNode.create(this.#alias));
     }
 }
+preventAwait(AliasedRawBuilderImpl, "don't await AliasedRawBuilder instances directly. AliasedRawBuilder should never be executed directly since it's always a part of another query.");

package/dist/esm/raw-builder/sql.js

@@ -6,21 +6,21 @@ import { parseStringReference } from '../parser/reference-parser.js';
 import { parseTable } from '../parser/table-parser.js';
 import { parseValueExpression } from '../parser/value-parser.js';
 import { createQueryId } from '../util/query-id.js';
-import { RawBuilder } from './raw-builder.js';
+import { createRawBuilder } from './raw-builder.js';
 export const sql = Object.assign((sqlFragments, ...parameters) => {
-    return new RawBuilder({
+    return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.create(sqlFragments, parameters?.map(parseValueExpression) ?? []),
     });
 }, {
     ref(columnReference) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChild(parseStringReference(columnReference)),
         });
     },
     val(value) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChild(parseValueExpression(value)),
         });
@@ -29,7 +29,7 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
         return this.val(value);
     },
     table(tableReference) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChild(parseTable(tableReference)),
         });
@@ -38,13 +38,13 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
         const fragments = new Array(ids.length + 1).fill('.');
         fragments[0] = '';
         fragments[fragments.length - 1] = '';
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.create(fragments, ids.map(IdentifierNode.create)),
         });
     },
     lit(value) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChild(ValueNode.createImmediate(value)),
         });
@@ -53,7 +53,7 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
         return this.lit(value);
     },
     raw(sql) {
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithSql(sql),
         });
@@ -67,7 +67,7 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
                 nodes[2 * i + 1] = sep;
             }
         }
-        return new RawBuilder({
+        return createRawBuilder({
             queryId: createQueryId(),
             rawNode: RawNode.createWithChildren(nodes),
         });

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

@@ -48,6 +48,10 @@ export declare class AlterTableBuilder implements ColumnAlteringInterface {
      * is because you can only add one column per `ALTER TABLE` query.
      */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
+    /**
+     * See {@link CreateTableBuilder.addPrimaryKeyConstraint}
+     */
+    addPrimaryKeyConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
     dropConstraint(constraintName: string): AlterTableDropConstraintBuilder;
     /**
      * Calls the given function passing `this` as the only argument.

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

@@ -22,6 +22,7 @@ import { AlterColumnBuilder, } from './alter-column-builder.js';
 import { AlterTableExecutor } from './alter-table-executor.js';
 import { AlterTableAddForeignKeyConstraintBuilder } from './alter-table-add-foreign-key-constraint-builder.js';
 import { AlterTableDropConstraintBuilder } from './alter-table-drop-constraint-builder.js';
+import { PrimaryConstraintNode } from '../operation-node/primary-constraint-node.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -114,6 +115,17 @@ export class AlterTableBuilder {
             constraintBuilder: new ForeignKeyConstraintBuilder(ForeignKeyConstraintNode.create(columns.map(ColumnNode.create), parseTable(targetTable), targetColumns.map(ColumnNode.create), constraintName)),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addPrimaryKeyConstraint}
+     */
+    addPrimaryKeyConstraint(constraintName, columns) {
+        return new AlterTableExecutor({
+            ...this.#props,
+            node: AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addConstraint: AddConstraintNode.create(PrimaryConstraintNode.create(columns, constraintName)),
+            }),
+        });
+    }
     dropConstraint(constraintName) {
         return new AlterTableDropConstraintBuilder({
             ...this.#props,

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

@@ -133,7 +133,7 @@ export declare class CreateIndexBuilder<C = never> implements OperationNodeSourc
      */
     where(lhs: C | Expression<any>, op: ComparisonOperatorExpression, rhs: unknown): CreateIndexBuilder<C>;
     where(factory: (qb: ExpressionBuilder<ShallowRecord<string, ShallowRecord<C & string, any>>, string>) => Expression<SqlBool>): CreateIndexBuilder<C>;
-    where(expression: Expression<any>): CreateIndexBuilder<C>;
+    where(expression: Expression<SqlBool>): CreateIndexBuilder<C>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.

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

@@ -5,7 +5,7 @@ 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 { parseFilter, } from '../parser/binary-operation-parser.js';
+import { parseValueBinaryOperationOrExpression, } 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 {
@@ -148,7 +148,7 @@ export class CreateIndexBuilder {
         const transformer = new ImmediateValueTransformer();
         return new CreateIndexBuilder({
             ...this.#props,
-            node: QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode(parseFilter(args))),
+            node: QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode(parseValueBinaryOperationOrExpression(args))),
         });
     }
     /**

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

@@ -1,3 +1,4 @@
+import { DrainOuterGeneric } from './type-utils.js';
 /**
  * This type can be used to specify a different type for
  * select, insert and update operations.
@@ -123,9 +124,9 @@ export type UpdateKeys<R> = {
  * // }
  * ```
  */
-export type Selectable<R> = {
+export type Selectable<R> = DrainOuterGeneric<{
     [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
-};
+}>;
 /**
  * Given a table interface, extracts the insert type from all
  * {@link ColumnType} types.
@@ -147,11 +148,11 @@ export type Selectable<R> = {
  * // }
  * ```
  */
-export type Insertable<R> = {
+export type Insertable<R> = DrainOuterGeneric<{
     [K in NonNullableInsertKeys<R>]: InsertType<R[K]>;
 } & {
     [K in NullableInsertKeys<R>]?: InsertType<R[K]>;
-};
+}>;
 /**
  * Given a table interface, extracts the update type from all
  * {@link ColumnType} types.
@@ -172,7 +173,7 @@ export type Insertable<R> = {
  * // }
  * ```
  */
-export type Updateable<R> = {
+export type Updateable<R> = DrainOuterGeneric<{
     [K in UpdateKeys<R>]?: UpdateType<R[K]>;
-};
+}>;
 export {};

package/dist/esm/util/json-object-args.d.ts

@@ -0,0 +1,3 @@
+import { Expression } from '../expression/expression.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+export declare function getJsonObjectArgs(node: SelectQueryNode, table: string): Expression<unknown>[];

package/dist/esm/util/json-object-args.js

@@ -0,0 +1,32 @@
+/// <reference types="./json-object-args.d.ts" />
+import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { ReferenceNode } from '../operation-node/reference-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+export function getJsonObjectArgs(node, table) {
+    const args = [];
+    for (const { selection: s } of node.selections ?? []) {
+        if (ReferenceNode.is(s) && ColumnNode.is(s.column)) {
+            args.push(colName(s.column.column.name), colRef(table, s.column.column.name));
+        }
+        else if (ColumnNode.is(s)) {
+            args.push(colName(s.column.name), colRef(table, s.column.name));
+        }
+        else if (AliasNode.is(s) && IdentifierNode.is(s.alias)) {
+            args.push(colName(s.alias.name), colRef(table, s.alias.name));
+        }
+        else {
+            throw new Error(`can't extract column names from the select query node`);
+        }
+    }
+    return args;
+}
+function colName(col) {
+    return new ExpressionWrapper(ValueNode.createImmediate(col));
+}
+function colRef(table, col) {
+    return new ExpressionWrapper(ReferenceNode.create(ColumnNode.create(col), TableNode.create(table)));
+}

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

@@ -13,6 +13,7 @@ export declare function isBuffer(obj: unknown): obj is {
 export declare function isFunction(obj: unknown): obj is Function;
 export declare function isObject(obj: unknown): obj is ShallowRecord<string, unknown>;
 export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
+export declare function isPlainObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;
 export declare function asArray<T>(arg: T | T[]): T[];

package/dist/esm/util/object-utils.js

@@ -43,6 +43,13 @@ export function isObject(obj) {
 export function isArrayBufferOrView(obj) {
     return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
 }
+export function isPlainObject(obj) {
+    return (isObject(obj) &&
+        !Array.isArray(obj) &&
+        !isDate(obj) &&
+        !isBuffer(obj) &&
+        !isArrayBufferOrView(obj));
+}
 export function getLast(arr) {
     return arr[arr.length - 1];
 }

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

@@ -40,9 +40,9 @@ export type AnyColumn<DB, TB extends keyof DB> = DrainOuterGeneric<{
 /**
  * Extracts a column type.
  */
-export type ExtractColumnType<DB, TB extends keyof DB, C> = {
+export type ExtractColumnType<DB, TB extends keyof DB, C> = DrainOuterGeneric<{
     [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
-}[TB];
+}[TB]>;
 /**
  * Given a database type and a union of table names in that db, returns
  * a union type with all possible `table`.`column` combinations.
@@ -74,21 +74,21 @@ export type ExtractColumnType<DB, TB extends keyof DB, C> = {
  * // Columns == 'person.id' | 'pet.name' | 'pet.species'
  * ```
  */
-export type AnyColumnWithTable<DB, TB extends keyof DB> = {
+export type AnyColumnWithTable<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${T}.${keyof DB[T]}` : never : never;
-}[TB];
+}[TB]>;
 /**
  * Just like {@link AnyColumn} but with a ` as <string>` suffix.
  */
-export type AnyAliasedColumn<DB, TB extends keyof DB> = {
+export type AnyAliasedColumn<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${keyof DB[T]} as ${string}` : never : never;
-}[TB];
+}[TB]>;
 /**
  * Just like {@link AnyColumnWithTable} but with a ` as <string>` suffix.
  */
-export type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
+export type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${T}.${keyof DB[T]} as ${string}` : never : never;
-}[TB];
+}[TB]>;
 /**
  * Extracts the item type of an array.
  */
@@ -124,9 +124,9 @@ 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<{
+export type NarrowPartial<S, T> = DrainOuterGeneric<T extends object ? {
     [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];
-}>;
+} : never>;
 export type SqlBool = boolean | 0 | 1;
 /**
  * Utility to reduce depth of TypeScript's internal type instantiation stack.

package/helpers/sqlite.d.ts

@@ -0,0 +1 @@
+export * from '../dist/cjs/helpers/sqlite.js'

package/helpers/sqlite.js

@@ -0,0 +1 @@
+module.exports = require('../dist/cjs/helpers/sqlite.js')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -26,6 +26,11 @@
       "import": "./dist/esm/helpers/mysql.js",
       "require": "./dist/cjs/helpers/mysql.js",
       "default": "./dist/cjs/helpers/mysql.js"
+    },
+    "./helpers/sqlite": {
+      "import": "./dist/esm/helpers/sqlite.js",
+      "require": "./dist/cjs/helpers/sqlite.js",
+      "default": "./dist/cjs/helpers/sqlite.js"
     }
   },
   "scripts": {
@@ -40,6 +45,7 @@
     "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:bun": "npm run build && cd test/bun && bun install && bun run test",
+    "test:cloudflare-workers": "npm run build && cd test/cloudflare-workers && npm ci && npm 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",
@@ -48,8 +54,6 @@
     "build": "npm run clean && concurrently -n esm,cjs \"npm run build:esm\" \"npm run build:cjs\" && concurrently -n modulefix,docfix \"npm run script:module-fixup\" \"npm run script:copy-interface-doc\"",
     "build:esm": "tsc -p tsconfig.json && npm run script:add-deno-type-references",
     "build:cjs": "tsc -p tsconfig-cjs.json",
-    "docs:build": "typedoc --excludePrivate --excludeInternal --customCss ./docs-theme.css src/index.ts && npm run docs:postprocess",
-    "docs:postprocess": "node scripts/post-process-docs.js",
     "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",
@@ -85,7 +89,6 @@
     "prettier": "^2.8.8",
     "sinon": "^15.1.0",
     "tsd": "^0.28.1",
-    "typedoc": "^0.24.8",
     "typescript": "^5.1.6"
   }
 }