kysely 0.28.1 → 0.28.2

package/deno.check.d.ts

@@ -20,6 +20,7 @@ export interface Database {
 }
 
 interface AuditTable {
+  id: Generated<number>
   action: string
 }
 
@@ -63,11 +64,13 @@ interface ToyTable {
 }
 
 interface WineTable {
+  id: Generated<number>
   name: string
   stock: number
 }
 
 interface WineStockChangeTable {
+  id: Generated<number>
   stock_delta: number
   wine_name: string
 }

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

@@ -51,7 +51,8 @@ class SqliteIntrospector {
             'p.dflt_value',
             'p.pk',
         ])
-            .orderBy(['tl.name', 'p.cid'])
+            .orderBy('tl.name')
+            .orderBy('p.cid')
             .execute();
         const columnsByTable = {};
         for (const row of tableMetadata) {

package/dist/cjs/dynamic/dynamic-table-builder.d.ts

@@ -0,0 +1,16 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+export declare class DynamicTableBuilder<T extends string> {
+    #private;
+    get table(): T;
+    constructor(table: T);
+    as<A extends string>(alias: A): AliasedDynamicTableBuilder<T, A>;
+}
+export declare class AliasedDynamicTableBuilder<T extends string, A extends string> implements OperationNodeSource {
+    #private;
+    get table(): T;
+    get alias(): A;
+    constructor(table: T, alias: A);
+    toOperationNode(): AliasNode;
+}
+export declare function isAliasedDynamicTableBuilder(obj: unknown): obj is AliasedDynamicTableBuilder<any, any>;

package/dist/cjs/dynamic/dynamic-table-builder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasedDynamicTableBuilder = exports.DynamicTableBuilder = void 0;
+exports.isAliasedDynamicTableBuilder = isAliasedDynamicTableBuilder;
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class DynamicTableBuilder {
+    #table;
+    get table() {
+        return this.#table;
+    }
+    constructor(table) {
+        this.#table = table;
+    }
+    as(alias) {
+        return new AliasedDynamicTableBuilder(this.#table, alias);
+    }
+}
+exports.DynamicTableBuilder = DynamicTableBuilder;
+class AliasedDynamicTableBuilder {
+    #table;
+    #alias;
+    get table() {
+        return this.#table;
+    }
+    get alias() {
+        return this.#alias;
+    }
+    constructor(table, alias) {
+        this.#table = table;
+        this.#alias = alias;
+    }
+    toOperationNode() {
+        return alias_node_js_1.AliasNode.create((0, table_parser_js_1.parseTable)(this.#table), identifier_node_js_1.IdentifierNode.create(this.#alias));
+    }
+}
+exports.AliasedDynamicTableBuilder = AliasedDynamicTableBuilder;
+function isAliasedDynamicTableBuilder(obj) {
+    return ((0, object_utils_js_1.isObject)(obj) &&
+        (0, operation_node_source_js_1.isOperationNodeSource)(obj) &&
+        (0, object_utils_js_1.isString)(obj.table) &&
+        (0, object_utils_js_1.isString)(obj.alias));
+}

package/dist/cjs/dynamic/dynamic.d.ts

@@ -1,5 +1,6 @@
 import { DynamicReferenceBuilder } from './dynamic-reference-builder.js';
-export declare class DynamicModule {
+import { DynamicTableBuilder } from './dynamic-table-builder.js';
+export declare class DynamicModule<DB> {
     /**
      * Creates a dynamic reference to a column that is not know at compile time.
      *
@@ -86,4 +87,38 @@ export declare class DynamicModule {
      * ```
      */
     ref<R extends string = never>(reference: string): DynamicReferenceBuilder<R>;
+    /**
+     * Creates a table reference to a table that's not fully known at compile time.
+     *
+     * The type `T` is allowed to be a union of multiple tables.
+     *
+     * <!-- siteExample("select", "Generic find query", 130) -->
+     *
+     * A generic type-safe helper function for finding a row by a column value:
+     *
+     * ```ts
+     * import { SelectType } from 'kysely'
+     * import { Database } from 'type-editor'
+     *
+     * async function getRowByColumn<
+     *   T extends keyof Database,
+     *   C extends keyof Database[T] & string,
+     *   V extends SelectType<Database[T][C]>,
+     * >(t: T, c: C, v: V) {
+     *   // We need to use the dynamic module since the table name
+     *   // is not known at compile time.
+     *   const { table, ref } = db.dynamic
+     *
+     *   return await db
+     *     .selectFrom(table(t).as('t'))
+     *     .selectAll()
+     *     .where(ref(c), '=', v)
+     *     .orderBy('t.id')
+     *     .executeTakeFirstOrThrow()
+     * }
+     *
+     * const person = await getRowByColumn('person', 'first_name', 'Arnold')
+     * ```
+     */
+    table<T extends keyof DB & string>(table: T): DynamicTableBuilder<T>;
 }

package/dist/cjs/dynamic/dynamic.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicModule = void 0;
 const dynamic_reference_builder_js_1 = require("./dynamic-reference-builder.js");
+const dynamic_table_builder_js_1 = require("./dynamic-table-builder.js");
 class DynamicModule {
     /**
      * Creates a dynamic reference to a column that is not know at compile time.
@@ -91,5 +92,41 @@ class DynamicModule {
     ref(reference) {
         return new dynamic_reference_builder_js_1.DynamicReferenceBuilder(reference);
     }
+    /**
+     * Creates a table reference to a table that's not fully known at compile time.
+     *
+     * The type `T` is allowed to be a union of multiple tables.
+     *
+     * <!-- siteExample("select", "Generic find query", 130) -->
+     *
+     * A generic type-safe helper function for finding a row by a column value:
+     *
+     * ```ts
+     * import { SelectType } from 'kysely'
+     * import { Database } from 'type-editor'
+     *
+     * async function getRowByColumn<
+     *   T extends keyof Database,
+     *   C extends keyof Database[T] & string,
+     *   V extends SelectType<Database[T][C]>,
+     * >(t: T, c: C, v: V) {
+     *   // We need to use the dynamic module since the table name
+     *   // is not known at compile time.
+     *   const { table, ref } = db.dynamic
+     *
+     *   return await db
+     *     .selectFrom(table(t).as('t'))
+     *     .selectAll()
+     *     .where(ref(c), '=', v)
+     *     .orderBy('t.id')
+     *     .executeTakeFirstOrThrow()
+     * }
+     *
+     * const person = await getRowByColumn('person', 'first_name', 'Arnold')
+     * ```
+     */
+    table(table) {
+        return new dynamic_table_builder_js_1.DynamicTableBuilder(table);
+    }
 }
 exports.DynamicModule = DynamicModule;

package/dist/cjs/kysely.d.ts

@@ -65,7 +65,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * The {@link DynamicModule} module can be used to bypass strict typing and
      * passing in dynamic values for the queries.
      */
-    get dynamic(): DynamicModule;
+    get dynamic(): DynamicModule<DB>;
     /**
      * Returns a {@link DatabaseIntrospector | database introspector}.
      */

package/dist/cjs/parser/table-parser.d.ts

@@ -4,7 +4,8 @@ import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { AliasedExpression } from '../expression/expression.js';
 import { DrainOuterGeneric } from '../util/type-utils.js';
-export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB>;
+import { AliasedDynamicTableBuilder } from '../dynamic/dynamic-table-builder.js';
+export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB> | AliasedDynamicTableBuilder<any, any>;
 export type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export type SimpleTableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB>;
 export type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
@@ -14,8 +15,8 @@ export type From<DB, TE> = DrainOuterGeneric<{
 }>;
 export type FromTables<DB, TB extends keyof DB, TE> = DrainOuterGeneric<TB | ExtractAliasFromTableExpression<DB, TE>>;
 export type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA extends keyof DB ? TA : never : TE extends keyof DB ? TE : never;
-type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
-type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : never;
+type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : TE extends AliasedDynamicTableBuilder<any, infer DA> ? DA : never;
+type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedDynamicTableBuilder<infer T, infer DA> ? DA extends A ? T extends keyof DB ? DB[T] : never : never : never;
 export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];
 export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;
 export declare function parseAliasedTable(from: string): TableNode | AliasNode;

package/dist/cjs/parser/table-parser.js

@@ -9,6 +9,7 @@ const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
 const expression_parser_js_1 = require("./expression-parser.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const dynamic_table_builder_js_1 = require("../dynamic/dynamic-table-builder.js");
 function parseTableExpressionOrList(table) {
     if ((0, object_utils_js_1.isReadonlyArray)(table)) {
         return table.map((it) => parseTableExpression(it));
@@ -21,6 +22,9 @@ function parseTableExpression(table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return parseAliasedTable(table);
     }
+    else if ((0, dynamic_table_builder_js_1.isAliasedDynamicTableBuilder)(table)) {
+        return table.toOperationNode();
+    }
     else {
         return (0, expression_parser_js_1.parseAliasedExpression)(table);
     }

package/dist/cjs/query-builder/order-by-interface.d.ts

@@ -40,24 +40,6 @@ export interface OrderByInterface<DB, TB extends keyof DB, O> {
      * order by "id", "fn" desc
      * ```
      *
-     * Multiple columns/expressions per call:
-     *
-     * ```ts
-     * await db
-     *   .selectFrom('person')
-     *   .select('person.first_name as fn')
-     *   .orderBy(['id', 'fn'])
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."first_name" as "fn"
-     * from "person"
-     * order by "id", "fn"
-     * ```
-     *
      * Building advanced modifiers:
      *
      * ```ts

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

@@ -1246,24 +1246,6 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * order by "id", "fn" desc
      * ```
      *
-     * Multiple columns/expressions per call:
-     *
-     * ```ts
-     * await db
-     *   .selectFrom('person')
-     *   .select('person.first_name as fn')
-     *   .orderBy(['id', 'fn'])
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."first_name" as "fn"
-     * from "person"
-     * order by "id", "fn"
-     * ```
-     *
      * Building advanced modifiers:
      *
      * ```ts

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

@@ -49,7 +49,8 @@ export class SqliteIntrospector {
             'p.dflt_value',
             'p.pk',
         ])
-            .orderBy(['tl.name', 'p.cid'])
+            .orderBy('tl.name')
+            .orderBy('p.cid')
             .execute();
         const columnsByTable = {};
         for (const row of tableMetadata) {

package/dist/esm/dynamic/dynamic-table-builder.d.ts

@@ -0,0 +1,16 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+export declare class DynamicTableBuilder<T extends string> {
+    #private;
+    get table(): T;
+    constructor(table: T);
+    as<A extends string>(alias: A): AliasedDynamicTableBuilder<T, A>;
+}
+export declare class AliasedDynamicTableBuilder<T extends string, A extends string> implements OperationNodeSource {
+    #private;
+    get table(): T;
+    get alias(): A;
+    constructor(table: T, alias: A);
+    toOperationNode(): AliasNode;
+}
+export declare function isAliasedDynamicTableBuilder(obj: unknown): obj is AliasedDynamicTableBuilder<any, any>;

package/dist/esm/dynamic/dynamic-table-builder.js

@@ -0,0 +1,41 @@
+/// <reference types="./dynamic-table-builder.d.ts" />
+import { AliasNode } from '../operation-node/alias-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { parseTable } from '../parser/table-parser.js';
+import { isObject, isString } from '../util/object-utils.js';
+export class DynamicTableBuilder {
+    #table;
+    get table() {
+        return this.#table;
+    }
+    constructor(table) {
+        this.#table = table;
+    }
+    as(alias) {
+        return new AliasedDynamicTableBuilder(this.#table, alias);
+    }
+}
+export class AliasedDynamicTableBuilder {
+    #table;
+    #alias;
+    get table() {
+        return this.#table;
+    }
+    get alias() {
+        return this.#alias;
+    }
+    constructor(table, alias) {
+        this.#table = table;
+        this.#alias = alias;
+    }
+    toOperationNode() {
+        return AliasNode.create(parseTable(this.#table), IdentifierNode.create(this.#alias));
+    }
+}
+export function isAliasedDynamicTableBuilder(obj) {
+    return (isObject(obj) &&
+        isOperationNodeSource(obj) &&
+        isString(obj.table) &&
+        isString(obj.alias));
+}

package/dist/esm/dynamic/dynamic.d.ts

@@ -1,5 +1,6 @@
 import { DynamicReferenceBuilder } from './dynamic-reference-builder.js';
-export declare class DynamicModule {
+import { DynamicTableBuilder } from './dynamic-table-builder.js';
+export declare class DynamicModule<DB> {
     /**
      * Creates a dynamic reference to a column that is not know at compile time.
      *
@@ -86,4 +87,38 @@ export declare class DynamicModule {
      * ```
      */
     ref<R extends string = never>(reference: string): DynamicReferenceBuilder<R>;
+    /**
+     * Creates a table reference to a table that's not fully known at compile time.
+     *
+     * The type `T` is allowed to be a union of multiple tables.
+     *
+     * <!-- siteExample("select", "Generic find query", 130) -->
+     *
+     * A generic type-safe helper function for finding a row by a column value:
+     *
+     * ```ts
+     * import { SelectType } from 'kysely'
+     * import { Database } from 'type-editor'
+     *
+     * async function getRowByColumn<
+     *   T extends keyof Database,
+     *   C extends keyof Database[T] & string,
+     *   V extends SelectType<Database[T][C]>,
+     * >(t: T, c: C, v: V) {
+     *   // We need to use the dynamic module since the table name
+     *   // is not known at compile time.
+     *   const { table, ref } = db.dynamic
+     *
+     *   return await db
+     *     .selectFrom(table(t).as('t'))
+     *     .selectAll()
+     *     .where(ref(c), '=', v)
+     *     .orderBy('t.id')
+     *     .executeTakeFirstOrThrow()
+     * }
+     *
+     * const person = await getRowByColumn('person', 'first_name', 'Arnold')
+     * ```
+     */
+    table<T extends keyof DB & string>(table: T): DynamicTableBuilder<T>;
 }

package/dist/esm/dynamic/dynamic.js

@@ -1,5 +1,6 @@
 /// <reference types="./dynamic.d.ts" />
 import { DynamicReferenceBuilder } from './dynamic-reference-builder.js';
+import { DynamicTableBuilder } from './dynamic-table-builder.js';
 export class DynamicModule {
     /**
      * Creates a dynamic reference to a column that is not know at compile time.
@@ -89,4 +90,40 @@ export class DynamicModule {
     ref(reference) {
         return new DynamicReferenceBuilder(reference);
     }
+    /**
+     * Creates a table reference to a table that's not fully known at compile time.
+     *
+     * The type `T` is allowed to be a union of multiple tables.
+     *
+     * <!-- siteExample("select", "Generic find query", 130) -->
+     *
+     * A generic type-safe helper function for finding a row by a column value:
+     *
+     * ```ts
+     * import { SelectType } from 'kysely'
+     * import { Database } from 'type-editor'
+     *
+     * async function getRowByColumn<
+     *   T extends keyof Database,
+     *   C extends keyof Database[T] & string,
+     *   V extends SelectType<Database[T][C]>,
+     * >(t: T, c: C, v: V) {
+     *   // We need to use the dynamic module since the table name
+     *   // is not known at compile time.
+     *   const { table, ref } = db.dynamic
+     *
+     *   return await db
+     *     .selectFrom(table(t).as('t'))
+     *     .selectAll()
+     *     .where(ref(c), '=', v)
+     *     .orderBy('t.id')
+     *     .executeTakeFirstOrThrow()
+     * }
+     *
+     * const person = await getRowByColumn('person', 'first_name', 'Arnold')
+     * ```
+     */
+    table(table) {
+        return new DynamicTableBuilder(table);
+    }
 }

package/dist/esm/kysely.d.ts

@@ -65,7 +65,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * The {@link DynamicModule} module can be used to bypass strict typing and
      * passing in dynamic values for the queries.
      */
-    get dynamic(): DynamicModule;
+    get dynamic(): DynamicModule<DB>;
     /**
      * Returns a {@link DatabaseIntrospector | database introspector}.
      */

package/dist/esm/parser/table-parser.d.ts

@@ -4,7 +4,8 @@ import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { AliasedExpression } from '../expression/expression.js';
 import { DrainOuterGeneric } from '../util/type-utils.js';
-export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB>;
+import { AliasedDynamicTableBuilder } from '../dynamic/dynamic-table-builder.js';
+export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB> | AliasedDynamicTableBuilder<any, any>;
 export type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export type SimpleTableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB>;
 export type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
@@ -14,8 +15,8 @@ export type From<DB, TE> = DrainOuterGeneric<{
 }>;
 export type FromTables<DB, TB extends keyof DB, TE> = DrainOuterGeneric<TB | ExtractAliasFromTableExpression<DB, TE>>;
 export type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA extends keyof DB ? TA : never : TE extends keyof DB ? TE : never;
-type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
-type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : never;
+type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : TE extends AliasedDynamicTableBuilder<any, infer DA> ? DA : never;
+type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedDynamicTableBuilder<infer T, infer DA> ? DA extends A ? T extends keyof DB ? DB[T] : never : never : never;
 export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];
 export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;
 export declare function parseAliasedTable(from: string): TableNode | AliasNode;

package/dist/esm/parser/table-parser.js

@@ -4,6 +4,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
 import { parseAliasedExpression, } from './expression-parser.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isAliasedDynamicTableBuilder, } from '../dynamic/dynamic-table-builder.js';
 export function parseTableExpressionOrList(table) {
     if (isReadonlyArray(table)) {
         return table.map((it) => parseTableExpression(it));
@@ -16,6 +17,9 @@ export function parseTableExpression(table) {
     if (isString(table)) {
         return parseAliasedTable(table);
     }
+    else if (isAliasedDynamicTableBuilder(table)) {
+        return table.toOperationNode();
+    }
     else {
         return parseAliasedExpression(table);
     }

package/dist/esm/query-builder/order-by-interface.d.ts

@@ -40,24 +40,6 @@ export interface OrderByInterface<DB, TB extends keyof DB, O> {
      * order by "id", "fn" desc
      * ```
      *
-     * Multiple columns/expressions per call:
-     *
-     * ```ts
-     * await db
-     *   .selectFrom('person')
-     *   .select('person.first_name as fn')
-     *   .orderBy(['id', 'fn'])
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."first_name" as "fn"
-     * from "person"
-     * order by "id", "fn"
-     * ```
-     *
      * Building advanced modifiers:
      *
      * ```ts

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

@@ -1246,24 +1246,6 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * order by "id", "fn" desc
      * ```
      *
-     * Multiple columns/expressions per call:
-     *
-     * ```ts
-     * await db
-     *   .selectFrom('person')
-     *   .select('person.first_name as fn')
-     *   .orderBy(['id', 'fn'])
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."first_name" as "fn"
-     * from "person"
-     * order by "id", "fn"
-     * ```
-     *
      * Building advanced modifiers:
      *
      * ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.28.1",
+  "version": "0.28.2",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -113,7 +113,7 @@
     "sinon": "^19.0.2",
     "tarn": "^3.0.2",
     "tedious": "^19.0.0",
-    "tsd": "^0.31.1",
+    "tsd": "^0.32.0",
     "tsx": "^4.19.1",
     "typescript": "^5.6.3"
   }