kysely 0.23.2 → 0.23.4

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

@@ -211,7 +211,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```ts
      * db.schema
      *   .createTable('test')
-     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .$call((builder) => builder.addColumn('id', 'integer'))
      *   .execute()
      * ```
      *
@@ -231,10 +231,14 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      *
      * db.schema
      *   .createTable('test')
-     *   .call(addDefaultColumns)
+     *   .$call(addDefaultColumns)
      *   .execute()
      * ```
      */
+    $call<T>(func: (qb: this) => T): T;
+    /**
+     * @deprecated Use `$call` instead
+     */
     call<T>(func: (qb: this) => T): T;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;

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

@@ -278,7 +278,7 @@ class CreateTableBuilder {
      * ```ts
      * db.schema
      *   .createTable('test')
-     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .$call((builder) => builder.addColumn('id', 'integer'))
      *   .execute()
      * ```
      *
@@ -298,13 +298,19 @@ class CreateTableBuilder {
      *
      * db.schema
      *   .createTable('test')
-     *   .call(addDefaultColumns)
+     *   .$call(addDefaultColumns)
      *   .execute()
      * ```
      */
-    call(func) {
+    $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/util/type-utils.d.ts

@@ -96,9 +96,21 @@ export declare type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
  * Extracts the item type of an array.
  */
 export declare type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
+/**
+ * Any select query builder.
+ */
 export declare type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
+/**
+ * Given a query output type `O` evaluates to the output type of a `executeTakeFirst` call.
+ */
 export declare type SingleResultType<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O | undefined;
+/**
+ * Represents a database row whose column names and their types are unknown.
+ */
 export declare type UnknownRow = Record<string, unknown>;
+/**
+ * Makes all properties of object type `T` nullable.
+ */
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
@@ -123,5 +135,11 @@ export declare type Nullable<T> = {
  * // { 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.
+ */
 export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;

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

@@ -25,12 +25,38 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -26,19 +26,45 @@ export interface DialectAdapter {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise
      * `db` is a single connection (session) that will be used to execute the
      * migrations.
      */
-    acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    acquireMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
      *
@@ -47,5 +73,21 @@ export interface DialectAdapter {
      * is a single connection (session) that was used to execute the migrations
      * and the `acquireMigrationLock` call.
      */
-    releaseMigrationLock(db: Kysely<any>): Promise<void>;
+    releaseMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
+}
+export interface MigrationLockOptions {
+    /**
+     * The name of the migration lock table.
+     */
+    readonly lockTable: string;
+    /**
+     * The id of the only row in the migration lock table.
+     */
+    readonly lockRowId: string;
+    /**
+     * The schema in which the migration lock table lives. This is only
+     * defined if the user has specified a custom schema in the migration
+     * settings.
+     */
+    readonly lockTableSchema?: string;
 }

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

@@ -19,12 +19,38 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -11,7 +11,7 @@ export class MysqlIntrospector {
         let rawSchemas = await this.#db
             .selectFrom('information_schema.schemata')
             .select('schema_name')
-            .castTo()
+            .$castTo()
             .execute();
         return rawSchemas.map((it) => ({ name: it.SCHEMA_NAME }));
     }
@@ -29,8 +29,8 @@ export class MysqlIntrospector {
         ])
             .where('table_schema', '=', sql `database()`)
             .orderBy('table_name')
-            .orderBy('column_name')
-            .castTo();
+            .orderBy('ordinal_position')
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('table_name', '!=', DEFAULT_MIGRATION_TABLE)

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

@@ -19,12 +19,38 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -11,7 +11,7 @@ export class PostgresIntrospector {
         let rawSchemas = await this.#db
             .selectFrom('pg_catalog.pg_namespace')
             .select('nspname')
-            .castTo()
+            .$castTo()
             .execute();
         return rawSchemas.map((it) => ({ name: it.nspname }));
     }
@@ -55,8 +55,8 @@ export class PostgresIntrospector {
             .where('a.attisdropped', '!=', true)
             .orderBy('ns.nspname')
             .orderBy('c.relname')
-            .orderBy('a.attname')
-            .castTo();
+            .orderBy('a.attnum')
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('c.relname', '!=', DEFAULT_MIGRATION_TABLE)

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

@@ -18,12 +18,38 @@ export declare class SqliteAdapter implements DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -17,7 +17,7 @@ export class SqliteIntrospector {
             .where('name', 'not like', 'sqlite_%')
             .select('name')
             .orderBy('name')
-            .castTo();
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('name', '!=', DEFAULT_MIGRATION_TABLE)
@@ -38,7 +38,7 @@ export class SqliteIntrospector {
             .selectFrom('sqlite_master')
             .where('name', '=', table)
             .select('sql')
-            .castTo()
+            .$castTo()
             .execute();
         // Try to find the name of the column that has `autoincrement` 🤦
         const autoIncrementCol = createSql[0]?.sql
@@ -50,7 +50,7 @@ export class SqliteIntrospector {
         const columns = await db
             .selectFrom(sql `pragma_table_info(${table})`.as('table_info'))
             .select(['name', 'type', 'notnull', 'dflt_value'])
-            .orderBy('name')
+            .orderBy('cid')
             .execute();
         return {
             name: table,

package/dist/esm/index.d.ts

@@ -159,6 +159,7 @@ export * from './operation-node/partition-by-item-node.js';
 export * from './operation-node/set-operation-node.js';
 export * from './operation-node/binary-operation-node.js';
 export * from './operation-node/unary-operation-node.js';
+export * from './operation-node/using-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';
@@ -172,7 +173,7 @@ export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.j
 export { TableExpression, TableExpressionOrList, } from './parser/table-parser.js';
 export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-parser.js';
 export { InsertObject } from './parser/insert-values-parser.js';
-export { MutationObject } from './parser/update-set-parser.js';
+export { UpdateObject } from './parser/update-set-parser.js';
 export { OrderByExpression, OrderByDirectionExpression, } from './parser/order-by-parser.js';
 export { ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList, } from './parser/binary-operation-parser.js';
 export { ExistsExpression } from './parser/unary-operation-parser.js';

package/dist/esm/index.js

@@ -160,6 +160,7 @@ export * from './operation-node/partition-by-item-node.js';
 export * from './operation-node/set-operation-node.js';
 export * from './operation-node/binary-operation-node.js';
 export * from './operation-node/unary-operation-node.js';
+export * from './operation-node/using-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';

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

@@ -24,12 +24,17 @@ export interface Migration {
  * other way.
  *
  * ```ts
+ * import { promises as fs } from 'fs'
+ * import path from 'path'
+ *
  * const migrator = new Migrator({
  *   db,
- *   provider: new FileMigrationProvider(
+ *   provider: new FileMigrationProvider({
+ *     fs,
+ *     path,
  *     // Path to the folder that contains all your migrations.
- *     'some/path/to/migrations'
- *   )
+ *     migrationFolder: 'some/path/to/migrations'
+ *   })
  * })
  * ```
  */

package/dist/esm/migration/migrator.js

@@ -17,12 +17,17 @@ export const NO_MIGRATIONS = freeze({ __noMigrations__: true });
  * other way.
  *
  * ```ts
+ * import { promises as fs } from 'fs'
+ * import path from 'path'
+ *
  * const migrator = new Migrator({
  *   db,
- *   provider: new FileMigrationProvider(
+ *   provider: new FileMigrationProvider({
+ *     fs,
+ *     path,
  *     // Path to the folder that contains all your migrations.
- *     'some/path/to/migrations'
- *   )
+ *     migrationFolder: 'some/path/to/migrations'
+ *   })
  * })
  * ```
  */
@@ -316,9 +321,14 @@ export class Migrator {
     }
     async #runMigrations(getTargetMigrationIndex) {
         const adapter = this.#props.db.getExecutor().adapter;
+        const lockOptions = freeze({
+            lockTable: this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE,
+            lockRowId: MIGRATION_LOCK_ID,
+            lockTableSchema: this.#props.migrationTableSchema,
+        });
         const run = async (db) => {
             try {
-                await adapter.acquireMigrationLock(db);
+                await adapter.acquireMigrationLock(db, lockOptions);
                 const state = await this.#getState(db);
                 if (state.migrations.length === 0) {
                     return { results: [] };
@@ -336,7 +346,7 @@ export class Migrator {
                 return { results: [] };
             }
             finally {
-                await adapter.releaseMigrationLock(db);
+                await adapter.releaseMigrationLock(db, lockOptions);
             }
         };
         if (adapter.supportsTransactionalDdl) {

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

@@ -11,6 +11,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly expression?: OperationNode;
     readonly unique?: boolean;
     readonly using?: RawNode;
+    readonly ifNotExists?: boolean;
 }
 /**
  * @internal

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

@@ -8,9 +8,11 @@ import { LimitNode } from './limit-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { ExplainNode } from './explain-node.js';
+import { UsingNode } from './using-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
+    readonly using?: UsingNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
     readonly returning?: ReturningNode;
@@ -28,4 +30,5 @@ export declare const DeleteQueryNode: Readonly<{
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;
+    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

package/dist/esm/operation-node/delete-query-node.js

@@ -2,6 +2,7 @@
 import { freeze } from '../util/object-utils.js';
 import { FromNode } from './from-node.js';
 import { OrderByNode } from './order-by-node.js';
+import { UsingNode } from './using-node.js';
 /**
  * @internal
  */
@@ -36,4 +37,12 @@ export const DeleteQueryNode = freeze({
             explain,
         });
     },
+    cloneWithUsing(deleteNode, tables) {
+        return freeze({
+            ...deleteNode,
+            using: deleteNode.using !== undefined
+                ? UsingNode.cloneWithTables(deleteNode.using, tables)
+                : UsingNode.create(tables),
+        });
+    },
 });

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

@@ -76,6 +76,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
+import { UsingNode } from './using-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -181,6 +182,7 @@ export declare class OperationNodeTransformer {
     protected transformPartitionByItem(node: PartitionByItemNode): PartitionByItemNode;
     protected transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode;
     protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
+    protected transformUsing(node: UsingNode): UsingNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -110,6 +110,7 @@ export class OperationNodeTransformer {
         SetOperationNode: this.transformSetOperation.bind(this),
         BinaryOperationNode: this.transformBinaryOperation.bind(this),
         UnaryOperationNode: this.transformUnaryOperation.bind(this),
+        UsingNode: this.transformUsing.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -259,6 +260,7 @@ export class OperationNodeTransformer {
         return requireAllProps({
             kind: 'DeleteQueryNode',
             from: this.transformNode(node.from),
+            using: this.transformNode(node.using),
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
@@ -402,6 +404,7 @@ export class OperationNodeTransformer {
             expression: this.transformNode(node.expression),
             unique: node.unique,
             using: this.transformNode(node.using),
+            ifNotExists: node.ifNotExists,
         });
     }
     transformList(node) {
@@ -687,6 +690,12 @@ export class OperationNodeTransformer {
             operand: this.transformNode(node.operand),
         });
     }
+    transformUsing(node) {
+        return requireAllProps({
+            kind: 'UsingNode',
+            tables: node.tables,
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -76,6 +76,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
+import { UsingNode } from './using-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -158,4 +159,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitSetOperation(node: SetOperationNode): void;
     protected abstract visitBinaryOperation(node: BinaryOperationNode): void;
     protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
+    protected abstract visitUsing(node: UsingNode): void;
 }

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

@@ -83,6 +83,7 @@ export class OperationNodeVisitor {
         SetOperationNode: this.visitSetOperation.bind(this),
         BinaryOperationNode: this.visitBinaryOperation.bind(this),
         UnaryOperationNode: this.visitUnaryOperation.bind(this),
+        UsingNode: this.visitUsing.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);