kysely 0.25.0 → 0.26.1

package/dist/esm/parser/group-by-parser.d.ts

@@ -1,6 +1,6 @@
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { ReferenceExpression } from './reference-parser.js';
-export declare type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
-export declare type GroupByArg<DB, TB extends keyof DB, O> = GroupByExpression<DB, TB, O> | ReadonlyArray<GroupByExpression<DB, TB, O>> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<GroupByExpression<DB, TB, O>>);
+export type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
+export type GroupByArg<DB, TB extends keyof DB, O> = GroupByExpression<DB, TB, O> | ReadonlyArray<GroupByExpression<DB, TB, O>> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<GroupByExpression<DB, TB, O>>);
 export declare function parseGroupBy(groupBy: GroupByArg<any, any, any>): GroupByItemNode[];

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

@@ -3,12 +3,12 @@ import { ValueExpression } from './value-parser.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
-export declare type InsertObject<DB, TB extends keyof DB> = {
+export type InsertObject<DB, TB extends keyof DB> = {
     [C in NonNullableInsertKeys<DB[TB]>]: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
 } & {
     [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>> | undefined;
 };
-export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-export declare type InsertObjectOrListFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => InsertObjectOrList<DB, TB>;
-export declare type InsertExpression<DB, TB extends keyof DB> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB>;
+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];

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

@@ -2,9 +2,9 @@ import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
 import { From, FromTables } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
-export declare type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
-declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
-declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
+export type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
+export type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
+type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
+type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
 export declare function parseJoin(joinType: JoinType, args: any[]): JoinNode;
 export {};

package/dist/esm/parser/order-by-parser.d.ts

@@ -1,8 +1,8 @@
 import { Expression } from '../expression/expression.js';
 import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { ReferenceExpression } from './reference-parser.js';
-export declare type OrderByDirection = 'asc' | 'desc';
+export type OrderByDirection = 'asc' | 'desc';
 export declare function isOrderByDirection(thing: unknown): thing is OrderByDirection;
-export declare type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
-export declare type OrderByDirectionExpression = OrderByDirection | Expression<any>;
+export type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
+export type OrderByDirectionExpression = OrderByDirection | Expression<any>;
 export declare function parseOrderBy(orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

package/dist/esm/parser/partition-by-parser.d.ts

@@ -1,6 +1,6 @@
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
 import { StringReference } from './reference-parser.js';
-export declare type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
-export declare type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
+export type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
 export declare function parsePartitionBy(partitionBy: PartitionByExpressionOrList<any, any>): PartitionByItemNode[];

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

@@ -1,5 +1,6 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
+import { ReferenceNode } from '../operation-node/reference-node.js';
 import { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ExpressionOrFactory } from './expression-parser.js';
@@ -9,18 +10,21 @@ import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
 import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
 import { OrderByDirection } from './order-by-parser.js';
-export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
-export declare type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
-export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
-export declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
-export declare type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
-export declare type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;
+import { JSONOperatorWith$ } from '../operation-node/operator-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+export type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
+export type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
+export type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
+export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
+export type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
+export type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
+export type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;
 export declare function parseSimpleReferenceExpression(exp: SimpleReferenceExpression<any, any>): SimpleReferenceExpressionNode;
 export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): OperationNode[];
 export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): OperationNode;
-export declare function parseStringReference(ref: string): SimpleReferenceExpressionNode;
+export declare function parseJSONReference(ref: string, op: JSONOperatorWith$): JSONReferenceNode;
+export declare function parseStringReference(ref: string): ReferenceNode;
 export declare function parseAliasedStringReference(ref: string): SimpleReferenceExpressionNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
 export declare function parseOrderedColumnName(column: string): OperationNode;

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

@@ -7,6 +7,10 @@ import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { isOrderByDirection, parseOrderBy, } from './order-by-parser.js';
+import { OperatorNode, isJSONOperator, } from '../operation-node/operator-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
+import { JSONPathNode } from '../operation-node/json-path-node.js';
 export function parseSimpleReferenceExpression(exp) {
     if (isString(exp)) {
         return parseStringReference(exp);
@@ -27,23 +31,30 @@ export function parseReferenceExpression(exp) {
     }
     return parseSimpleReferenceExpression(exp);
 }
+export function parseJSONReference(ref, op) {
+    const referenceNode = parseStringReference(ref);
+    if (isJSONOperator(op)) {
+        return JSONReferenceNode.create(referenceNode, JSONOperatorChainNode.create(OperatorNode.create(op)));
+    }
+    const opWithoutLastChar = op.slice(0, -1);
+    if (isJSONOperator(opWithoutLastChar)) {
+        return JSONReferenceNode.create(referenceNode, JSONPathNode.create(OperatorNode.create(opWithoutLastChar)));
+    }
+    throw new Error(`Invalid JSON operator: ${op}`);
+}
 export function parseStringReference(ref) {
     const COLUMN_SEPARATOR = '.';
-    if (ref.includes(COLUMN_SEPARATOR)) {
-        const parts = ref.split(COLUMN_SEPARATOR).map(trim);
-        if (parts.length === 3) {
-            return parseStringReferenceWithTableAndSchema(parts);
-        }
-        else if (parts.length === 2) {
-            return parseStringReferenceWithTable(parts);
-        }
-        else {
-            throw new Error(`invalid column reference ${ref}`);
-        }
+    if (!ref.includes(COLUMN_SEPARATOR)) {
+        return ReferenceNode.create(ColumnNode.create(ref));
     }
-    else {
-        return ColumnNode.create(ref);
+    const parts = ref.split(COLUMN_SEPARATOR).map(trim);
+    if (parts.length === 3) {
+        return parseStringReferenceWithTableAndSchema(parts);
+    }
+    if (parts.length === 2) {
+        return parseStringReferenceWithTable(parts);
     }
+    throw new Error(`invalid column reference ${ref}`);
 }
 export function parseAliasedStringReference(ref) {
     const ALIAS_SEPARATOR = ' as ';
@@ -73,11 +84,11 @@ export function parseOrderedColumnName(column) {
 }
 function parseStringReferenceWithTableAndSchema(parts) {
     const [schema, table, column] = parts;
-    return ReferenceNode.create(TableNode.createWithSchema(schema, table), ColumnNode.create(column));
+    return ReferenceNode.create(ColumnNode.create(column), TableNode.createWithSchema(schema, table));
 }
 function parseStringReferenceWithTable(parts) {
     const [table, column] = parts;
-    return ReferenceNode.create(TableNode.create(table), ColumnNode.create(column));
+    return ReferenceNode.create(ColumnNode.create(column), TableNode.create(table));
 }
 function trim(str) {
     return str.trim();

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

@@ -2,5 +2,5 @@ import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
 import { Selection, AllSelection } from './select-parser.js';
-export declare 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 declare 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 ? 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 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>;

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

@@ -1,21 +1,21 @@
 import { AliasedSelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, ExtractColumnType } from '../util/type-utils.js';
+import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { Selectable, SelectType } from '../util/column-type.js';
 import { AliasedExpression } from '../expression/expression.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
-export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
-export declare type SelectArg<DB, TB extends keyof DB, SE extends SelectExpression<DB, TB>> = SE | ReadonlyArray<SE> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SE>);
-export declare type Selection<DB, TB extends keyof DB, SE> = DrainOuterGeneric<{
+export type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
+export type SelectArg<DB, TB extends keyof DB, SE extends SelectExpression<DB, TB>> = SE | ReadonlyArray<SE> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SE>);
+export type Selection<DB, TB extends keyof DB, SE> = {
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
-}>;
-declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedExpression<any, infer EA> ? EA : SE extends (qb: any) => AliasedExpression<any, infer EA> ? EA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
-declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
-declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : never : SE extends AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends (qb: any) => AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
-declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
-export declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
+};
+type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedExpression<any, infer EA> ? EA : SE extends (qb: any) => AliasedExpression<any, infer EA> ? EA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
+type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
+type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : never : SE extends AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends (qb: any) => AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
+type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
+export type AllSelection<DB, TB extends keyof DB> = Selectable<{
     [C in AnyColumn<DB, TB>]: {
         [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
     }[TB];

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

@@ -4,20 +4,20 @@ import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { AliasedExpression } from '../expression/expression.js';
 import { DrainOuterGeneric, ShallowRecord } from '../util/type-utils.js';
-export declare type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB>;
-export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
-export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
-export declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
-export declare type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
-export declare type From<DB, TE> = DrainOuterGeneric<{
+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 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 declare type FromTables<DB, TB extends keyof DB, TE> = DrainOuterGeneric<TB | ExtractAliasFromTableExpression<DB, TE>>;
-export declare type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never;
-export declare type PickTableWithAlias<DB, T extends AnyAliasedTable<DB>> = T extends `${infer TB} as ${infer A}` ? TB extends keyof DB ? ShallowRecord<A, DB[TB]> : never : never;
-declare 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;
-declare 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;
-declare type AnyTable<DB> = keyof DB & string;
+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 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 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[];
 export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;
 export declare function parseAliasedTable(from: string): TableNode | AliasNode;

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

@@ -2,7 +2,7 @@ import { UnaryOperator } from '../operation-node/operator-node.js';
 import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
 import { ExpressionOrFactory } from './expression-parser.js';
 import { ReferenceExpression } from './reference-parser.js';
-export declare type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
+export type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
 export declare function parseExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
 export declare function parseNotExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
 export declare function parseUnaryOperation(operator: UnaryOperator, operand: ReferenceExpression<any, any>): UnaryOperationNode;

package/dist/esm/parser/update-set-parser.d.ts

@@ -2,9 +2,9 @@ import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
-export declare type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = {
+export type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = {
     [C in UpdateKeys<DB[UT]>]?: ValueExpression<DB, TB, UpdateType<DB[UT][C]>> | undefined;
 };
-export declare type UpdateObjectFactory<DB, TB extends keyof DB, UT extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>;
-export declare type UpdateExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
+export type UpdateObjectFactory<DB, TB extends keyof DB, UT extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>;
+export type UpdateExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
 export declare function parseUpdateExpression(update: UpdateExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/parser/update-set-parser.js

@@ -1,13 +1,11 @@
 /// <reference types="./update-set-parser.d.ts" />
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
-import { expressionBuilder } from '../expression/expression-builder.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
 import { isFunction } from '../util/object-utils.js';
 import { parseValueExpression } from './value-parser.js';
 export function parseUpdateExpression(update) {
-    const updateObj = isFunction(update)
-        ? update(expressionBuilder())
-        : update;
+    const updateObj = isFunction(update) ? update(expressionBuilder()) : update;
     return Object.entries(updateObj)
         .filter(([_, value]) => value !== undefined)
         .map(([key, value]) => {

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

@@ -2,10 +2,10 @@ import { ExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
-export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
-export declare type ExtractTypeFromValueExpressionOrList<VE> = VE extends ReadonlyArray<infer AV> ? ExtractTypeFromValueExpression<AV> : ExtractTypeFromValueExpression<VE>;
-declare type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilder<any, any, Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
+export type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
+export type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
+export type ExtractTypeFromValueExpressionOrList<VE> = VE extends ReadonlyArray<infer AV> ? ExtractTypeFromValueExpression<AV> : ExtractTypeFromValueExpression<VE>;
+type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilder<any, any, Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
 export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
 export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;
 export {};

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

@@ -5,21 +5,25 @@ import { CommonTableExpressionNode } from '../operation-node/common-table-expres
 import { QueryCreator } from '../query-creator.js';
 import { Expression } from '../expression/expression.js';
 import { ShallowRecord } from '../util/type-utils.js';
-export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
-export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & ShallowRecord<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
-export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & ShallowRecord<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
-declare type CommonTableExpressionOutput<DB, CN extends string> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
+export type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
+export type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpressionName<CN>;
+}>) => CommonTableExpressionOutput<DB, CN>;
+export type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpression<CTE>;
+}>;
+type CommonTableExpressionOutput<DB, CN extends string> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
 /**
  * Given a common CommonTableExpression CTE extracts the row type from it.
  *
  * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
  * would result in `Pick<Person, 'id' | 'first_name'>`.
  */
-declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : never : never;
+type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : never : never;
 /**
  * Extracts 'person' from a string like 'person(id, first_name)'.
  */
-declare type ExtractTableFromCommonTableExpressionName<CN extends string> = CN extends `${infer TB}(${string})` ? TB : CN;
+type ExtractTableFromCommonTableExpressionName<CN extends string> = CN extends `${infer TB}(${string})` ? TB : CN;
 /**
  * Parses a string like 'person(id, first_name)' into a type:
  *
@@ -29,12 +33,12 @@ declare type ExtractTableFromCommonTableExpressionName<CN extends string> = CN e
  * }
  *
  */
-declare type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${string}(${infer CL})` ? {
+type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${string}(${infer CL})` ? {
     [C in ExtractColumnNamesFromColumnList<CL>]: any;
 } : ShallowRecord<string, any>;
 /**
  * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
  */
-declare type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
+type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
 export declare function parseCommonTableExpression(name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
 export {};

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

@@ -1,4 +1,4 @@
-export declare type StringMapper = (str: string) => string;
+export type StringMapper = (str: string) => string;
 /**
  * Creates a function that transforms camel case strings to snake case.
  */

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

@@ -0,0 +1,42 @@
+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 declare class ParseJSONResultsPlugin implements KyselyPlugin {
+    /**
+     * 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}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * const plugin = {
+     *   data: new WeakMap<QueryId, SomeData>(),
+     *
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     this.data.set(args.queryId, something)
+     *     return args.node
+     *   },
+     *
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
+     *     const data = this.data.get(args.queryId)
+     *     return args.result
+     *   }
+     * }
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

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

@@ -0,0 +1,29 @@
+/// <reference types="./parse-json-results-plugin.d.ts" />
+import { isString } from '../../util/object-utils.js';
+export class ParseJSONResultsPlugin {
+    // noop
+    transformQuery(args) {
+        return args.node;
+    }
+    async transformResult(args) {
+        const { result } = args;
+        return {
+            ...args.result,
+            rows: result.rows.map(parseRow),
+        };
+    }
+}
+function parseRow(row) {
+    return Object.entries(row).reduce((row, [key, value]) => {
+        if (isString(value) && value.match(/^[\[\{]/) != null) {
+            try {
+                value = JSON.parse(value);
+            }
+            catch (err) {
+                // this catch block is intentionally empty.
+            }
+        }
+        row[key] = value;
+        return row;
+    }, {});
+}

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

@@ -31,6 +31,7 @@ const ROOT_OPERATION_NODES = freeze({
 export class WithSchemaTransformer extends OperationNodeTransformer {
     #schema;
     #schemableIds = new Set();
+    #ctes = new Set();
     constructor(schema) {
         super();
         this.#schema = schema;
@@ -39,6 +40,10 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
         if (!this.#isRootOperationNode(node)) {
             return super.transformNodeImpl(node);
         }
+        const ctes = this.#collectCTEs(node);
+        for (const cte of ctes) {
+            this.#ctes.add(cte);
+        }
         const tables = this.#collectSchemableIds(node);
         for (const table of tables) {
             this.#schemableIds.add(table);
@@ -47,6 +52,9 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
         for (const table of tables) {
             this.#schemableIds.delete(table);
         }
+        for (const cte of ctes) {
+            this.#ctes.delete(cte);
+        }
         return transformed;
     }
     transformSchemableIdentifier(node) {
@@ -93,10 +101,14 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
                 this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
             }
         }
+        return schemableIds;
+    }
+    #collectCTEs(node) {
+        const ctes = new Set();
         if ('with' in node && node.with) {
-            this.#removeCommonTableExpressionTables(node.with, schemableIds);
+            this.#collectCTEIds(node.with, ctes);
         }
-        return schemableIds;
+        return ctes;
     }
     #collectSchemableIdsFromTableExpr(node, schemableIds) {
         const table = TableNode.is(node)
@@ -109,13 +121,17 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
         }
     }
     #collectSchemableId(node, schemableIds) {
-        if (!this.#schemableIds.has(node.identifier.name)) {
-            schemableIds.add(node.identifier.name);
+        const id = node.identifier.name;
+        if (!this.#schemableIds.has(id) && !this.#ctes.has(id)) {
+            schemableIds.add(id);
         }
     }
-    #removeCommonTableExpressionTables(node, schemableIds) {
+    #collectCTEIds(node, ctes) {
         for (const expr of node.expressions) {
-            schemableIds.delete(expr.name.table.table.identifier.name);
+            const cteId = expr.name.table.table.identifier.name;
+            if (!this.#ctes.has(cteId)) {
+                ctes.add(cteId);
+            }
         }
     }
 }