kysely 0.12.0 → 0.14.0

package/dist/cjs/operation-node/on-conflict-node.d.ts

@@ -1,13 +1,19 @@
 import { ColumnNode } from './column-node.js';
 import { ColumnUpdateNode } from './column-update-node.js';
 import { IdentifierNode } from './identifier-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind'>;
+import { RawNode } from './raw-node.js';
+import { WhereNode } from './where-node.js';
+export declare type OnConflictNodeProps = Omit<OnConflictNode, 'kind' | 'indexWhere' | 'updateWhere'>;
 export interface OnConflictNode extends OperationNode {
     readonly kind: 'OnConflictNode';
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly constraint?: IdentifierNode;
+    readonly indexExpression?: RawNode;
+    readonly indexWhere?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
+    readonly updateWhere?: WhereNode;
     readonly doNothing?: boolean;
 }
 /**
@@ -15,5 +21,10 @@ export interface OnConflictNode extends OperationNode {
  */
 export declare const OnConflictNode: Readonly<{
     is(node: OperationNode): node is OnConflictNode;
-    create(props: OnConflictNodeProps): OnConflictNode;
+    create(): OnConflictNode;
+    cloneWith(node: OnConflictNode, props: OnConflictNodeProps): OnConflictNode;
+    cloneWithIndexWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithIndexOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithUpdateWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
+    cloneWithUpdateOrWhere(node: OnConflictNode, filter: FilterExpressionNode): OnConflictNode;
 }>;

package/dist/cjs/operation-node/on-conflict-node.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnConflictNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const where_node_js_1 = require("./where-node.js");
 /**
  * @internal
  */
@@ -9,10 +10,47 @@ exports.OnConflictNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'OnConflictNode';
     },
-    create(props) {
+    create() {
         return (0, object_utils_js_1.freeze)({
             kind: 'OnConflictNode',
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
             ...props,
         });
     },
+    cloneWithIndexWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            indexWhere: node.indexWhere
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.indexWhere, 'And', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithIndexOrWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            indexWhere: node.indexWhere
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.indexWhere, 'Or', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithUpdateWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            updateWhere: node.updateWhere
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.updateWhere, 'And', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithUpdateOrWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            updateWhere: node.updateWhere
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.updateWhere, 'Or', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
 });

package/dist/cjs/operation-node/operation-node-transformer.d.ts

@@ -44,6 +44,7 @@ import { ReferencesNode } from './references-node.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { WithNode } from './with-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { HavingNode } from './having-node.js';
 import { CreateSchemaNode } from './create-schema-node.js';
 import { DropSchemaNode } from './drop-schema-node.js';
@@ -60,7 +61,7 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
-import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
@@ -142,6 +143,7 @@ export declare class OperationNodeTransformer {
     protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
     protected transformWith(node: WithNode): WithNode;
     protected transformCommonTableExpression(node: CommonTableExpressionNode): CommonTableExpressionNode;
+    protected transformCommonTableExpressionName(node: CommonTableExpressionNameNode): CommonTableExpressionNameNode;
     protected transformHaving(node: HavingNode): HavingNode;
     protected transformCreateSchema(node: CreateSchemaNode): CreateSchemaNode;
     protected transformDropSchema(node: DropSchemaNode): DropSchemaNode;
@@ -154,7 +156,7 @@ export declare class OperationNodeTransformer {
     protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
-    protected transformGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): GeneratedAlwaysAsNode;
+    protected transformGenerated(node: GeneratedNode): GeneratedNode;
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -81,6 +81,7 @@ class OperationNodeTransformer {
         CheckConstraintNode: this.transformCheckConstraint.bind(this),
         WithNode: this.transformWith.bind(this),
         CommonTableExpressionNode: this.transformCommonTableExpression.bind(this),
+        CommonTableExpressionNameNode: this.transformCommonTableExpressionName.bind(this),
         HavingNode: this.transformHaving.bind(this),
         CreateSchemaNode: this.transformCreateSchema.bind(this),
         DropSchemaNode: this.transformDropSchema.bind(this),
@@ -95,7 +96,7 @@ class OperationNodeTransformer {
         UnionNode: this.transformUnion.bind(this),
         CreateViewNode: this.transformCreateView.bind(this),
         DropViewNode: this.transformDropView.bind(this),
-        GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
+        GeneratedNode: this.transformGenerated.bind(this),
         DefaultValueNode: this.transformDefaultValue.bind(this),
         OnNode: this.transformOn.bind(this),
         ValuesNode: this.transformValues.bind(this),
@@ -283,10 +284,11 @@ class OperationNodeTransformer {
             primaryKey: node.primaryKey,
             autoIncrement: node.autoIncrement,
             unique: node.unique,
-            nullable: node.nullable,
+            notNull: node.notNull,
+            unsigned: node.unsigned,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
-            generatedAlwaysAs: this.transformNode(node.generatedAlwaysAs),
+            generated: this.transformNode(node.generated),
         };
     }
     transformAddColumn(node) {
@@ -362,7 +364,10 @@ class OperationNodeTransformer {
             kind: 'OnConflictNode',
             columns: this.transformNodeList(node.columns),
             constraint: this.transformNode(node.constraint),
+            indexExpression: this.transformNode(node.indexExpression),
+            indexWhere: this.transformNode(node.indexWhere),
             updates: this.transformNodeList(node.updates),
+            updateWhere: this.transformNode(node.updateWhere),
             doNothing: node.doNothing,
         };
     }
@@ -447,6 +452,7 @@ class OperationNodeTransformer {
         return {
             kind: 'WithNode',
             expressions: this.transformNodeList(node.expressions),
+            recursive: node.recursive,
         };
     }
     transformCommonTableExpression(node) {
@@ -456,6 +462,13 @@ class OperationNodeTransformer {
             expression: this.transformNode(node.expression),
         };
     }
+    transformCommonTableExpressionName(node) {
+        return {
+            kind: 'CommonTableExpressionNameNode',
+            table: this.transformNode(node.table),
+            columns: this.transformNodeList(node.columns),
+        };
+    }
     transformHaving(node) {
         return {
             kind: 'HavingNode',
@@ -553,11 +566,14 @@ class OperationNodeTransformer {
             materialized: node.materialized,
         };
     }
-    transformGeneratedAlwaysAs(node) {
+    transformGenerated(node) {
         return {
-            kind: 'GeneratedAlwaysAsNode',
-            expression: this.transformNode(node.expression),
+            kind: 'GeneratedNode',
+            byDefault: node.byDefault,
+            always: node.always,
+            identity: node.identity,
             stored: node.stored,
+            expression: this.transformNode(node.expression),
         };
     }
     transformDefaultValue(node) {

package/dist/cjs/operation-node/operation-node-visitor.d.ts

@@ -44,6 +44,7 @@ import { ReferencesNode } from './references-node.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { WithNode } from './with-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { HavingNode } from './having-node.js';
 import { CreateSchemaNode } from './create-schema-node.js';
 import { DropSchemaNode } from './drop-schema-node.js';
@@ -60,7 +61,7 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
-import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
@@ -110,6 +111,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitCheckConstraint(node: CheckConstraintNode): void;
     protected abstract visitWith(node: WithNode): void;
     protected abstract visitCommonTableExpression(node: CommonTableExpressionNode): void;
+    protected abstract visitCommonTableExpressionName(node: CommonTableExpressionNameNode): void;
     protected abstract visitHaving(node: HavingNode): void;
     protected abstract visitCreateSchema(node: CreateSchemaNode): void;
     protected abstract visitDropSchema(node: DropSchemaNode): void;
@@ -130,7 +132,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitOperator(node: OperatorNode): void;
     protected abstract visitCreateView(node: CreateViewNode): void;
     protected abstract visitDropView(node: DropViewNode): void;
-    protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
+    protected abstract visitGenerated(node: GeneratedNode): void;
     protected abstract visitDefaultValue(node: DefaultValueNode): void;
     protected abstract visitOn(node: OnNode): void;
     protected abstract visitValues(node: ValuesNode): void;

package/dist/cjs/operation-node/operation-node-visitor.js

@@ -55,6 +55,7 @@ class OperationNodeVisitor {
         CheckConstraintNode: this.visitCheckConstraint.bind(this),
         WithNode: this.visitWith.bind(this),
         CommonTableExpressionNode: this.visitCommonTableExpression.bind(this),
+        CommonTableExpressionNameNode: this.visitCommonTableExpressionName.bind(this),
         HavingNode: this.visitHaving.bind(this),
         CreateSchemaNode: this.visitCreateSchema.bind(this),
         DropSchemaNode: this.visitDropSchema.bind(this),
@@ -69,7 +70,7 @@ class OperationNodeVisitor {
         UnionNode: this.visitUnion.bind(this),
         CreateViewNode: this.visitCreateView.bind(this),
         DropViewNode: this.visitDropView.bind(this),
-        GeneratedAlwaysAsNode: this.visitGeneratedAlwaysAs.bind(this),
+        GeneratedNode: this.visitGenerated.bind(this),
         DefaultValueNode: this.visitDefaultValue.bind(this),
         OnNode: this.visitOn.bind(this),
         ValuesNode: this.visitValues.bind(this),

package/dist/cjs/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/operation-node/with-node.d.ts

@@ -1,14 +1,16 @@
 import { OperationNode } from './operation-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+export declare type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>;
 export interface WithNode extends OperationNode {
     readonly kind: 'WithNode';
     readonly expressions: ReadonlyArray<CommonTableExpressionNode>;
+    readonly recursive?: boolean;
 }
 /**
  * @internal
  */
 export declare const WithNode: Readonly<{
     is(node: OperationNode): node is WithNode;
-    create(expression: CommonTableExpressionNode): WithNode;
+    create(expression: CommonTableExpressionNode, params?: WithNodeParams | undefined): WithNode;
     cloneWithExpression(withNode: WithNode, expression: CommonTableExpressionNode): WithNode;
 }>;

package/dist/cjs/operation-node/with-node.js

@@ -9,10 +9,11 @@ exports.WithNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'WithNode';
     },
-    create(expression) {
+    create(expression, params) {
         return (0, object_utils_js_1.freeze)({
             kind: 'WithNode',
             expressions: (0, object_utils_js_1.freeze)([expression]),
+            ...params,
         });
     },
     cloneWithExpression(withNode, expression) {

package/dist/cjs/package.json

@@ -1,3 +1 @@
-{
-    "type": "commonjs"
-}
+{"type":"commonjs"}

package/dist/cjs/parser/parse-context.d.ts

@@ -34,8 +34,22 @@ export declare class DefaultParseContext implements ParseContext {
     #private;
     constructor(adapter: DialectAdapter);
     get adapter(): DialectAdapter;
+    /**
+     * Creates a select query builder with a {@link NoopQueryExecutor}.
+     */
     createSelectQueryBuilder(): SelectQueryBuilder<any, any, any>;
+    /**
+     * Creates an expression builder for building stuff like subqueries.
+     * {@link NoopQueryExecutor} is used as the executor and the queries
+     * built using the returned builder can never be executed.
+     */
     createExpressionBuilder(): ExpressionBuilder<any, any>;
+    /**
+     * Creates a query creator with a {@link NoopQueryExecutor}.
+     */
     createQueryCreator(): QueryCreator<any>;
+    /**
+     * Creates an instance of a join builder.
+     */
     createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
 }

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

@@ -5,10 +5,37 @@ 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 { 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>) => 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 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 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/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;