kysely-ddl 0.1.0

package/dist/generator/diff.js

@@ -0,0 +1,162 @@
+function byName(items) {
+    return new Map(items.map(item => [item.name, item]));
+}
+function sameArray(a, b) {
+    return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function sameConstraint(a, b) {
+    if (a.type !== b.type) {
+        return false;
+    }
+    if (a.type === 'check' && b.type === 'check') {
+        return a.def.expression === b.def.expression;
+    }
+    if (a.type === 'foreignKey' && b.type === 'foreignKey') {
+        return (sameArray(a.def.columns, b.def.columns) &&
+            a.def.refTable === b.def.refTable &&
+            sameArray(a.def.refColumns, b.def.refColumns) &&
+            a.def.onDelete === b.def.onDelete &&
+            a.def.onUpdate === b.def.onUpdate);
+    }
+    if ((a.type === 'primaryKey' || a.type === 'unique') &&
+        (b.type === 'primaryKey' || b.type === 'unique')) {
+        return sameArray(a.def.columns, b.def.columns);
+    }
+    return false;
+}
+function sameIndex(a, b) {
+    return a.unique === b.unique && sameArray(a.columns, b.columns) && a.where === b.where;
+}
+function sameColumn(a, b) {
+    return (a.type === b.type &&
+        a.notNull === b.notNull &&
+        a.default === b.default &&
+        a.identity === b.identity);
+}
+/** All constraints of a table in one list: their names share one namespace. */
+function constraintsOf(table, opts) {
+    const list = [];
+    if (table.primaryKey !== null) {
+        list.push({ type: 'primaryKey', def: table.primaryKey });
+    }
+    for (const def of table.uniques) {
+        list.push({ type: 'unique', def });
+    }
+    for (const def of table.checks) {
+        list.push({ type: 'check', def });
+    }
+    if (opts.withForeignKeys) {
+        for (const def of table.foreignKeys) {
+            list.push({ type: 'foreignKey', def });
+        }
+    }
+    return list;
+}
+export function diffSnapshots(prev, next) {
+    const prevTables = byName(prev.tables);
+    const nextTables = byName(next.tables);
+    const dropIndexes = [];
+    const dropConstraints = [];
+    const createTables = [];
+    const addColumns = [];
+    const alterColumns = [];
+    const addConstraints = [];
+    const createIndexes = [];
+    const addForeignKeys = [];
+    const dropColumns = [];
+    const dropTables = [];
+    // ── new tables ─────────────────────────────────────────────────────────────
+    for (const table of next.tables) {
+        if (prevTables.has(table.name)) {
+            continue;
+        }
+        // pk / unique / check go inside CREATE TABLE, fk and indexes separately
+        createTables.push({ kind: 'createTable', table });
+        for (const index of table.indexes) {
+            createIndexes.push({ kind: 'createIndex', table: table.name, index });
+        }
+        for (const def of table.foreignKeys) {
+            addForeignKeys.push({
+                kind: 'addConstraint',
+                table: table.name,
+                constraint: { type: 'foreignKey', def },
+            });
+        }
+    }
+    // ── dropped tables ─────────────────────────────────────────────────────────
+    for (const table of prev.tables) {
+        if (!nextTables.has(table.name)) {
+            dropTables.push({ kind: 'dropTable', table: table.name });
+        }
+    }
+    // ── existing tables ────────────────────────────────────────────────────────
+    for (const after of next.tables) {
+        const before = prevTables.get(after.name);
+        if (before === undefined) {
+            continue;
+        }
+        const beforeColumns = byName(before.columns);
+        const afterColumns = byName(after.columns);
+        for (const column of after.columns) {
+            const old = beforeColumns.get(column.name);
+            if (old === undefined) {
+                addColumns.push({ kind: 'addColumn', table: after.name, column });
+            }
+            else if (!sameColumn(old, column)) {
+                alterColumns.push({ kind: 'alterColumn', table: after.name, from: old, to: column });
+            }
+        }
+        for (const column of before.columns) {
+            if (!afterColumns.has(column.name)) {
+                dropColumns.push({ kind: 'dropColumn', table: after.name, column: column.name });
+            }
+        }
+        const beforeConstraints = byName(constraintsOf(before, { withForeignKeys: true }).map(c => ({ name: c.def.name, c })));
+        const afterConstraints = constraintsOf(after, { withForeignKeys: true });
+        const afterNames = new Set(afterConstraints.map(c => c.def.name));
+        for (const constraint of afterConstraints) {
+            const old = beforeConstraints.get(constraint.def.name);
+            if (old === undefined) {
+                const target = constraint.type === 'foreignKey' ? addForeignKeys : addConstraints;
+                target.push({ kind: 'addConstraint', table: after.name, constraint });
+            }
+            else if (!sameConstraint(old.c, constraint)) {
+                addConstraints.push({ kind: 'replaceConstraint', table: after.name, constraint });
+            }
+        }
+        for (const [name] of beforeConstraints) {
+            if (!afterNames.has(name)) {
+                dropConstraints.push({ kind: 'dropConstraint', table: after.name, name });
+            }
+        }
+        const beforeIndexes = byName(before.indexes);
+        const afterIndexes = byName(after.indexes);
+        for (const index of after.indexes) {
+            const old = beforeIndexes.get(index.name);
+            if (old === undefined) {
+                createIndexes.push({ kind: 'createIndex', table: after.name, index });
+            }
+            else if (!sameIndex(old, index)) {
+                dropIndexes.push({ kind: 'dropIndex', index: index.name });
+                createIndexes.push({ kind: 'createIndex', table: after.name, index });
+            }
+        }
+        for (const index of before.indexes) {
+            if (!afterIndexes.has(index.name)) {
+                dropIndexes.push({ kind: 'dropIndex', index: index.name });
+            }
+        }
+    }
+    return [
+        ...dropIndexes,
+        ...dropConstraints,
+        ...createTables,
+        ...addColumns,
+        ...alterColumns,
+        ...addConstraints,
+        ...createIndexes,
+        ...addForeignKeys,
+        ...dropColumns,
+        ...dropTables,
+    ];
+}

package/dist/generator/generate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Facade: schema + previous snapshot -> migration SQL and the new snapshot.
+ *
+ * How to write it to disk and how to apply it is not this function's concern.
+ */
+import type { AnyTable } from '../table/define.ts';
+import { type Change } from './diff.ts';
+import { type Snapshot } from './snapshot.ts';
+export interface GenerateResult {
+    /** Migration SQL; an empty string means no changes. */
+    readonly sql: string;
+    /** The same SQL as individual statements; the runner executes these. */
+    readonly statements: readonly string[];
+    /** The snapshot to store next to the migration. */
+    readonly snapshot: Snapshot;
+    /** Parsed changes; handy for tests and for a "what changed" summary. */
+    readonly changes: readonly Change[];
+}
+export declare function generateMigration(tables: readonly AnyTable[], previous?: Snapshot): GenerateResult;

package/dist/generator/generate.js

@@ -0,0 +1,8 @@
+import { diffSnapshots } from './diff.js';
+import { renderChanges, renderStatements } from './render.js';
+import { buildSnapshot, EMPTY_SNAPSHOT } from './snapshot.js';
+export function generateMigration(tables, previous = EMPTY_SNAPSHOT) {
+    const snapshot = buildSnapshot(tables);
+    const changes = diffSnapshots(previous, snapshot);
+    return { sql: renderChanges(changes), statements: renderStatements(changes), snapshot, changes };
+}

package/dist/generator/render.d.ts

@@ -0,0 +1,6 @@
+import type { Change } from './diff.ts';
+export declare function renderChange(change: Change): string[];
+/** Individual statements; `writeMigration` writes these to disk. */
+export declare function renderStatements(changes: readonly Change[]): string[];
+/** Multi-line statements are separated by a blank line, single-line ones follow each other. */
+export declare function renderChanges(changes: readonly Change[]): string;

package/dist/generator/render.js

@@ -0,0 +1,137 @@
+/**
+ * Changes -> SQL. Decides nothing, only prints: all decisions are made in diff.ts.
+ */
+import { quoteIdentifier as q } from '../table/sql.js';
+/** Every variant is handled above; TypeScript does not let control get here. */
+function unreachable(value) {
+    throw new Error(`unknown variant: ${JSON.stringify(value)}`);
+}
+function columns(names) {
+    return names.map(q).join(',');
+}
+function columnLine(column) {
+    const parts = [q(column.name), column.type];
+    if (column.default !== null) {
+        parts.push(`DEFAULT ${column.default}`);
+    }
+    if (column.identity !== null) {
+        parts.push(`GENERATED ${column.identity === 'always' ? 'ALWAYS' : 'BY DEFAULT'} AS IDENTITY`);
+    }
+    if (column.notNull) {
+        parts.push('NOT NULL');
+    }
+    return parts.join(' ');
+}
+/** Constraint body without the CONSTRAINT keyword and the name. */
+function constraintBody(constraint) {
+    switch (constraint.type) {
+        case 'primaryKey':
+            return `PRIMARY KEY(${columns(constraint.def.columns)})`;
+        case 'unique':
+            return `UNIQUE(${columns(constraint.def.columns)})`;
+        case 'check':
+            return `CHECK (${constraint.def.expression})`;
+        case 'foreignKey': {
+            const { def } = constraint;
+            const parts = [
+                `FOREIGN KEY (${columns(def.columns)})`,
+                `REFERENCES ${q(def.refTable)}(${columns(def.refColumns)})`,
+            ];
+            if (def.onDelete !== null) {
+                parts.push(`ON DELETE ${def.onDelete.toUpperCase()}`);
+            }
+            if (def.onUpdate !== null) {
+                parts.push(`ON UPDATE ${def.onUpdate.toUpperCase()}`);
+            }
+            return parts.join(' ');
+        }
+        default:
+            return unreachable(constraint);
+    }
+}
+function constraintClause(constraint) {
+    return `CONSTRAINT ${q(constraint.def.name)} ${constraintBody(constraint)}`;
+}
+function createTable(table) {
+    const lines = table.columns.map(columnLine);
+    if (table.primaryKey !== null) {
+        lines.push(constraintClause({ type: 'primaryKey', def: table.primaryKey }));
+    }
+    for (const def of table.uniques) {
+        lines.push(constraintClause({ type: 'unique', def }));
+    }
+    for (const def of table.checks) {
+        lines.push(constraintClause({ type: 'check', def }));
+    }
+    return `CREATE TABLE ${q(table.name)} (\n${lines.map(l => `\t${l}`).join(',\n')}\n);`;
+}
+function createIndex(table, index) {
+    const unique = index.unique ? 'UNIQUE ' : '';
+    const where = index.where === null ? '' : ` WHERE ${index.where}`;
+    return `CREATE ${unique}INDEX ${q(index.name)} ON ${q(table)} (${columns(index.columns)})${where};`;
+}
+function alterColumn(table, from, to) {
+    const head = `ALTER TABLE ${q(table)} ALTER COLUMN ${q(to.name)}`;
+    const out = [];
+    if (from.type !== to.type) {
+        out.push(`${head} TYPE ${to.type};`);
+    }
+    if (from.default !== to.default) {
+        out.push(to.default === null ? `${head} DROP DEFAULT;` : `${head} SET DEFAULT ${to.default};`);
+    }
+    if (from.notNull !== to.notNull) {
+        out.push(to.notNull ? `${head} SET NOT NULL;` : `${head} DROP NOT NULL;`);
+    }
+    if (from.identity !== to.identity) {
+        out.push(to.identity === null
+            ? `${head} DROP IDENTITY;`
+            : `${head} ADD GENERATED ${to.identity === 'always' ? 'ALWAYS' : 'BY DEFAULT'} AS IDENTITY;`);
+    }
+    return out;
+}
+export function renderChange(change) {
+    switch (change.kind) {
+        case 'createTable':
+            return [createTable(change.table)];
+        case 'dropTable':
+            return [`DROP TABLE ${q(change.table)};`];
+        case 'addColumn':
+            return [`ALTER TABLE ${q(change.table)} ADD COLUMN ${columnLine(change.column)};`];
+        case 'dropColumn':
+            return [`ALTER TABLE ${q(change.table)} DROP COLUMN ${q(change.column)};`];
+        case 'alterColumn':
+            return alterColumn(change.table, change.from, change.to);
+        case 'addConstraint':
+            return [`ALTER TABLE ${q(change.table)} ADD ${constraintClause(change.constraint)};`];
+        case 'dropConstraint':
+            return [`ALTER TABLE ${q(change.table)} DROP CONSTRAINT ${q(change.name)};`];
+        case 'replaceConstraint':
+            return [
+                `ALTER TABLE ${q(change.table)} DROP CONSTRAINT ${q(change.constraint.def.name)}, ` +
+                    `ADD ${constraintClause(change.constraint)};`,
+            ];
+        case 'createIndex':
+            return [createIndex(change.table, change.index)];
+        case 'dropIndex':
+            return [`DROP INDEX ${q(change.index)};`];
+        default:
+            return unreachable(change);
+    }
+}
+/** Individual statements; `writeMigration` writes these to disk. */
+export function renderStatements(changes) {
+    return changes.flatMap(renderChange);
+}
+/** Multi-line statements are separated by a blank line, single-line ones follow each other. */
+export function renderChanges(changes) {
+    const statements = renderStatements(changes);
+    let out = '';
+    statements.forEach((statement, i) => {
+        if (i > 0) {
+            const previous = statements[i - 1] ?? '';
+            out += previous.includes('\n') || statement.includes('\n') ? '\n\n' : '\n';
+        }
+        out += statement;
+    });
+    return out === '' ? '' : `${out}\n`;
+}

package/dist/generator/snapshot.d.ts

@@ -0,0 +1,48 @@
+import type { AnyTable, ReferentialAction } from '../table/define.ts';
+export declare const SNAPSHOT_VERSION = 1;
+export interface ColumnSnapshot {
+    readonly name: string;
+    /** The final postgres type, including `[]` for arrays. */
+    readonly type: string;
+    readonly notNull: boolean;
+    /** The rendered default SQL, or null. */
+    readonly default: string | null;
+    readonly identity: 'always' | 'byDefault' | null;
+}
+export interface TableSnapshot {
+    readonly name: string;
+    readonly columns: readonly ColumnSnapshot[];
+    readonly primaryKey: {
+        readonly name: string;
+        readonly columns: readonly string[];
+    } | null;
+    readonly uniques: readonly {
+        readonly name: string;
+        readonly columns: readonly string[];
+    }[];
+    readonly indexes: readonly {
+        readonly name: string;
+        readonly unique: boolean;
+        readonly columns: readonly string[];
+        readonly where: string | null;
+    }[];
+    readonly foreignKeys: readonly {
+        readonly name: string;
+        readonly columns: readonly string[];
+        readonly refTable: string;
+        readonly refColumns: readonly string[];
+        readonly onDelete: ReferentialAction | null;
+        readonly onUpdate: ReferentialAction | null;
+    }[];
+    readonly checks: readonly {
+        readonly name: string;
+        readonly expression: string;
+    }[];
+}
+export interface Snapshot {
+    readonly version: number;
+    readonly tables: readonly TableSnapshot[];
+}
+export declare const EMPTY_SNAPSHOT: Snapshot;
+/** Schema (a list of tables) -> snapshot. */
+export declare function buildSnapshot(tables: readonly AnyTable[]): Snapshot;

package/dist/generator/snapshot.js

@@ -0,0 +1,54 @@
+import { isSql, quoteLiteral, renderSql } from '../table/sql.js';
+export const SNAPSHOT_VERSION = 1;
+export const EMPTY_SNAPSHOT = { version: SNAPSHOT_VERSION, tables: [] };
+function renderDefault(value) {
+    if (value === undefined) {
+        return null;
+    }
+    if (isSql(value)) {
+        return renderSql(value);
+    }
+    return quoteLiteral(value);
+}
+function tableSnapshot(spec) {
+    return {
+        name: spec.name,
+        columns: spec.columns.map(column => ({
+            name: column.name,
+            type: column.array ? `${column.sqlType}[]` : column.sqlType,
+            notNull: column.notNull,
+            default: renderDefault(column.default),
+            identity: column.identity ?? null,
+        })),
+        primaryKey: spec.primaryKey !== undefined
+            ? { name: spec.primaryKey.name, columns: [...spec.primaryKey.columns] }
+            : null,
+        uniques: spec.uniques.map(u => ({ name: u.name, columns: [...u.columns] })),
+        indexes: spec.indexes.map(i => ({
+            name: i.name,
+            unique: i.unique,
+            columns: [...i.columns],
+            where: i.where !== undefined ? renderSql(i.where) : null,
+        })),
+        foreignKeys: spec.foreignKeys.map(f => ({
+            name: f.name,
+            columns: [...f.columns],
+            refTable: f.refTable,
+            refColumns: [...f.refColumns],
+            onDelete: f.onDelete ?? null,
+            onUpdate: f.onUpdate ?? null,
+        })),
+        checks: spec.checks.map(c => ({ name: c.name, expression: renderSql(c.expression) })),
+    };
+}
+/** Schema (a list of tables) -> snapshot. */
+export function buildSnapshot(tables) {
+    const seen = new Set();
+    for (const table of tables) {
+        if (seen.has(table.spec.name)) {
+            throw new Error(`table "${table.spec.name}" is declared twice`);
+        }
+        seen.add(table.spec.name);
+    }
+    return { version: SNAPSHOT_VERSION, tables: tables.map(t => tableSnapshot(t.spec)) };
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * kysely-ddl: PostgreSQL schema as code and SQL migration generation.
+ * Has no runtime dependency on Kysely or on any driver.
+ *
+ * Layers and dependency direction:
+ *
+ *   table ◄── generator ◄── migrator ◄── kysely
+ *
+ * Entry points:
+ *
+ *   kysely-ddl         — this file: tables, generation, migration files
+ *   kysely-ddl/kysely  — row types, migration runner, provider for Migrator
+ *
+ * Exports are sorted by module path: generator (snapshot, diff, render,
+ * facade), migrator (files on disk), table (table definitions).
+ */
+export { diffSnapshots } from './generator/diff.ts';
+export type { Change, Constraint } from './generator/diff.ts';
+export { generateMigration } from './generator/generate.ts';
+export type { GenerateResult } from './generator/generate.ts';
+export { renderChange, renderChanges, renderStatements } from './generator/render.ts';
+export { buildSnapshot, EMPTY_SNAPSHOT, SNAPSHOT_VERSION } from './generator/snapshot.ts';
+export type { ColumnSnapshot, Snapshot, TableSnapshot } from './generator/snapshot.ts';
+export { listMigrations, MIGRATION_EXTENSION, migrationTimestamp, readLatestSnapshot, readStatements, SNAPSHOT_FILE, STATEMENT_SEPARATOR, writeMigration, } from './migrator/store.ts';
+export { toCamelCase, toSnakeCase } from './table/casing.ts';
+export type { CamelCase, SnakeCase } from './table/casing.ts';
+export { ColumnBuilder, columnBuilders } from './table/columns.ts';
+export type { AnyColumn, ColumnBuilders, ColumnCfg, ColumnSpec, DefaultValue } from './table/columns.ts';
+export { AUTO_NAMES, defineTable, ref } from './table/define.ts';
+export type { AnyTable, ForeignKeyDef, Reference, ReferentialAction, ResolveColumns, ResolvedColumn, ResolvedColumnCfg, Table, TableOptions, TableSpec, } from './table/define.ts';
+export { assertIdentifier, autoName, fitIdentifier, MAX_IDENTIFIER_BYTES } from './table/identifier.ts';
+export { collectColumns, inArray, quoteIdentifier, quoteLiteral, renderSql, sql } from './table/sql.ts';
+export type { ColumnRef, Literal, Sql, SqlChunk } from './table/sql.ts';

package/dist/index.js

@@ -0,0 +1,26 @@
+/**
+ * kysely-ddl: PostgreSQL schema as code and SQL migration generation.
+ * Has no runtime dependency on Kysely or on any driver.
+ *
+ * Layers and dependency direction:
+ *
+ *   table ◄── generator ◄── migrator ◄── kysely
+ *
+ * Entry points:
+ *
+ *   kysely-ddl         — this file: tables, generation, migration files
+ *   kysely-ddl/kysely  — row types, migration runner, provider for Migrator
+ *
+ * Exports are sorted by module path: generator (snapshot, diff, render,
+ * facade), migrator (files on disk), table (table definitions).
+ */
+export { diffSnapshots } from './generator/diff.js';
+export { generateMigration } from './generator/generate.js';
+export { renderChange, renderChanges, renderStatements } from './generator/render.js';
+export { buildSnapshot, EMPTY_SNAPSHOT, SNAPSHOT_VERSION } from './generator/snapshot.js';
+export { listMigrations, MIGRATION_EXTENSION, migrationTimestamp, readLatestSnapshot, readStatements, SNAPSHOT_FILE, STATEMENT_SEPARATOR, writeMigration, } from './migrator/store.js';
+export { toCamelCase, toSnakeCase } from './table/casing.js';
+export { ColumnBuilder, columnBuilders } from './table/columns.js';
+export { AUTO_NAMES, defineTable, ref } from './table/define.js';
+export { assertIdentifier, autoName, fitIdentifier, MAX_IDENTIFIER_BYTES } from './table/identifier.js';
+export { collectColumns, inArray, quoteIdentifier, quoteLiteral, renderSql, sql } from './table/sql.js';

package/dist/kysely/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Everything tied to Kysely: row types, jsonb values, the migration runner on
+ * top of a ready `Kysely`, and the `.sql` file provider for the built-in `Migrator`.
+ * Entry point `kysely-ddl/kysely`.
+ */
+export type { inferKyselyDatabase, inferKyselyTable } from './infer.ts';
+export { jsonb, jsonbArray } from './json.ts';
+export type { Jsonb } from './json.ts';
+export { sqlFileMigrationProvider } from './provider.ts';
+export type { SqlMigrationProviderOptions } from './provider.ts';
+export { createMigrator, DEFAULT_JOURNAL_TABLE, migrateToLatest, MIGRATION_LOCK_ID, MigrationError, } from './runner.ts';
+export type { MigrationRunResult, MigrationStatus, MigratorOptions, SqlMigrator, TransactionMode } from './runner.ts';

package/dist/kysely/index.js

@@ -0,0 +1,3 @@
+export { jsonb, jsonbArray } from './json.js';
+export { sqlFileMigrationProvider } from './provider.js';
+export { createMigrator, DEFAULT_JOURNAL_TABLE, migrateToLatest, MIGRATION_LOCK_ID, MigrationError, } from './runner.js';

package/dist/kysely/infer.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Table types for Kysely, like zod's `z.infer`:
+ *
+ * ```ts
+ * type UserTable = inferKyselyTable<typeof userTable>;
+ * type DB = inferKyselyDatabase<typeof schema>;
+ *
+ * const db = new Kysely<DB>({ dialect });
+ * ```
+ *
+ * Keys are the COLUMN NAMES IN THE DATABASE. They are known at the type level
+ * because `defineTable` keeps them as literals, so the bridge does not depend on
+ * casing plugins or on conventions shared between two libraries.
+ *
+ * When Kysely runs with `CamelCasePlugin`, pass `true` as the second parameter:
+ * the column and table keys then become camelCase versions of the database names,
+ * exactly as the plugin rewrites them with default options:
+ *
+ * ```ts
+ * type DB = inferKyselyDatabase<typeof schema, true>;
+ * const db = new Kysely<DB>({ dialect, plugins: [new CamelCasePlugin()] });
+ * ```
+ *
+ * `kysely` is imported as a type only; there is no runtime dependency.
+ */
+import type { CamelCase } from '../table/casing.ts';
+import type { ResolvedColumnCfg, Table } from '../table/define.ts';
+import type { Jsonb } from './json.ts';
+import type { ColumnType } from 'kysely';
+type Cols<T extends Table> = T['_']['columns'];
+/** The key in the Kysely interface: the database name or, under `CamelCasePlugin`, its camelCase. */
+type Key<Name extends string, Camel extends boolean> = Camel extends true ? CamelCase<Name> : Name;
+/** What comes back from SELECT. */
+type Select<C extends ResolvedColumnCfg> = C['notNull'] extends true ? C['data'] : C['data'] | null;
+type ElementOf<T> = T extends readonly (infer E)[] ? E : never;
+/**
+ * What goes into INSERT / UPDATE before nullability and defaults are applied. For
+ * jsonb this is branded JSON text: only `jsonb()` produces it (`jsonbArray()` for
+ * `jsonb[]`), a raw object or string does not compile.
+ */
+type Written<C extends ResolvedColumnCfg> = C['json'] extends true ? C['array'] extends true ? Jsonb<ElementOf<C['data']>>[] : Jsonb<C['data']> : C['data'];
+/**
+ * What can be passed for a write:
+ *   identity always          -> not at all;
+ *   notNull without default  -> required field;
+ *   has a default            -> optional;
+ *   nullable                 -> optional and accepts null.
+ */
+type Insert<C extends ResolvedColumnCfg> = C['identity'] extends 'always' ? never : C['notNull'] extends true ? C['hasDefault'] extends true ? Written<C> | undefined : Written<C> : Written<C> | null | undefined;
+export type inferKyselyTable<T extends Table, Camel extends boolean = false> = {
+    [K in keyof Cols<T> as Key<Cols<T>[K]['name'], Camel>]: ColumnType<Select<Cols<T>[K]>, Insert<Cols<T>[K]>, Insert<Cols<T>[K]>>;
+};
+/**
+ * The interface of the whole database from a schema module: the key is the table
+ * name, the value is `inferKyselyTable`. Anything that is not a table (constants,
+ * types, zod schemas) is filtered out.
+ */
+export type inferKyselyDatabase<TSchema, Camel extends boolean = false> = {
+    [K in keyof TSchema as TSchema[K] extends Table ? Key<TSchema[K]['_']['name'], Camel> : never]: TSchema[K] extends Table ? inferKyselyTable<TSchema[K], Camel> : never;
+};
+export {};

package/dist/kysely/infer.js

@@ -0,0 +1 @@
+export {};

package/dist/kysely/json.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { type RawBuilder } from 'kysely';
+/** JSON text for a jsonb column. From the outside it is only produced by `jsonb()`. */
+export type Jsonb<T> = string & {
+    readonly __jsonb: T;
+};
+/**
+ * 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 declare function jsonb<T extends {}>(value: T): RawBuilder<Jsonb<T>>;
+/** A value for a `jsonb[]` column: each element is a separate JSON value, `null` inside is JSON null. */
+export declare function jsonbArray<T>(values: readonly T[]): RawBuilder<Jsonb<T>[]>;
+/**
+ * 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 declare function pgArrayLiteral(values: readonly (string | null)[]): string;