kysely 0.27.2 → 0.27.4

package/dist/esm/operation-node/query-node.d.ts

@@ -10,7 +10,10 @@ import { OperationNode } from './operation-node.js';
 import { ExplainNode } from './explain-node.js';
 import { ExplainFormat } from '../util/explainable.js';
 import { Expression } from '../expression/expression.js';
-export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode;
+import { MergeQueryNode } from './merge-query-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
+export type QueryNode = SelectQueryNode | InsertQueryNode | UpdateQueryNode | DeleteQueryNode | MergeQueryNode;
 type HasJoins = {
     joins?: ReadonlyArray<JoinNode>;
 };
@@ -23,15 +26,24 @@ type HasReturning = {
 type HasExplain = {
     explain?: ExplainNode;
 };
+type HasTop = {
+    top?: TopNode;
+};
+type HasOutput = {
+    output?: OutputNode;
+};
 /**
  * @internal
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
-    cloneWithJoin<T_1 extends HasJoins>(node: T_1, join: JoinNode): T_1;
-    cloneWithReturning<T_2 extends HasReturning>(node: T_2, selections: ReadonlyArray<SelectionNode>): T_2;
-    cloneWithoutWhere<T_3 extends HasWhere>(node: T_3): T_3;
-    cloneWithExplain<T_4 extends HasExplain>(node: T_4, format: ExplainFormat | undefined, options: Expression<any> | undefined): T_4;
+    cloneWithJoin<T extends HasJoins>(node: T, join: JoinNode): T;
+    cloneWithReturning<T extends HasReturning>(node: T, selections: ReadonlyArray<SelectionNode>): T;
+    cloneWithoutReturning<T extends HasReturning>(node: T): T;
+    cloneWithoutWhere<T extends HasWhere>(node: T): T;
+    cloneWithExplain<T extends HasExplain>(node: T, format: ExplainFormat | undefined, options: Expression<any> | undefined): T;
+    cloneWithTop<T extends HasTop>(node: T, top: TopNode): T;
+    cloneWithOutput<T extends HasOutput>(node: T, selections: ReadonlyArray<SelectionNode>): T;
 }>;
 export {};

package/dist/esm/operation-node/query-node.js

@@ -7,6 +7,8 @@ import { WhereNode } from './where-node.js';
 import { freeze } from '../util/object-utils.js';
 import { ReturningNode } from './returning-node.js';
 import { ExplainNode } from './explain-node.js';
+import { MergeQueryNode } from './merge-query-node.js';
+import { OutputNode } from './output-node.js';
 /**
  * @internal
  */
@@ -15,7 +17,8 @@ export const QueryNode = freeze({
         return (SelectQueryNode.is(node) ||
             InsertQueryNode.is(node) ||
             UpdateQueryNode.is(node) ||
-            DeleteQueryNode.is(node));
+            DeleteQueryNode.is(node) ||
+            MergeQueryNode.is(node));
     },
     cloneWithWhere(node, operation) {
         return freeze({
@@ -39,6 +42,12 @@ export const QueryNode = freeze({
                 : ReturningNode.create(selections),
         });
     },
+    cloneWithoutReturning(node) {
+        return freeze({
+            ...node,
+            returning: undefined,
+        });
+    },
     cloneWithoutWhere(node) {
         return freeze({
             ...node,
@@ -51,4 +60,18 @@ export const QueryNode = freeze({
             explain: ExplainNode.create(format, options?.toOperationNode()),
         });
     },
+    cloneWithTop(node, top) {
+        return freeze({
+            ...node,
+            top,
+        });
+    },
+    cloneWithOutput(node, selections) {
+        return freeze({
+            ...node,
+            output: node.output
+                ? OutputNode.cloneWithSelections(node.output, selections)
+                : OutputNode.create(selections),
+        });
+    },
 });

package/dist/esm/operation-node/select-query-node.d.ts

@@ -14,6 +14,8 @@ import { WithNode } from './with-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { ExplainNode } from './explain-node.js';
 import { SetOperationNode } from './set-operation-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from?: FromNode;
@@ -31,6 +33,8 @@ export interface SelectQueryNode extends OperationNode {
     readonly having?: HavingNode;
     readonly explain?: ExplainNode;
     readonly setOperations?: ReadonlyArray<SetOperationNode>;
+    readonly fetch?: FetchNode;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -47,10 +51,12 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
+    cloneWithFetch(selectNode: SelectQueryNode, fetch: FetchNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;
     cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): SelectQueryNode;
     cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;
     cloneWithoutOrderBy(select: SelectQueryNode): SelectQueryNode;
+    cloneWithoutGroupBy(select: SelectQueryNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -84,6 +84,12 @@ export const SelectQueryNode = freeze({
             offset,
         });
     },
+    cloneWithFetch(selectNode, fetch) {
+        return freeze({
+            ...selectNode,
+            fetch,
+        });
+    },
     cloneWithHaving(selectNode, operation) {
         return freeze({
             ...selectNode,
@@ -124,4 +130,10 @@ export const SelectQueryNode = freeze({
             orderBy: undefined,
         });
     },
+    cloneWithoutGroupBy(select) {
+        return freeze({
+            ...select,
+            groupBy: undefined,
+        });
+    },
 });

package/dist/esm/operation-node/top-node.d.ts

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export type TopModifier = 'percent' | 'with ties' | 'percent with ties';
+export interface TopNode extends OperationNode {
+    readonly kind: 'TopNode';
+    readonly expression: number | bigint;
+    readonly modifiers?: TopModifier;
+}
+/**
+ * @internal
+ */
+export declare const TopNode: Readonly<{
+    is(node: OperationNode): node is TopNode;
+    create(expression: number | bigint, modifiers?: TopModifier): TopNode;
+}>;

package/dist/esm/operation-node/top-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./top-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const TopNode = freeze({
+    is(node) {
+        return node.kind === 'TopNode';
+    },
+    create(expression, modifiers) {
+        return freeze({
+            kind: 'TopNode',
+            expression,
+            modifiers,
+        });
+    },
+});

package/dist/esm/operation-node/update-query-node.d.ts

@@ -8,10 +8,13 @@ import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { FromNode } from './from-node.js';
 import { ExplainNode } from './explain-node.js';
+import { LimitNode } from './limit-node.js';
+import { TopNode } from './top-node.js';
+import { OutputNode } from './output-node.js';
 export type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
-    readonly table: OperationNode;
+    readonly table?: OperationNode;
     readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
@@ -19,6 +22,9 @@ export interface UpdateQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
     readonly explain?: ExplainNode;
+    readonly limit?: LimitNode;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
 }
 /**
  * @internal
@@ -26,6 +32,8 @@ export interface UpdateQueryNode extends OperationNode {
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
     create(table: OperationNode, withNode?: WithNode): UpdateQueryNode;
+    createWithoutTable(): UpdateQueryNode;
     cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
+    cloneWithLimit(updateQuery: UpdateQueryNode, limit: LimitNode): UpdateQueryNode;
 }>;

package/dist/esm/operation-node/update-query-node.js

@@ -15,6 +15,11 @@ export const UpdateQueryNode = freeze({
             ...(withNode && { with: withNode }),
         });
     },
+    createWithoutTable() {
+        return freeze({
+            kind: 'UpdateQueryNode',
+        });
+    },
     cloneWithFromItems(updateQuery, fromItems) {
         return freeze({
             ...updateQuery,
@@ -31,4 +36,10 @@ export const UpdateQueryNode = freeze({
                 : updates,
         });
     },
+    cloneWithLimit(updateQuery, limit) {
+        return freeze({
+            ...updateQuery,
+            limit,
+        });
+    },
 });

package/dist/esm/operation-node/where-node.d.ts

@@ -9,5 +9,5 @@ export interface WhereNode extends OperationNode {
 export declare const WhereNode: Readonly<{
     is(node: OperationNode): node is WhereNode;
     create(filter: OperationNode): WhereNode;
-    cloneWithOperation(whereNode: WhereNode, operator: 'And' | 'Or', operation: OperationNode): WhereNode;
+    cloneWithOperation(whereNode: WhereNode, operator: "And" | "Or", operation: OperationNode): WhereNode;
 }>;

package/dist/esm/parser/binary-operation-parser.d.ts

@@ -18,4 +18,4 @@ export declare function parseValueBinaryOperationOrExpression(args: any[]): Oper
 export declare function parseValueBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
 export declare function parseReferentialBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
 export declare function parseFilterObject(obj: Readonly<FilterObject<any, any>>, combinator: 'and' | 'or'): OperationNode;
-export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or'): OperationNode;
+export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or', withParens?: boolean): OperationNode;

package/dist/esm/parser/binary-operation-parser.js

@@ -32,7 +32,7 @@ export function parseFilterObject(obj, combinator) {
         .filter(([, v]) => !isUndefined(v))
         .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
 }
-export function parseFilterList(list, combinator) {
+export function parseFilterList(list, combinator, withParens = true) {
     const combine = combinator === 'and' ? AndNode.create : OrNode.create;
     if (list.length === 0) {
         return BinaryOperationNode.create(ValueNode.createImmediate(1), OperatorNode.create('='), ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
@@ -41,7 +41,7 @@ export function parseFilterList(list, combinator) {
     for (let i = 1; i < list.length; ++i) {
         node = combine(node, toOperationNode(list[i]));
     }
-    if (list.length > 1) {
+    if (list.length > 1 && withParens) {
         return ParensNode.create(node);
     }
     return node;

package/dist/esm/parser/data-type-parser.js

@@ -1,8 +1,12 @@
 /// <reference types="./data-type-parser.d.ts" />
-import { DataTypeNode, } from '../operation-node/data-type-node.js';
+import { DataTypeNode, isColumnDataType, } from '../operation-node/data-type-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 export function parseDataTypeExpression(dataType) {
-    return isOperationNodeSource(dataType)
-        ? dataType.toOperationNode()
-        : DataTypeNode.create(dataType);
+    if (isOperationNodeSource(dataType)) {
+        return dataType.toOperationNode();
+    }
+    if (isColumnDataType(dataType)) {
+        return DataTypeNode.create(dataType);
+    }
+    throw new Error(`invalid column data type ${JSON.stringify(dataType)}`);
 }

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

@@ -0,0 +1,2 @@
+import { FetchModifier, FetchNode } from '../operation-node/fetch-node.js';
+export declare function parseFetch(rowCount: number | bigint, modifier: FetchModifier): FetchNode;

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

@@ -0,0 +1,15 @@
+/// <reference types="./fetch-parser.d.ts" />
+import { FetchNode } from '../operation-node/fetch-node.js';
+import { isBigInt, isNumber } from '../util/object-utils.js';
+export function parseFetch(rowCount, modifier) {
+    if (!isNumber(rowCount) && !isBigInt(rowCount)) {
+        throw new Error(`Invalid fetch row count: ${rowCount}`);
+    }
+    if (!isFetchModifier(modifier)) {
+        throw new Error(`Invalid fetch modifier: ${modifier}`);
+    }
+    return FetchNode.create(rowCount, modifier);
+}
+function isFetchModifier(value) {
+    return value === 'only' || value === 'with ties';
+}

package/dist/esm/parser/insert-values-parser.d.ts

@@ -9,6 +9,6 @@ export type InsertObject<DB, TB extends keyof DB> = {
     [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>> | undefined;
 };
 export type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-export type InsertObjectOrListFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => InsertObjectOrList<DB, TB>;
-export type InsertExpression<DB, TB extends keyof DB> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB>;
-export declare function parseInsertExpression(arg: InsertExpression<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];
+export type InsertObjectOrListFactory<DB, TB extends keyof DB, UT extends keyof DB = never> = (eb: ExpressionBuilder<DB, TB | UT>) => InsertObjectOrList<DB, TB>;
+export type InsertExpression<DB, TB extends keyof DB, UT extends keyof DB = never> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB, UT>;
+export declare function parseInsertExpression(arg: InsertExpression<any, any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];

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

@@ -0,0 +1,9 @@
+import { InsertQueryNode } from '../operation-node/insert-query-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { WhenNode } from '../operation-node/when-node.js';
+export declare function parseMergeWhen(type: {
+    isMatched: boolean;
+    bySource?: boolean;
+}, args?: any[], refRight?: boolean): WhenNode;
+export declare function parseMergeThen(result: 'delete' | 'do nothing' | OperationNodeSource | InsertQueryNode): OperationNode;

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

@@ -0,0 +1,28 @@
+/// <reference types="./merge-parser.d.ts" />
+import { MatchedNode } from '../operation-node/matched-node.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { WhenNode } from '../operation-node/when-node.js';
+import { isString } from '../util/object-utils.js';
+import { parseFilterList, parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression, } from './binary-operation-parser.js';
+export function parseMergeWhen(type, args, refRight) {
+    return WhenNode.create(parseFilterList([
+        MatchedNode.create(!type.isMatched, type.bySource),
+        ...(args && args.length > 0
+            ? [
+                args.length === 3 && refRight
+                    ? parseReferentialBinaryOperation(args[0], args[1], args[2])
+                    : parseValueBinaryOperationOrExpression(args),
+            ]
+            : []),
+    ], 'and', false));
+}
+export function parseMergeThen(result) {
+    if (isString(result)) {
+        return RawNode.create([result], []);
+    }
+    if (isOperationNodeSource(result)) {
+        return result.toOperationNode();
+    }
+    return result;
+}

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

@@ -1,7 +1,8 @@
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
+import { MergeResult } from '../query-builder/merge-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
 import { Selection, AllSelection, CallbackSelection } from './select-parser.js';
-export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult ? Selection<DB, TB, SE> : O extends DeleteResult ? Selection<DB, TB, SE> : O extends UpdateResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
-export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult ? CallbackSelection<DB, TB, CB> : O extends DeleteResult ? CallbackSelection<DB, TB, CB> : O extends UpdateResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
-export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult ? AllSelection<DB, TB> : O extends DeleteResult ? AllSelection<DB, TB> : O extends UpdateResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;
+export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
+export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
+export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;

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

@@ -6,16 +6,17 @@ import { AliasedExpression } from '../expression/expression.js';
 import { DrainOuterGeneric, ShallowRecord } from '../util/type-utils.js';
 export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB>;
 export type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
-export type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
+export type TableReference<DB> = SimpleTableReference<DB> | AliasedExpression<any, any>;
+export type SimpleTableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB>;
 export type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 export type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
 export type From<DB, TE> = DrainOuterGeneric<{
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 }>;
 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 : TE extends keyof DB ? TE : never;
+export type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA extends keyof DB ? TA : never : TE extends keyof DB ? TE : never;
 export type PickTableWithAlias<DB, T extends AnyAliasedTable<DB>> = T extends `${infer TB} as ${infer A}` ? TB extends keyof DB ? ShallowRecord<A, DB[TB]> : never : never;
-type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? ExtractTableAlias<DB, TE> : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : 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 AnyTable<DB> = keyof DB & string;
 export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];

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

@@ -0,0 +1,2 @@
+import { TopModifier, TopNode } from '../operation-node/top-node.js';
+export declare function parseTop(expression: number | bigint, modifiers?: TopModifier): TopNode;

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

@@ -0,0 +1,17 @@
+/// <reference types="./top-parser.d.ts" />
+import { TopNode } from '../operation-node/top-node.js';
+import { isBigInt, isNumber, isUndefined } from '../util/object-utils.js';
+export function parseTop(expression, modifiers) {
+    if (!isNumber(expression) && !isBigInt(expression)) {
+        throw new Error(`Invalid top expression: ${expression}`);
+    }
+    if (!isUndefined(modifiers) && !isTopModifiers(modifiers)) {
+        throw new Error(`Invalid top modifiers: ${modifiers}`);
+    }
+    return TopNode.create(expression, modifiers);
+}
+function isTopModifiers(modifiers) {
+    return (modifiers === 'percent' ||
+        modifiers === 'with ties' ||
+        modifiers === 'percent with ties');
+}

package/dist/esm/plugin/camel-case/camel-case-plugin.d.ts

@@ -35,7 +35,7 @@ export interface CamelCasePluginOptions {
 }
 /**
  * A plugin that converts snake_case identifiers in the database into
- * camelCase in the javascript side.
+ * camelCase in the JavaScript side.
  *
  * For example let's assume we have a table called `person_table`
  * with columns `first_name` and `last_name` in the database. When
@@ -75,7 +75,7 @@ export interface CamelCasePluginOptions {
  * ```
  *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: table names, columns, schemas,
+ * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
  * the database was defined in camelCase.
  *

package/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -4,7 +4,7 @@ import { SnakeCaseTransformer } from './camel-case-transformer.js';
 import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
 /**
  * A plugin that converts snake_case identifiers in the database into
- * camelCase in the javascript side.
+ * camelCase in the JavaScript side.
  *
  * For example let's assume we have a table called `person_table`
  * with columns `first_name` and `last_name` in the database. When
@@ -44,7 +44,7 @@ import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
  * ```
  *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: table names, columns, schemas,
+ * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
  * the database was defined in camelCase.
  *

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.d.ts

@@ -2,6 +2,20 @@ import { QueryResult } from '../../driver/database-connection.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
 import { UnknownRow } from '../../util/type-utils.js';
 import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+export interface ParseJSONResultsPluginOptions {
+    /**
+     * When `'in-place'`, arrays' and objects' values are parsed in-place. This is
+     * the most time and space efficient option.
+     *
+     * This can result in runtime errors if some objects/arrays are readonly.
+     *
+     * When `'create'`, new arrays and objects are created to avoid such errors.
+     *
+     * Defaults to `'in-place'`.
+     */
+    objectStrategy?: ObjectStrategy;
+}
+type ObjectStrategy = 'in-place' | 'create';
 /**
  * Parses JSON strings in query results into JSON objects.
  *
@@ -16,6 +30,9 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
  * ```
  */
 export declare class ParseJSONResultsPlugin implements KyselyPlugin {
+    #private;
+    readonly opt: ParseJSONResultsPluginOptions;
+    constructor(opt?: ParseJSONResultsPluginOptions);
     /**
      * This is called for each query before it is executed. You can modify the query by
      * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
@@ -53,3 +70,4 @@ export declare class ParseJSONResultsPlugin implements KyselyPlugin {
      */
     transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }
+export {};

package/dist/esm/plugin/parse-json-results/parse-json-results-plugin.js

@@ -14,6 +14,12 @@ import { isPlainObject, isString } from '../../util/object-utils.js';
  * ```
  */
 export class ParseJSONResultsPlugin {
+    opt;
+    #objectStrategy;
+    constructor(opt = {}) {
+        this.opt = opt;
+        this.#objectStrategy = opt.objectStrategy || 'in-place';
+    }
     // noop
     transformQuery(args) {
         return args.node;
@@ -21,32 +27,33 @@ export class ParseJSONResultsPlugin {
     async transformResult(args) {
         return {
             ...args.result,
-            rows: parseArray(args.result.rows),
+            rows: parseArray(args.result.rows, this.#objectStrategy),
         };
     }
 }
-function parseArray(arr) {
+function parseArray(arr, objectStrategy) {
+    const target = objectStrategy === 'create' ? new Array(arr.length) : arr;
     for (let i = 0; i < arr.length; ++i) {
-        arr[i] = parse(arr[i]);
+        target[i] = parse(arr[i], objectStrategy);
     }
-    return arr;
+    return target;
 }
-function parse(obj) {
+function parse(obj, objectStrategy) {
     if (isString(obj)) {
         return parseString(obj);
     }
     if (Array.isArray(obj)) {
-        return parseArray(obj);
+        return parseArray(obj, objectStrategy);
     }
     if (isPlainObject(obj)) {
-        return parseObject(obj);
+        return parseObject(obj, objectStrategy);
     }
     return obj;
 }
 function parseString(str) {
     if (maybeJson(str)) {
         try {
-            return parse(JSON.parse(str));
+            return parse(JSON.parse(str), 'in-place');
         }
         catch (err) {
             // this catch block is intentionally empty.
@@ -57,9 +64,10 @@ function parseString(str) {
 function maybeJson(value) {
     return value.match(/^[\[\{]/) != null;
 }
-function parseObject(obj) {
+function parseObject(obj, objectStrategy) {
+    const target = objectStrategy === 'create' ? {} : obj;
     for (const key in obj) {
-        obj[key] = parse(obj[key]);
+        target[key] = parse(obj[key], objectStrategy);
     }
-    return obj;
+    return target;
 }

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -27,6 +27,7 @@ const ROOT_OPERATION_NODES = freeze({
     RawNode: true,
     SelectQueryNode: true,
     UpdateQueryNode: true,
+    MergeQueryNode: true,
 });
 export class WithSchemaTransformer extends OperationNodeTransformer {
     #schema;
@@ -101,6 +102,9 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
                 this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
             }
         }
+        if ('using' in node && node.using) {
+            this.#collectSchemableIdsFromTableExpr(node.using, schemableIds);
+        }
         return schemableIds;
     }
     #collectCTEs(node) {