kysely 0.16.11 → 0.17.2

package/dist/cjs/query-executor/query-executor-base.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryExecutorBase = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const NO_PLUGINS = (0, object_utils_js_1.freeze)([]);
+class QueryExecutorBase {
+    #plugins;
+    constructor(plugins = NO_PLUGINS) {
+        this.#plugins = plugins;
+    }
+    get plugins() {
+        return this.#plugins;
+    }
+    transformQuery(node, queryId) {
+        for (const plugin of this.#plugins) {
+            const transformedNode = plugin.transformQuery({ node, queryId });
+            // We need to do a runtime check here. There is no good way
+            // to write types that enforce this constraint.
+            if (transformedNode.kind === node.kind) {
+                node = transformedNode;
+            }
+            else {
+                throw new Error([
+                    `KyselyPlugin.transformQuery must return a node`,
+                    `of the same kind that was given to it.`,
+                    `The plugin was given a ${node.kind}`,
+                    `but it returned a ${transformedNode.kind}`,
+                ].join(' '));
+            }
+        }
+        return node;
+    }
+    async executeQuery(compiledQuery, queryId) {
+        return await this.provideConnection(async (connection) => {
+            const result = await connection.executeQuery(compiledQuery);
+            return this.#transformResult(result, queryId);
+        });
+    }
+    async #transformResult(result, queryId) {
+        for (const plugin of this.#plugins) {
+            result = await plugin.transformResult({ result, queryId });
+        }
+        return result;
+    }
+}
+exports.QueryExecutorBase = QueryExecutorBase;

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

@@ -0,0 +1,8 @@
+import { QueryExecutor } from './query-executor.js';
+/**
+ * @internal
+ * @private
+ */
+export interface QueryExecutorProvider {
+    getExecutor(): QueryExecutor;
+}

package/dist/cjs/query-executor/query-executor-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -4,15 +4,21 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { RootOperationNode } from '../query-compiler/query-compiler.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryId } from '../util/query-id.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
 /**
- * This class abstracts away the details of how to compile a query into SQL
+ * This interface abstracts away the details of how to compile a query into SQL
  * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */
-export declare abstract class QueryExecutor {
-    #private;
-    constructor(plugins?: KyselyPlugin[]);
+export interface QueryExecutor extends ConnectionProvider {
+    /**
+     * Returns the adapter for the current dialect.
+     */
+    get adapter(): DialectAdapter;
+    /**
+     * Returns all installed plugins.
+     */
     get plugins(): ReadonlyArray<KyselyPlugin>;
     /**
      * Given the query the user has built (expressed as an operation node tree)
@@ -25,32 +31,33 @@ export declare abstract class QueryExecutor {
      * the output of {@link transformQuery} into this method but you can
      * compile any query using this method.
      */
-    abstract compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
+    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
     /**
      * Executes a compiled query and runs the result through all plugins'
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
-    /**
-     * Executes a compiled query.
-     */
-    protected abstract executeQueryImpl<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */
-    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * last plugin.
      */
-    abstract withPlugin(plugin: KyselyPlugin): QueryExecutor;
+    withPlugin(plugin: KyselyPlugin): QueryExecutor;
+    /**
+     * Returns a copy of this executor with a list of plugins added
+     * as the last plugins.
+     */
+    withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * first plugin.
      */
-    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
+    withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
     /**
      * Returns a copy of this executor without any plugins.
      */
-    abstract withoutPlugins(): QueryExecutor;
+    withoutPlugins(): QueryExecutor;
 }

package/dist/cjs/query-executor/query-executor.js

@@ -1,59 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryExecutor = void 0;
-const object_utils_js_1 = require("../util/object-utils.js");
-const NO_PLUGINS = (0, object_utils_js_1.freeze)([]);
-/**
- * This class abstracts away the details of how to compile a query into SQL
- * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
- * and other classes that execute queries can just pass around and instance of
- * `QueryExecutor`.
- */
-class QueryExecutor {
-    #plugins;
-    constructor(plugins) {
-        this.#plugins = plugins ?? NO_PLUGINS;
-    }
-    get plugins() {
-        return this.#plugins;
-    }
-    /**
-     * Given the query the user has built (expressed as an operation node tree)
-     * this method runs it through all plugins' `transformQuery` methods and
-     * returns the result.
-     */
-    transformQuery(node, queryId) {
-        for (const plugin of this.#plugins) {
-            const transformedNode = plugin.transformQuery({ node, queryId });
-            // We need to do a runtime check here. There is no good way
-            // to write types that enforce this constraint.
-            if (transformedNode.kind === node.kind) {
-                node = transformedNode;
-            }
-            else {
-                throw new Error([
-                    `KyselyPlugin.transformQuery must return a node`,
-                    `of the same kind that was given to it.`,
-                    `The plugin was given a ${node.kind}`,
-                    `but it returned a ${transformedNode.kind}`,
-                ].join(' '));
-            }
-        }
-        return node;
-    }
-    /**
-     * Executes a compiled query and runs the result through all plugins'
-     * `transformResult` method.
-     */
-    async executeQuery(compiledQuery, queryId) {
-        const result = await this.executeQueryImpl(compiledQuery, queryId);
-        return this.#transformResult(result, queryId);
-    }
-    async #transformResult(result, queryId) {
-        for (const plugin of this.#plugins) {
-            result = await plugin.transformResult({ result, queryId });
-        }
-        return result;
-    }
-}
-exports.QueryExecutor = QueryExecutor;

package/dist/cjs/raw-builder/raw-builder.d.ts

@@ -2,25 +2,57 @@ import { QueryResult } from '../driver/database-connection.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { CompiledQuery } from '../query-compiler/compiled-query.js';
-import { QueryExecutor } from '../query-executor/query-executor.js';
-import { QueryId } from '../util/query-id.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js';
+import { QueryId } from '../util/query-id.js';
+/**
+ * An instance of this class can be used to create raw SQL snippets or queries.
+ *
+ * You shouldn't need to create `RawBuilder` instances directly. Instead you should
+ * use the {@link sql} template tag.
+ */
 export declare class RawBuilder<O = unknown> implements OperationNodeSource {
     #private;
     constructor(props: RawBuilderProps);
+    /**
+     * Returns an aliased version of the SQL expression.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `full_name: string` field exists in the result type.
+     * console.log(result.full_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select concat(first_name, ' ', last_name) as "full_name"
+     * from "person"
+     * ```
+     */
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
     /**
      * Change the output type of the raw expression.
      *
-     * This doesn't produce any SQL. This methods simply returns a copy
-     * of this `RawBuilder` with a new output type.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `RawBuilder` with a new output type.
      */
     castTo<T>(): RawBuilder<T>;
+    /**
+     * Adds a plugin for this SQL snippet.
+     */
     withPlugin(plugin: KyselyPlugin): RawBuilder<O>;
     toOperationNode(): RawNode;
-    compile(): CompiledQuery;
-    execute(): Promise<QueryResult<O>>;
+    execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>;
 }
 /**
  * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
@@ -40,8 +72,7 @@ export declare class AliasedRawBuilder<O = unknown, A extends string = never> im
     constructor(rawBuilder: RawBuilder<O>, alias: A);
 }
 export interface RawBuilderProps {
-    readonly queryId?: QueryId;
-    readonly executor?: QueryExecutor;
-    readonly sql: string;
-    readonly parameters?: ReadonlyArray<unknown>;
+    readonly queryId: QueryId;
+    readonly rawNode: RawNode;
+    readonly plugins?: ReadonlyArray<KyselyPlugin>;
 }

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

@@ -2,75 +2,85 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AliasedRawBuilder = exports.RawBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
-const raw_node_js_1 = require("../operation-node/raw-node.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
-const reference_parser_js_1 = require("../parser/reference-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
-const query_id_js_1 = require("../util/query-id.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
+/**
+ * An instance of this class can be used to create raw SQL snippets or queries.
+ *
+ * You shouldn't need to create `RawBuilder` instances directly. Instead you should
+ * use the {@link sql} template tag.
+ */
 class RawBuilder {
     #props;
     constructor(props) {
-        this.#props = (0, object_utils_js_1.freeze)({
-            queryId: props.queryId ?? (0, query_id_js_1.createQueryId)(),
-            executor: props.executor ?? new noop_query_executor_js_1.NoopQueryExecutor(),
-            sql: props.sql,
-            parameters: props.parameters,
-        });
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    /**
+     * Returns an aliased version of the SQL expression.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `full_name: string` field exists in the result type.
+     * console.log(result.full_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select concat(first_name, ' ', last_name) as "full_name"
+     * from "person"
+     * ```
+     */
     as(alias) {
         return new AliasedRawBuilder(this, alias);
     }
     /**
      * Change the output type of the raw expression.
      *
-     * This doesn't produce any SQL. This methods simply returns a copy
-     * of this `RawBuilder` with a new output type.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `RawBuilder` with a new output type.
      */
     castTo() {
-        return new RawBuilder({
-            ...this.#props,
-        });
+        return new RawBuilder({ ...this.#props });
     }
+    /**
+     * Adds a plugin for this SQL snippet.
+     */
     withPlugin(plugin) {
         return new RawBuilder({
             ...this.#props,
-            executor: this.#props.executor.withPlugin(plugin),
+            plugins: this.#props.plugins !== undefined
+                ? (0, object_utils_js_1.freeze)([...this.#props.plugins, plugin])
+                : (0, object_utils_js_1.freeze)([plugin]),
         });
     }
     toOperationNode() {
-        const parameterPlaceholderRegex = /(\?\??)/g;
-        const sql = this.#props.sql;
-        const parameters = this.#props.parameters ?? [];
-        const sqlFragments = [];
-        const argNodes = [];
-        let paramIdx = 0;
-        let sqlIdx = 0;
-        let match = null;
-        while ((match = parameterPlaceholderRegex.exec(sql))) {
-            const str = match[1];
-            if (paramIdx >= parameters.length) {
-                throw new Error(`value not provided for all placeholders in string ${sql}`);
-            }
-            if (match.index > 0 && sql[match.index - 1] === '\\') {
-                continue;
-            }
-            sqlFragments.push(sql.slice(sqlIdx, match.index).replace(/\\\?/g, '?'));
-            argNodes.push(parseRawArg(str, parameters[paramIdx]));
-            sqlIdx = match.index + str.length;
-            ++paramIdx;
-        }
-        sqlFragments.push(sql.slice(sqlIdx));
-        const rawNode = raw_node_js_1.RawNode.create(sqlFragments, argNodes);
-        return this.#props.executor.transformQuery(rawNode, this.#props.queryId);
+        const executor = this.#props.plugins !== undefined
+            ? noop_query_executor_js_1.NOOP_QUERY_EXECUTOR.withPlugins(this.#props.plugins)
+            : noop_query_executor_js_1.NOOP_QUERY_EXECUTOR;
+        return this.#toOperationNode(executor);
     }
-    compile() {
-        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    async execute(executorProvider) {
+        const executor = this.#props.plugins !== undefined
+            ? executorProvider.getExecutor().withPlugins(this.#props.plugins)
+            : executorProvider.getExecutor();
+        return executor.executeQuery(this.#compile(executor), this.#props.queryId);
     }
-    async execute() {
-        return this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    #toOperationNode(executor) {
+        return executor.transformQuery(this.#props.rawNode, this.#props.queryId);
+    }
+    #compile(executor) {
+        return executor.compileQuery(this.#toOperationNode(executor), this.#props.queryId);
     }
 }
 exports.RawBuilder = RawBuilder;
@@ -101,14 +111,3 @@ class AliasedRawBuilder {
     }
 }
 exports.AliasedRawBuilder = AliasedRawBuilder;
-function parseRawArg(match, arg) {
-    if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-        return arg.toOperationNode();
-    }
-    else if (match === '??') {
-        return (0, reference_parser_js_1.parseStringReference)(arg);
-    }
-    else {
-        return value_node_js_1.ValueNode.create(arg);
-    }
-}