kysely 0.9.3 → 0.9.7

package/dist/cjs/dialect/mysql/mysql-dialect.d.ts

@@ -5,6 +5,13 @@ import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../../introspection/database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
+ *
+ * The {@link MysqlDialectConfig | configuration} passed to the constructor
+ * is given as-is to the mysql2 library's [createPool](https://github.com/sidorares/node-mysql2#using-connection-pools)
+ * method.
+ */
 export declare class MysqlDialect implements Dialect {
     #private;
     constructor(config: MysqlDialectConfig);
@@ -17,6 +24,8 @@ export declare class MysqlDialect implements Dialect {
  * Config for the mysql dialect.
  *
  * This interface is equal to `mysql2` library's pool config.
+ *
+ * https://github.com/sidorares/node-mysql2#using-connection-pools
  */
 export interface MysqlDialectConfig {
     /**
@@ -176,6 +185,8 @@ export interface MysqlDialectConfig {
     keepAliveInitialDelay?: number;
     /**
      * Called once for each created connection.
+     *
+     * This is a Kysely specific feature and does not come from the `pg` module.
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
 }

package/dist/cjs/dialect/mysql/mysql-dialect.js

@@ -5,6 +5,13 @@ const mysql_driver_js_1 = require("./mysql-driver.js");
 const mysql_query_compiler_js_1 = require("./mysql-query-compiler.js");
 const mysql_introspector_js_1 = require("./mysql-introspector.js");
 const mysql_adapter_js_1 = require("./mysql-adapter.js");
+/**
+ * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
+ *
+ * The {@link MysqlDialectConfig | configuration} passed to the constructor
+ * is given as-is to the mysql2 library's [createPool](https://github.com/sidorares/node-mysql2#using-connection-pools)
+ * method.
+ */
 class MysqlDialect {
     #config;
     constructor(config) {

package/dist/cjs/dialect/postgres/postgres-dialect.d.ts

@@ -8,6 +8,16 @@ import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../../introspection/database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
+ *
+ * The {@link PostgresDialectConfig | configuration} passed to the constructor
+ * is given as-is to the pg library's [Pool](https://node-postgres.com/api/pool)
+ * constructor. See the following two links for more documentation:
+ *
+ * https://node-postgres.com/api/pool
+ * https://node-postgres.com/api/client
+ */
 export declare class PostgresDialect implements Dialect {
     #private;
     constructor(config: PostgresDialectConfig);
@@ -19,7 +29,7 @@ export declare class PostgresDialect implements Dialect {
 /**
  * Config for the postgres dialect.
  *
- * This interface is equal to `pg` library's pool config:
+ * This interface is equal to `pg` library's `Pool` config:
  *
  * https://node-postgres.com/api/pool
  * https://node-postgres.com/api/client
@@ -105,6 +115,8 @@ export interface PostgresDialectConfig {
     application_name?: string;
     /**
      * Called once for each created connection.
+     *
+     * This is a Kysely specific feature and does not come from the `pg` module.
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
     keepAlive?: boolean;

package/dist/cjs/dialect/postgres/postgres-dialect.js

@@ -5,6 +5,16 @@ const postgres_driver_js_1 = require("./postgres-driver.js");
 const postgres_introspector_js_1 = require("./postgres-introspector.js");
 const postgres_query_compiler_js_1 = require("./postgres-query-compiler.js");
 const postgres_adapter_js_1 = require("./postgres-adapter.js");
+/**
+ * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
+ *
+ * The {@link PostgresDialectConfig | configuration} passed to the constructor
+ * is given as-is to the pg library's [Pool](https://node-postgres.com/api/pool)
+ * constructor. See the following two links for more documentation:
+ *
+ * https://node-postgres.com/api/pool
+ * https://node-postgres.com/api/client
+ */
 class PostgresDialect {
     #config;
     constructor(config) {

package/dist/cjs/dialect/postgres/postgres-driver.js

@@ -16,10 +16,10 @@ class PostgresDriver {
         // installed. As you can see, there IS an import from `pg` at the
         // top level too, but that's only for types. It doesn't get compiled
         // into javascript. You can check the built javascript code.
-        const PoolConstrucor = await importPgPool();
+        const PoolConstructor = await importPgPool();
         // Use the `pg` module's own pool. All drivers should use the
         // pool provided by the database library if possible.
-        this.#pool = new PoolConstrucor(this.#config);
+        this.#pool = new PoolConstructor(this.#config);
     }
     async acquireConnection() {
         const client = await this.#pool.connect();

package/dist/cjs/dialect/postgres/postgres-query-compiler.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
-// The default query compiler is for postgres dialect.
+// The default query compiler is for PostgreSQL.
 class PostgresQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
 }
 exports.PostgresQueryCompiler = PostgresQueryCompiler;

package/dist/cjs/driver/runtime-driver.d.ts

@@ -1,3 +1,4 @@
+import { Log } from '../util/log.js';
 import { DatabaseConnection } from './database-connection.js';
 import { Driver, TransactionSettings } from './driver.js';
 /**
@@ -7,10 +8,10 @@ import { Driver, TransactionSettings } from './driver.js';
  */
 export declare class RuntimeDriver implements Driver {
     #private;
-    constructor(driver: Driver);
+    constructor(driver: Driver, log: Log);
     init(): Promise<void>;
     acquireConnection(): Promise<DatabaseConnection>;
-    releaseConnection(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(runtimeConnection: DatabaseConnection): Promise<void>;
     beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
     commitTransaction(connection: DatabaseConnection): Promise<void>;
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;

package/dist/cjs/driver/runtime-driver.js

@@ -8,10 +8,13 @@ exports.RuntimeDriver = void 0;
  */
 class RuntimeDriver {
     #driver;
+    #log;
     #initPromise;
     #destroyPromise;
-    constructor(driver) {
+    #connections = new WeakMap();
+    constructor(driver, log) {
         this.#driver = driver;
+        this.#log = log;
     }
     async init() {
         if (!this.#initPromise) {
@@ -24,10 +27,18 @@ class RuntimeDriver {
     }
     async acquireConnection() {
         await this.init();
-        return this.#driver.acquireConnection();
+        const connection = await this.#driver.acquireConnection();
+        let runtimeConnection = this.#connections.get(connection);
+        if (!runtimeConnection) {
+            runtimeConnection = new RuntimeConnection(connection, this.#log);
+            this.#connections.set(connection, runtimeConnection);
+        }
+        return runtimeConnection;
     }
-    releaseConnection(connection) {
-        return this.#driver.releaseConnection(connection);
+    async releaseConnection(runtimeConnection) {
+        if (runtimeConnection instanceof RuntimeConnection) {
+            await this.#driver.releaseConnection(runtimeConnection.connection);
+        }
     }
     beginTransaction(connection, settings) {
         return this.#driver.beginTransaction(connection, settings);
@@ -53,3 +64,45 @@ class RuntimeDriver {
     }
 }
 exports.RuntimeDriver = RuntimeDriver;
+class RuntimeConnection {
+    #connection;
+    #log;
+    get connection() {
+        return this.#connection;
+    }
+    constructor(connection, log) {
+        this.#connection = connection;
+        this.#log = log;
+    }
+    async executeQuery(compiledQuery) {
+        const startTime = process.hrtime.bigint();
+        try {
+            return await this.#connection.executeQuery(compiledQuery);
+        }
+        catch (error) {
+            this.#logError(error);
+            throw error;
+        }
+        finally {
+            this.#logQuery(compiledQuery, startTime);
+        }
+    }
+    #logError(error) {
+        this.#log.error(() => ({
+            level: 'error',
+            error,
+        }));
+    }
+    #logQuery(compiledQuery, startTime) {
+        this.#log.query(() => ({
+            level: 'query',
+            sql: compiledQuery.sql,
+            queryDurationMillis: this.#calculateDurationMillis(startTime),
+        }));
+    }
+    #calculateDurationMillis(startTime) {
+        const endTime = process.hrtime.bigint();
+        const durationNanos = Number(endTime - startTime);
+        return durationNanos / 1_000_000;
+    }
+}

package/dist/cjs/index.d.ts

@@ -110,7 +110,7 @@ export * from './operation-node/operation-node-source.js';
 export * from './operation-node/order-by-node.js';
 export * from './introspection/database-introspector.js';
 export * from './util/compilable.js';
-export { AnyColumn, UnknownRow as AnyRow } from './util/type-utils.js';
+export { AnyColumn, UnknownRow, AnyQueryBuilder } from './util/type-utils.js';
 export { SelectExpression, SelectExpressionOrList, } from './parser/select-parser.js';
 export { ReferenceExpression, ReferenceExpressionOrList, } from './parser/reference-parser.js';
 export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
@@ -120,3 +120,4 @@ export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-
 export { InsertObject } from './parser/insert-values-parser.js';
 export { MutationObject } from './parser/update-set-parser.js';
 export { OrderByExpression, OrderByDirectionExpression, } from './parser/order-by-parser.js';
+export { UnionExpression } from './parser/union-parser.js';

package/dist/cjs/kysely.d.ts

@@ -10,6 +10,7 @@ import { DatabaseIntrospector } from './introspection/database-introspector.js';
 import { Driver, IsolationLevel } from './driver/driver.js';
 import { ParseContext } from './parser/parse-context.js';
 import { FunctionBuilder } from './query-builder/function-builder.js';
+import { LogLevel } from './util/log.js';
 /**
  * The main Kysely class.
  *
@@ -127,15 +128,20 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      */
     get fn(): FunctionBuilder<DB, keyof DB>;
     /**
-     * Starts a transaction. If the callback throws the transaction is rolled back,
-     * otherwise it's committed.
+     * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
      *
-     * @example
-     * In the example below if either query fails or `someFunction` throws, both inserts
-     * will be rolled back. Otherwise the transaction will be committed by the time the
-     * `transaction` function returns the output value. The output value of the
-     * `transaction` method is the value returned from the callback.
+     * 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.
      *
+     * @example
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
@@ -188,6 +194,10 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * ```
      */
     connection(): ConnectionBuilder<DB>;
+    /**
+     * Returns a copy of this Kysely instance with the given plugin installed.
+     */
+    withPlugin(plugin: KyselyPlugin): Kysely<DB>;
     /**
      * Returns a copy of this Kysely instance without any plugins.
      */
@@ -220,8 +230,20 @@ export interface KyselyProps {
 }
 export declare function isKyselyProps(obj: unknown): obj is KyselyProps;
 export interface KyselyConfig {
-    dialect: Dialect;
-    plugins?: KyselyPlugin[];
+    readonly dialect: Dialect;
+    readonly plugins?: KyselyPlugin[];
+    /**
+     * A list of log levels to log.
+     *
+     * Currently there's only two levels: `query` and `error`.
+     * This will be expanded based on user feedback later.
+     *
+     * Log levels:
+     *
+     *  - query: Log each query's SQL and duration using console.log
+     *  - error: Log all query errors using console.error
+     */
+    readonly log?: ReadonlyArray<LogLevel>;
 }
 export declare class ConnectionBuilder<DB> {
     #private;

package/dist/cjs/kysely.js

@@ -15,6 +15,7 @@ const driver_js_1 = require("./driver/driver.js");
 const prevent_await_js_1 = require("./util/prevent-await.js");
 const parse_context_js_1 = require("./parser/parse-context.js");
 const function_builder_js_1 = require("./query-builder/function-builder.js");
+const log_js_1 = require("./util/log.js");
 /**
  * The main Kysely class.
  *
@@ -60,15 +61,16 @@ class Kysely extends query_creator_js_1.QueryCreator {
     constructor(args) {
         if (isKyselyProps(args)) {
             super({ executor: args.executor, parseContext: args.parseContext });
-            this.#props = (0, object_utils_js_1.freeze)(args);
+            this.#props = (0, object_utils_js_1.freeze)({ ...args });
         }
         else {
             const dialect = args.dialect;
             const driver = dialect.createDriver();
             const compiler = dialect.createQueryCompiler();
             const adapter = dialect.createAdapter();
+            const log = new log_js_1.Log(args.log ?? []);
             const parseContext = new parse_context_js_1.DefaultParseContext(adapter);
-            const runtimeDriver = new runtime_driver_js_1.RuntimeDriver(driver);
+            const runtimeDriver = new runtime_driver_js_1.RuntimeDriver(driver, log);
             const connectionProvider = new default_connection_provider_js_1.DefaultConnectionProvider(runtimeDriver);
             const executor = new default_query_executor_js_1.DefaultQueryExecutor(compiler, connectionProvider, args.plugins ?? []);
             super({ executor, parseContext });
@@ -166,15 +168,20 @@ class Kysely extends query_creator_js_1.QueryCreator {
         return new function_builder_js_1.FunctionBuilder({ executor: this.#props.executor });
     }
     /**
-     * Starts a transaction. If the callback throws the transaction is rolled back,
-     * otherwise it's committed.
+     * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
      *
-     * @example
-     * In the example below if either query fails or `someFunction` throws, both inserts
-     * will be rolled back. Otherwise the transaction will be committed by the time the
-     * `transaction` function returns the output value. The output value of the
-     * `transaction` method is the value returned from the callback.
+     * 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.
      *
+     * @example
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
@@ -231,6 +238,15 @@ class Kysely extends query_creator_js_1.QueryCreator {
     connection() {
         return new ConnectionBuilder({ ...this.#props });
     }
+    /**
+     * Returns a copy of this Kysely instance with the given plugin installed.
+     */
+    withPlugin(plugin) {
+        return new Kysely({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
     /**
      * Returns a copy of this Kysely instance without any plugins.
      */

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

@@ -24,6 +24,38 @@ export declare class MigrationModule {
      *   path.join(__dirname, 'migrations')
      * )
      * ```
+     *
+     * In the next example, we use a record of migration objects instead of file folder path.
+     * The keys in the object are migration names that can be anything you want. The order of
+     * the migrations is determined based on the alphabetical order of the keys in the record.
+     * This can be useful if you are using a bundler like webpack or esbuild.
+     *
+     * @example
+     * ```ts
+     * await db.migration.migrateToLatest({
+     *   migration1: {
+     *     async up(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     },
+     *
+     *     async down(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     }
+     *   },
+     *
+     *   migration2: {
+     *     async up(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     },
+     *
+     *     async down(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     }
+     *   },
+     *
+     *  ...
+     * })
+     * ```
      */
     migrateToLatest(migrationsFolderPath: string): Promise<void>;
     migrateToLatest(allMigrations: Record<string, Migration>): Promise<void>;

package/dist/cjs/operation-node/operator-node.d.ts

@@ -1,6 +1,6 @@
 import { ArrayItemType } from '../util/type-utils.js';
 import { OperationNode } from './operation-node.js';
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists", "&&"];
 export declare type Operator = ArrayItemType<typeof OPERATORS>;
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';

package/dist/cjs/operation-node/operator-node.js

@@ -33,6 +33,7 @@ exports.OPERATORS = [
     '!~*',
     'exists',
     'not exists',
+    '&&',
 ];
 /**
  * @internal

package/dist/cjs/parser/join-parser.d.ts

@@ -3,9 +3,9 @@ import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
 import { ExtractAliasFromTableExpression, TableExpressionDatabase } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { ParseContext } from './parse-context.js';
-export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyJoinColumn<DB, TB, F> | AnyJoinColumnWithTable<DB, TB, F>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
-declare type AnyJoinColumn<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
-declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, F> = AnyColumnWithTable<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
+export declare type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>>) => JoinBuilder<any, any>;
+declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>>;
+declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>>;
 export declare function parseJoin(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;
 export {};

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CamelCasePlugin = void 0;
-const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
+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.
@@ -72,9 +73,9 @@ class CamelCasePlugin {
     #snakeCase;
     #snakeCaseTransformer;
     constructor(opt = {}) {
-        this.#camelCase = createCamelCase(opt);
-        this.#snakeCase = createSnakeCase(opt);
-        this.#snakeCaseTransformer = new SnakeCaseTransformer(this.snakeCase.bind(this));
+        this.#camelCase = (0, camel_case_js_1.createCamelCaseMapper)(opt);
+        this.#snakeCase = (0, camel_case_js_1.createSnakeCaseMapper)(opt);
+        this.#snakeCaseTransformer = new camel_case_transformer_js_1.SnakeCaseTransformer(this.snakeCase.bind(this));
     }
     transformQuery(args) {
         return this.#snakeCaseTransformer.transformNode(args.node);
@@ -109,118 +110,6 @@ class CamelCasePlugin {
     }
 }
 exports.CamelCasePlugin = CamelCasePlugin;
-class SnakeCaseTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
-    #snakeCase;
-    constructor(snakeCase) {
-        super();
-        this.#snakeCase = snakeCase;
-    }
-    transformIdentifier(node) {
-        node = super.transformIdentifier(node);
-        return {
-            ...node,
-            identifier: this.#snakeCase(node.identifier),
-        };
-    }
-}
 function canMap(obj) {
     return (0, object_utils_js_1.isObject)(obj) && !(obj instanceof Date) && !Buffer.isBuffer(obj);
 }
-function createSnakeCase({ upperCase = false, underscoreBeforeDigits = false, underscoreBetweenUppercaseLetters = false, } = {}) {
-    return memoize((str) => {
-        if (str.length === 0) {
-            return str;
-        }
-        const upper = str.toUpperCase();
-        const lower = str.toLowerCase();
-        let out = lower[0];
-        for (let i = 1, l = str.length; i < l; ++i) {
-            const char = str[i];
-            const prevChar = str[i - 1];
-            const upperChar = upper[i];
-            const prevUpperChar = upper[i - 1];
-            const lowerChar = lower[i];
-            const prevLowerChar = lower[i - 1];
-            // If underScoreBeforeDigits is true then, well, insert an underscore
-            // before digits :). Only the first digit gets an underscore if
-            // there are multiple.
-            if (underscoreBeforeDigits && isDigit(char) && !isDigit(prevChar)) {
-                out += '_' + char;
-                continue;
-            }
-            // Test if `char` is an upper-case character and that the character
-            // actually has different upper and lower case versions.
-            if (char === upperChar && upperChar !== lowerChar) {
-                const prevCharacterIsUppercase = prevChar === prevUpperChar && prevUpperChar !== prevLowerChar;
-                // If underscoreBetweenUppercaseLetters is true, we always place an underscore
-                // before consecutive uppercase letters (e.g. "fooBAR" becomes "foo_b_a_r").
-                // Otherwise, we don't (e.g. "fooBAR" becomes "foo_bar").
-                if (underscoreBetweenUppercaseLetters || !prevCharacterIsUppercase) {
-                    out += '_' + lowerChar;
-                }
-                else {
-                    out += lowerChar;
-                }
-            }
-            else {
-                out += char;
-            }
-        }
-        if (upperCase) {
-            return out.toUpperCase();
-        }
-        else {
-            return out;
-        }
-    });
-}
-function createCamelCase({ upperCase = false } = {}) {
-    return memoize((str) => {
-        if (str.length === 0) {
-            return str;
-        }
-        if (upperCase && isAllUpperCaseSnakeCase(str)) {
-            // Only convert to lower case if the string is all upper
-            // case snake_case. This allows camelCase strings to go
-            // through without changing.
-            str = str.toLowerCase();
-        }
-        let out = str[0];
-        for (let i = 1, l = str.length; i < l; ++i) {
-            const char = str[i];
-            const prevChar = str[i - 1];
-            if (char !== '_') {
-                if (prevChar === '_') {
-                    out += char.toUpperCase();
-                }
-                else {
-                    out += char;
-                }
-            }
-        }
-        return out;
-    });
-}
-function isAllUpperCaseSnakeCase(str) {
-    for (let i = 1, l = str.length; i < l; ++i) {
-        const char = str[i];
-        if (char !== '_' && char !== char.toUpperCase()) {
-            return false;
-        }
-    }
-    return true;
-}
-function isDigit(char) {
-    return char >= '0' && char <= '9';
-}
-function memoize(func) {
-    const cache = new Map();
-    return (str) => {
-        let mapped = cache.get(str);
-        if (!mapped) {
-            mapped = func(str);
-            cache.set(str, mapped);
-        }
-        return mapped;
-    };
-}

package/dist/cjs/plugin/camel-case/camel-case-transformer.d.ts

@@ -0,0 +1,8 @@
+import { IdentifierNode } from '../../operation-node/identifier-node.js';
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { StringMapper } from './camel-case.js';
+export declare class SnakeCaseTransformer extends OperationNodeTransformer {
+    #private;
+    constructor(snakeCase: StringMapper);
+    protected transformIdentifier(node: IdentifierNode): IdentifierNode;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnakeCaseTransformer = void 0;
+const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
+class SnakeCaseTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
+    #snakeCase;
+    constructor(snakeCase) {
+        super();
+        this.#snakeCase = snakeCase;
+    }
+    transformIdentifier(node) {
+        node = super.transformIdentifier(node);
+        return {
+            ...node,
+            identifier: this.#snakeCase(node.identifier),
+        };
+    }
+}
+exports.SnakeCaseTransformer = SnakeCaseTransformer;

package/dist/cjs/plugin/camel-case/camel-case.d.ts

@@ -0,0 +1,15 @@
+export declare type StringMapper = (str: string) => string;
+/**
+ * Creates a function that transforms camel case strings to snake case.
+ */
+export declare function createSnakeCaseMapper({ upperCase, underscoreBeforeDigits, underscoreBetweenUppercaseLetters, }?: {
+    upperCase?: boolean | undefined;
+    underscoreBeforeDigits?: boolean | undefined;
+    underscoreBetweenUppercaseLetters?: boolean | undefined;
+}): StringMapper;
+/**
+ * Creates a function that transforms snake case strings to camel case.
+ */
+export declare function createCamelCaseMapper({ upperCase, }?: {
+    upperCase?: boolean | undefined;
+}): StringMapper;