kysely 0.11.4 → 0.13.0

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

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
-const column_node_js_1 = require("../operation-node/column-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const query_node_js_1 = require("../operation-node/query-node.js");
+const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
 function parseValueExpressionOrList(ctx, arg) {
-    if (Array.isArray(arg)) {
+    if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return parseValueExpressionList(ctx, arg);
     }
     else {
@@ -17,23 +15,11 @@ function parseValueExpressionOrList(ctx, arg) {
     }
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
-function parseValueExpression(ctx, arg) {
-    if ((0, object_utils_js_1.isPrimitive)(arg)) {
-        return value_node_js_1.ValueNode.create(arg);
+function parseValueExpression(ctx, exp) {
+    if ((0, object_utils_js_1.isPrimitive)(exp)) {
+        return value_node_js_1.ValueNode.create(exp);
     }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-        const node = arg.toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if ((0, object_utils_js_1.isFunction)(arg)) {
-        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
-        if (!query_node_js_1.QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    throw new Error(`invalid value expression ${JSON.stringify(arg)}`);
+    return (0, complex_expression_parser_js_1.parseComplexExpression)(ctx, exp);
 }
 exports.parseValueExpression = parseValueExpression;
 function parseValueExpressionList(ctx, arg) {
@@ -41,14 +27,5 @@ function parseValueExpressionList(ctx, arg) {
         // Optimization for large lists of primitive values.
         return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);
     }
-    return value_list_node_js_1.ValueListNode.create(arg.map((it) => {
-        const node = parseValueExpression(ctx, it);
-        if (column_node_js_1.ColumnNode.is(node)) {
-            throw new Error('value lists cannot have column references');
-        }
-        if (value_list_node_js_1.ValueListNode.is(node) || primitive_value_list_node_js_1.PrimitiveValueListNode.is(node)) {
-            throw new Error('value lists cannot have nested lists');
-        }
-        return node;
-    }));
+    return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(ctx, it)));
 }

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

@@ -1,11 +1,41 @@
+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 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;
-export declare function parseCommonTableExpression(ctx: ParseContext, name: string, expression: CommonTableExpression<any>): CommonTableExpressionNode;
+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> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<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 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;
+/**
+ * Extracts 'person' from a string like 'person(id, first_name)'.
+ */
+declare type ExtractTableFromCommonTableExpressionName<CN extends string> = CN extends `${infer TB}(${string})` ? TB : CN;
+/**
+ * Parses a string like 'person(id, first_name)' into a type:
+ *
+ * {
+ *   id: any,
+ *   first_name: any
+ * }
+ *
+ */
+declare type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${string}(${infer CL})` ? {
+    [C in ExtractColumnNamesFromColumnList<CL>]: any;
+} : Record<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;
+export declare function parseCommonTableExpression(ctx: ParseContext, name: string, expression: CommonTableExpression<any, any>): CommonTableExpressionNode;
 export {};

package/dist/cjs/parser/with-parser.js

@@ -1,10 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCommonTableExpression = void 0;
-const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
+const common_table_expression_name_node_js_1 = require("../operation-node/common-table-expression-name-node.js");
 function parseCommonTableExpression(ctx, name, expression) {
     const builder = expression(ctx.createQueryCreator());
-    return common_table_expression_node_js_1.CommonTableExpressionNode.create(identifier_node_js_1.IdentifierNode.create(name), builder.toOperationNode());
+    return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(name), builder.toOperationNode());
 }
 exports.parseCommonTableExpression = parseCommonTableExpression;
+function parseCommonTableExpressionName(name) {
+    if (name.includes('(')) {
+        const parts = name.split(/[\(\)]/);
+        const table = parts[0];
+        const columns = parts[1].split(',').map((it) => it.trim());
+        return common_table_expression_name_node_js_1.CommonTableExpressionNameNode.create(table, columns);
+    }
+    else {
+        return common_table_expression_name_node_js_1.CommonTableExpressionNameNode.create(name);
+    }
+}

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

@@ -12,8 +12,8 @@ export interface CamelCasePluginOptions {
     upperCase?: boolean;
     /**
      * If true, an underscore is added before each digit when converting
-     * camelCase to snake_case. For example `foo1Bar => foo_1_bar` and
-     * `foo_1_bar => foo1Bar`
+     * camelCase to snake_case. For example `foo12Bar => foo_12_bar` and
+     * `foo_12_bar => foo12Bar`
      *
      * Defaults to false.
      */
@@ -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/cjs/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/cjs/plugin/immediate-value.ts/immediate-value-plugin.js

@@ -15,8 +15,8 @@ class ImmediateValuePlugin {
     transformQuery(args) {
         return this.#transformer.transformNode(args.node);
     }
-    async transformResult(args) {
-        return args.result;
+    transformResult(args) {
+        return Promise.resolve(args.result);
     }
 }
 exports.ImmediateValuePlugin = ImmediateValuePlugin;

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

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

@@ -82,6 +82,9 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         if ('joins' in node && node.joins) {
             this.#collectTablesFromJoins(node.joins, tables);
         }
+        if ('with' in node && node.with) {
+            this.#removeCommonTableExpressionTables(node.with, tables);
+        }
         return tables;
     }
     #collectTablesFromTableExpressionNodes(nodes, tables) {
@@ -104,5 +107,10 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
             tables.add(table.table.identifier);
         }
     }
+    #removeCommonTableExpressionTables(node, tables) {
+        for (const expr of node.expressions) {
+            tables.delete(expr.name.table.table.identifier);
+        }
+    }
 }
 exports.WithSchemaTransformer = WithSchemaTransformer;