kysely 0.10.1 → 0.11.0

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

@@ -0,0 +1,112 @@
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { importFunction } from '../../util/dynamic-import.js';
+export class SqliteDriver {
+    #config;
+    #connectionMutex = new ConnectionMutex();
+    #db;
+    #connection;
+    constructor(config) {
+        this.#config = config;
+    }
+    async init() {
+        // Import the `better-sqlite3` module here instead at the top of the file
+        // so that this file can be loaded by node without `better-sqlite3` driver
+        // installed. As you can see, there IS an import from `better-sqlite3` at
+        // the top level too, but that's only for types. It doesn't get compiled
+        // into javascript. You can check the built javascript code.
+        const DatabaseConstructor = await importBetterSqlite3Database();
+        const options = {};
+        if (typeof this.#config.readonly === 'boolean') {
+            options.readonly = this.#config.readonly;
+        }
+        if (typeof this.#config.fileMustExist === 'boolean') {
+            options.fileMustExist = this.#config.fileMustExist;
+        }
+        if (typeof this.#config.timeout === 'number') {
+            options.timeout = this.#config.timeout;
+        }
+        if (typeof this.#config.verbose === 'function') {
+            options.verbose = this.#config.verbose;
+        }
+        this.#db = new DatabaseConstructor(this.#config.databasePath, options);
+        this.#connection = new SqliteConnection(this.#db);
+        if (this.#config.onCreateConnection) {
+            await this.#config.onCreateConnection(this.#connection);
+        }
+    }
+    async acquireConnection() {
+        // sqlite effectively only has one single connection. We use a mutex
+        // here to wait until the single connection has been released.
+        await this.#connectionMutex.lock();
+        return this.#connection;
+    }
+    async beginTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('begin'));
+    }
+    async commitTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('commit'));
+    }
+    async rollbackTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('rollback'));
+    }
+    async releaseConnection() {
+        this.#connectionMutex.unlock();
+    }
+    async destroy() {
+        this.#db?.close();
+    }
+}
+async function importBetterSqlite3Database() {
+    try {
+        return await importFunction('better-sqlite3');
+    }
+    catch (error) {
+        console.error(error);
+        throw new Error('SQLite client not installed. Please run `npm install better-sqlite3`');
+    }
+}
+class SqliteConnection {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    executeQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const stmt = this.#db.prepare(sql);
+        if (stmt.reader) {
+            return Promise.resolve({
+                rows: stmt.all(parameters),
+            });
+        }
+        else {
+            const { changes, lastInsertRowid } = stmt.run(parameters);
+            return Promise.resolve({
+                numUpdatedOrDeletedRows: changes !== undefined && changes !== null
+                    ? BigInt(changes)
+                    : undefined,
+                insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
+                    ? BigInt(lastInsertRowid)
+                    : undefined,
+                rows: [],
+            });
+        }
+    }
+}
+class ConnectionMutex {
+    #promise;
+    #resolve;
+    async lock() {
+        while (this.#promise) {
+            await this.#promise;
+        }
+        this.#promise = new Promise((resolve) => {
+            this.#resolve = resolve;
+        });
+    }
+    unlock() {
+        const resolve = this.#resolve;
+        this.#promise = undefined;
+        this.#resolve = undefined;
+        resolve?.();
+    }
+}

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

@@ -0,0 +1,7 @@
+import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions } from '../../introspection/database-introspector.js';
+import { Kysely } from '../../kysely.js';
+export declare class SqliteIntrospector implements DatabaseIntrospector {
+    #private;
+    constructor(db: Kysely<any>);
+    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
+}

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

@@ -0,0 +1,27 @@
+import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, } from '../../migration/migration.js';
+export class SqliteIntrospector {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async getMetadata(options = { withInternalKyselyTables: false }) {
+        let query = this.#db
+            .selectFrom('sqlite_schema')
+            .where('type', '=', 'table')
+            .where('name', 'not like', 'sqlite_%')
+            .select('name');
+        if (!options.withInternalKyselyTables) {
+            query = query
+                .where('name', '!=', MIGRATION_TABLE)
+                .where('name', '!=', MIGRATION_LOCK_TABLE);
+        }
+        const result = await query.execute();
+        return {
+            tables: result.map((it) => ({
+                name: it.name,
+                // TODO: Get columns somehow.
+                columns: [],
+            })),
+        };
+    }
+}

package/dist/esm/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -0,0 +1,7 @@
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
+    protected visitReturning(): void;
+    protected getSql(): string;
+    protected getCurrentParameterPlaceholder(): string;
+    protected getAutoIncrement(): string;
+}

package/dist/esm/dialect/sqlite/sqlite-query-compiler.js

@@ -0,0 +1,15 @@
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export class SqliteQueryCompiler extends DefaultQueryCompiler {
+    visitReturning() {
+        // Do nothing.
+    }
+    getSql() {
+        return super.getSql().trimEnd();
+    }
+    getCurrentParameterPlaceholder() {
+        return '?';
+    }
+    getAutoIncrement() {
+        return 'autoincrement';
+    }
+}

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

@@ -12,12 +12,12 @@ export interface QueryResult<O> {
      * This is defined for update and delete queries and contains
      * the number of rows the query updated/deleted.
      */
-    readonly numUpdatedOrDeletedRows?: number;
+    readonly numUpdatedOrDeletedRows?: bigint;
     /**
      * This is defined for insert queries on dialects that return
      * the auto incrementing primary key from an insert.
      */
-    readonly insertedPrimaryKey?: number;
+    readonly insertId?: bigint;
     /**
      * The rows returned by the query. This is always defined and is
      * empty if the query returned no rows.

package/dist/esm/index.d.ts

@@ -3,6 +3,9 @@ export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
 export * from './query-builder/expression-builder.js';
+export * from './query-builder/insert-result.js';
+export * from './query-builder/delete-result.js';
+export * from './query-builder/update-result.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -37,6 +40,11 @@ export * from './dialect/mysql/mysql-query-compiler.js';
 export * from './dialect/mysql/mysql-driver.js';
 export * from './dialect/mysql/mysql-introspector.js';
 export * from './dialect/mysql/mysql-adapter.js';
+export * from './dialect/sqlite/sqlite-dialect.js';
+export * from './dialect/sqlite/sqlite-query-compiler.js';
+export * from './dialect/sqlite/sqlite-driver.js';
+export * from './dialect/sqlite/sqlite-introspector.js';
+export * from './dialect/sqlite/sqlite-adapter.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/query-compiler.js';
 export * from './migration/migration.js';

package/dist/esm/index.js

@@ -3,6 +3,9 @@ export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
 export * from './query-builder/expression-builder.js';
+export * from './query-builder/insert-result.js';
+export * from './query-builder/delete-result.js';
+export * from './query-builder/update-result.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -37,6 +40,11 @@ export * from './dialect/mysql/mysql-query-compiler.js';
 export * from './dialect/mysql/mysql-driver.js';
 export * from './dialect/mysql/mysql-introspector.js';
 export * from './dialect/mysql/mysql-adapter.js';
+export * from './dialect/sqlite/sqlite-dialect.js';
+export * from './dialect/sqlite/sqlite-query-compiler.js';
+export * from './dialect/sqlite/sqlite-driver.js';
+export * from './dialect/sqlite/sqlite-introspector.js';
+export * from './dialect/sqlite/sqlite-adapter.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/query-compiler.js';
 export * from './migration/migration.js';

package/dist/esm/kysely.d.ts

@@ -116,7 +116,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"
@@ -146,17 +146,19 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
+     *       id: db.generated,
      *       first_name: 'Jennifer',
-     *      last_name: 'Aniston',
+     *       last_name: 'Aniston',
      *     })
      *     .returning('id')
-     *     .executeTakeFirst()
+     *     .executeTakeFirstOrThrow()
      *
      *   await someFunction(trx, jennifer)
      *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer!.id,
+     *       id: db.generated,
+     *       user_id: jennifer.id,
      *       name: 'Catto',
      *       species: 'cat'
      *     })

package/dist/esm/kysely.js

@@ -151,7 +151,7 @@ export class Kysely extends QueryCreator {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"
@@ -183,17 +183,19 @@ export class Kysely extends QueryCreator {
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
+     *       id: db.generated,
      *       first_name: 'Jennifer',
-     *      last_name: 'Aniston',
+     *       last_name: 'Aniston',
      *     })
      *     .returning('id')
-     *     .executeTakeFirst()
+     *     .executeTakeFirstOrThrow()
      *
      *   await someFunction(trx, jennifer)
      *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer!.id,
+     *       id: db.generated,
+     *       user_id: jennifer.id,
      *       name: 'Catto',
      *       species: 'cat'
      *     })

package/dist/esm/migration/migration.d.ts

@@ -62,5 +62,5 @@ export declare class MigrationModule {
 }
 export interface Migration {
     up(db: Kysely<any>): Promise<void>;
-    down(db: Kysely<any>): Promise<void>;
+    down?(db: Kysely<any>): Promise<void>;
 }

package/dist/esm/migration/migration.js

@@ -57,7 +57,7 @@ async function ensureMigrationTableExists(db) {
                 .execute();
         }
         catch (error) {
-            // At least on postgres, `if not exists` doesn't guarantee the `create table`
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
             // query doesn't throw if the table already exits. That's why we check if
             // the table exist here and ignore the error if it does.
             if (!(await doesTableExists(db, MIGRATION_TABLE))) {
@@ -77,7 +77,7 @@ async function ensureMigrationLockTableExists(db) {
                 .execute();
         }
         catch (error) {
-            // At least on postgres, `if not exists` doesn't guarantee the `create table`
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
             // query doesn't throw if the table already exits. That's why we check if
             // the table exist here and ignore the error if it does.
             if (!(await doesTableExists(db, MIGRATION_LOCK_TABLE))) {
@@ -179,5 +179,5 @@ function ensureMigrationsAreNotCorrupted(executedMigrationNames, oldMigrationNam
     }
 }
 function isMigration(obj) {
-    return isObject(obj) && isFunction(obj.up) && isFunction(obj.down);
+    return isObject(obj) && isFunction(obj.up);
 }

package/dist/esm/operation-node/create-view-node.d.ts

@@ -9,6 +9,7 @@ export interface CreateViewNode extends OperationNode {
     readonly name: IdentifierNode;
     readonly materialized?: boolean;
     readonly orReplace?: boolean;
+    readonly ifNotExists?: boolean;
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly as?: SelectQueryNode | RawNode;
 }

package/dist/esm/operation-node/having-node.d.ts

@@ -1,18 +1,14 @@
-import { AndNode } from './and-node.js';
-import { FilterNode } from './filter-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { OrNode } from './or-node.js';
-import { ParensNode } from './parens-node.js';
-export declare type HavingNodeChild = FilterNode | AndNode | OrNode | ParensNode;
 export interface HavingNode extends OperationNode {
     readonly kind: 'HavingNode';
-    readonly having: HavingNodeChild;
+    readonly having: FilterExpressionNode;
 }
 /**
  * @internal
  */
 export declare const HavingNode: Readonly<{
     is(node: OperationNode): node is HavingNode;
-    create(filter: HavingNodeChild): HavingNode;
-    cloneWithFilter(havingNode: HavingNode, op: 'And' | 'Or', having: HavingNodeChild): HavingNode;
+    create(filter: FilterExpressionNode): HavingNode;
+    cloneWithFilter(havingNode: HavingNode, op: 'And' | 'Or', filter: FilterExpressionNode): HavingNode;
 }>;

package/dist/esm/operation-node/having-node.js

@@ -14,12 +14,12 @@ export const HavingNode = freeze({
             having: filter,
         });
     },
-    cloneWithFilter(havingNode, op, having) {
+    cloneWithFilter(havingNode, op, filter) {
         return freeze({
             ...havingNode,
             having: op === 'And'
-                ? AndNode.create(havingNode.having, having)
-                : OrNode.create(havingNode.having, having),
+                ? AndNode.create(havingNode.having, filter)
+                : OrNode.create(havingNode.having, filter),
         });
     },
 });

package/dist/esm/operation-node/join-node.d.ts

@@ -1,18 +1,15 @@
 import { AliasNode } from './alias-node.js';
-import { AndNode } from './and-node.js';
-import { FilterNode } from './filter-node.js';
+import { OnNode } from './on-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { OrNode } from './or-node.js';
-import { ParensNode } from './parens-node.js';
 import { TableNode } from './table-node.js';
 export declare type JoinTableNode = TableNode | AliasNode;
 export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin';
-export declare type JoinNodeOnNode = FilterNode | AndNode | OrNode | ParensNode;
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;
     readonly table: JoinTableNode;
-    readonly on?: JoinNodeOnNode;
+    readonly on?: OnNode;
 }
 /**
  * @internal
@@ -20,7 +17,7 @@ export interface JoinNode extends OperationNode {
 export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
-    createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
-    cloneWithOrOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
+    createWithOn(joinType: JoinType, table: JoinTableNode, on: FilterExpressionNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, filter: FilterExpressionNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, filter: FilterExpressionNode): JoinNode;
 }>;

package/dist/esm/operation-node/join-node.js

@@ -1,6 +1,5 @@
 import { freeze } from '../util/object-utils.js';
-import { AndNode } from './and-node.js';
-import { OrNode } from './or-node.js';
+import { OnNode } from './on-node.js';
 /**
  * @internal
  */
@@ -21,19 +20,23 @@ export const JoinNode = freeze({
             kind: 'JoinNode',
             joinType,
             table,
-            on,
+            on: OnNode.create(on),
         });
     },
-    cloneWithOn(joinNode, on) {
+    cloneWithOn(joinNode, filter) {
         return freeze({
             ...joinNode,
-            on: joinNode.on ? AndNode.create(joinNode.on, on) : on,
+            on: joinNode.on
+                ? OnNode.cloneWithFilter(joinNode.on, 'And', filter)
+                : OnNode.create(filter),
         });
     },
-    cloneWithOrOn(joinNode, on) {
+    cloneWithOrOn(joinNode, filter) {
         return freeze({
             ...joinNode,
-            on: joinNode.on ? OrNode.create(joinNode.on, on) : on,
+            on: joinNode.on
+                ? OnNode.cloneWithFilter(joinNode.on, 'Or', filter)
+                : OnNode.create(filter),
         });
     },
 });

package/dist/esm/operation-node/on-node.d.ts

@@ -0,0 +1,14 @@
+import { FilterExpressionNode } from './operation-node-utils.js';
+import { OperationNode } from './operation-node.js';
+export interface OnNode extends OperationNode {
+    readonly kind: 'OnNode';
+    readonly on: FilterExpressionNode;
+}
+/**
+ * @internal
+ */
+export declare const OnNode: Readonly<{
+    is(node: OperationNode): node is OnNode;
+    create(filter: FilterExpressionNode): OnNode;
+    cloneWithFilter(onNode: OnNode, op: 'And' | 'Or', filter: FilterExpressionNode): OnNode;
+}>;

package/dist/esm/operation-node/on-node.js

@@ -0,0 +1,25 @@
+import { freeze } from '../util/object-utils.js';
+import { AndNode } from './and-node.js';
+import { OrNode } from './or-node.js';
+/**
+ * @internal
+ */
+export const OnNode = freeze({
+    is(node) {
+        return node.kind === 'OnNode';
+    },
+    create(filter) {
+        return freeze({
+            kind: 'OnNode',
+            on: filter,
+        });
+    },
+    cloneWithFilter(onNode, op, filter) {
+        return freeze({
+            ...onNode,
+            on: op === 'And'
+                ? AndNode.create(onNode.on, filter)
+                : OrNode.create(onNode.on, filter),
+        });
+    },
+});

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -62,6 +62,7 @@ import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
 import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { DefaultValueNode } from './default-value-node.js';
+import { OnNode } from './on-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -153,6 +154,7 @@ export declare class OperationNodeTransformer {
     protected transformDropView(node: DropViewNode): DropViewNode;
     protected transformGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): GeneratedAlwaysAsNode;
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
+    protected transformOn(node: OnNode): OnNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/dist/esm/operation-node/operation-node-transformer.js

@@ -94,6 +94,7 @@ export class OperationNodeTransformer {
         DropViewNode: this.transformDropView.bind(this),
         GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
         DefaultValueNode: this.transformDefaultValue.bind(this),
+        OnNode: this.transformOn.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -525,6 +526,7 @@ export class OperationNodeTransformer {
             kind: 'CreateViewNode',
             name: this.transformNode(node.name),
             orReplace: node.orReplace,
+            ifNotExists: node.ifNotExists,
             materialized: node.materialized,
             columns: this.transformNodeList(node.columns),
             as: this.transformNode(node.as),
@@ -551,6 +553,12 @@ export class OperationNodeTransformer {
             defaultValue: this.transformNode(node.defaultValue),
         };
     }
+    transformOn(node) {
+        return {
+            kind: 'OnNode',
+            on: this.transformNode(node.on),
+        };
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -62,9 +62,11 @@ import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
 import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { DefaultValueNode } from './default-value-node.js';
+import { OnNode } from './on-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
+    protected get parentNode(): OperationNode | undefined;
     protected readonly visitNode: (node: OperationNode) => void;
     protected abstract visitSelectQuery(node: SelectQueryNode): void;
     protected abstract visitSelection(node: SelectionNode): void;
@@ -129,4 +131,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitDropView(node: DropViewNode): void;
     protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
     protected abstract visitDefaultValue(node: DefaultValueNode): void;
+    protected abstract visitOn(node: OnNode): void;
 }

package/dist/esm/operation-node/operation-node-visitor.js

@@ -1,6 +1,9 @@
 import { freeze } from '../util/object-utils.js';
 export class OperationNodeVisitor {
     nodeStack = [];
+    get parentNode() {
+        return this.nodeStack[this.nodeStack.length - 2];
+    }
     #visitors = freeze({
         AliasNode: this.visitAlias.bind(this),
         ColumnNode: this.visitColumn.bind(this),
@@ -65,6 +68,7 @@ export class OperationNodeVisitor {
         DropViewNode: this.visitDropView.bind(this),
         GeneratedAlwaysAsNode: this.visitGeneratedAlwaysAs.bind(this),
         DefaultValueNode: this.visitDefaultValue.bind(this),
+        OnNode: this.visitOn.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/query-node.d.ts

@@ -2,10 +2,10 @@ import { InsertQueryNode } from './insert-query-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { UpdateQueryNode } from './update-query-node.js';
 import { DeleteQueryNode } from './delete-query-node.js';
-import { WhereChildNode } from './where-node.js';
 import { JoinNode } from './join-node.js';
 import { SelectionNode } from './selection-node.js';
 import { OperationNode } from './operation-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 export declare type QueryNode = SelectQueryNode | DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
 export declare type MutatingQueryNode = DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
 export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | UpdateQueryNode;
@@ -16,8 +16,8 @@ export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     isMutating(node: OperationNode): node is MutatingQueryNode;
     isFilterable(node: OperationNode): node is FilterableQueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: WhereChildNode): T;
-    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: WhereChildNode): T_1;
+    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: FilterExpressionNode): T;
+    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: FilterExpressionNode): T_1;
     cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
     cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
 }>;

package/dist/esm/operation-node/select-query-node.d.ts

@@ -1,12 +1,12 @@
 import { FromNode } from './from-node.js';
 import { GroupByItemNode } from './group-by-item-node.js';
 import { GroupByNode } from './group-by-node.js';
-import { HavingNode, HavingNodeChild } from './having-node.js';
+import { HavingNode } from './having-node.js';
 import { JoinNode } from './join-node.js';
 import { LimitNode } from './limit-node.js';
 import { OffsetNode } from './offset-node.js';
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
+import { FilterExpressionNode, TableExpressionNode } from './operation-node-utils.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { SelectionNode } from './selection-node.js';
@@ -44,8 +44,8 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
-    cloneWithOrHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
     cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
 }>;