kysely 0.27.4 → 0.27.6

package/dist/esm/migration/migrator.js

@@ -18,16 +18,29 @@ export const NO_MIGRATIONS = freeze({ __noMigrations__: true });
  * other way.
  *
  * ```ts
- * import { promises as fs } from 'fs'
- * import path from 'path'
+ * import { promises as fs } from 'node:fs'
+ * import path from 'node:path'
+ * import * as Sqlite from 'better-sqlite3'
+ * import {
+ *   FileMigrationProvider,
+ *   Kysely,
+ *   Migrator,
+ *   SqliteDialect
+ * } from 'kysely'
+ *
+ * const db = new Kysely<any>({
+ *   dialect: new SqliteDialect({
+ *     database: Sqlite(':memory:')
+ *   })
+ * })
  *
  * const migrator = new Migrator({
  *   db,
  *   provider: new FileMigrationProvider({
  *     fs,
- *     path,
  *     // Path to the folder that contains all your migrations.
- *     migrationFolder: 'some/path/to/migrations'
+ *     migrationFolder: 'some/path/to/migrations',
+ *     path,
  *   })
  * })
  * ```
@@ -48,6 +61,7 @@ export class Migrator {
                 .withPlugin(this.#schemaPlugin)
                 .selectFrom(this.#migrationTable)
                 .select(['name', 'timestamp'])
+                .$narrowType()
                 .execute()
             : [];
         const migrations = await this.#resolveMigrations();
@@ -76,19 +90,18 @@ export class Migrator {
      * ### Examples
      *
      * ```ts
-     * const db = new Kysely<Database>({
-     *   dialect: new PostgresDialect({
-     *     host: 'localhost',
-     *     database: 'kysely_test',
-     *   }),
-     * })
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import * as Sqlite from 'better-sqlite3'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
      *
      * const migrator = new Migrator({
      *   db,
-     *   provider: new FileMigrationProvider(
-     *     // Path to the folder that contains all your migrations.
-     *     'some/path/to/migrations'
-     *   )
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
      * })
      *
      * const { error, results } = await migrator.migrateToLatest()
@@ -121,6 +134,20 @@ export class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateTo('some_migration')
      * ```
      *
@@ -130,6 +157,20 @@ export class Migrator {
      * you can use a special constant `NO_MIGRATIONS`:
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator, NO_MIGRATIONS } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateTo(NO_MIGRATIONS)
      * ```
      */
@@ -168,6 +209,20 @@ export class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateUp()
      * ```
      */
@@ -185,6 +240,20 @@ export class Migrator {
      * ### Examples
      *
      * ```ts
+     * import { promises as fs } from 'node:fs'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
      * await migrator.migrateDown()
      * ```
      */
@@ -395,10 +464,19 @@ export class Migrator {
         const executedMigrations = await db
             .withPlugin(this.#schemaPlugin)
             .selectFrom(this.#migrationTable)
-            .select('name')
-            .orderBy(['timestamp', 'name'])
+            .select(['name', 'timestamp'])
+            .$narrowType()
             .execute();
-        return executedMigrations.map((it) => it.name);
+        const nameComparator = this.#props.nameComparator || ((a, b) => a.localeCompare(b));
+        return (executedMigrations
+            // https://github.com/kysely-org/kysely/issues/843
+            .sort((a, b) => {
+            if (a.timestamp === b.timestamp) {
+                return nameComparator(a.name, b.name);
+            }
+            return (new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        })
+            .map((it) => it.name));
     }
     #ensureNoMissingMigrations(migrations, executedMigrations) {
         // Ensure all executed migrations exist in the `migrations` list.

package/dist/esm/operation-node/aggregate-function-node.d.ts

@@ -1,11 +1,14 @@
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
 import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
+import { OrderByItemNode } from './order-by-item-node.js';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: string;
     readonly aggregated: readonly OperationNode[];
     readonly distinct?: boolean;
+    readonly orderBy?: OrderByNode;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
 }
@@ -16,6 +19,7 @@ export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
     create(aggregateFunction: string, aggregated?: readonly OperationNode[]): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;

package/dist/esm/operation-node/aggregate-function-node.js

@@ -1,6 +1,7 @@
 /// <reference types="./aggregate-function-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
 import { WhereNode } from './where-node.js';
+import { OrderByNode } from './order-by-node.js';
 /**
  * @internal
  */
@@ -21,6 +22,14 @@ export const AggregateFunctionNode = freeze({
             distinct: true,
         });
     },
+    cloneWithOrderBy(aggregateFunctionNode, orderItems) {
+        return freeze({
+            ...aggregateFunctionNode,
+            orderBy: aggregateFunctionNode.orderBy
+                ? OrderByNode.cloneWithItems(aggregateFunctionNode.orderBy, orderItems)
+                : OrderByNode.create(orderItems),
+        });
+    },
     cloneWithFilter(aggregateFunctionNode, filter) {
         return freeze({
             ...aggregateFunctionNode,

package/dist/esm/operation-node/data-type-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["varchar", "char", "text", "integer", "int2", "int4", "int8", "smallint", "bigint", "boolean", "real", "double precision", "float4", "float8", "decimal", "numeric", "binary", "bytea", "date", "datetime", "time", "timetz", "timestamp", "timestamptz", "serial", "bigserial", "uuid", "json", "jsonb", "blob", "varbinary"];
+declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["varchar", "char", "text", "integer", "int2", "int4", "int8", "smallint", "bigint", "boolean", "real", "double precision", "float4", "float8", "decimal", "numeric", "binary", "bytea", "date", "datetime", "time", "timetz", "timestamp", "timestamptz", "serial", "bigserial", "uuid", "json", "jsonb", "blob", "varbinary", "int4range", "int4multirange", "int8range", "int8multirange", "numrange", "nummultirange", "tsrange", "tsmultirange", "tstzrange", "tstzmultirange", "daterange", "datemultirange"];
 type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number];
 export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`;
 export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;

package/dist/esm/operation-node/data-type-node.js

@@ -32,6 +32,18 @@ const SIMPLE_COLUMN_DATA_TYPES = [
     'jsonb',
     'blob',
     'varbinary',
+    'int4range',
+    'int4multirange',
+    'int8range',
+    'int8multirange',
+    'numrange',
+    'nummultirange',
+    'tsrange',
+    'tsmultirange',
+    'tstzrange',
+    'tstzmultirange',
+    'daterange',
+    'datemultirange',
 ];
 const COLUMN_DATA_TYPE_REGEX = [
     /^varchar\(\d+\)$/,

package/dist/esm/operation-node/delete-query-node.d.ts

@@ -22,6 +22,7 @@ export interface DeleteQueryNode extends OperationNode {
     readonly orderBy?: OrderByNode;
     readonly limit?: LimitNode;
     readonly explain?: ExplainNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly top?: TopNode;
     readonly output?: OutputNode;
 }

package/dist/esm/operation-node/insert-query-node.d.ts

@@ -22,6 +22,7 @@ export interface InsertQueryNode extends OperationNode {
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
     readonly defaultValues?: boolean;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly top?: TopNode;
     readonly output?: OutputNode;
 }

package/dist/esm/operation-node/merge-query-node.d.ts

@@ -14,6 +14,7 @@ export interface MergeQueryNode extends OperationNode {
     readonly with?: WithNode;
     readonly top?: TopNode;
     readonly output?: OutputNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -106,9 +106,12 @@ import { OutputNode } from './output-node.js';
  * snake_case, you'd do something like this:
  *
  * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
  * class CamelCaseTransformer extends OperationNodeTransformer {
- *   transformIdentifier(node: IdentifierNode): IdentifierNode {
- *     node = super.transformIdentifier(node),
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
  *
  *     return {
  *       ...node,
@@ -118,7 +121,10 @@ import { OutputNode } from './output-node.js';
  * }
  *
  * const transformer = new CamelCaseTransformer()
- * const tree = transformer.transformNode(tree)
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
  * ```
  */
 export declare class OperationNodeTransformer {

package/dist/esm/operation-node/operation-node-transformer.js

@@ -15,9 +15,12 @@ import { requireAllProps } from '../util/require-all-props.js';
  * snake_case, you'd do something like this:
  *
  * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
  * class CamelCaseTransformer extends OperationNodeTransformer {
- *   transformIdentifier(node: IdentifierNode): IdentifierNode {
- *     node = super.transformIdentifier(node),
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
  *
  *     return {
  *       ...node,
@@ -27,7 +30,10 @@ import { requireAllProps } from '../util/require-all-props.js';
  * }
  *
  * const transformer = new CamelCaseTransformer()
- * const tree = transformer.transformNode(tree)
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
  * ```
  */
 export class OperationNodeTransformer {
@@ -261,6 +267,7 @@ export class OperationNodeTransformer {
             returning: this.transformNode(node.returning),
             onConflict: this.transformNode(node.onConflict),
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             ignore: node.ignore,
             replace: node.replace,
@@ -284,6 +291,7 @@ export class OperationNodeTransformer {
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
@@ -381,6 +389,7 @@ export class OperationNodeTransformer {
             where: this.transformNode(node.where),
             updates: this.transformNodeList(node.updates),
             returning: this.transformNode(node.returning),
+            endModifiers: this.transformNodeList(node.endModifiers),
             with: this.transformNode(node.with),
             explain: this.transformNode(node.explain),
             limit: this.transformNode(node.limit),
@@ -687,6 +696,7 @@ export class OperationNodeTransformer {
             kind: 'AggregateFunctionNode',
             aggregated: this.transformNodeList(node.aggregated),
             distinct: node.distinct,
+            orderBy: this.transformNode(node.orderBy),
             filter: this.transformNode(node.filter),
             func: node.func,
             over: this.transformNode(node.over),
@@ -797,6 +807,7 @@ export class OperationNodeTransformer {
             whens: this.transformNodeList(node.whens),
             with: this.transformNode(node.with),
             top: this.transformNode(node.top),
+            endModifiers: this.transformNodeList(node.endModifiers),
             output: this.transformNode(node.output),
         });
     }

package/dist/esm/operation-node/query-node.d.ts

@@ -32,11 +32,15 @@ type HasTop = {
 type HasOutput = {
     output?: OutputNode;
 };
+type HasEndModifiers = {
+    endModifiers?: ReadonlyArray<OperationNode>;
+};
 /**
  * @internal
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
+    cloneWithEndModifier<T extends HasEndModifiers>(node: T, modifier: OperationNode): T;
     cloneWithWhere<T extends HasWhere>(node: T, operation: OperationNode): T;
     cloneWithJoin<T extends HasJoins>(node: T, join: JoinNode): T;
     cloneWithReturning<T extends HasReturning>(node: T, selections: ReadonlyArray<SelectionNode>): T;

package/dist/esm/operation-node/query-node.js

@@ -20,6 +20,14 @@ export const QueryNode = freeze({
             DeleteQueryNode.is(node) ||
             MergeQueryNode.is(node));
     },
+    cloneWithEndModifier(node, modifier) {
+        return freeze({
+            ...node,
+            endModifiers: node.endModifiers
+                ? freeze([...node.endModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
     cloneWithWhere(node, operation) {
         return freeze({
             ...node,

package/dist/esm/operation-node/select-query-node.d.ts

@@ -46,7 +46,6 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;
     cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
-    cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithOrderByItems(selectNode: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;

package/dist/esm/operation-node/select-query-node.js

@@ -48,14 +48,6 @@ export const SelectQueryNode = freeze({
                 : freeze([modifier]),
         });
     },
-    cloneWithEndModifier(select, modifier) {
-        return freeze({
-            ...select,
-            endModifiers: select.endModifiers
-                ? freeze([...select.endModifiers, modifier])
-                : freeze([modifier]),
-        });
-    },
     cloneWithOrderByItems(selectNode, items) {
         return freeze({
             ...selectNode,

package/dist/esm/operation-node/update-query-node.d.ts

@@ -22,6 +22,7 @@ export interface UpdateQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
     readonly explain?: ExplainNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly limit?: LimitNode;
     readonly top?: TopNode;
     readonly output?: OutputNode;

package/dist/esm/parser/insert-values-parser.js

@@ -40,9 +40,11 @@ function parseRowValues(row, columns) {
         length: columns.size,
     });
     let hasUndefinedOrComplexColumns = false;
+    let indexedRowColumns = rowColumns.length;
     for (const col of rowColumns) {
         const columnIdx = columns.get(col);
         if (isUndefined(columnIdx)) {
+            indexedRowColumns--;
             continue;
         }
         const value = row[col];
@@ -51,7 +53,7 @@ function parseRowValues(row, columns) {
         }
         rowValues[columnIdx] = value;
     }
-    const hasMissingColumns = rowColumns.length < columns.size;
+    const hasMissingColumns = indexedRowColumns < columns.size;
     if (hasMissingColumns || hasUndefinedOrComplexColumns) {
         const defaultValue = DefaultInsertValueNode.create();
         return ValueListNode.create(rowValues.map((it) => isUndefined(it) ? defaultValue : parseValueExpression(it)));

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

@@ -42,38 +42,39 @@ export interface CamelCasePluginOptions {
  * using `CamelCasePlugin` we would setup Kysely like this:
  *
  * ```ts
- * interface Person {
- *   firstName: string
- *   lastName: string
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
  *
- * interface Database {
- *   personTable: Person
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
  * }
  *
- * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     database: 'kysely_test',
- *     host: 'localhost',
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   }),
- *   plugins: [
- *     new CamelCasePlugin()
- *   ]
+ *   plugins: [new CamelCasePlugin()],
  * })
  *
- * const person = await db.selectFrom('personTable')
+ * const person = await db.selectFrom('userMetadata')
  *   .where('firstName', '=', 'Arnold')
  *   .select(['firstName', 'lastName'])
  *   .executeTakeFirst()
  *
- * // generated sql:
- * // select first_name, last_name from person_table where first_name = $1
- *
  * if (person) {
  *   console.log(person.firstName)
  * }
  * ```
  *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
  * As you can see from the example, __everything__ needs to be defined
  * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
@@ -88,11 +89,15 @@ export interface CamelCasePluginOptions {
  * ```ts
  * class MyCamelCasePlugin extends CamelCasePlugin {
  *   protected override snakeCase(str: string): string {
- *     return mySnakeCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  *
  *   protected override camelCase(str: string): string {
- *     return myCamelCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  * }
  * ```
@@ -111,19 +116,41 @@ export declare class CamelCasePlugin implements KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`

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

@@ -11,38 +11,39 @@ import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
  * using `CamelCasePlugin` we would setup Kysely like this:
  *
  * ```ts
- * interface Person {
- *   firstName: string
- *   lastName: string
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
  *
- * interface Database {
- *   personTable: Person
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
  * }
  *
- * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     database: 'kysely_test',
- *     host: 'localhost',
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   }),
- *   plugins: [
- *     new CamelCasePlugin()
- *   ]
+ *   plugins: [new CamelCasePlugin()],
  * })
  *
- * const person = await db.selectFrom('personTable')
+ * const person = await db.selectFrom('userMetadata')
  *   .where('firstName', '=', 'Arnold')
  *   .select(['firstName', 'lastName'])
  *   .executeTakeFirst()
  *
- * // generated sql:
- * // select first_name, last_name from person_table where first_name = $1
- *
  * if (person) {
  *   console.log(person.firstName)
  * }
  * ```
  *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
  * As you can see from the example, __everything__ needs to be defined
  * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
@@ -57,11 +58,15 @@ import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
  * ```ts
  * class MyCamelCasePlugin extends CamelCasePlugin {
  *   protected override snakeCase(str: string): string {
- *     return mySnakeCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  *
  *   protected override camelCase(str: string): string {
- *     return myCamelCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  * }
  * ```

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

@@ -20,7 +20,10 @@ export function createSnakeCaseMapper({ upperCase = false, underscoreBeforeDigit
             // 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)) {
+            if (underscoreBeforeDigits &&
+                isDigit(char) &&
+                !isDigit(prevChar) &&
+                !out.endsWith('_')) {
                 out += '_' + char;
                 continue;
             }