kysely 0.24.2 → 0.26.0

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, 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/esm/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/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

@@ -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/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);
+            }
         }
     }
 }

package/dist/esm/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>;

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

@@ -5,8 +5,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { createOverBuilder } from '../parser/parse-utils.js';
-import { parseReferentialComparison, parseWhere, } from '../parser/binary-operation-parser.js';
-import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
+import { parseReferentialComparison, parseFilter, } from '../parser/binary-operation-parser.js';
 export class AggregateFunctionBuilder {
     #props;
     constructor(props) {
@@ -26,7 +25,7 @@ export class AggregateFunctionBuilder {
      * 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()
      *
@@ -74,25 +73,7 @@ export class AggregateFunctionBuilder {
     filterWhere(...args) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseWhere(args)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    filterWhereExists(arg) {
-        return new AggregateFunctionBuilder({
-            ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseExists(arg)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    filterWhereNotExists(arg) {
-        return new AggregateFunctionBuilder({
-            ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseNotExists(arg)),
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseFilter(args)),
         });
     }
     /**
@@ -133,42 +114,6 @@ export class AggregateFunctionBuilder {
             aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhere(...args) {
-        return new AggregateFunctionBuilder({
-            ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, parseWhere(args)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhereExists(arg) {
-        return new AggregateFunctionBuilder({
-            ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, parseExists(arg)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhereNotExists(arg) {
-        return new AggregateFunctionBuilder({
-            ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, parseNotExists(arg)),
-        });
-    }
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orFilterWhereRef(lhs, op, rhs) {
-        return new AggregateFunctionBuilder({
-            ...this.#props,
-            aggregateFunctionNode: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, parseReferentialComparison(lhs, op, rhs)),
-        });
-    }
     /**
      * Adds an `over` clause (window functions) after the function.
      *
@@ -178,7 +123,7 @@ export class AggregateFunctionBuilder {
      * 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()
      * ```
@@ -197,7 +142,7 @@ export class AggregateFunctionBuilder {
      * 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')
      *   )