kysely 0.11.2 → 0.12.1

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

@@ -1,49 +1,26 @@
-import { ColumnNode } from '../operation-node/column-node.js';
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { isFunction, isPrimitive } from '../util/object-utils.js';
-import { QueryNode } from '../operation-node/query-node.js';
+import { isPrimitive, isReadonlyArray, } from '../util/object-utils.js';
+import { parseComplexExpression, } from './complex-expression-parser.js';
 export function parseValueExpressionOrList(ctx, arg) {
-    if (Array.isArray(arg)) {
+    if (isReadonlyArray(arg)) {
         return parseValueExpressionList(ctx, arg);
     }
     else {
         return parseValueExpression(ctx, arg);
     }
 }
-export function parseValueExpression(ctx, arg) {
-    if (isPrimitive(arg)) {
-        return ValueNode.create(arg);
+export function parseValueExpression(ctx, exp) {
+    if (isPrimitive(exp)) {
+        return ValueNode.create(exp);
     }
-    else if (isOperationNodeSource(arg)) {
-        const node = arg.toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if (isFunction(arg)) {
-        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    throw new Error(`invalid value expression ${JSON.stringify(arg)}`);
+    return parseComplexExpression(ctx, exp);
 }
 function parseValueExpressionList(ctx, arg) {
     if (arg.every(isPrimitive)) {
         // Optimization for large lists of primitive values.
         return PrimitiveValueListNode.create(arg);
     }
-    return ValueListNode.create(arg.map((it) => {
-        const node = parseValueExpression(ctx, it);
-        if (ColumnNode.is(node)) {
-            throw new Error('value lists cannot have column references');
-        }
-        if (ValueListNode.is(node) || PrimitiveValueListNode.is(node)) {
-            throw new Error('value lists cannot have nested lists');
-        }
-        return node;
-    }));
+    return ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
 }

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

@@ -1,11 +1,14 @@
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
+import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
+import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
-export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => QueryBuilder<DB, any> | AnyRawBuilder;
+export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => SelectQueryBuilder<DB, any, any> | InsertQueryBuilder<DB, any, any> | UpdateQueryBuilder<DB, any, any> | DeleteQueryBuilder<DB, any, any> | AnyRawBuilder;
 export declare type QueryCreatorWithCommonTableExpression<DB, N extends string, E extends CommonTableExpression<DB>> = QueryCreator<DB & Record<N, ExtractRowTypeFromCommonTableExpression<E>>>;
-declare type ExtractRowTypeFromCommonTableExpression<E> = E extends (creator: QueryCreator<any>) => infer Q ? Q extends QueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowTypeFromCommonTableExpression<E> = E extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
 export declare function parseCommonTableExpression(ctx: ParseContext, name: string, expression: CommonTableExpression<any>): CommonTableExpressionNode;
 export {};

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

@@ -94,7 +94,41 @@ export interface CamelCasePluginOptions {
 export declare class CamelCasePlugin implements KyselyPlugin {
     #private;
     constructor(opt?: CamelCasePluginOptions);
+    /**
+     * 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>>;
     protected mapRow(row: UnknownRow): UnknownRow;
     protected snakeCase(str: string): string;

package/dist/esm/plugin/immediate-value.ts/immediate-value-plugin.d.ts

@@ -12,6 +12,40 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
  */
 export declare class ImmediateValuePlugin implements KyselyPlugin {
     #private;
+    /**
+     * 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/immediate-value.ts/immediate-value-plugin.js

@@ -12,7 +12,7 @@ export class ImmediateValuePlugin {
     transformQuery(args) {
         return this.#transformer.transformNode(args.node);
     }
-    async transformResult(args) {
-        return args.result;
+    transformResult(args) {
+        return Promise.resolve(args.result);
     }
 }

package/dist/esm/plugin/with-schema/with-schema-plugin.d.ts

@@ -5,6 +5,40 @@ import { UnknownRow } from '../../util/type-utils.js';
 export declare class WithSchemaPlugin implements KyselyPlugin {
     #private;
     constructor(schema: string);
+    /**
+     * 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>>;
 }