kysely 0.27.2 → 0.27.4

package/dist/cjs/query-builder/insert-query-builder.d.ts

@@ -11,7 +11,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { InsertResult } from './insert-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
+import { ReturningAllRow, ReturningCallbackRow, ReturningRow } from '../parser/returning-parser.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
@@ -21,7 +21,8 @@ import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
-export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
+import { OutputCallback, OutputExpression, OutputInterface, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
+export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OutputInterface<DB, TB, O, 'inserted'>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: InsertQueryBuilderProps);
     /**
@@ -143,11 +144,10 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .insertInto('person')
      *   .values(({ ref, selectFrom, fn }) => ({
      *     first_name: 'Jennifer',
-     *     last_name: sql`concat(${ani}, ${ston})`,
+     *     last_name: sql<string>`>concat(${ani}, ${ston})`,
      *     middle_name: ref('first_name'),
      *     age: selectFrom('person')
-     *       .select(fn.avg<number>('age')
-     *       .as('avg_age')),
+     *       .select(fn.avg<number>('age').as('avg_age')),
      *   }))
      *   .executeTakeFirst()
      * ```
@@ -215,7 +215,9 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * <!-- siteExample("insert", "Insert subquery", 50) -->
      *
-     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method:
+     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method.
+     * This API doesn't follow our WYSIWYG principles and might be a bit difficult to
+     * remember. The reasons for this design stem from implementation difficulties.
      *
      * ```ts
      * const result = await db.insertInto('person')
@@ -241,6 +243,14 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     expression(expression: ExpressionOrFactory<DB, TB, any>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Creates an `insert into "person" default values` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .defaultValues()
+     *   .execute()
+     * ```
      */
     defaultValues(): InsertQueryBuilder<DB, TB, O>;
     /**
@@ -265,6 +275,50 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```
      */
     ignore(): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert top into` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Insert the first 5 rows:
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .top(5)
+     *   .columns(['first_name', 'gender'])
+     *   .expression(
+     *     (eb) => eb.selectFrom('pet').select(['name', sql.lit('other').as('gender')])
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * insert top(5) into "person" ("first_name", "gender") select "name", 'other' as "gender" from "pet"
+     * ```
+     *
+     * Insert the first 50 percent of rows:
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .top(50, 'percent')
+     *   .columns(['first_name', 'gender'])
+     *   .expression(
+     *     (eb) => eb.selectFrom('pet').select(['name', sql.lit('other').as('gender')])
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * insert top(50) percent into "person" ("first_name", "gender") select "name", 'other' as "gender" from "pet"
+     * ```
+     */
+    top(expression: number | bigint, modifiers?: 'percent'): InsertQueryBuilder<DB, TB, O>;
     /**
      * Adds an `on conflict` clause to the query.
      *
@@ -334,7 +388,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *     species: 'cat',
      *   })
      *   .onConflict((oc) => oc
-     *     .expression(sql`lower(name)`)
+     *     .expression(sql<string>`lower(name)`)
      *     .doUpdateSet({ species: 'hamster' })
      *   )
      *   .execute()
@@ -501,8 +555,110 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
      */
     returningAll(): InsertQueryBuilder<DB, TB, Selectable<DB[TB]>>;
+    /**
+     * 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, TB, 'inserted'>>(selections: readonly OE[]): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    output<CB extends OutputCallback<DB, TB, 'inserted'>>(callback: CB): InsertQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>>;
+    output<OE extends OutputExpression<DB, TB, 'inserted'>>(selection: OE): InsertQueryBuilder<DB, 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.
+     */
+    outputAll(table: 'inserted'): InsertQueryBuilder<DB, TB, ReturningAllRow<DB, TB, O>>;
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values({ first_name: 'James', last_name: 'Smith', age: 42 })
+     *   .returning(['first_name'])
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("James", "Smith", 42)
+     * ```
+     */
+    clearReturning(): InsertQueryBuilder<DB, TB, InsertResult>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -614,17 +770,17 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * 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/cjs/query-builder/insert-query-builder.js

@@ -15,6 +15,7 @@ const expression_parser_js_1 = require("../parser/expression-parser.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
 const on_conflict_builder_js_1 = require("./on-conflict-builder.js");
 const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
+const top_parser_js_1 = require("../parser/top-parser.js");
 class InsertQueryBuilder {
     #props;
     constructor(props) {
@@ -139,11 +140,10 @@ class InsertQueryBuilder {
      *   .insertInto('person')
      *   .values(({ ref, selectFrom, fn }) => ({
      *     first_name: 'Jennifer',
-     *     last_name: sql`concat(${ani}, ${ston})`,
+     *     last_name: sql<string>`>concat(${ani}, ${ston})`,
      *     middle_name: ref('first_name'),
      *     age: selectFrom('person')
-     *       .select(fn.avg<number>('age')
-     *       .as('avg_age')),
+     *       .select(fn.avg<number>('age').as('avg_age')),
      *   }))
      *   .executeTakeFirst()
      * ```
@@ -227,7 +227,9 @@ class InsertQueryBuilder {
      *
      * <!-- siteExample("insert", "Insert subquery", 50) -->
      *
-     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method:
+     * You can create an `INSERT INTO SELECT FROM` query using the `expression` method.
+     * This API doesn't follow our WYSIWYG principles and might be a bit difficult to
+     * remember. The reasons for this design stem from implementation difficulties.
      *
      * ```ts
      * const result = await db.insertInto('person')
@@ -260,6 +262,14 @@ class InsertQueryBuilder {
     }
     /**
      * Creates an `insert into "person" default values` query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .defaultValues()
+     *   .execute()
+     * ```
      */
     defaultValues() {
         return new InsertQueryBuilder({
@@ -298,6 +308,55 @@ class InsertQueryBuilder {
             }),
         });
     }
+    /**
+     * Changes an `insert into` query to an `insert top into` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Insert the first 5 rows:
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .top(5)
+     *   .columns(['first_name', 'gender'])
+     *   .expression(
+     *     (eb) => eb.selectFrom('pet').select(['name', sql.lit('other').as('gender')])
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * insert top(5) into "person" ("first_name", "gender") select "name", 'other' as "gender" from "pet"
+     * ```
+     *
+     * Insert the first 50 percent of rows:
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .top(50, 'percent')
+     *   .columns(['first_name', 'gender'])
+     *   .expression(
+     *     (eb) => eb.selectFrom('pet').select(['name', sql.lit('other').as('gender')])
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * insert top(50) percent into "person" ("first_name", "gender") select "name", 'other' as "gender" from "pet"
+     * ```
+     */
+    top(expression, modifiers) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),
+        });
+    }
     /**
      * Adds an `on conflict` clause to the query.
      *
@@ -367,7 +426,7 @@ class InsertQueryBuilder {
      *     species: 'cat',
      *   })
      *   .onConflict((oc) => oc
-     *     .expression(sql`lower(name)`)
+     *     .expression(sql<string>`lower(name)`)
      *     .doUpdateSet({ species: 'hamster' })
      *   )
      *   .execute()
@@ -497,6 +556,42 @@ class InsertQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)()),
         });
     }
+    output(args) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(args)),
+        });
+    }
+    outputAll(table) {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
+        });
+    }
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values({ first_name: 'James', last_name: 'Smith', age: 42 })
+     *   .returning(['first_name'])
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("James", "Smith", 42)
+     * ```
+     */
+    clearReturning() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithoutReturning(this.#props.queryNode),
+        });
+    }
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -621,17 +716,17 @@ class InsertQueryBuilder {
     /**
      * 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.
      *
@@ -684,9 +779,11 @@ class InsertQueryBuilder {
      */
     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 [