kysely 0.12.1 → 0.12.2

package/dist/esm/query-compiler/default-query-compiler.js

@@ -570,6 +570,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitWith(node) {
         this.append('with ');
+        if (node.recursive) {
+            this.append('recursive ');
+        }
         this.compileList(node.expressions);
     }
     visitCommonTableExpression(node) {
@@ -577,6 +580,14 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(' as ');
         this.visitNode(node.expression);
     }
+    visitCommonTableExpressionName(node) {
+        this.visitNode(node.table);
+        if (node.columns) {
+            this.append('(');
+            this.compileList(node.columns);
+            this.append(')');
+        }
+    }
     visitAlterTable(node) {
         this.append('alter table ');
         this.visitNode(node.table);

package/dist/esm/query-creator.d.ts

@@ -5,7 +5,7 @@ import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
 import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { RawBuilder } from './raw-builder/raw-builder.js';
-import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';
+import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { ParseContext } from './parser/parse-context.js';
 import { InsertResult } from './query-builder/insert-result.js';
@@ -206,7 +206,7 @@ export declare class QueryCreator<DB> {
      */
     updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
     /**
-     * Creates a `with` query (common table expressions).
+     * Creates a `with` query (Common Table Expression).
      *
      * ### Examples
      *
@@ -227,8 +227,32 @@ export declare class QueryCreator<DB> {
      *   .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<N extends string, E extends CommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    /**
+     * Creates a recursive `with` query (Common Table Expression).
+     *
+     * See the {@link with} method for examples and more documentation.
      */
-    with<N extends string, E extends CommonTableExpression<DB>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    withRecursive<N extends string, E extends RecursiveCommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.

package/dist/esm/query-creator.js

@@ -133,7 +133,7 @@ export class QueryCreator {
         });
     }
     /**
-     * Creates a `with` query (common table expressions).
+     * Creates a `with` query (Common Table Expression).
      *
      * ### Examples
      *
@@ -154,6 +154,24 @@ export 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 = parseCommonTableExpression(this.#props.parseContext, name, expression);
@@ -164,6 +182,20 @@ export class QueryCreator {
                 : 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 = parseCommonTableExpression(this.#props.parseContext, name, expression);
+        return new QueryCreator({
+            ...this.#props,
+            withNode: this.#props.withNode
+                ? WithNode.cloneWithExpression(this.#props.withNode, cte)
+                : WithNode.create(cte, { recursive: true }),
+        });
+    }
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.

package/dist/esm/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/esm/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/esm/raw-builder/raw-builder.js

@@ -47,7 +47,7 @@ export 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/package.json

@@ -1,13 +1,13 @@
 {
   "name": "kysely",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
     "url": "git://github.com/koskimas/kysely.git"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=14.0.0"
   },
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",