kysely 0.23.5 → 0.24.0

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressionBuilder = exports.createExpressionBuilder = void 0;
+const select_query_builder_js_1 = require("../query-builder/select-query-builder.js");
+const select_query_node_js_1 = require("../operation-node/select-query-node.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
+const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugin.js");
+const query_id_js_1 = require("../util/query-id.js");
+const function_module_js_1 = require("../query-builder/function-module.js");
+const reference_parser_js_1 = require("../parser/reference-parser.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const and_node_js_1 = require("../operation-node/and-node.js");
+const or_node_js_1 = require("../operation-node/or-node.js");
+const parens_node_js_1 = require("../operation-node/parens-node.js");
+const expression_wrapper_js_1 = require("./expression-wrapper.js");
+const unary_operation_parser_js_1 = require("../parser/unary-operation-parser.js");
+const value_parser_js_1 = require("../parser/value-parser.js");
+const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+function createExpressionBuilder(executor = noop_query_executor_js_1.NOOP_QUERY_EXECUTOR) {
+    function unary(op, expr) {
+        return new expression_wrapper_js_1.ExpressionWrapper((0, unary_operation_parser_js_1.parseUnaryOperation)(op, expr));
+    }
+    return {
+        get fn() {
+            return (0, function_module_js_1.createFunctionModule)();
+        },
+        selectFrom(table) {
+            return new select_query_builder_js_1.SelectQueryBuilder({
+                queryId: (0, query_id_js_1.createQueryId)(),
+                executor: executor,
+                queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(table)),
+            });
+        },
+        ref(reference) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, reference_parser_js_1.parseStringReference)(reference));
+        },
+        val(value) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, value_parser_js_1.parseValueExpressionOrList)(value));
+        },
+        cmpr(lhs, op, rhs) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseValueBinaryOperation)(lhs, op, rhs));
+        },
+        bxp(lhs, op, rhs) {
+            return new expression_wrapper_js_1.ExpressionWrapper((0, binary_operation_parser_js_1.parseValueBinaryOperation)(lhs, op, rhs));
+        },
+        unary,
+        not(expr) {
+            return unary('not', expr);
+        },
+        exists(expr) {
+            return unary('exists', expr);
+        },
+        neg(expr) {
+            return unary('-', expr);
+        },
+        and(exprs) {
+            if (exprs.length === 0) {
+                return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(true));
+            }
+            else if (exprs.length === 1) {
+                return new expression_wrapper_js_1.ExpressionWrapper(exprs[0].toOperationNode());
+            }
+            let node = and_node_js_1.AndNode.create(exprs[0].toOperationNode(), exprs[1].toOperationNode());
+            for (let i = 2; i < exprs.length; ++i) {
+                node = and_node_js_1.AndNode.create(node, exprs[i].toOperationNode());
+            }
+            return new expression_wrapper_js_1.ExpressionWrapper(parens_node_js_1.ParensNode.create(node));
+        },
+        or(exprs) {
+            if (exprs.length === 0) {
+                return new expression_wrapper_js_1.ExpressionWrapper(value_node_js_1.ValueNode.createImmediate(false));
+            }
+            else if (exprs.length === 1) {
+                return new expression_wrapper_js_1.ExpressionWrapper(exprs[0].toOperationNode());
+            }
+            let node = or_node_js_1.OrNode.create(exprs[0].toOperationNode(), exprs[1].toOperationNode());
+            for (let i = 2; i < exprs.length; ++i) {
+                node = or_node_js_1.OrNode.create(node, exprs[i].toOperationNode());
+            }
+            return new expression_wrapper_js_1.ExpressionWrapper(parens_node_js_1.ParensNode.create(node));
+        },
+        withSchema(schema) {
+            return createExpressionBuilder(executor.withPluginAtFront(new with_schema_plugin_js_1.WithSchemaPlugin(schema)));
+        },
+    };
+}
+exports.createExpressionBuilder = createExpressionBuilder;
+function expressionBuilder(_) {
+    return createExpressionBuilder();
+}
+exports.expressionBuilder = expressionBuilder;

package/dist/cjs/expression/expression-wrapper.d.ts

@@ -0,0 +1,92 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { AliasedExpression, Expression } from './expression.js';
+export declare class ExpressionWrapper<T> implements Expression<T> {
+    #private;
+    constructor(node: OperationNode);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): T | undefined;
+    /**
+     * Returns an aliased version of the 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(eb =>
+     *     eb.cmpr('first_name', '=', 'Jennifer').as('is_jennifer')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `is_jennifer: SqlBool` field exists in the result type.
+     * console.log(result.is_jennifer)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```ts
+     * select "first_name" = $1 as "is_jennifer"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedExpression<T, A>;
+    as<A extends string>(alias: Expression<unknown>): AliasedExpression<T, A>;
+    /**
+     * Change the output type of the raw expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `ExpressionWrapper` with a new output type.
+     */
+    $castTo<T>(): ExpressionWrapper<T>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): OperationNode;
+}
+export declare class AliasedExpressionWrapper<T, A extends string> implements AliasedExpression<T, A> {
+    #private;
+    constructor(expr: Expression<T>, alias: A | Expression<unknown>);
+    /** @private */
+    /**
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<T>;
+    /** @private */
+    /**
+     * Returns the alias.
+     */
+    get alias(): A | Expression<unknown>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     */
+    toOperationNode(): AliasNode;
+}

package/dist/cjs/expression/expression-wrapper.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasedExpressionWrapper = exports.ExpressionWrapper = void 0;
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+class ExpressionWrapper {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    as(alias) {
+        return new AliasedExpressionWrapper(this, alias);
+    }
+    /**
+     * Change the output type of the raw expression.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `ExpressionWrapper` with a new output type.
+     */
+    $castTo() {
+        return new ExpressionWrapper(this.#node);
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}
+exports.ExpressionWrapper = ExpressionWrapper;
+class AliasedExpressionWrapper {
+    #expr;
+    #alias;
+    constructor(expr, alias) {
+        this.#expr = expr;
+        this.#alias = alias;
+    }
+    /** @private */
+    get expression() {
+        return this.#expr;
+    }
+    /** @private */
+    get alias() {
+        return this.#alias;
+    }
+    toOperationNode() {
+        return alias_node_js_1.AliasNode.create(this.#expr.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias)
+            ? this.#alias.toOperationNode()
+            : identifier_node_js_1.IdentifierNode.create(this.#alias));
+    }
+}
+exports.AliasedExpressionWrapper = AliasedExpressionWrapper;

package/dist/cjs/expression/expression.d.ts

@@ -90,7 +90,7 @@ export interface AliasedExpression<T, A extends string> extends OperationNodeSou
     /**
      * Returns the alias.
      */
-    get alias(): A;
+    get alias(): A | Expression<unknown>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      */

package/dist/cjs/helpers/postgres.d.ts

@@ -0,0 +1,133 @@
+import { Expression } from '../expression/expression.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Simplify } from '../util/type-utils.js';
+/**
+ * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into arrays.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce(jsonb_agg(agg), '[]') from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *   ) as agg
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>[]>;
+/**
+ * A postgres helper for turning a subquery (or other expression) into a JSONB object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select to_jsonb(obj) from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = $1
+ *   ) as obj
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>>;
+/**
+ * The PostgreSQL `jsonb_build_object` function.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonbBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: sql<string>`first_name || ' ' || last_name`
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", jsonb_build_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', first_name || ' ' || last_name
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export declare function jsonbBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
+    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+}>>;

package/dist/cjs/helpers/postgres.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonbBuildObject = exports.jsonObjectFrom = exports.jsonArrayFrom = void 0;
+const sql_js_1 = require("../raw-builder/sql.js");
+/**
+ * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into arrays.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce(jsonb_agg(agg), '[]') from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *   ) as agg
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+function jsonArrayFrom(expr) {
+    return (0, sql_js_1.sql) `(select coalesce(jsonb_agg(agg), '[]') from ${expr} as agg)`;
+}
+exports.jsonArrayFrom = jsonArrayFrom;
+/**
+ * A postgres helper for turning a subquery (or other expression) into a JSONB object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select to_jsonb(obj) from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = $1
+ *   ) as obj
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+function jsonObjectFrom(expr) {
+    return (0, sql_js_1.sql) `(select to_jsonb(obj) from ${expr} as obj)`;
+}
+exports.jsonObjectFrom = jsonObjectFrom;
+/**
+ * The PostgreSQL `jsonb_build_object` function.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonbBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: sql<string>`first_name || ' ' || last_name`
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", jsonb_build_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', first_name || ' ' || last_name
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+function jsonbBuildObject(obj) {
+    return (0, sql_js_1.sql) `jsonb_build_object(${sql_js_1.sql.join(Object.keys(obj).flatMap((k) => [sql_js_1.sql.lit(k), obj[k]]))})`;
+}
+exports.jsonbBuildObject = jsonbBuildObject;

package/dist/cjs/index.d.ts

@@ -1,6 +1,7 @@
 export * from './kysely.js';
 export * from './query-creator.js';
 export * from './expression/expression.js';
+export { ExpressionBuilder, expressionBuilder, } from './expression/expression-builder.js';
 export * from './query-builder/where-interface.js';
 export * from './query-builder/returning-interface.js';
 export * from './query-builder/having-interface.js';
@@ -10,7 +11,6 @@ export * from './query-builder/update-query-builder.js';
 export * from './query-builder/delete-query-builder.js';
 export * from './query-builder/no-result-error.js';
 export * from './query-builder/join-builder.js';
-export * from './query-builder/expression-builder.js';
 export * from './query-builder/function-module.js';
 export * from './query-builder/insert-result.js';
 export * from './query-builder/delete-result.js';
@@ -163,11 +163,12 @@ export * from './operation-node/using-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';
+export * from './util/streamable.js';
 export * from './util/log.js';
-export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, AnySelectQueryBuilder, Equals, UnknownRow, } from './util/type-utils.js';
+export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, AnySelectQueryBuilder, Equals, UnknownRow, Simplify, SqlBool, } from './util/type-utils.js';
 export * from './util/infer-result.js';
 export { logOnce } from './util/log-once.js';
-export { SelectExpression, SelectExpressionOrList, Selection, } from './parser/select-parser.js';
+export { SelectExpression, SelectArg, Selection, } from './parser/select-parser.js';
 export { ReferenceExpression, ReferenceExpressionOrList, SimpleReferenceExpression, StringReference, ExtractTypeFromStringReference, ExtractTypeFromReferenceExpression, } from './parser/reference-parser.js';
 export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
 export { TableExpression, TableExpressionOrList, } from './parser/table-parser.js';

package/dist/cjs/index.js

@@ -14,10 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logOnce = void 0;
+exports.logOnce = exports.expressionBuilder = void 0;
 __exportStar(require("./kysely.js"), exports);
 __exportStar(require("./query-creator.js"), exports);
 __exportStar(require("./expression/expression.js"), exports);
+var expression_builder_js_1 = require("./expression/expression-builder.js");
+Object.defineProperty(exports, "expressionBuilder", { enumerable: true, get: function () { return expression_builder_js_1.expressionBuilder; } });
 __exportStar(require("./query-builder/where-interface.js"), exports);
 __exportStar(require("./query-builder/returning-interface.js"), exports);
 __exportStar(require("./query-builder/having-interface.js"), exports);
@@ -27,7 +29,6 @@ __exportStar(require("./query-builder/update-query-builder.js"), exports);
 __exportStar(require("./query-builder/delete-query-builder.js"), exports);
 __exportStar(require("./query-builder/no-result-error.js"), exports);
 __exportStar(require("./query-builder/join-builder.js"), exports);
-__exportStar(require("./query-builder/expression-builder.js"), exports);
 __exportStar(require("./query-builder/function-module.js"), exports);
 __exportStar(require("./query-builder/insert-result.js"), exports);
 __exportStar(require("./query-builder/delete-result.js"), exports);
@@ -180,6 +181,7 @@ __exportStar(require("./operation-node/using-node.js"), exports);
 __exportStar(require("./util/column-type.js"), exports);
 __exportStar(require("./util/compilable.js"), exports);
 __exportStar(require("./util/explainable.js"), exports);
+__exportStar(require("./util/streamable.js"), exports);
 __exportStar(require("./util/log.js"), exports);
 __exportStar(require("./util/infer-result.js"), exports);
 var log_once_js_1 = require("./util/log-once.js");

package/dist/cjs/kysely.d.ts

@@ -9,6 +9,10 @@ import { Driver, IsolationLevel } from './driver/driver.js';
 import { FunctionModule } from './query-builder/function-module.js';
 import { LogConfig } from './util/log.js';
 import { QueryExecutorProvider } from './query-executor/query-executor-provider.js';
+import { QueryResult } from './driver/database-connection.js';
+import { CompiledQuery } from './query-compiler/compiled-query.js';
+import { QueryId } from './util/query-id.js';
+import { Compilable } from './util/compilable.js';
 /**
  * The main Kysely class.
  *
@@ -225,6 +229,12 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * @private
      */
     getExecutor(): QueryExecutor;
+    /**
+     * Executes a given compiled query or query builder.
+     *
+     * See {@link https://github.com/koskimas/kysely/blob/master/site/docs/recipes/splitting-build-compile-and-execute-code.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
+     */
+    executeQuery<R>(query: CompiledQuery<R> | Compilable<R>, queryId?: QueryId): Promise<QueryResult<R>>;
 }
 export declare class Transaction<DB> extends Kysely<DB> {
     #private;

package/dist/cjs/kysely.js

@@ -13,6 +13,8 @@ const driver_js_1 = require("./driver/driver.js");
 const prevent_await_js_1 = require("./util/prevent-await.js");
 const function_module_js_1 = require("./query-builder/function-module.js");
 const log_js_1 = require("./util/log.js");
+const query_id_js_1 = require("./util/query-id.js");
+const compilable_js_1 = require("./util/compilable.js");
 /**
  * The main Kysely class.
  *
@@ -135,7 +137,7 @@ class Kysely extends query_creator_js_1.QueryCreator {
      * ```
      */
     get fn() {
-        return new function_module_js_1.FunctionModule();
+        return (0, function_module_js_1.createFunctionModule)();
     }
     /**
      * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
@@ -284,6 +286,15 @@ class Kysely extends query_creator_js_1.QueryCreator {
     getExecutor() {
         return this.#props.executor;
     }
+    /**
+     * Executes a given compiled query or query builder.
+     *
+     * See {@link https://github.com/koskimas/kysely/blob/master/site/docs/recipes/splitting-build-compile-and-execute-code.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
+     */
+    executeQuery(query, queryId = (0, query_id_js_1.createQueryId)()) {
+        const compiledQuery = (0, compilable_js_1.isCompilable)(query) ? query.compile() : query;
+        return this.getExecutor().executeQuery(compiledQuery, queryId);
+    }
 }
 exports.Kysely = Kysely;
 class Transaction extends Kysely {

package/dist/cjs/migration/file-migration-provider.d.ts

@@ -22,8 +22,11 @@ export declare class FileMigrationProvider implements MigrationProvider {
      * Returns all migrations, old and new.
      *
      * For example if you have your migrations in a folder as separate files,
-     * you can use the {@link FileMigrationProvider} that implements this
-     * method to return all migrations in a folder.
+     * you can implement this method to return all migration in that folder
+     * as {@link Migration} objects.
+     *
+     * Kysely already has a built-in {@link FileMigrationProvider} for node.js
+     * that does exactly that.
      *
      * The keys of the returned object are migration names and values are the
      * migrations. The order of the migrations is determined by the alphabetical

package/dist/cjs/migration/migrator.d.ts

@@ -258,8 +258,11 @@ export interface MigrationProvider {
      * Returns all migrations, old and new.
      *
      * For example if you have your migrations in a folder as separate files,
-     * you can use the {@link FileMigrationProvider} that implements this
-     * method to return all migrations in a folder.
+     * you can implement this method to return all migration in that folder
+     * as {@link Migration} objects.
+     *
+     * Kysely already has a built-in {@link FileMigrationProvider} for node.js
+     * that does exactly that.
      *
      * The keys of the returned object are migration names and values are the
      * migrations. The order of the migrations is determined by the alphabetical