kysely-ddl 0.1.0

package/dist/kysely/json.js

@@ -0,0 +1,54 @@
+/**
+ * Values for jsonb columns.
+ *
+ * Drivers disagree on how a jsonb parameter should be passed. `pg` expects JSON
+ * text: it serializes objects itself, but turns a JS array into a postgres array
+ * literal (`{1,2,3}`) and gets `invalid input syntax for type json`. `Bun.SQL`
+ * looks at the parameter type reported by the server and for jsonb serializes the
+ * JS value to JSON itself, so a ready JSON string gets encoded a second time and
+ * becomes a jsonb string, while a number or boolean is rejected by postgres.
+ *
+ * The one representation both understand is a text parameter with an explicit
+ * `$1::text::jsonb` cast. That is what `jsonb()` and `jsonbArray()` build, and the
+ * `Jsonb<T>` brand in the write types (`inferKyselyTable`) keeps a raw object or
+ * string from being passed around the helper.
+ *
+ * ```ts
+ * await db.insertInto('user').values({ settings: jsonb({ theme: 'dark' }) }).execute();
+ * await db.updateTable('user').set({ settings: jsonb({ theme: 'light' }) }).execute();
+ * await db.selectFrom('user').where('settings', '@>', jsonb({ theme: 'dark' })).execute();
+ * ```
+ */
+import { sql } from 'kysely';
+/**
+ * A value for a jsonb column: an object, an array, a string, a number or a boolean.
+ *
+ * `null` and `undefined` are rejected on purpose. `jsonb(null)` would write JSON
+ * null rather than SQL NULL: it passes a `NOT NULL` column, is invisible to
+ * `IS NULL` and `COALESCE`, and is indistinguishable from SQL NULL when read.
+ * SQL NULL for a nullable column is passed as a plain `null` without the helper.
+ * A top-level JSON null is needed so rarely that raw `sql` remains for it.
+ */
+export function jsonb(value) {
+    return sql `${encode(value)}::text::jsonb`;
+}
+/** A value for a `jsonb[]` column: each element is a separate JSON value, `null` inside is JSON null. */
+export function jsonbArray(values) {
+    return sql `${pgArrayLiteral(values.map(encode))}::text::jsonb[]`;
+}
+function encode(value) {
+    // lib.d.ts types JSON.stringify as returning string, but for undefined, functions and symbols it returns undefined
+    const text = JSON.stringify(value);
+    if (text === undefined) {
+        throw new Error(`jsonb(): a value of type ${typeof value} cannot be serialized to JSON`);
+    }
+    return text;
+}
+/**
+ * A postgres array literal from strings: `{"a","b,c","d\"e",NULL}`. Every element
+ * is quoted, so commas, braces and spaces inside are safe.
+ */
+export function pgArrayLiteral(values) {
+    const elements = values.map(value => value === null ? 'NULL' : `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`);
+    return `{${elements.join(',')}}`;
+}

package/dist/kysely/provider.d.ts

@@ -0,0 +1,20 @@
+import type { MigrationProvider } from 'kysely/migration';
+export interface SqlMigrationProviderOptions {
+    /**
+     * What to do on `migrateDown` / `migrateTo`.
+     *
+     * The generator only writes forward, and migrations have no `down`. Without
+     * `down`, Kysely skips the migration (`NotExecuted`) and leaves it in the
+     * journal: `migrateDown` quietly does nothing. By default the provider supplies
+     * a `down` that fails with a clear error: a rollback must not look successful.
+     * `skip` restores Kysely's behaviour. A paired rollback, when needed, is
+     * written by hand and wired through your own provider.
+     */
+    readonly onDown?: 'throw' | 'skip';
+}
+/**
+ * A provider that hands `.sql` files from a folder to the `Migrator`.
+ * The migration name is the file name without the extension, the order is
+ * alphabetical (hence the timestamp prefix).
+ */
+export declare function sqlFileMigrationProvider(dir: string, options?: SqlMigrationProviderOptions): MigrationProvider;

package/dist/kysely/provider.js

@@ -0,0 +1,63 @@
+/**
+ * Running migrations with Kysely's built-in `Migrator`.
+ *
+ * No runner of its own is needed here: Kysely already handles the lock
+ * (`kysely_migration_lock`), the record of what has been applied
+ * (`kysely_migration`), ordering and the transaction. The one thing it lacks is
+ * loading migrations from anything but modules with `up`/`down` functions
+ * (`FileMigrationProvider`), while we generate plain SQL. That is what
+ * `sqlFileMigrationProvider` covers.
+ *
+ * ```ts
+ * import { Migrator } from 'kysely/migration';
+ *
+ * const migrator = new Migrator({
+ *   db,
+ *   provider: sqlFileMigrationProvider('./migrations'),
+ * });
+ *
+ * const { error, results } = await migrator.migrateToLatest();
+ * ```
+ *
+ * On transactions: on postgres Kysely runs the WHOLE run in one transaction by
+ * default, DDL is transactional there, so a failing migration rolls back all the
+ * previous ones from the same run. It is disabled with
+ * `new Migrator({ ..., disableTransactions: true })`; that is needed for
+ * operations postgres forbids inside a transaction (`CREATE INDEX CONCURRENTLY`
+ * and the like).
+ */
+import { sql } from 'kysely';
+import { listMigrations, readStatements } from '../migrator/store.js';
+/**
+ * A provider that hands `.sql` files from a folder to the `Migrator`.
+ * The migration name is the file name without the extension, the order is
+ * alphabetical (hence the timestamp prefix).
+ */
+export function sqlFileMigrationProvider(dir, options = {}) {
+    const onDown = options.onDown ?? 'throw';
+    return {
+        async getMigrations() {
+            const migrations = {};
+            for (const name of listMigrations(dir)) {
+                migrations[name] = {
+                    async up(db) {
+                        // one statement at a time: the driver does not trip over
+                        // multi-statement text, and an error points at a specific query
+                        for (const statement of readStatements(dir, name)) {
+                            await sql.raw(statement).execute(db);
+                        }
+                    },
+                    ...(onDown === 'throw'
+                        ? {
+                            down() {
+                                return Promise.reject(new Error(`${name}: no rollback available. The generator only writes forward migrations: ` +
+                                    'write the reverse migration yourself or pass { onDown: "skip" }.'));
+                            },
+                        }
+                        : {}),
+                };
+            }
+            return migrations;
+        },
+    };
+}

package/dist/kysely/runner.d.ts

@@ -0,0 +1,76 @@
+/**
+ * A runner for `.sql` migrations on top of a ready `Kysely`.
+ *
+ * Kysely is the only abstraction over the driver: under `pg` that is
+ * `PostgresDialect`, under Bun any postgres dialect over `Bun.SQL` (the repository
+ * has a test one, `test/helpers/bun-dialect.ts`). The runner needs one connection
+ * for the whole run, the advisory lock and the transaction live on it, so it works
+ * through `db.connection()`.
+ *
+ * Compatible with Kysely's `Migrator`: the same `kysely_migration` journal
+ * (`name varchar(255)`, `timestamp varchar(255)` in ISO) and the same lock key as
+ * `PostgresAdapter`. The two runners can alternate on one database and will not
+ * run at the same time.
+ *
+ * Why a runner of our own when `Migrator` exists: that one is built around modules
+ * with `up`/`down`. Here there are flat `.sql` files, a status without applying,
+ * an error naming the failing statement and three transaction modes. Whoever is
+ * happy with `Migrator` takes `sqlFileMigrationProvider`.
+ */
+import { type Kysely } from 'kysely';
+/** Same as Kysely, so both runners see one state. */
+export declare const DEFAULT_JOURNAL_TABLE = "kysely_migration";
+/** The `pg_advisory_lock` key, the same as Kysely's `PostgresAdapter` uses. */
+export declare const MIGRATION_LOCK_ID = 3853314791062309107n;
+export type TransactionMode = 'all' | 'each' | 'none';
+export interface MigratorOptions {
+    /**
+     * A ready `Kysely` with any postgres dialect. Not a `Transaction`: the runner
+     * opens transactions and takes the lock itself.
+     */
+    readonly db: Kysely<any>;
+    /** The folder with `.sql` migrations, the same one `writeMigration` writes to. */
+    readonly migrationsDir: string;
+    /** The journal table. `kysely_migration` by default, like Kysely. */
+    readonly journalTable?: string;
+    /**
+     * `all` (default): the whole run in one transaction, like Kysely, so a failing
+     * migration rolls back the previous ones from the same run. `each`: a
+     * transaction per migration. `none`: no transactions, needed for
+     * `CREATE INDEX CONCURRENTLY`.
+     */
+    readonly transaction?: TransactionMode;
+    /**
+     * Allow migrations that sort before already applied ones (two branches each
+     * added a migration and merged out of name order). An error by default.
+     */
+    readonly allowUnordered?: boolean;
+}
+export interface MigrationStatus {
+    readonly applied: readonly string[];
+    readonly pending: readonly string[];
+}
+export interface MigrationRunResult {
+    /** What this particular run applied, in application order. */
+    readonly applied: readonly string[];
+}
+export interface SqlMigrator {
+    /** What is applied and what is pending. Also checks that the journal and the folder agree. */
+    status(): Promise<MigrationStatus>;
+    /** Applies everything pending. A failing statement throws `MigrationError`. */
+    toLatest(): Promise<MigrationRunResult>;
+}
+/** A failing statement: which migration, which query and what was applied before it. */
+export declare class MigrationError extends Error {
+    readonly migration: string;
+    readonly statement: string;
+    /** Migrations applied by this run before the error. With `transaction: 'all'` they are rolled back. */
+    readonly applied: readonly string[];
+    readonly name = "MigrationError";
+    constructor(migration: string, statement: string, 
+    /** Migrations applied by this run before the error. With `transaction: 'all'` they are rolled back. */
+    applied: readonly string[], cause: unknown);
+}
+export declare function createMigrator(options: MigratorOptions): SqlMigrator;
+/** `createMigrator(options).toLatest()` in one line. */
+export declare function migrateToLatest(options: MigratorOptions): Promise<MigrationRunResult>;

package/dist/kysely/runner.js

@@ -0,0 +1,169 @@
+/**
+ * A runner for `.sql` migrations on top of a ready `Kysely`.
+ *
+ * Kysely is the only abstraction over the driver: under `pg` that is
+ * `PostgresDialect`, under Bun any postgres dialect over `Bun.SQL` (the repository
+ * has a test one, `test/helpers/bun-dialect.ts`). The runner needs one connection
+ * for the whole run, the advisory lock and the transaction live on it, so it works
+ * through `db.connection()`.
+ *
+ * Compatible with Kysely's `Migrator`: the same `kysely_migration` journal
+ * (`name varchar(255)`, `timestamp varchar(255)` in ISO) and the same lock key as
+ * `PostgresAdapter`. The two runners can alternate on one database and will not
+ * run at the same time.
+ *
+ * Why a runner of our own when `Migrator` exists: that one is built around modules
+ * with `up`/`down`. Here there are flat `.sql` files, a status without applying,
+ * an error naming the failing statement and three transaction modes. Whoever is
+ * happy with `Migrator` takes `sqlFileMigrationProvider`.
+ */
+import { sql } from 'kysely';
+import { listMigrations, readStatements } from '../migrator/store.js';
+/** Same as Kysely, so both runners see one state. */
+export const DEFAULT_JOURNAL_TABLE = 'kysely_migration';
+/** The `pg_advisory_lock` key, the same as Kysely's `PostgresAdapter` uses. */
+export const MIGRATION_LOCK_ID = 3853314791062309107n;
+/** How long to wait for another run. An hour, like Kysely. */
+const LOCK_TIMEOUT_MS = 60 * 60 * 1000;
+/** A failing statement: which migration, which query and what was applied before it. */
+export class MigrationError extends Error {
+    migration;
+    statement;
+    applied;
+    name = 'MigrationError';
+    constructor(migration, statement, 
+    /** Migrations applied by this run before the error. With `transaction: 'all'` they are rolled back. */
+    applied, cause) {
+        super(`${migration}: statement failed\n${statement}\n${describe(cause)}`, { cause });
+        this.migration = migration;
+        this.statement = statement;
+        this.applied = applied;
+    }
+}
+function describe(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+export function createMigrator(options) {
+    const { db, migrationsDir: dir } = options;
+    if (db.isTransaction) {
+        throw new Error('createMigrator: pass a Kysely instance, not a Transaction: the runner manages transactions and the lock itself');
+    }
+    const journal = options.journalTable ?? DEFAULT_JOURNAL_TABLE;
+    if (!/^[a-z_][a-z0-9_]*$/i.test(journal)) {
+        throw new Error(`journalTable: "${journal}" may only contain letters, digits and underscores`);
+    }
+    const table = sql.table(journal);
+    const mode = options.transaction ?? 'all';
+    const allowUnordered = options.allowUnordered ?? false;
+    return {
+        status: () => db.connection().execute(async (connection) => {
+            await ensureJournal(connection, table);
+            return readState(connection, table, dir, allowUnordered);
+        }),
+        toLatest: () => db.connection().execute(connection => withLock(connection, async () => {
+            await ensureJournal(connection, table);
+            const state = await readState(connection, table, dir, allowUnordered);
+            return apply(connection, table, dir, state.pending, mode);
+        })),
+    };
+}
+/** `createMigrator(options).toLatest()` in one line. */
+export function migrateToLatest(options) {
+    return createMigrator(options).toLatest();
+}
+async function run(connection, statement) {
+    await sql.raw(statement).execute(connection);
+}
+async function withLock(connection, fn) {
+    // set_config(..., true) lasts until the end of the current transaction; outside BEGIN that is exactly one statement
+    await run(connection, `with set_timeout as (select set_config('lock_timeout', '${LOCK_TIMEOUT_MS}', true)) ` +
+        `select pg_advisory_lock(${MIGRATION_LOCK_ID}) from set_timeout`);
+    const unlock = `select pg_advisory_unlock(${MIGRATION_LOCK_ID})`;
+    let result;
+    try {
+        result = await fn();
+    }
+    catch (error) {
+        // if the connection died, the server released the lock itself; keeping the original error matters more
+        await run(connection, unlock).catch(() => undefined);
+        throw error;
+    }
+    await run(connection, unlock);
+    return result;
+}
+async function ensureJournal(connection, table) {
+    await sql `create table if not exists ${table} ("name" varchar(255) not null primary key, "timestamp" varchar(255) not null)`.execute(connection);
+}
+async function readState(connection, table, dir, allowUnordered) {
+    const files = listMigrations(dir);
+    const { rows } = await sql `select "name" from ${table}`.execute(connection);
+    // sort here, by character codes, like the files and like Kysely, not by the database collation
+    const applied = rows.map(row => row.name).toSorted();
+    const onDisk = new Set(files);
+    const missing = applied.filter(name => !onDisk.has(name));
+    if (missing.length > 0) {
+        throw new Error(`${dir}: the journal has migrations that are missing on disk: ${missing.join(', ')}. ` +
+            'Restore the files from history or delete the journal rows by hand.');
+    }
+    const done = new Set(applied);
+    const pending = files.filter(name => !done.has(name));
+    const last = applied.at(-1);
+    if (!allowUnordered && last !== undefined) {
+        const outOfOrder = pending.filter(name => name < last);
+        if (outOfOrder.length > 0) {
+            throw new Error(`${dir}: migrations ${outOfOrder.join(', ')} sort before the already applied ${last}. ` +
+                'Rename them with a newer timestamp or pass allowUnordered: true.');
+        }
+    }
+    return { applied, pending };
+}
+async function apply(connection, table, dir, pending, mode) {
+    const applied = [];
+    if (pending.length === 0) {
+        return { applied };
+    }
+    const runOne = async (name) => {
+        for (const statement of readStatements(dir, name)) {
+            try {
+                await run(connection, statement);
+            }
+            catch (error) {
+                throw new MigrationError(name, statement, [...applied], error);
+            }
+        }
+        await sql `insert into ${table} ("name", "timestamp") values (${name}, ${new Date().toISOString()})`.execute(connection);
+        applied.push(name);
+    };
+    // begin/commit by hand, on the same connection: PostgresDriver inside Kysely does the same
+    const inTransaction = async (fn) => {
+        await run(connection, 'begin');
+        try {
+            await fn();
+        }
+        catch (error) {
+            await run(connection, 'rollback').catch(() => undefined);
+            throw error;
+        }
+        await run(connection, 'commit');
+    };
+    switch (mode) {
+        case 'all':
+            await inTransaction(async () => {
+                for (const name of pending) {
+                    await runOne(name);
+                }
+            });
+            break;
+        case 'each':
+            for (const name of pending) {
+                await inTransaction(() => runOne(name));
+            }
+            break;
+        case 'none':
+            for (const name of pending) {
+                await runOne(name);
+            }
+            break;
+    }
+    return { applied };
+}

package/dist/migrator/store.d.ts

@@ -0,0 +1,17 @@
+import type { GenerateResult } from '../generator/generate.ts';
+import { type Snapshot } from '../generator/snapshot.ts';
+export declare const MIGRATION_EXTENSION = ".sql";
+export declare const SNAPSHOT_FILE = "snapshot.json";
+/**
+ * Separator between statements inside a file. It is an SQL comment, so the file
+ * stays valid when fed to psql as a whole.
+ */
+export declare const STATEMENT_SEPARATOR = "--> statement-breakpoint";
+export declare function migrationTimestamp(now?: Date): string;
+/** Migration names (without `.sql`), sorted the way Kysely sorts them: by character codes. */
+export declare function listMigrations(dir: string): string[];
+/** The schema state after the latest migration; the next diff is computed from it. */
+export declare function readLatestSnapshot(dir: string): Snapshot;
+export declare function readStatements(dir: string, name: string): string[];
+/** Writes the migration file, updates the snapshot and returns the migration name. */
+export declare function writeMigration(dir: string, name: string, result: GenerateResult): string;

package/dist/migrator/store.js

@@ -0,0 +1,96 @@
+/**
+ * Migrations on disk: flat `.sql` files next to a single snapshot.
+ *
+ * ```
+ * migrations/
+ *   20260910120000_init.sql
+ *   20260910123000_add_tickets.sql
+ *   snapshot.json
+ * ```
+ *
+ * There is no separate journal: the file list is the journal, and what has been
+ * applied is known to `kysely_migration` in the database itself. The file name
+ * without the extension is also the migration name for `Migrator`, hence the
+ * timestamp prefix: Kysely sorts migrations as strings.
+ *
+ * There is a single snapshot describing the state after the LATEST migration,
+ * which is all that is needed to compute the next diff. The price is merge
+ * conflicts: two branches that each add a migration diverge in one file, and
+ * the snapshot has to be regenerated after the merge.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { EMPTY_SNAPSHOT } from '../generator/snapshot.js';
+export const MIGRATION_EXTENSION = '.sql';
+export const SNAPSHOT_FILE = 'snapshot.json';
+/**
+ * Separator between statements inside a file. It is an SQL comment, so the file
+ * stays valid when fed to psql as a whole.
+ */
+export const STATEMENT_SEPARATOR = '--> statement-breakpoint';
+/** Parses the file name prefix back into a date. */
+function parseTimestamp(value) {
+    return new Date(Date.UTC(Number(value.slice(0, 4)), Number(value.slice(4, 6)) - 1, Number(value.slice(6, 8)), Number(value.slice(8, 10)), Number(value.slice(10, 12)), Number(value.slice(12, 14))));
+}
+/** `20260910123045`: Kysely sorts migrations by name, hence this prefix. */
+const pad = (value, width = 2) => String(value).padStart(width, '0');
+export function migrationTimestamp(now = new Date()) {
+    return (`${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}` +
+        `${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`);
+}
+/** Migration names (without `.sql`), sorted the way Kysely sorts them: by character codes. */
+export function listMigrations(dir) {
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    return fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter(entry => entry.isFile() && entry.name.endsWith(MIGRATION_EXTENSION))
+        .map(entry => entry.name.slice(0, -MIGRATION_EXTENSION.length))
+        .toSorted();
+}
+/** The schema state after the latest migration; the next diff is computed from it. */
+export function readLatestSnapshot(dir) {
+    const file = path.join(dir, SNAPSHOT_FILE);
+    if (!fs.existsSync(file)) {
+        if (listMigrations(dir).length > 0) {
+            throw new Error(`${dir}: migrations exist but ${SNAPSHOT_FILE} is missing. ` +
+                'Without it there is nothing to diff against: restore the file from history.');
+        }
+        return EMPTY_SNAPSHOT;
+    }
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+export function readStatements(dir, name) {
+    const text = fs.readFileSync(path.join(dir, `${name}${MIGRATION_EXTENSION}`), 'utf8');
+    return text
+        .split(STATEMENT_SEPARATOR)
+        .map(statement => statement.trim())
+        .filter(statement => statement !== '');
+}
+/** Writes the migration file, updates the snapshot and returns the migration name. */
+export function writeMigration(dir, name, result) {
+    if (result.statements.length === 0) {
+        throw new Error('nothing to write: no changes');
+    }
+    if (!/^[a-z0-9_]+$/.test(name)) {
+        throw new Error(`migration name "${name}": only [a-z0-9_] is allowed`);
+    }
+    // Names must grow monotonically: Kysely applies migrations in alphabetical
+    // order. Two migrations created within the same second would get the same
+    // prefix, and the suffix would decide the order, that is, by luck.
+    const previous = listMigrations(dir).at(-1);
+    let stamp = migrationTimestamp();
+    if (previous !== undefined && stamp <= previous.slice(0, 14)) {
+        stamp = migrationTimestamp(new Date(parseTimestamp(previous.slice(0, 14)).getTime() + 1000));
+    }
+    const migration = `${stamp}_${name}`;
+    const file = path.join(dir, `${migration}${MIGRATION_EXTENSION}`);
+    if (fs.existsSync(file)) {
+        throw new Error(`migration ${migration} already exists`);
+    }
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, `${result.statements.join(`\n${STATEMENT_SEPARATOR}\n`)}\n`);
+    fs.writeFileSync(path.join(dir, SNAPSHOT_FILE), `${JSON.stringify(result.snapshot, null, 2)}\n`);
+    return migration;
+}

package/dist/table/casing.d.ts

@@ -0,0 +1,26 @@
+/**
+ * snake_case and camelCase at the type level and at runtime, following the
+ * rules of Kysely's `CamelCasePlugin` with default options. This way the names
+ * derived from schema properties and the type keys under the plugin match what
+ * the plugin does to identifiers and result rows:
+ *
+ *   createdAt  -> created_at  -> createdAt
+ *   appleID    -> apple_id    -> appleId       consecutive capitals are not split
+ *   parseJSONValue -> parse_jsonvalue           the boundary after an acronym is lost
+ *   line2Total -> line2_total -> line2Total
+ *
+ * Names with an underscore before a digit (`field_2` -> `field2`) and with a
+ * leading underscore do not round-trip, exactly the plugin's own limitations.
+ */
+type IsUpper<C extends string> = C extends Uppercase<C> ? (C extends Lowercase<C> ? false : true) : false;
+type SnakeInner<S extends string, PrevUpper extends boolean, Acc extends string> = S extends `${infer C}${infer R}` ? IsUpper<C> extends true ? SnakeInner<R, true, `${Acc}${PrevUpper extends true ? '' : '_'}${Lowercase<C>}`> : SnakeInner<R, false, `${Acc}${C}`> : Acc;
+/** `createdAt` -> `created_at`. The first letter is lowercased without an underscore. */
+export type SnakeCase<S extends string> = S extends `${infer C}${infer R}` ? SnakeInner<R, IsUpper<C>, Lowercase<C>> : S;
+type CamelInner<S extends string, AfterUnderscore extends boolean, Acc extends string> = S extends `${infer C}${infer R}` ? C extends '_' ? CamelInner<R, true, Acc> : CamelInner<R, false, `${Acc}${AfterUnderscore extends true ? Uppercase<C> : C}`> : Acc;
+/** `created_at` -> `createdAt`. The first character stays as is, like the plugin does. */
+export type CamelCase<S extends string> = S extends `${infer C}${infer R}` ? CamelInner<R, C extends '_' ? true : false, C> : S;
+/** Runtime counterpart of `SnakeCase`: the same algorithm as `CamelCasePlugin`. */
+export declare function toSnakeCase(input: string): string;
+/** Runtime counterpart of `CamelCase`: this is how the plugin renames result row keys. */
+export declare function toCamelCase(input: string): string;
+export {};

package/dist/table/casing.js

@@ -0,0 +1,43 @@
+/**
+ * snake_case and camelCase at the type level and at runtime, following the
+ * rules of Kysely's `CamelCasePlugin` with default options. This way the names
+ * derived from schema properties and the type keys under the plugin match what
+ * the plugin does to identifiers and result rows:
+ *
+ *   createdAt  -> created_at  -> createdAt
+ *   appleID    -> apple_id    -> appleId       consecutive capitals are not split
+ *   parseJSONValue -> parse_jsonvalue           the boundary after an acronym is lost
+ *   line2Total -> line2_total -> line2Total
+ *
+ * Names with an underscore before a digit (`field_2` -> `field2`) and with a
+ * leading underscore do not round-trip, exactly the plugin's own limitations.
+ */
+function isUpper(char) {
+    return char === char.toUpperCase() && char !== char.toLowerCase();
+}
+/** Runtime counterpart of `SnakeCase`: the same algorithm as `CamelCasePlugin`. */
+export function toSnakeCase(input) {
+    let out = input.charAt(0).toLowerCase();
+    for (let i = 1; i < input.length; i++) {
+        const char = input.charAt(i);
+        if (isUpper(char)) {
+            out += isUpper(input.charAt(i - 1)) ? char.toLowerCase() : `_${char.toLowerCase()}`;
+        }
+        else {
+            out += char;
+        }
+    }
+    return out;
+}
+/** Runtime counterpart of `CamelCase`: this is how the plugin renames result row keys. */
+export function toCamelCase(input) {
+    let out = input.charAt(0);
+    for (let i = 1; i < input.length; i++) {
+        const char = input.charAt(i);
+        if (char === '_') {
+            continue;
+        }
+        out += input.charAt(i - 1) === '_' ? char.toUpperCase() : char;
+    }
+    return out;
+}