kysely 0.12.1 → 0.12.2

package/dist/cjs/query-creator.js

@@ -136,7 +136,7 @@ class QueryCreator {
         });
     }
     /**
-     * Creates a `with` query (common table expressions).
+     * Creates a `with` query (Common Table Expression).
      *
      * ### Examples
      *
@@ -157,6 +157,24 @@ class QueryCreator {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The CTE name can optionally specify column names in addition to
+     * a name. In that case Kysely requires the expression to retun
+     * rows with the same columns.
+     *
+     * ```ts
+     * await db
+     *   .with('jennifers(id, age)', (db) => db
+     *     .selectFrom('person')
+     *     .where('first_name', '=', 'Jennifer')
+     *     // This is ok since we return columns with the same
+     *     // names as specified by `jennifers(id, age)`.
+     *     .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
      */
     with(name, expression) {
         const cte = (0, with_parser_js_1.parseCommonTableExpression)(this.#props.parseContext, name, expression);
@@ -167,6 +185,20 @@ class QueryCreator {
                 : with_node_js_1.WithNode.create(cte),
         });
     }
+    /**
+     * Creates a recursive `with` query (Common Table Expression).
+     *
+     * See the {@link with} method for examples and more documentation.
+     */
+    withRecursive(name, expression) {
+        const cte = (0, with_parser_js_1.parseCommonTableExpression)(this.#props.parseContext, name, expression);
+        return new QueryCreator({
+            ...this.#props,
+            withNode: this.#props.withNode
+                ? with_node_js_1.WithNode.cloneWithExpression(this.#props.withNode, cte)
+                : with_node_js_1.WithNode.create(cte, { recursive: true }),
+        });
+    }
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.

package/dist/cjs/query-executor/default-query-executor.d.ts

@@ -7,10 +7,29 @@ import { QueryExecutor } from './query-executor.js';
 export declare class DefaultQueryExecutor extends QueryExecutor {
     #private;
     constructor(compiler: QueryCompiler, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
     compileQuery(node: RootOperationNode): CompiledQuery;
     protected executeQueryImpl<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
     withPlugin(plugin: KyselyPlugin): DefaultQueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
     withPluginAtFront(plugin: KyselyPlugin): DefaultQueryExecutor;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
     withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
     withoutPlugins(): QueryExecutor;
 }

package/dist/cjs/query-executor/noop-query-executor.d.ts

@@ -8,10 +8,29 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
  * other needed things to actually execute queries.
  */
 export declare class NoopQueryExecutor extends QueryExecutor {
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
     compileQuery(): CompiledQuery;
     protected executeQueryImpl<R>(): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
     withConnectionProvider(): QueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
     withPlugin(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
     withPluginAtFront(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
     withoutPlugins(): QueryExecutor;
 }

package/dist/cjs/raw-builder/raw-builder.js

@@ -50,7 +50,7 @@ class RawBuilder {
             if (match.index > 0 && sql[match.index - 1] === '\\') {
                 continue;
             }
-            sqlFragments.push(sql.slice(sqlIdx, match.index).replaceAll('\\?', '?'));
+            sqlFragments.push(sql.slice(sqlIdx, match.index).replace(/\\\?/g, '?'));
             argNodes.push(parseRawArg(str, parameters[paramIdx]));
             sqlIdx = match.index + str.length;
             ++paramIdx;

package/dist/esm/index.d.ts

@@ -73,6 +73,7 @@ export * from './operation-node/column-definition-node.js';
 export * from './operation-node/column-node.js';
 export * from './operation-node/column-update-node.js';
 export * from './operation-node/common-table-expression-node.js';
+export * from './operation-node/common-table-expression-name-node.js';
 export * from './operation-node/constraint-node.js';
 export * from './operation-node/create-index-node.js';
 export * from './operation-node/create-schema-node.js';

package/dist/esm/index.js

@@ -73,6 +73,7 @@ export * from './operation-node/column-definition-node.js';
 export * from './operation-node/column-node.js';
 export * from './operation-node/column-update-node.js';
 export * from './operation-node/common-table-expression-node.js';
+export * from './operation-node/common-table-expression-name-node.js';
 export * from './operation-node/constraint-node.js';
 export * from './operation-node/create-index-node.js';
 export * from './operation-node/create-schema-node.js';

package/dist/esm/kysely.d.ts

@@ -207,6 +207,38 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * Returns a copy of this Kysely instance without any plugins.
      */
     withoutPlugins(): Kysely<DB>;
+    /**
+     * Returns a copy of this Kysely instance with tables added to its
+     * database type.
+     *
+     * This method only modifies the types and doesn't affect any of the
+     * executed queries in any way.
+     *
+     * ### Examples
+     *
+     * The following example adds and uses a temporary table:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('temp_table')
+     *   .temporary()
+     *   .addColumn('some_column', 'integer')
+     *   .execute()
+     *
+     * const tempDb = db.withTables<{
+     *   temp_table: {
+     *     some_column: number
+     *   }
+     * }>()
+     *
+     * await tempDb
+     *   .insertInto('temp_table')
+     *   .values({ some_column: 100 })
+     *   .execute()
+     * ```
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
     /**
      * Releases all resources and disconnects from the database.
      *
@@ -223,13 +255,132 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
 export declare class Transaction<DB> extends Kysely<DB> {
     #private;
     constructor(props: KyselyProps);
+    /**
+     * Returns true if this `Kysely` instance is a transaction.
+     *
+     * You can also use `db instanceof Transaction`.
+     */
     get isTransaction(): true;
+    /**
+     * Returns the {@link MigrationModule} module for managing and running migrations.
+     */
     get migration(): MigrationModule;
+    /**
+     * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
+     *
+     * The returned {@link TransactionBuilder} can be used to configure the transaction. The
+     * {@link TransactionBuilder.execute} method can then be called to run the transaction.
+     * {@link TransactionBuilder.execute} takes a function that is run inside the
+     * transaction. If the function throws, the transaction is rolled back. Otherwise
+     * the transaction is committed.
+     *
+     * The callback function passed to the {@link TransactionBuilder.execute | execute}
+     * method gets the transaction object as its only argument. The transaction is
+     * of type {@link Transaction} which inherits {@link Kysely}. Any query
+     * started through the transaction object is executed inside the transaction.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const catto = await db.transaction().execute(async (trx) => {
+     *   const jennifer = await trx.insertInto('person')
+     *     .values({
+     *       id: db.generated,
+     *       first_name: 'Jennifer',
+     *       last_name: 'Aniston',
+     *     })
+     *     .returning('id')
+     *     .executeTakeFirstOrThrow()
+     *
+     *   await someFunction(trx, jennifer)
+     *
+     *   return await trx.insertInto('pet')
+     *     .values({
+     *       id: db.generated,
+     *       user_id: jennifer.id,
+     *       name: 'Catto',
+     *       species: 'cat'
+     *     })
+     *     .returning('*')
+     *     .executeTakeFirst()
+     * })
+     * ```
+     *
+     * Setting the isolation level:
+     *
+     * ```ts
+     * await db
+     *   .transaction()
+     *   .setIsolationLevel('serializable')
+     *   .execute(async (trx) => {
+     *     await doStuff(trx)
+     *   })
+     * ```
+     */
     transaction(): TransactionBuilder<DB>;
+    /**
+     * Provides a kysely instance bound to a single database connection.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db
+     *   .connection()
+     *   .execute(async (db) => {
+     *     // `db` is an instance of `Kysely` that's bound to a single
+     *     // database connection. All queries executed through `db` use
+     *     // the same connection.
+     *     await doStuff(db)
+     *   })
+     * ```
+     */
     connection(): ConnectionBuilder<DB>;
+    /**
+     * Releases all resources and disconnects from the database.
+     *
+     * You need to call this when you are done using the `Kysely` instance.
+     */
     destroy(): Promise<void>;
+    /**
+     * Returns a copy of this Kysely instance with the given plugin installed.
+     */
     withPlugin(plugin: KyselyPlugin): Transaction<DB>;
+    /**
+     * Returns a copy of this Kysely instance without any plugins.
+     */
     withoutPlugins(): Transaction<DB>;
+    /**
+     * Returns a copy of this Kysely instance with tables added to its
+     * database type.
+     *
+     * This method only modifies the types and doesn't affect any of the
+     * executed queries in any way.
+     *
+     * ### Examples
+     *
+     * The following example adds and uses a temporary table:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('temp_table')
+     *   .temporary()
+     *   .addColumn('some_column', 'integer')
+     *   .execute()
+     *
+     * const tempDb = db.withTables<{
+     *   temp_table: {
+     *     some_column: number
+     *   }
+     * }>()
+     *
+     * await tempDb
+     *   .insertInto('temp_table')
+     *   .values({ some_column: 100 })
+     *   .execute()
+     * ```
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): Transaction<DB & T>;
 }
 export interface KyselyProps {
     readonly config: KyselyConfig;

package/dist/esm/kysely.js

@@ -258,6 +258,40 @@ export class Kysely extends QueryCreator {
             executor: this.#props.executor.withoutPlugins(),
         });
     }
+    /**
+     * Returns a copy of this Kysely instance with tables added to its
+     * database type.
+     *
+     * This method only modifies the types and doesn't affect any of the
+     * executed queries in any way.
+     *
+     * ### Examples
+     *
+     * The following example adds and uses a temporary table:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('temp_table')
+     *   .temporary()
+     *   .addColumn('some_column', 'integer')
+     *   .execute()
+     *
+     * const tempDb = db.withTables<{
+     *   temp_table: {
+     *     some_column: number
+     *   }
+     * }>()
+     *
+     * await tempDb
+     *   .insertInto('temp_table')
+     *   .values({ some_column: 100 })
+     *   .execute()
+     * ```
+     */
+    withTables() {
+        return new Kysely({ ...this.#props });
+    }
     /**
      * Releases all resources and disconnects from the database.
      *
@@ -311,6 +345,9 @@ export class Transaction extends Kysely {
             executor: this.#props.executor.withoutPlugins(),
         });
     }
+    withTables() {
+        return new Transaction({ ...this.#props });
+    }
 }
 export function isKyselyProps(obj) {
     return (isObject(obj) &&

package/dist/esm/operation-node/common-table-expression-name-node.d.ts

@@ -0,0 +1,15 @@
+import { ColumnNode } from './column-node.js';
+import { OperationNode } from './operation-node.js';
+import { TableNode } from './table-node.js';
+export interface CommonTableExpressionNameNode extends OperationNode {
+    readonly kind: 'CommonTableExpressionNameNode';
+    readonly table: TableNode;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+}
+/**
+ * @internal
+ */
+export declare const CommonTableExpressionNameNode: Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNameNode;
+    create(tableName: string, columnNames?: readonly string[] | undefined): CommonTableExpressionNameNode;
+}>;

package/dist/esm/operation-node/common-table-expression-name-node.js

@@ -0,0 +1,20 @@
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+import { TableNode } from './table-node.js';
+/**
+ * @internal
+ */
+export const CommonTableExpressionNameNode = freeze({
+    is(node) {
+        return node.kind === 'CommonTableExpressionNameNode';
+    },
+    create(tableName, columnNames) {
+        return freeze({
+            kind: 'CommonTableExpressionNameNode',
+            table: TableNode.create(tableName),
+            columns: columnNames
+                ? freeze(columnNames.map(ColumnNode.create))
+                : undefined,
+        });
+    },
+});

package/dist/esm/operation-node/common-table-expression-node.d.ts

@@ -1,10 +1,10 @@
-import { IdentifierNode } from './identifier-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { OperationNode } from './operation-node.js';
 import { QueryNode } from './query-node.js';
 import { RawNode } from './raw-node.js';
 export interface CommonTableExpressionNode extends OperationNode {
     readonly kind: 'CommonTableExpressionNode';
-    readonly name: IdentifierNode;
+    readonly name: CommonTableExpressionNameNode;
     readonly expression: QueryNode | RawNode;
 }
 /**
@@ -12,5 +12,5 @@ export interface CommonTableExpressionNode extends OperationNode {
  */
 export declare const CommonTableExpressionNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNode;
-    create(name: IdentifierNode, expression: QueryNode | RawNode): CommonTableExpressionNode;
+    create(name: CommonTableExpressionNameNode, expression: QueryNode | RawNode): CommonTableExpressionNode;
 }>;

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

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

@@ -78,6 +78,7 @@ export 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),
@@ -444,6 +445,7 @@ export class OperationNodeTransformer {
         return {
             kind: 'WithNode',
             expressions: this.transformNodeList(node.expressions),
+            recursive: node.recursive,
         };
     }
     transformCommonTableExpression(node) {
@@ -453,6 +455,13 @@ export 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',

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

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

@@ -52,6 +52,7 @@ export 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),

package/dist/esm/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' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/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/esm/operation-node/with-node.js

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

package/dist/esm/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/esm/parser/with-parser.js

@@ -1,6 +1,17 @@
-import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
 export function parseCommonTableExpression(ctx, name, expression) {
     const builder = expression(ctx.createQueryCreator());
-    return CommonTableExpressionNode.create(IdentifierNode.create(name), builder.toOperationNode());
+    return CommonTableExpressionNode.create(parseCommonTableExpressionName(name), builder.toOperationNode());
+}
+function parseCommonTableExpressionName(name) {
+    if (name.includes('(')) {
+        const parts = name.split(/[\(\)]/);
+        const table = parts[0];
+        const columns = parts[1].split(',').map((it) => it.trim());
+        return CommonTableExpressionNameNode.create(table, columns);
+    }
+    else {
+        return CommonTableExpressionNameNode.create(name);
+    }
 }

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

@@ -79,6 +79,9 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
         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) {
@@ -101,4 +104,9 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
             tables.add(table.table.identifier);
         }
     }
+    #removeCommonTableExpressionTables(node, tables) {
+        for (const expr of node.expressions) {
+            tables.delete(expr.name.table.table.identifier);
+        }
+    }
 }

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -68,6 +68,7 @@ import { GeneratedAlwaysAsNode } from '../operation-node/generated-always-as-nod
 import { DefaultValueNode } from '../operation-node/default-value-node.js';
 import { OnNode } from '../operation-node/on-node.js';
 import { ValuesNode } from '../operation-node/values-node.js';
+import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -129,6 +130,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitList(node: ListNode): void;
     protected visitWith(node: WithNode): void;
     protected visitCommonTableExpression(node: CommonTableExpressionNode): void;
+    protected visitCommonTableExpressionName(node: CommonTableExpressionNameNode): void;
     protected visitAlterTable(node: AlterTableNode): void;
     protected visitAddColumn(node: AddColumnNode): void;
     protected visitRenameColumn(node: RenameColumnNode): void;