kysely 0.27.4 → 0.27.5

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

@@ -21,15 +21,24 @@ export interface OutputInterface<DB, TB extends keyof DB, O, OP extends OutputPr
      *   .output('inserted.id')
      *   .values({
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     gender: 'female',
      *   })
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name", "gender")
+     * output "inserted"."id"
+     * values (@1, @2, @3)
      * ```
      *
      * Return multiple columns:
      *
      * ```ts
-     * const { id, first_name } = await db
+     * const { old_first_name, old_last_name, new_first_name, new_last_name } = await db
      *   .updateTable('person')
      *   .set({ first_name: 'John', last_name: 'Doe' })
      *   .output([
@@ -39,7 +48,19 @@ export interface OutputInterface<DB, TB extends keyof DB, O, OP extends OutputPr
      *     'inserted.last_name as new_last_name',
      *   ])
      *   .where('created_at', '<', new Date())
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "first_name" = @1, "last_name" = @2
+     * 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" < @3
      * ```
      *
      * Return arbitrary expressions:
@@ -47,11 +68,19 @@ export interface OutputInterface<DB, TB extends keyof DB, O, OP extends OutputPr
      * ```ts
      * import { sql } from 'kysely'
      *
-     * const { id, full_name } = await db
+     * const { full_name } = await db
      *   .deleteFrom('person')
-     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name'))
      *   .where('created_at', '<', new Date())
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * delete from "person"
+     * output concat("deleted"."first_name", ' ', "deleted"."last_name") as "full_name"
+     * where "created_at" < @1
      * ```
      *
      * Return the action performed on the row:
@@ -72,7 +101,21 @@ export interface OutputInterface<DB, TB extends keyof DB, O, OP extends OutputPr
      *     'inserted.id as inserted_id',
      *     'deleted.id as deleted_id',
      *   ])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "pet"."owner_id" = "person"."id"
+     * when matched then delete
+     * when not matched then
+     * insert ("first_name", "last_name", "gender")
+     * values (@1, @2, @3)
+     * output "inserted"."id" as "inserted_id", "deleted"."id" as "deleted_id"
      * ```
+     *
      */
     output<OE extends OutputExpression<DB, TB, OP>>(selections: ReadonlyArray<OE>): OutputInterface<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>, OP>;
     output<CB extends OutputCallback<DB, TB, OP>>(callback: CB): OutputInterface<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>, OP>;

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

@@ -26,20 +26,20 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      *     last_name: 'Aniston'
      *   })
      *   .returning('id')
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
      * ```
      *
      * Return multiple columns:
      *
      * ```ts
-     * const { id, first_name } = await db
+     * const { id, last_name } = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
      *   .returning(['id', 'last_name'])
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
      * ```
      *
      * Return arbitrary expressions:
@@ -56,9 +56,9 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      *   .returning((eb) => [
      *     'id as id',
      *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
-     *     eb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
+     *     eb.selectFrom('pet').select('pet.id').limit(1).as('first_pet_id')
      *   ])
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
      * ```
      */
     returning<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): ReturningInterface<DB, TB, ReturningRow<DB, TB, O, SE>>;

package/dist/esm/query-builder/select-query-builder-expression.d.ts

@@ -5,11 +5,19 @@ export interface SelectQueryBuilderExpression<O> extends AliasableExpression<O>
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
+     * ### Examples
+     *
      * If you are creating a custom expression, it's often easiest to use the {@link sql}
      * template tag to build the node:
      *
      * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
      * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
      *   toOperationNode(): OperationNode {
      *     return sql`some sql here`.toOperationNode()
      *   }