kysely 0.27.3 → 0.27.4

package/dist/esm/query-builder/update-query-builder.d.ts

@@ -3,7 +3,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
 import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { SelectExpression, SelectCallback } from '../parser/select-parser.js';
-import { ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
+import { ReturningAllRow, ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
@@ -17,7 +17,6 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
-import { Selectable } from '../util/column-type.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
@@ -25,7 +24,8 @@ import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ValueExpression } from '../parser/value-parser.js';
-export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
+import { OutputCallback, OutputExpression, OutputInterface, OutputPrefix, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
+export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OutputInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -290,7 +290,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -695,7 +695,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .set('first_name', 'Foo')
      *   // As always, both arguments can be arbitrary expressions or
      *   // callbacks that give you access to an expression builder:
-     *   .set(sql`address['postalCode']`, (eb) => eb.val('61710))
+     *   .set(sql<string>`address['postalCode']`, (eb) => eb.val('61710))
      *   .where('id', '=', '1')
      *   .executeTakeFirst()
      * ```
@@ -736,7 +736,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *     first_name: selectFrom('person').select('first_name').limit(1),
      *     middle_name: ref('first_name'),
      *     age: eb('age', '+', 1),
-     *     last_name: sql`${'Ani'} || ${'ston'}`,
+     *     last_name: sql<string>`${'Ani'} || ${'ston'}`,
      *   }))
      *   .where('id', '=', 1)
      *   .executeTakeFirst()
@@ -822,8 +822,93 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
+     */
+    returningAll<T extends TB>(tables: ReadonlyArray<T>): UpdateQueryBuilder<DB, UT, TB, ReturningAllRow<DB, T, O>>;
+    returningAll<T extends TB>(table: T): UpdateQueryBuilder<DB, UT, TB, ReturningAllRow<DB, T, O>>;
+    returningAll(): UpdateQueryBuilder<DB, UT, TB, ReturningAllRow<DB, TB, O>>;
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like MS SQL Server (MSSQL), this method can be chained
+     * to `insert`, `update`, `delete` and `merge` queries to return data.
+     *
+     * Also see the {@link outputAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .output('inserted.id')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, first_name } = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'John', last_name: 'Doe' })
+     *   .output([
+     *     'deleted.first_name as old_first_name',
+     *     'deleted.last_name as old_last_name',
+     *     'inserted.first_name as new_first_name',
+     *     'inserted.last_name as new_last_name',
+     *   ])
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name } = await db
+     *   .deleteFrom('person')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return the action performed on the row:
+     *
+     * ```ts
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .whenNotMatched()
+     *   .thenInsertValues({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'male'
+     *   })
+     *   .output([
+     *     'inserted.id as inserted_id',
+     *     'deleted.id as deleted_id',
+     *   ])
+     * ```
+     */
+    output<OE extends OutputExpression<DB, UT>>(selections: readonly OE[]): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    output<CB extends OutputCallback<DB, TB>>(callback: CB): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>>;
+    output<OE extends OutputExpression<DB, TB>>(selection: OE): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    /**
+     * Adds an `output {prefix}.*` to an `insert`/`update`/`delete`/`merge` query on databases
+     * that support `output` such as MS SQL Server (MSSQL).
+     *
+     * Also see the {@link output} method.
      */
-    returningAll(): UpdateQueryBuilder<DB, UT, TB, Selectable<DB[TB]>>;
+    outputAll(table: OutputPrefix): UpdateQueryBuilder<DB, UT, TB, ReturningAllRow<DB, TB, O>>;
     /**
      * Clears all `returning` clauses from the query.
      *
@@ -960,17 +1045,17 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
-     * This method can be used to simplify excessively complex types to make typescript happy
+     * This method can be used to simplify excessively complex types to make TypeScript happy
      * and much faster.
      *
      * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
-     * for typescript and you get errors like this:
+     * for TypeScript and you get errors like this:
      *
      * ```
      * error TS2589: Type instantiation is excessively deep and possibly infinite.
      * ```
      *
-     * In these case you can often use this method to help typescript a little bit. When you use this
+     * In these case you can often use this method to help TypeScript a little bit. When you use this
      * method to assert the output type of a query, Kysely can drop the complex output type that
      * consists of multiple nested helper types and replace it with the simple asserted type.
      *

package/dist/esm/query-builder/update-query-builder.js

@@ -148,10 +148,22 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(selection)),
         });
     }
-    returningAll() {
+    returningAll(table) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll()),
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll(table)),
+        });
+    }
+    output(args) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectArg(args)),
+        });
+    }
+    outputAll(table) {
+        return new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithOutput(this.#props.queryNode, parseSelectAll(table)),
         });
     }
     /**
@@ -308,17 +320,17 @@ export class UpdateQueryBuilder {
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
-     * This method can be used to simplify excessively complex types to make typescript happy
+     * This method can be used to simplify excessively complex types to make TypeScript happy
      * and much faster.
      *
      * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
-     * for typescript and you get errors like this:
+     * for TypeScript and you get errors like this:
      *
      * ```
      * error TS2589: Type instantiation is excessively deep and possibly infinite.
      * ```
      *
-     * In these case you can often use this method to help typescript a little bit. When you use this
+     * In these case you can often use this method to help TypeScript a little bit. When you use this
      * method to assert the output type of a query, Kysely can drop the complex output type that
      * consists of multiple nested helper types and replace it with the simple asserted type.
      *
@@ -373,9 +385,11 @@ export class UpdateQueryBuilder {
      */
     async execute() {
         const compiledQuery = this.compile();
-        const query = compiledQuery.query;
         const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
-        if (this.#props.executor.adapter.supportsReturning && query.returning) {
+        const { adapter } = this.#props.executor;
+        const query = compiledQuery.query;
+        if ((query.returning && adapter.supportsReturning) ||
+            (query.output && adapter.supportsOutput)) {
             return result.rows;
         }
         return [

package/dist/esm/query-builder/update-result.d.ts

@@ -1,5 +1,14 @@
 export declare class UpdateResult {
+    /**
+     * The number of rows the update query updated (even if not changed).
+    */
     readonly numUpdatedRows: bigint;
+    /**
+     * The number of rows the update query changed.
+     *
+     * This is **optional** and only supported in dialects such as MySQL.
+     * You would probably use {@link numUpdatedRows} in most cases.
+    */
     readonly numChangedRows?: bigint;
     constructor(numUpdatedRows: bigint, numChangedRows: bigint | undefined);
 }

package/dist/esm/query-builder/update-result.js

@@ -1,6 +1,15 @@
 /// <reference types="./update-result.d.ts" />
 export class UpdateResult {
+    /**
+     * The number of rows the update query updated (even if not changed).
+    */
     numUpdatedRows;
+    /**
+     * The number of rows the update query changed.
+     *
+     * This is **optional** and only supported in dialects such as MySQL.
+     * You would probably use {@link numUpdatedRows} in most cases.
+    */
     numChangedRows;
     constructor(numUpdatedRows, numChangedRows) {
         this.numUpdatedRows = numUpdatedRows;

package/dist/esm/query-builder/where-interface.d.ts

@@ -265,7 +265,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -94,6 +94,7 @@ import { AddIndexNode } from '../operation-node/add-index-node.js';
 import { CastNode } from '../operation-node/cast-node.js';
 import { FetchNode } from '../operation-node/fetch-node.js';
 import { TopNode } from '../operation-node/top-node.js';
+import { OutputNode } from '../operation-node/output-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -195,6 +196,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitAddIndex(node: AddIndexNode): void;
     protected visitCast(node: CastNode): void;
     protected visitFetch(node: FetchNode): void;
+    protected visitOutput(node: OutputNode): void;
     protected visitTop(node: TopNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;

package/dist/esm/query-compiler/default-query-compiler.js

@@ -18,6 +18,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     compileQuery(node) {
         this.#sql = '';
         this.#parameters = [];
+        this.nodeStack.splice(0, this.nodeStack.length);
         this.visitNode(node);
         return freeze({
             query: node,
@@ -174,6 +175,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.compileList(node.columns);
             this.append(')');
         }
+        if (node.output) {
+            this.append(' ');
+            this.visitNode(node.output);
+        }
         if (node.values) {
             this.append(' ');
             this.visitNode(node.values);
@@ -221,6 +226,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.visitNode(node.from);
+        if (node.output) {
+            this.append(' ');
+            this.visitNode(node.output);
+        }
         if (node.using) {
             this.append(' ');
             this.visitNode(node.using);
@@ -391,6 +400,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
     }
     visitColumnDefinition(node) {
+        if (node.ifNotExists) {
+            this.append('if not exists ');
+        }
         this.visitNode(node.column);
         this.append(' ');
         this.visitNode(node.dataType);
@@ -517,6 +529,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.updates) {
             this.compileList(node.updates);
         }
+        if (node.output) {
+            this.append(' ');
+            this.visitNode(node.output);
+        }
         if (node.from) {
             this.append(' ');
             this.visitNode(node.from);
@@ -1091,7 +1107,11 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         if (node.whens) {
             this.append(' ');
-            this.compileList(node.whens);
+            this.compileList(node.whens, ' ');
+        }
+        if (node.output) {
+            this.append(' ');
+            this.visitNode(node.output);
         }
     }
     visitMatched(node) {
@@ -1132,6 +1152,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.rowCount);
         this.append(` rows ${node.modifier}`);
     }
+    visitOutput(node) {
+        this.append('output ');
+        this.compileList(node.selections);
+    }
     visitTop(node) {
         this.append(`top(${node.expression})`);
         if (node.modifiers) {

package/dist/esm/query-creator.d.ts

@@ -125,10 +125,10 @@ export declare class QueryCreator<DB> {
      * ```
      */
     selectFrom<TE extends keyof DB & string>(from: TE[]): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, never>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB & PickTableWithAlias<DB, TE>, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, never>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     /**
      * Creates a `select` query builder without a `from` clause.
      *
@@ -365,24 +365,77 @@ export declare class QueryCreator<DB> {
      *
      * ### Examples
      *
+     * <!-- siteExample("cte", "Simple selects", 10) -->
+     *
+     * Common table expressions (CTE) are a great way to modularize complex queries.
+     * Essentially they allow you to run multiple separate queries within a
+     * single roundtrip to the DB.
+     *
+     * Since CTEs are a part of the main query, query optimizers inside DB
+     * engines are able to optimize the overall query. For example, postgres
+     * is able to inline the CTEs inside the using queries if it decides it's
+     * faster.
+     *
      * ```ts
-     * await db
+     * const result = await db
+     *   // Create a CTE called `jennifers` that selects all
+     *   // persons named 'Jennifer'.
      *   .with('jennifers', (db) => db
      *     .selectFrom('person')
      *     .where('first_name', '=', 'Jennifer')
      *     .select(['id', 'age'])
      *   )
+     *   // Select all rows from the `jennifers` CTE and
+     *   // further filter it.
      *   .with('adult_jennifers', (db) => db
      *     .selectFrom('jennifers')
      *     .where('age', '>', 18)
      *     .select(['id', 'age'])
      *   )
+     *   // Finally select all adult jennifers that are
+     *   // also younger than 60.
      *   .selectFrom('adult_jennifers')
      *   .where('age', '<', 60)
      *   .selectAll()
      *   .execute()
      * ```
      *
+     * <!-- siteExample("cte", "Inserts, updates and deletions", 20) -->
+     *
+     * Some databases like postgres also allow you to run other queries than selects
+     * in CTEs. On these databases CTEs are extremely powerful:
+     *
+     * ```ts
+     * const result = await db
+     *   .with('new_person', (db) => db
+     *     .insertInto('person')
+     *     .values({
+     *       first_name: 'Jennifer',
+     *       age: 35,
+     *     })
+     *     .returning('id')
+     *   )
+     *   .with('new_pet', (db) => db
+     *     .insertInto('pet')
+     *     .values({
+     *       name: 'Doggo',
+     *       species: 'dog',
+     *       is_favorite: true,
+     *       // Use the id of the person we just inserted.
+     *       owner_id: db
+     *         .selectFrom('new_person')
+     *         .select('id')
+     *     })
+     *     .returning('id')
+     *   )
+     *   .selectFrom(['new_person', 'new_pet'])
+     *   .select([
+     *     'new_person.id as person_id',
+     *     'new_pet.id as pet_id'
+     *   ])
+     *   .execute()
+     * ```
+     *
      * The CTE name can optionally specify column names in addition to
      * a name. In that case Kysely requires the expression to retun
      * rows with the same columns.

package/dist/esm/query-creator.js

@@ -139,24 +139,77 @@ export class QueryCreator {
      *
      * ### Examples
      *
+     * <!-- siteExample("cte", "Simple selects", 10) -->
+     *
+     * Common table expressions (CTE) are a great way to modularize complex queries.
+     * Essentially they allow you to run multiple separate queries within a
+     * single roundtrip to the DB.
+     *
+     * Since CTEs are a part of the main query, query optimizers inside DB
+     * engines are able to optimize the overall query. For example, postgres
+     * is able to inline the CTEs inside the using queries if it decides it's
+     * faster.
+     *
      * ```ts
-     * await db
+     * const result = await db
+     *   // Create a CTE called `jennifers` that selects all
+     *   // persons named 'Jennifer'.
      *   .with('jennifers', (db) => db
      *     .selectFrom('person')
      *     .where('first_name', '=', 'Jennifer')
      *     .select(['id', 'age'])
      *   )
+     *   // Select all rows from the `jennifers` CTE and
+     *   // further filter it.
      *   .with('adult_jennifers', (db) => db
      *     .selectFrom('jennifers')
      *     .where('age', '>', 18)
      *     .select(['id', 'age'])
      *   )
+     *   // Finally select all adult jennifers that are
+     *   // also younger than 60.
      *   .selectFrom('adult_jennifers')
      *   .where('age', '<', 60)
      *   .selectAll()
      *   .execute()
      * ```
      *
+     * <!-- siteExample("cte", "Inserts, updates and deletions", 20) -->
+     *
+     * Some databases like postgres also allow you to run other queries than selects
+     * in CTEs. On these databases CTEs are extremely powerful:
+     *
+     * ```ts
+     * const result = await db
+     *   .with('new_person', (db) => db
+     *     .insertInto('person')
+     *     .values({
+     *       first_name: 'Jennifer',
+     *       age: 35,
+     *     })
+     *     .returning('id')
+     *   )
+     *   .with('new_pet', (db) => db
+     *     .insertInto('pet')
+     *     .values({
+     *       name: 'Doggo',
+     *       species: 'dog',
+     *       is_favorite: true,
+     *       // Use the id of the person we just inserted.
+     *       owner_id: db
+     *         .selectFrom('new_person')
+     *         .select('id')
+     *     })
+     *     .returning('id')
+     *   )
+     *   .selectFrom(['new_person', 'new_pet'])
+     *   .select([
+     *     'new_person.id as person_id',
+     *     'new_pet.id as pet_id'
+     *   ])
+     *   .execute()
+     * ```
+     *
      * The CTE name can optionally specify column names in addition to
      * a name. In that case Kysely requires the expression to retun
      * rows with the same columns.

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

@@ -33,12 +33,12 @@ export interface Sql {
      *     // method to give it an alias.
      *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
      *   )
-     *   .where(sql`birthdate between ${date1} and ${date2}`)
+     *   .where(sql<boolean>`birthdate between ${date1} and ${date2}`)
      *   // Here we assume we have list of nicknames for the person
      *   // (a list of strings) and we use the PostgreSQL `@>` operator
      *   // to test if all of them are valid nicknames for the user.
-     *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
-     *   .orderBy(sql`concat(first_name, ' ', last_name)`)
+     *   .where('nicknames', '@>', sql<string[]>`ARRAY[${sql.join(nicknames)}]`)
+     *   .orderBy(sql<string>`concat(first_name, ' ', last_name)`)
      *   .execute()
      * ```
      *
@@ -63,7 +63,7 @@ export interface Sql {
      *
      * ```ts
      * const petName = db.selectFrom('pet').select('name').limit(1)
-     * const fullName = sql`concat(first_name, ' ', last_name)`
+     * const fullName = sql<string>`concat(first_name, ' ', last_name)`
      *
      * sql`
      *   select ${fullName} as full_name, ${petName} as pet_name
@@ -301,7 +301,7 @@ export interface Sql {
      *   return db
      *     .selectFrom('person')
      *     .selectAll()
-     *     .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
+     *     .where('nicknames', '@>', sql<string[]>`ARRAY[${sql.join(nicknames)}]`)
      *     .execute()
      * }
      * ```

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

@@ -2,6 +2,7 @@
 import { AlterColumnNode } from '../operation-node/alter-column-node.js';
 import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
+import { preventAwait } from '../util/prevent-await.js';
 export class AlterColumnBuilder {
     #column;
     constructor(column) {
@@ -30,6 +31,7 @@ export class AlterColumnBuilder {
         return func(this);
     }
 }
+preventAwait(AlterColumnBuilder, "don't await AlterColumnBuilder instances");
 /**
  * Allows us to force consumers to do exactly one alteration to a column.
  *
@@ -54,3 +56,4 @@ export class AlteredColumnBuilder {
         return this.#alterColumnNode;
     }
 }
+preventAwait(AlteredColumnBuilder, "don't await AlteredColumnBuilder instances");

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

@@ -72,7 +72,7 @@ export declare class AlterTableAddIndexBuilder implements OperationNodeSource, C
      * await db.schema
      *   .alterTable('person')
      *   .addIndex('person_first_name_index')
-     *   .expression(sql`(first_name < 'Sami')`)
+     *   .expression(sql<boolean>`(first_name < 'Sami')`)
      *   .execute()
      * ```
      *

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

@@ -97,7 +97,7 @@ export class AlterTableAddIndexBuilder {
      * await db.schema
      *   .alterTable('person')
      *   .addIndex('person_first_name_index')
-     *   .expression(sql`(first_name < 'Sami')`)
+     *   .expression(sql<boolean>`(first_name < 'Sami')`)
      *   .execute()
      * ```
      *

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

@@ -200,6 +200,7 @@ export class AlterTableBuilder {
         return func(this);
     }
 }
+preventAwait(AlterTableBuilder, "don't await AlterTableBuilder instances");
 export class AlterTableColumnAlteringBuilder {
     #props;
     constructor(props) {
@@ -248,6 +249,4 @@ export class AlterTableColumnAlteringBuilder {
         await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
-preventAwait(AlterTableBuilder, "don't await AlterTableBuilder instances");
-preventAwait(AlterColumnBuilder, "don't await AlterColumnBuilder instances");
 preventAwait(AlterTableColumnAlteringBuilder, "don't await AlterTableColumnAlteringBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/column-definition-builder.d.ts

@@ -220,6 +220,11 @@ export declare class ColumnDefinitionBuilder implements OperationNodeSource {
      * ```
      */
     nullsNotDistinct(): ColumnDefinitionBuilder;
+    /**
+     * Adds `if not exists` specifier.
+     * This only works for PostgreSQL.
+     */
+    ifNotExists(): ColumnDefinitionBuilder;
     /**
      * This can be used to add any additional SQL to the end of the column definition.
      *

package/dist/esm/schema/column-definition-builder.js

@@ -297,6 +297,13 @@ export class ColumnDefinitionBuilder {
     nullsNotDistinct() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { nullsNotDistinct: true }));
     }
+    /**
+     * Adds `if not exists` specifier.
+     * This only works for PostgreSQL.
+     */
+    ifNotExists() {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { ifNotExists: true }));
+    }
     /**
      * This can be used to add any additional SQL to the end of the column definition.
      *