kysely 0.27.0 → 0.27.1

package/README.md

@@ -13,7 +13,7 @@
 # [Kysely](https://kysely.dev)
 
 Kysely (pronounce “Key-Seh-Lee”) is a type-safe and autocompletion-friendly typescript SQL query builder.
-Inspired by [knex](http://knexjs.org/). Mainly developed for [node.js](https://nodejs.org/en/) but also 
+Inspired by [knex](http://knexjs.org/). Mainly developed for [node.js](https://nodejs.org/en/) but also
 runs on all other javascript environments like [deno](https://deno.land/).
 
 ![](https://github.com/kysely-org/kysely/blob/master/assets/demo.gif)
@@ -32,7 +32,7 @@ hatches for these situations. See the [sql template tag](https://kysely-org.gith
 and the [DynamicModule](https://kysely-org.github.io/kysely-apidoc/classes/DynamicModule.html#ref) for more info.
 
 All API documentation is written in the typing files and you can simply hover over the module, class
-or method you're using to see it in your IDE. The same documentation is also hosted [here](https://github.com/kysely-org/kysely).
+or method you're using to see it in your IDE. The same documentation is also hosted [here](https://kysely-org.github.io/kysely-apidoc/).
 
 If you start using Kysely and can't find something you'd want to use, please open an issue or join our
 [discord server](https://discord.gg/xyBJ3GwvAm).

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

@@ -67,12 +67,14 @@ class MssqlIntrospector {
         const tableDictionary = {};
         for (const rawColumn of rawColumns) {
             const key = `${rawColumn.table_schema_name}.${rawColumn.table_name}`;
-            const table = (tableDictionary[key] ||= (0, object_utils_js_1.freeze)({
-                columns: [],
-                isView: rawColumn.table_type === 'V ',
-                name: rawColumn.table_name,
-                schema: rawColumn.table_schema_name ?? undefined,
-            }));
+            const table = (tableDictionary[key] =
+                tableDictionary[key] ||
+                    (0, object_utils_js_1.freeze)({
+                        columns: [],
+                        isView: rawColumn.table_type === 'V ',
+                        name: rawColumn.table_name,
+                        schema: rawColumn.table_schema_name ?? undefined,
+                    }));
             table.columns.push((0, object_utils_js_1.freeze)({
                 dataType: rawColumn.type_name,
                 dataTypeSchema: rawColumn.type_schema_name ?? undefined,

package/dist/cjs/expression/expression-wrapper.d.ts

@@ -243,7 +243,17 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `ExpressionWrapper` with a new output type.
      */
-    $castTo<T>(): ExpressionWrapper<DB, TB, T>;
+    $castTo<C>(): ExpressionWrapper<DB, TB, C>;
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull(): ExpressionWrapper<DB, TB, Exclude<T, null>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -397,7 +407,7 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `OrWrapper` with a new output type.
      */
-    $castTo<T extends SqlBool>(): OrWrapper<DB, TB, T>;
+    $castTo<C extends SqlBool>(): OrWrapper<DB, TB, C>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -533,7 +543,7 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `AndWrapper` with a new output type.
      */
-    $castTo<T extends SqlBool>(): AndWrapper<DB, TB, T>;
+    $castTo<C extends SqlBool>(): AndWrapper<DB, TB, C>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *

package/dist/cjs/expression/expression-wrapper.js

@@ -35,6 +35,18 @@ class ExpressionWrapper {
     $castTo() {
         return new ExpressionWrapper(this.#node);
     }
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull() {
+        return new ExpressionWrapper(this.#node);
+    }
     toOperationNode() {
         return this.#node;
     }

package/dist/cjs/operation-node/insert-query-node.d.ts

@@ -19,6 +19,7 @@ export interface InsertQueryNode extends OperationNode {
     readonly ignore?: boolean;
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
+    readonly defaultValues?: boolean;
 }
 /**
  * @internal

package/dist/cjs/operation-node/limit-node.d.ts

@@ -1,13 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { ValueNode } from './value-node.js';
 export interface LimitNode extends OperationNode {
     readonly kind: 'LimitNode';
-    readonly limit: ValueNode;
+    readonly limit: OperationNode;
 }
 /**
  * @internal
  */
 export declare const LimitNode: Readonly<{
     is(node: OperationNode): node is LimitNode;
-    create(limit: number): LimitNode;
+    create(limit: OperationNode): LimitNode;
 }>;

package/dist/cjs/operation-node/limit-node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LimitNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const value_node_js_1 = require("./value-node.js");
 /**
  * @internal
  */
@@ -13,7 +12,7 @@ exports.LimitNode = (0, object_utils_js_1.freeze)({
     create(limit) {
         return (0, object_utils_js_1.freeze)({
             kind: 'LimitNode',
-            limit: value_node_js_1.ValueNode.create(limit),
+            limit,
         });
     },
 });

package/dist/cjs/operation-node/offset-node.d.ts

@@ -1,13 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { ValueNode } from './value-node.js';
 export interface OffsetNode extends OperationNode {
     readonly kind: 'OffsetNode';
-    readonly offset: ValueNode;
+    readonly offset: OperationNode;
 }
 /**
  * @internal
  */
 export declare const OffsetNode: Readonly<{
     is(node: OperationNode): node is OffsetNode;
-    create(offset: number): OffsetNode;
+    create(offset: OperationNode): OffsetNode;
 }>;

package/dist/cjs/operation-node/offset-node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OffsetNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const value_node_js_1 = require("./value-node.js");
 /**
  * @internal
  */
@@ -13,7 +12,7 @@ exports.OffsetNode = (0, object_utils_js_1.freeze)({
     create(offset) {
         return (0, object_utils_js_1.freeze)({
             kind: 'OffsetNode',
-            offset: value_node_js_1.ValueNode.create(offset),
+            offset,
         });
     },
 });

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

@@ -259,6 +259,7 @@ class OperationNodeTransformer {
             ignore: node.ignore,
             replace: node.replace,
             explain: this.transformNode(node.explain),
+            defaultValues: node.defaultValues,
         });
     }
     transformValues(node) {
@@ -635,6 +636,7 @@ class OperationNodeTransformer {
             kind: 'SelectModifierNode',
             modifier: node.modifier,
             rawModifier: this.transformNode(node.rawModifier),
+            of: this.transformNodeList(node.of),
         });
     }
     transformCreateType(node) {

package/dist/cjs/operation-node/select-modifier-node.d.ts

@@ -4,12 +4,13 @@ export interface SelectModifierNode extends OperationNode {
     readonly kind: 'SelectModifierNode';
     readonly modifier?: SelectModifier;
     readonly rawModifier?: OperationNode;
+    readonly of?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const SelectModifierNode: Readonly<{
     is(node: OperationNode): node is SelectModifierNode;
-    create(modifier: SelectModifier): SelectModifierNode;
+    create(modifier: SelectModifier, of?: ReadonlyArray<OperationNode>): SelectModifierNode;
     createWithExpression(modifier: OperationNode): SelectModifierNode;
 }>;

package/dist/cjs/operation-node/select-modifier-node.js

@@ -9,10 +9,11 @@ exports.SelectModifierNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'SelectModifierNode';
     },
-    create(modifier) {
+    create(modifier, of) {
         return (0, object_utils_js_1.freeze)({
             kind: 'SelectModifierNode',
             modifier,
+            of,
         });
     },
     createWithExpression(modifier) {

package/dist/cjs/query-builder/aggregate-function-builder.d.ts

@@ -199,6 +199,23 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * what the provided function returns.
      */
     $call<T>(func: (qb: this) => T): T;
+    /**
+     * Casts the expression to the given type.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AggregateFunctionBuilder` with a new output type.
+     */
+    $castTo<C>(): AggregateFunctionBuilder<DB, TB, C>;
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull(): AggregateFunctionBuilder<DB, TB, Exclude<O, null>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *

package/dist/cjs/query-builder/aggregate-function-builder.js

@@ -172,6 +172,27 @@ class AggregateFunctionBuilder {
     $call(func) {
         return func(this);
     }
+    /**
+     * Casts the expression to the given type.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AggregateFunctionBuilder` with a new output type.
+     */
+    $castTo() {
+        return new AggregateFunctionBuilder(this.#props);
+    }
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull() {
+        return new AggregateFunctionBuilder(this.#props);
+    }
     toOperationNode() {
         return this.#props.aggregateFunctionNode;
     }

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

@@ -29,7 +29,7 @@ export declare class CaseThenBuilder<DB, TB extends keyof DB, W, O> {
      * A `then` call can be followed by {@link Whenable.when}, {@link CaseWhenBuilder.else},
      * {@link CaseWhenBuilder.end} or {@link CaseWhenBuilder.endCase} call.
      */
-    then<E extends Expression<any>>(expression: E): CaseWhenBuilder<DB, TB, W, O | ExtractTypeFromValueExpression<E>>;
+    then<E extends Expression<unknown>>(expression: E): CaseWhenBuilder<DB, TB, W, O | ExtractTypeFromValueExpression<E>>;
     then<V>(value: V): CaseWhenBuilder<DB, TB, W, O | V>;
 }
 export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements Whenable<DB, TB, W, O>, Endable<DB, TB, O | null> {
@@ -48,7 +48,7 @@ export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements W
      *
      * An `else` call must be followed by an {@link Endable.end} or {@link Endable.endCase} call.
      */
-    else<O2>(expression: Expression<O2>): CaseEndBuilder<DB, TB, O | O2>;
+    else<E extends Expression<unknown>>(expression: E): CaseEndBuilder<DB, TB, O | ExtractTypeFromValueExpression<E>>;
     else<V>(value: V): CaseEndBuilder<DB, TB, O | V>;
     /**
      * Adds an `end` keyword to the case operator.

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

@@ -23,6 +23,7 @@ import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../p
 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 DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: DeleteQueryBuilderProps);
@@ -814,7 +815,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .execute()
      * ```
      */
-    limit(limit: number): DeleteQueryBuilder<DB, TB, O>;
+    limit(limit: ValueExpression<DB, TB, number>): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -877,10 +878,10 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `DeleteQueryBuilder` with a new output type.
      */
-    $castTo<T>(): DeleteQueryBuilder<DB, TB, T>;
+    $castTo<C>(): DeleteQueryBuilder<DB, TB, C>;
     /**
      * Narrows (parts of) the output type of the query.
      *

package/dist/cjs/query-builder/delete-query-builder.js

@@ -13,6 +13,7 @@ const delete_query_node_js_1 = require("../operation-node/delete-query-node.js")
 const limit_node_js_1 = require("../operation-node/limit-node.js");
 const order_by_parser_js_1 = require("../parser/order-by-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const value_parser_js_1 = require("../parser/value-parser.js");
 class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -139,7 +140,7 @@ class DeleteQueryBuilder {
     limit(limit) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create(limit)),
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create((0, value_parser_js_1.parseValueExpression)(limit))),
         });
     }
     /**
@@ -213,8 +214,8 @@ class DeleteQueryBuilder {
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `DeleteQueryBuilder` with a new output type.
      */
     $castTo() {
         return new DeleteQueryBuilder(this.#props);

package/dist/cjs/query-builder/function-module.d.ts

@@ -138,7 +138,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * from "person"
      * ```
      */
-    agg<O, RE extends ReferenceExpression<DB, TB>>(name: string, args?: ReadonlyArray<RE>): AggregateFunctionBuilder<DB, TB, O>;
+    agg<O, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(name: string, args?: ReadonlyArray<RE>): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `avg` function for the column or expression given as the argument.
      *

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

@@ -240,6 +240,10 @@ 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.
+     */
+    defaultValues(): InsertQueryBuilder<DB, TB, O>;
     /**
      * Changes an `insert into` query to an `insert ignore into` query.
      *
@@ -563,10 +567,10 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `InsertQueryBuilder` with a new output type.
      */
-    $castTo<T>(): InsertQueryBuilder<DB, TB, T>;
+    $castTo<C>(): InsertQueryBuilder<DB, TB, C>;
     /**
      * Narrows (parts of) the output type of the query.
      *

package/dist/cjs/query-builder/insert-query-builder.js

@@ -98,6 +98,17 @@ class InsertQueryBuilder {
             }),
         });
     }
+    /**
+     * Creates an `insert into "person" default values` query.
+     */
+    defaultValues() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                defaultValues: true,
+            }),
+        });
+    }
     /**
      * Changes an `insert into` query to an `insert ignore into` query.
      *
@@ -398,8 +409,8 @@ class InsertQueryBuilder {
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `InsertQueryBuilder` with a new output type.
      */
     $castTo() {
         return new InsertQueryBuilder(this.#props);

package/dist/cjs/query-builder/json-path-builder.d.ts

@@ -232,7 +232,8 @@ export declare class TraversedJSONPathBuilder<S, O> extends JSONPathBuilder<S, O
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `JSONPathBuilder` with a new output type.
      */
-    $castTo<T>(): JSONPathBuilder<T>;
+    $castTo<C>(): JSONPathBuilder<C>;
+    $notNull(): JSONPathBuilder<Exclude<O, null>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *

package/dist/cjs/query-builder/json-path-builder.js

@@ -165,6 +165,9 @@ class TraversedJSONPathBuilder extends JSONPathBuilder {
     $castTo() {
         return new JSONPathBuilder(this.#node);
     }
+    $notNull() {
+        return new JSONPathBuilder(this.#node);
+    }
     toOperationNode() {
         return this.#node;
     }

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

@@ -25,6 +25,7 @@ import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { SelectQueryBuilderExpression } from './select-query-builder-expression.js';
+import { ValueExpression } from '../parser/value-parser.js';
 export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInterface<DB, TB>, HavingInterface<DB, TB>, SelectQueryBuilderExpression<O>, Compilable<O>, Explainable, Streamable<O> {
     /**
      * Adds a `where` expression to the query.
@@ -674,19 +675,19 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Adds the `for update` modifier to a select query on supported databases.
      */
-    forUpdate(): SelectQueryBuilder<DB, TB, O>;
+    forUpdate(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for share` modifier to a select query on supported databases.
      */
-    forShare(): SelectQueryBuilder<DB, TB, O>;
+    forShare(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for key share` modifier to a select query on supported databases.
      */
-    forKeyShare(): SelectQueryBuilder<DB, TB, O>;
+    forKeyShare(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for no key update` modifier to a select query on supported databases.
      */
-    forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O>;
+    forNoKeyUpdate(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `skip locked` modifier to a select query on supported databases.
      */
@@ -1161,7 +1162,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .limit(10)
      * ```
      */
-    limit(limit: number): SelectQueryBuilder<DB, TB, O>;
+    limit(limit: ValueExpression<DB, TB, number>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds an offset clause to the query.
      *
@@ -1177,7 +1178,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .limit(10)
      * ```
      */
-    offset(offset: number): SelectQueryBuilder<DB, TB, O>;
+    offset(offset: ValueExpression<DB, TB, number>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `union`.
      *
@@ -1549,10 +1550,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `SelectQueryBuilder` with a new output type.
      */
-    $castTo<T>(): SelectQueryBuilder<DB, TB, T>;
+    $castTo<C>(): SelectQueryBuilder<DB, TB, C>;
     /**
      * Changes the output type from an object to a tuple.
      *
@@ -1831,4 +1832,5 @@ type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = Se
 type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 }>;
+type TableOrList<TB extends keyof any> = (TB & string) | ReadonlyArray<TB & string>;
 export {};

package/dist/cjs/query-builder/select-query-builder.js

@@ -4,6 +4,7 @@ exports.createSelectQueryBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const select_modifier_node_js_1 = require("../operation-node/select-modifier-node.js");
 const join_parser_js_1 = require("../parser/join-parser.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
 const select_parser_js_1 = require("../parser/select-parser.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
@@ -19,6 +20,7 @@ const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 const set_operation_parser_js_1 = require("../parser/set-operation-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
+const value_parser_js_1 = require("../parser/value-parser.js");
 class SelectQueryBuilderImpl {
     #props;
     constructor(props) {
@@ -84,28 +86,28 @@ class SelectQueryBuilderImpl {
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('Distinct')),
         });
     }
-    forUpdate() {
+    forUpdate(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForUpdate')),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForUpdate', of ? (0, object_utils_js_1.asArray)(of).map(table_parser_js_1.parseTable) : undefined)),
         });
     }
-    forShare() {
+    forShare(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForShare')),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForShare', of ? (0, object_utils_js_1.asArray)(of).map(table_parser_js_1.parseTable) : undefined)),
         });
     }
-    forKeyShare() {
+    forKeyShare(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForKeyShare')),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForKeyShare', of ? (0, object_utils_js_1.asArray)(of).map(table_parser_js_1.parseTable) : undefined)),
         });
     }
-    forNoKeyUpdate() {
+    forNoKeyUpdate(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForNoKeyUpdate')),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForNoKeyUpdate', of ? (0, object_utils_js_1.asArray)(of).map(table_parser_js_1.parseTable) : undefined)),
         });
     }
     skipLocked() {
@@ -177,13 +179,13 @@ class SelectQueryBuilderImpl {
     limit(limit) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create(limit)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create((0, value_parser_js_1.parseValueExpression)(limit))),
         });
     }
     offset(offset) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOffset(this.#props.queryNode, offset_node_js_1.OffsetNode.create(offset)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOffset(this.#props.queryNode, offset_node_js_1.OffsetNode.create((0, value_parser_js_1.parseValueExpression)(offset))),
         });
     }
     union(expression) {

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

@@ -829,10 +829,10 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `UpdateQueryBuilder` with a new output type.
      */
-    $castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
+    $castTo<C>(): UpdateQueryBuilder<DB, UT, TB, C>;
     /**
      * Narrows (parts of) the output type of the query.
      *

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

@@ -156,8 +156,8 @@ class UpdateQueryBuilder {
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `UpdateQueryBuilder` with a new output type.
      */
     $castTo() {
         return new UpdateQueryBuilder(this.#props);

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

@@ -164,6 +164,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.values);
         }
+        if (node.defaultValues) {
+            this.append(' ');
+            this.append('default values');
+        }
         if (node.onConflict) {
             this.append(' ');
             this.visitNode(node.onConflict);
@@ -869,6 +873,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         else {
             this.append(SELECT_MODIFIER_SQL[node.modifier]);
         }
+        if (node.of) {
+            this.append(' of ');
+            this.compileList(node.of, ', ');
+        }
     }
     visitCreateType(node) {
         this.append('create type ');