kysely 0.27.2 → 0.27.4

package/dist/cjs/plugin/camel-case/camel-case-plugin.js

@@ -6,7 +6,7 @@ const camel_case_transformer_js_1 = require("./camel-case-transformer.js");
 const camel_case_js_1 = require("./camel-case.js");
 /**
  * A plugin that converts snake_case identifiers in the database into
- * camelCase in the javascript side.
+ * camelCase in the JavaScript side.
  *
  * For example let's assume we have a table called `person_table`
  * with columns `first_name` and `last_name` in the database. When
@@ -46,7 +46,7 @@ const camel_case_js_1 = require("./camel-case.js");
  * ```
  *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: table names, columns, schemas,
+ * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
  * the database was defined in camelCase.
  *

package/dist/cjs/plugin/camel-case/camel-case.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCamelCaseMapper = exports.createSnakeCaseMapper = void 0;
+exports.createSnakeCaseMapper = createSnakeCaseMapper;
+exports.createCamelCaseMapper = createCamelCaseMapper;
 /**
  * Creates a function that transforms camel case strings to snake case.
  */
@@ -52,7 +53,6 @@ function createSnakeCaseMapper({ upperCase = false, underscoreBeforeDigits = fal
         }
     });
 }
-exports.createSnakeCaseMapper = createSnakeCaseMapper;
 /**
  * Creates a function that transforms snake case strings to camel case.
  */
@@ -83,7 +83,6 @@ function createCamelCaseMapper({ upperCase = false, } = {}) {
         return out;
     });
 }
-exports.createCamelCaseMapper = createCamelCaseMapper;
 function isAllUpperCaseSnakeCase(str) {
     for (let i = 1, l = str.length; i < l; ++i) {
         const char = str[i];

package/dist/cjs/plugin/parse-json-results/parse-json-results-plugin.d.ts

@@ -2,6 +2,20 @@ import { QueryResult } from '../../driver/database-connection.js';
 import { RootOperationNode } from '../../query-compiler/query-compiler.js';
 import { UnknownRow } from '../../util/type-utils.js';
 import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+export interface ParseJSONResultsPluginOptions {
+    /**
+     * When `'in-place'`, arrays' and objects' values are parsed in-place. This is
+     * the most time and space efficient option.
+     *
+     * This can result in runtime errors if some objects/arrays are readonly.
+     *
+     * When `'create'`, new arrays and objects are created to avoid such errors.
+     *
+     * Defaults to `'in-place'`.
+     */
+    objectStrategy?: ObjectStrategy;
+}
+type ObjectStrategy = 'in-place' | 'create';
 /**
  * Parses JSON strings in query results into JSON objects.
  *
@@ -16,6 +30,9 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
  * ```
  */
 export declare class ParseJSONResultsPlugin implements KyselyPlugin {
+    #private;
+    readonly opt: ParseJSONResultsPluginOptions;
+    constructor(opt?: ParseJSONResultsPluginOptions);
     /**
      * 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}
@@ -53,3 +70,4 @@ export declare class ParseJSONResultsPlugin implements KyselyPlugin {
      */
     transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }
+export {};

package/dist/cjs/plugin/parse-json-results/parse-json-results-plugin.js

@@ -16,6 +16,12 @@ const object_utils_js_1 = require("../../util/object-utils.js");
  * ```
  */
 class ParseJSONResultsPlugin {
+    opt;
+    #objectStrategy;
+    constructor(opt = {}) {
+        this.opt = opt;
+        this.#objectStrategy = opt.objectStrategy || 'in-place';
+    }
     // noop
     transformQuery(args) {
         return args.node;
@@ -23,33 +29,34 @@ class ParseJSONResultsPlugin {
     async transformResult(args) {
         return {
             ...args.result,
-            rows: parseArray(args.result.rows),
+            rows: parseArray(args.result.rows, this.#objectStrategy),
         };
     }
 }
 exports.ParseJSONResultsPlugin = ParseJSONResultsPlugin;
-function parseArray(arr) {
+function parseArray(arr, objectStrategy) {
+    const target = objectStrategy === 'create' ? new Array(arr.length) : arr;
     for (let i = 0; i < arr.length; ++i) {
-        arr[i] = parse(arr[i]);
+        target[i] = parse(arr[i], objectStrategy);
     }
-    return arr;
+    return target;
 }
-function parse(obj) {
+function parse(obj, objectStrategy) {
     if ((0, object_utils_js_1.isString)(obj)) {
         return parseString(obj);
     }
     if (Array.isArray(obj)) {
-        return parseArray(obj);
+        return parseArray(obj, objectStrategy);
     }
     if ((0, object_utils_js_1.isPlainObject)(obj)) {
-        return parseObject(obj);
+        return parseObject(obj, objectStrategy);
     }
     return obj;
 }
 function parseString(str) {
     if (maybeJson(str)) {
         try {
-            return parse(JSON.parse(str));
+            return parse(JSON.parse(str), 'in-place');
         }
         catch (err) {
             // this catch block is intentionally empty.
@@ -60,9 +67,10 @@ function parseString(str) {
 function maybeJson(value) {
     return value.match(/^[\[\{]/) != null;
 }
-function parseObject(obj) {
+function parseObject(obj, objectStrategy) {
+    const target = objectStrategy === 'create' ? {} : obj;
     for (const key in obj) {
-        obj[key] = parse(obj[key]);
+        target[key] = parse(obj[key], objectStrategy);
     }
-    return obj;
+    return target;
 }

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

@@ -29,6 +29,7 @@ const ROOT_OPERATION_NODES = (0, object_utils_js_1.freeze)({
     RawNode: true,
     SelectQueryNode: true,
     UpdateQueryNode: true,
+    MergeQueryNode: true,
 });
 class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
     #schema;
@@ -103,6 +104,9 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
                 this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
             }
         }
+        if ('using' in node && node.using) {
+            this.#collectSchemableIdsFromTableExpr(node.using, schemableIds);
+        }
         return schemableIds;
     }
     #collectCTEs(node) {

package/dist/cjs/query-builder/delete-query-builder.d.ts

@@ -24,7 +24,8 @@ import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ValueExpression } from '../parser/value-parser.js';
-export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
+import { OutputCallback, OutputExpression, OutputInterface, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
+export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OutputInterface<DB, TB, O, 'deleted'>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: DeleteQueryBuilderProps);
     /**
@@ -289,7 +290,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     sql`coalesce(first_name, last_name)`,
+     *     sql<string>`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -399,6 +400,46 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     clearWhere(): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Changes a `delete from` query into a `delete top from` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Delete the first 5 rows:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('person')
+     *   .top(5)
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * delete top(5) from "person" where "age" > @1
+     * ```
+     *
+     * Delete the first 50% of rows:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('person')
+     *   .top(50, 'percent')
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * delete top(50) percent from "person" where "age" > @1
+     * ```
+     */
+    top(expression: number | bigint, modifiers?: 'percent'): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds a `using` clause to the query.
      *
@@ -759,9 +800,151 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
      * that support `returning` such as PostgreSQL.
+     *
+     * Also see the {@link returning} method.
      */
     returningAll<T extends TB>(table: T): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, T, O>>;
     returningAll(): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, TB, O>>;
+    /**
+     * Allows you to return data from modified rows.
+     *
+     * On supported databases like MS SQL Server (MSSQL), this method can be chained
+     * to `insert`, `update`, `delete` and `merge` queries to return data.
+     *
+     * Also see the {@link outputAll} method.
+     *
+     * ### Examples
+     *
+     * Return one column:
+     *
+     * ```ts
+     * const { id } = await db
+     *   .insertInto('person')
+     *   .output('inserted.id')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return multiple columns:
+     *
+     * ```ts
+     * const { id, first_name } = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'John', last_name: 'Doe' })
+     *   .output([
+     *     'deleted.first_name as old_first_name',
+     *     'deleted.last_name as old_last_name',
+     *     'inserted.first_name as new_first_name',
+     *     'inserted.last_name as new_last_name',
+     *   ])
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return arbitrary expressions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { id, full_name } = await db
+     *   .deleteFrom('person')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .where('created_at', '<', new Date())
+     *   .executeTakeFirst()
+     * ```
+     *
+     * Return the action performed on the row:
+     *
+     * ```ts
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .whenNotMatched()
+     *   .thenInsertValues({
+     *     first_name: 'John',
+     *     last_name: 'Doe',
+     *     gender: 'male'
+     *   })
+     *   .output([
+     *     'inserted.id as inserted_id',
+     *     'deleted.id as deleted_id',
+     *   ])
+     * ```
+     */
+    output<OE extends OutputExpression<DB, TB, 'deleted'>>(selections: readonly OE[]): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    output<CB extends OutputCallback<DB, TB, 'deleted'>>(callback: CB): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputCallback<CB>>>;
+    output<OE extends OutputExpression<DB, TB, 'deleted'>>(selection: OE): DeleteQueryBuilder<DB, TB, ReturningRow<DB, TB, O, SelectExpressionFromOutputExpression<OE>>>;
+    /**
+     * Adds an `output {prefix}.*` to an `insert`/`update`/`delete`/`merge` query on databases
+     * that support `output` such as MS SQL Server (MSSQL).
+     *
+     * Also see the {@link output} method.
+     */
+    outputAll(table: 'deleted'): DeleteQueryBuilder<DB, TB, ReturningAllRow<DB, TB, O>>;
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max"
+     * ```
+     */
+    clearReturning(): DeleteQueryBuilder<DB, TB, DeleteResult>;
+    /**
+     * Clears the `limit` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .limit(5)
+     *   .clearLimit()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max" returning *
+     * ```
+     */
+    clearLimit(): DeleteQueryBuilder<DB, TB, O>;
+    /**
+     * Clears the `order by` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .orderBy('id')
+     *   .clearOrderBy()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max" returning *
+     * ```
+     */
+    clearOrderBy(): DeleteQueryBuilder<DB, TB, O>;
     /**
      * Adds an `order by` clause to the query.
      *
@@ -927,17 +1110,17 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
-     * This method can be used to simplify excessively complex types to make typescript happy
+     * This method can be used to simplify excessively complex types to make TypeScript happy
      * and much faster.
      *
      * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
-     * for typescript and you get errors like this:
+     * for TypeScript and you get errors like this:
      *
      * ```
      * error TS2589: Type instantiation is excessively deep and possibly infinite.
      * ```
      *
-     * In these case you can often use this method to help typescript a little bit. When you use this
+     * In these case you can often use this method to help TypeScript a little bit. When you use this
      * method to assert the output type of a query, Kysely can drop the complex output type that
      * consists of multiple nested helper types and replace it with the simple asserted type.
      *

package/dist/cjs/query-builder/delete-query-builder.js

@@ -14,6 +14,7 @@ const limit_node_js_1 = require("../operation-node/limit-node.js");
 const order_by_parser_js_1 = require("../parser/order-by-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const value_parser_js_1 = require("../parser/value-parser.js");
+const top_parser_js_1 = require("../parser/top-parser.js");
 class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -37,6 +38,51 @@ class DeleteQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithoutWhere(this.#props.queryNode),
         });
     }
+    /**
+     * Changes a `delete from` query into a `delete top from` query.
+     *
+     * `top` clause is only supported by some dialects like MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Delete the first 5 rows:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('person')
+     *   .top(5)
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * delete top(5) from "person" where "age" > @1
+     * ```
+     *
+     * Delete the first 50% of rows:
+     *
+     * ```ts
+     * await db
+     *   .deleteFrom('person')
+     *   .top(50, 'percent')
+     *   .where('age', '>', 18)
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MS SQL Server):
+     *
+     * ```sql
+     * delete top(50) percent from "person" where "age" > @1
+     * ```
+     */
+    top(expression, modifiers) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithTop(this.#props.queryNode, (0, top_parser_js_1.parseTop)(expression, modifiers)),
+        });
+    }
     using(tables) {
         return new DeleteQueryBuilder({
             ...this.#props,
@@ -79,6 +125,92 @@ class DeleteQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
         });
     }
+    output(args) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectArg)(args)),
+        });
+    }
+    outputAll(table) {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithOutput(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
+        });
+    }
+    /**
+     * Clears all `returning` clauses from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .clearReturning()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max"
+     * ```
+     */
+    clearReturning() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithoutReturning(this.#props.queryNode),
+        });
+    }
+    /**
+     * Clears the `limit` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .limit(5)
+     *   .clearLimit()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max" returning *
+     * ```
+     */
+    clearLimit() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithoutLimit(this.#props.queryNode),
+        });
+    }
+    /**
+     * Clears the `order by` clause from the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.deleteFrom('pet')
+     *   .returningAll()
+     *   .where('name', '=', 'Max')
+     *   .orderBy('id')
+     *   .clearOrderBy()
+     * ```
+     *
+     * The generated SQL(PostgreSQL):
+     *
+     * ```sql
+     * delete from "pet" where "name" = "Max" returning *
+     * ```
+     */
+    clearOrderBy() {
+        return new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
+        });
+    }
     /**
      * Adds an `order by` clause to the query.
      *
@@ -267,17 +399,17 @@ class DeleteQueryBuilder {
     /**
      * Asserts that query's output row type equals the given type `T`.
      *
-     * This method can be used to simplify excessively complex types to make typescript happy
+     * This method can be used to simplify excessively complex types to make TypeScript happy
      * and much faster.
      *
      * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
-     * for typescript and you get errors like this:
+     * for TypeScript and you get errors like this:
      *
      * ```
      * error TS2589: Type instantiation is excessively deep and possibly infinite.
      * ```
      *
-     * In these case you can often use this method to help typescript a little bit. When you use this
+     * In these case you can often use this method to help TypeScript a little bit. When you use this
      * method to assert the output type of a query, Kysely can drop the complex output type that
      * consists of multiple nested helper types and replace it with the simple asserted type.
      *
@@ -330,9 +462,11 @@ class DeleteQueryBuilder {
      */
     async execute() {
         const compiledQuery = this.compile();
-        const query = compiledQuery.query;
         const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
-        if (this.#props.executor.adapter.supportsReturning && query.returning) {
+        const { adapter } = this.#props.executor;
+        const query = compiledQuery.query;
+        if ((query.returning && adapter.supportsReturning) ||
+            (query.output && adapter.supportsOutput)) {
             return result.rows;
         }
         return [

package/dist/cjs/query-builder/function-module.d.ts

@@ -106,7 +106,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * ```ts
      * db.selectFrom('person')
      *   .selectAll('person')
-     *   .where(sql`upper(first_name)`, '=', 'JENNIFER')
+     *   .where(sql<string>`upper(first_name)`, '=', 'JENNIFER')
      * ```
      */
     <O, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(name: string, args?: ReadonlyArray<RE>): ExpressionWrapper<DB, TB, O>;
@@ -173,7 +173,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * If this function is used in a `select` statement, the type of the selected
      * expression will be `number | string` by default. This is because Kysely can't know the
      * type the db driver outputs. Sometimes the output can be larger than the largest
-     * javascript number and a string is returned instead. Most drivers allow you
+     * JavaScript number and a string is returned instead. Most drivers allow you
      * to configure the output type of large numbers and Kysely can't know if you've
      * done so.
      *
@@ -292,7 +292,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * If this function is used in a `select` statement, the type of the selected
      * expression will be `number | string | bigint` by default. This is because
      * Kysely can't know the type the db driver outputs. Sometimes the output can
-     * be larger than the largest javascript number and a string is returned instead.
+     * be larger than the largest JavaScript number and a string is returned instead.
      * Most drivers allow you to configure the output type of large numbers and Kysely
      * can't know if you've done so.
      *
@@ -344,7 +344,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * If this is used in a `select` statement, the type of the selected expression
      * will be `number | string | bigint` by default. This is because Kysely
      * can't know the type the db driver outputs. Sometimes the output can be larger
-     * than the largest javascript number and a string is returned instead. Most
+     * than the largest JavaScript number and a string is returned instead. Most
      * drivers allow you to configure the output type of large numbers and Kysely
      * can't know if you've done so.
      *
@@ -513,7 +513,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * If this function is used in a `select` statement, the type of the selected
      * expression will be `number | string` by default. This is because Kysely can't know the
      * type the db driver outputs. Sometimes the output can be larger than the largest
-     * javascript number and a string is returned instead. Most drivers allow you
+     * JavaScript number and a string is returned instead. Most drivers allow you
      * to configure the output type of large numbers and Kysely can't know if you've
      * done so.
      *

package/dist/cjs/query-builder/function-module.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFunctionModule = void 0;
+exports.createFunctionModule = createFunctionModule;
 const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
 const aggregate_function_node_js_1 = require("../operation-node/aggregate-function-node.js");
 const function_node_js_1 = require("../operation-node/function-node.js");
@@ -60,4 +60,3 @@ function createFunctionModule() {
         },
     });
 }
-exports.createFunctionModule = createFunctionModule;