kysely 0.24.2 → 0.26.0

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

@@ -1,6 +1,7 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
-import { AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.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';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
@@ -8,15 +9,22 @@ import { SelectType } from '../util/column-type.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { Expression } from '../expression/expression.js';
 import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.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> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : 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;
+import { OrderByDirection } from './order-by-parser.js';
+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/cjs/parser/reference-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseColumnName = exports.parseAliasedStringReference = exports.parseStringReference = exports.parseReferenceExpression = exports.parseReferenceExpressionOrList = exports.parseSimpleReferenceExpression = void 0;
+exports.parseOrderedColumnName = exports.parseColumnName = exports.parseAliasedStringReference = exports.parseStringReference = exports.parseJSONReference = exports.parseReferenceExpression = exports.parseReferenceExpressionOrList = exports.parseSimpleReferenceExpression = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
 const reference_node_js_1 = require("../operation-node/reference-node.js");
@@ -8,6 +8,11 @@ const table_node_js_1 = require("../operation-node/table-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const expression_parser_js_1 = require("./expression-parser.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const order_by_parser_js_1 = require("./order-by-parser.js");
+const operator_node_js_1 = require("../operation-node/operator-node.js");
+const json_reference_node_js_1 = require("../operation-node/json-reference-node.js");
+const json_operator_chain_node_js_1 = require("../operation-node/json-operator-chain-node.js");
+const json_path_node_js_1 = require("../operation-node/json-path-node.js");
 function parseSimpleReferenceExpression(exp) {
     if ((0, object_utils_js_1.isString)(exp)) {
         return parseStringReference(exp);
@@ -31,23 +36,31 @@ function parseReferenceExpression(exp) {
     return parseSimpleReferenceExpression(exp);
 }
 exports.parseReferenceExpression = parseReferenceExpression;
+function parseJSONReference(ref, op) {
+    const referenceNode = parseStringReference(ref);
+    if ((0, operator_node_js_1.isJSONOperator)(op)) {
+        return json_reference_node_js_1.JSONReferenceNode.create(referenceNode, json_operator_chain_node_js_1.JSONOperatorChainNode.create(operator_node_js_1.OperatorNode.create(op)));
+    }
+    const opWithoutLastChar = op.slice(0, -1);
+    if ((0, operator_node_js_1.isJSONOperator)(opWithoutLastChar)) {
+        return json_reference_node_js_1.JSONReferenceNode.create(referenceNode, json_path_node_js_1.JSONPathNode.create(operator_node_js_1.OperatorNode.create(opWithoutLastChar)));
+    }
+    throw new Error(`Invalid JSON operator: ${op}`);
+}
+exports.parseJSONReference = parseJSONReference;
 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 reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(ref));
     }
-    else {
-        return column_node_js_1.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}`);
 }
 exports.parseStringReference = parseStringReference;
 function parseAliasedStringReference(ref) {
@@ -65,13 +78,27 @@ function parseColumnName(column) {
     return column_node_js_1.ColumnNode.create(column);
 }
 exports.parseColumnName = parseColumnName;
+function parseOrderedColumnName(column) {
+    const ORDER_SEPARATOR = ' ';
+    if (column.includes(ORDER_SEPARATOR)) {
+        const [columnName, order] = column.split(ORDER_SEPARATOR).map(trim);
+        if (!(0, order_by_parser_js_1.isOrderByDirection)(order)) {
+            throw new Error(`invalid order direction "${order}" next to "${columnName}"`);
+        }
+        return (0, order_by_parser_js_1.parseOrderBy)(columnName, order);
+    }
+    else {
+        return parseColumnName(column);
+    }
+}
+exports.parseOrderedColumnName = parseOrderedColumnName;
 function parseStringReferenceWithTableAndSchema(parts) {
     const [schema, table, column] = parts;
-    return reference_node_js_1.ReferenceNode.create(table_node_js_1.TableNode.createWithSchema(schema, table), column_node_js_1.ColumnNode.create(column));
+    return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(column), table_node_js_1.TableNode.createWithSchema(schema, table));
 }
 function parseStringReferenceWithTable(parts) {
     const [table, column] = parts;
-    return reference_node_js_1.ReferenceNode.create(table_node_js_1.TableNode.create(table), column_node_js_1.ColumnNode.create(column));
+    return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(column), table_node_js_1.TableNode.create(table));
 }
 function trim(str) {
     return str.trim();

package/dist/cjs/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/cjs/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, ExtractColumnType, ValueType } 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> = {
+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 ? ValueType<O> : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : 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/cjs/parser/table-parser.d.ts

@@ -3,20 +3,21 @@ import { TableNode } from '../operation-node/table-node.js';
 import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { AliasedExpression } from '../expression/expression.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> = {
+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 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> = 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 ? Record<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/cjs/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/cjs/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/cjs/parser/update-set-parser.js

@@ -7,9 +7,7 @@ const expression_builder_js_1 = require("../expression/expression-builder.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const value_parser_js_1 = require("./value-parser.js");
 function parseUpdateExpression(update) {
-    const updateObj = (0, object_utils_js_1.isFunction)(update)
-        ? update((0, expression_builder_js_1.expressionBuilder)())
-        : update;
+    const updateObj = (0, object_utils_js_1.isFunction)(update) ? update((0, expression_builder_js_1.expressionBuilder)()) : update;
     return Object.entries(updateObj)
         .filter(([_, value]) => value !== undefined)
         .map(([key, value]) => {

package/dist/cjs/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/cjs/parser/with-parser.d.ts

@@ -4,21 +4,26 @@ import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { QueryCreator } from '../query-creator.js';
 import { Expression } from '../expression/expression.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 & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
-export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<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>>;
+import { ShallowRecord } from '../util/type-utils.js';
+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:
  *
@@ -28,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;
-} : Record<string, 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/cjs/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/cjs/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/cjs/plugin/parse-json-results/parse-json-results-plugin.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseJSONResultsPlugin = void 0;
+const object_utils_js_1 = require("../../util/object-utils.js");
+class ParseJSONResultsPlugin {
+    // noop
+    transformQuery(args) {
+        return args.node;
+    }
+    async transformResult(args) {
+        const { result } = args;
+        return {
+            ...args.result,
+            rows: result.rows.map(parseRow),
+        };
+    }
+}
+exports.ParseJSONResultsPlugin = ParseJSONResultsPlugin;
+function parseRow(row) {
+    return Object.entries(row).reduce((row, [key, value]) => {
+        if ((0, object_utils_js_1.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/cjs/plugin/with-schema/with-schema-transformer.js

@@ -33,6 +33,7 @@ const ROOT_OPERATION_NODES = (0, object_utils_js_1.freeze)({
 class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
     #schema;
     #schemableIds = new Set();
+    #ctes = new Set();
     constructor(schema) {
         super();
         this.#schema = schema;
@@ -41,6 +42,10 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         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);
@@ -49,6 +54,9 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         for (const table of tables) {
             this.#schemableIds.delete(table);
         }
+        for (const cte of ctes) {
+            this.#ctes.delete(cte);
+        }
         return transformed;
     }
     transformSchemableIdentifier(node) {
@@ -95,10 +103,14 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
                 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 = table_node_js_1.TableNode.is(node)
@@ -111,13 +123,17 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         }
     }
     #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);
+            }
         }
     }
 }

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

@@ -4,7 +4,6 @@ import { OverBuilder } from './over-builder.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
-import { ExistsExpression } from '../parser/unary-operation-parser.js';
 import { WhereExpressionFactory } from './where-interface.js';
 export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements Expression<O> {
     #private;
@@ -37,7 +36,7 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * const result = await db
      *   .selectFrom('person')
      *   .select(
-     *     eb => eb.fn.count<number>('id').as('person_count')
+     *     (eb) => eb.fn.count<number>('id').as('person_count')
      *   )
      *   .executeTakeFirstOrThrow()
      *
@@ -80,7 +79,7 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      *
      * Similar to {@link WhereInterface}'s `where` method.
      *
-     * Also see {@link orFilterWhere}, {@link filterWhereExists} and {@link filterWhereRef}.
+     * Also see {@link filterWhereRef}.
      *
      * ### Examples
      *
@@ -119,14 +118,6 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
     filterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
     filterWhere(factory: WhereExpressionFactory<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     filterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    filterWhereExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    filterWhereNotExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Adds a `filter` clause with a nested `where` clause after the function, where
      * both sides of the operator are references to columns.
@@ -160,30 +151,6 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```
      */
     filterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhere(factory: WhereExpressionFactory<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhereExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhereNotExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Adds an `over` clause (window functions) after the function.
      *
@@ -193,7 +160,7 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * const result = await db
      *   .selectFrom('person')
      *   .select(
-     *     eb => eb.fn.avg<number>('age').over().as('average_age')
+     *     (eb) => eb.fn.avg<number>('age').over().as('average_age')
      *   )
      *   .execute()
      * ```
@@ -212,7 +179,7 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * const result = await db
      *   .selectFrom('person')
      *   .select(
-     *     eb => eb.fn.avg<number>('age').over(
+     *     (eb) => eb.fn.avg<number>('age').over(
      *       ob => ob.partitionBy('last_name').orderBy('first_name', 'asc')
      *     ).as('average_age')
      *   )
@@ -272,4 +239,4 @@ export declare class AliasedAggregateFunctionBuilder<DB, TB extends keyof DB, O
 export interface AggregateFunctionBuilderProps {
     aggregateFunctionNode: AggregateFunctionNode;
 }
-export declare type OverBuilderCallback<DB, TB extends keyof DB> = (builder: OverBuilder<DB, TB>) => OverBuilder<DB, TB>;
+export type OverBuilderCallback<DB, TB extends keyof DB> = (builder: OverBuilder<DB, TB>) => OverBuilder<DB, TB>;