flint-orm 0.4.0 → 0.4.2

package/API.md

@@ -110,7 +110,9 @@ text()
   .unique() // UNIQUE
   .default('hello') // DEFAULT 'hello'
   .defaultFn(() => new Date()) // DEFAULT (computed at insert)
-  .references(otherColumn); // REFERENCES
+  .references(otherColumn) // REFERENCES otherColumn
+  .onDelete('cascade') // ON DELETE CASCADE
+  .onUpdate('set null'); // ON UPDATE SET NULL
 ```
 
 **Integer-only:**
@@ -591,6 +593,9 @@ import { addTable, dropTable, renameTable, addColumn, dropColumn, renameColumn,
 | `renameColumn` | `ALTER TABLE ... RENAME COLUMN ... TO` |
 | `createIndex`  | `CREATE [UNIQUE] INDEX ...`            |
 | `dropIndex`    | `DROP INDEX ...`                       |
+| `modifyColumn` | `ALTER TABLE ... ALTER COLUMN ...`     |
+| `modifyIndex`  | `DROP INDEX IF EXISTS ...; CREATE ...` |
+| `rebuildTable` | Temp table → copy → drop → rename     |
 
 ---
 
@@ -606,6 +611,7 @@ import { addTable, dropTable, renameTable, addColumn, dropColumn, renameColumn,
 | `SQLExpression`   | `{ sql: string; params: unknown[] }`                                                      |
 | `Executable`      | Anything with a `.toSQL()` method (for `batch()`)                                         |
 | `Driver`          | `'bun-sqlite' \| 'better-sqlite3' \| 'libsql' \| 'libsql-web' \| 'turso' \| 'turso-sync'` |
+| `RebuildTableOp`  | Migration op that recreates a table with a new schema                                     |
 
 ---
 

package/README.md

@@ -78,6 +78,8 @@ const posts = table('posts', {
 - `.default(value)` — static default value
 - `.defaultFn(fn)` — dynamic default (called on insert when value is omitted)
 - `.references(target)` — foreign key reference
+- `.onDelete(action)` — foreign key ON DELETE action (`cascade`, `set null`, `set default`, `restrict`, `no action`)
+- `.onUpdate(action)` — foreign key ON UPDATE action (`cascade`, `set null`, `set default`, `restrict`, `no action`)
 - `.autoIncrement()` — integer auto-increment (integer columns only)
 - `.defaultNow()` — use `Date.now()` as default (date columns only)
 - `.onUpdateTimestamp()` — always set to `Date.now()` on update (date columns only)
@@ -323,7 +325,7 @@ flint migrate --dry-run     # show what would run
 5. Writes a migration folder with `migration.ts` (operations) + `state.json` (snapshot)
 6. `flint migrate` reads pending migrations and executes them in order
 
-Unsafe changes (type changes, primary key changes) throw an error and must be handled manually.
+Unsafe changes (type changes, primary key changes, FK modifications, UNIQUE changes, DEFAULT removal) automatically emit a `rebuildTable` operation that recreates the table with the new schema and copies data safely within a transaction.
 
 ## Subpath Imports
 

package/dist/config.d.ts

@@ -0,0 +1,30 @@
+export type Driver = 'bun-sqlite' | 'better-sqlite3' | 'libsql' | 'libsql-web' | 'turso-sync' | 'turso';
+export interface DatabaseConfig {
+    /** Path or URL to the SQLite database. */
+    url: string;
+    /** Auth token (required for libsql, libsql-web, turso-sync drivers). */
+    authToken?: string;
+}
+export interface FlintConfig {
+    /** Which SQLite driver to use. */
+    driver: Driver;
+    /** Database connection details. */
+    database: DatabaseConfig;
+    /** Path to schema folder or file containing table() exports. */
+    schema: string;
+    /** Path to the migrations directory. Defaults to "./flint". */
+    migrations?: string;
+}
+/**
+ * Define a flint-orm config.
+ *
+ * @example
+ * import { defineConfig } from "flint-orm/config";
+ *
+ * export default defineConfig({
+ *   driver: "bun-sqlite",
+ *   database: { url: "./app.db" },
+ *   schema: "./src/schema",
+ * });
+ */
+export declare function defineConfig(config: FlintConfig): FlintConfig;

package/dist/drivers/better-sqlite3.d.ts

@@ -0,0 +1,38 @@
+import Database from 'better-sqlite3';
+import type { Executor } from '../executor';
+/** Synchronous executor backed by better-sqlite3, wrapped in Promises for uniform API. */
+export declare class BetterSqlite3Executor implements Executor {
+    #private;
+    constructor(client: Database.Database);
+    all(sql: string, params: unknown[]): Promise<unknown[]>;
+    get(sql: string, params: unknown[]): Promise<unknown>;
+    run(sql: string, params: unknown[]): Promise<void>;
+    transaction(fn: () => void | Promise<void>): Promise<void>;
+    close(): void;
+}
+/**
+ * Create a flint database client using better-sqlite3.
+ *
+ * @example
+ * import { flint } from 'flint-orm/better-sqlite3'
+ * const db = flint({ url: './app.db' })
+ */
+export declare function flint(details: {
+    url: string;
+}): {
+    select: () => import("..").SelectStage1;
+    insert: <T extends import("..").AnyTable>(table: T) => import("..").InsertStage1<T>;
+    update: <T extends import("..").AnyTable>(table: T) => import("..").UpdateStage1<T>;
+    delete: <T extends import("..").AnyTable>(table: T) => import("../query/builder").DeleteBuilder<T, false, keyof import("..").InferRow<T>>;
+    leftJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    innerJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    batch: (queries: import("..").Executable[]) => Promise<void>;
+    count: <T extends import("..").AnyTable>(table: T, condition?: import("..").Condition) => Promise<number>;
+    countColumn: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number>;
+    sum: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    avg: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    min: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    max: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    $run(query: string, ...params: unknown[]): Promise<void>;
+    $executor: Executor;
+};

package/dist/drivers/bun-sqlite.d.ts

@@ -0,0 +1,38 @@
+import { Database } from 'bun:sqlite';
+import type { Executor } from '../executor';
+/** Synchronous executor backed by bun:sqlite, wrapped in Promises for uniform API. */
+export declare class BunSqliteExecutor implements Executor {
+    #private;
+    constructor(client: Database);
+    all(sql: string, params: unknown[]): Promise<unknown[]>;
+    get(sql: string, params: unknown[]): Promise<unknown>;
+    run(sql: string, params: unknown[]): Promise<void>;
+    transaction(fn: () => void | Promise<void>): Promise<void>;
+    close(): void;
+}
+/**
+ * Create a flint database client using bun:sqlite.
+ *
+ * @example
+ * import { flint } from 'flint-orm/bun-sqlite'
+ * const db = flint({ url: './app.db' })
+ */
+export declare function flint(details: {
+    url: string;
+}): {
+    select: () => import("..").SelectStage1;
+    insert: <T extends import("..").AnyTable>(table: T) => import("..").InsertStage1<T>;
+    update: <T extends import("..").AnyTable>(table: T) => import("..").UpdateStage1<T>;
+    delete: <T extends import("..").AnyTable>(table: T) => import("../query/builder").DeleteBuilder<T, false, keyof import("..").InferRow<T>>;
+    leftJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    innerJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    batch: (queries: import("..").Executable[]) => Promise<void>;
+    count: <T extends import("..").AnyTable>(table: T, condition?: import("..").Condition) => Promise<number>;
+    countColumn: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number>;
+    sum: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    avg: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    min: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    max: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    $run(query: string, ...params: unknown[]): Promise<void>;
+    $executor: Executor;
+};

package/dist/drivers/libsql-web.d.ts

@@ -0,0 +1,44 @@
+import type { Client } from '@libsql/client';
+import type { Executor } from '../executor';
+/** Async executor backed by @libsql/client/web. */
+export declare class LibsqlWebExecutor implements Executor {
+    #private;
+    constructor(client: Client);
+    all(sql: string, params: unknown[]): Promise<unknown[]>;
+    get(sql: string, params: unknown[]): Promise<unknown>;
+    run(sql: string, params: unknown[]): Promise<void>;
+    transaction(fn: () => void | Promise<void>): Promise<void>;
+    close(): void;
+}
+export interface LibSQLWebConnectionDetails {
+    /** Database URL — must use ws:, wss:, http:, or https: scheme. */
+    url: string;
+    authToken?: string;
+}
+/**
+ * Create a flint database client using @libsql/client/web.
+ *
+ * **Note:** The web client only supports `ws:`, `wss:`, `http:`, and `https:` URLs.
+ * `file:` URLs are not supported — use the `flint-orm/libsql` entry point for local SQLite files.
+ *
+ * @example
+ * import { flint } from 'flint-orm/libsql-web'
+ * const db = flint({ url: 'libsql://your-db.turso.io', authToken: '...' })
+ */
+export declare function flint(details: LibSQLWebConnectionDetails): {
+    select: () => import("..").SelectStage1;
+    insert: <T extends import("..").AnyTable>(table: T) => import("..").InsertStage1<T>;
+    update: <T extends import("..").AnyTable>(table: T) => import("..").UpdateStage1<T>;
+    delete: <T extends import("..").AnyTable>(table: T) => import("../query/builder").DeleteBuilder<T, false, keyof import("..").InferRow<T>>;
+    leftJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    innerJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    batch: (queries: import("..").Executable[]) => Promise<void>;
+    count: <T extends import("..").AnyTable>(table: T, condition?: import("..").Condition) => Promise<number>;
+    countColumn: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number>;
+    sum: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    avg: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    min: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    max: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    $run(query: string, ...params: unknown[]): Promise<void>;
+    $executor: Executor;
+};

package/dist/drivers/libsql.d.ts

@@ -0,0 +1,40 @@
+import type { Client } from '@libsql/client';
+import type { Executor } from '../executor';
+/** Async executor backed by `@libsql/client`. */
+export declare class LibsqlExecutor implements Executor {
+    #private;
+    constructor(client: Client);
+    all(sql: string, params: unknown[]): Promise<unknown[]>;
+    get(sql: string, params: unknown[]): Promise<unknown>;
+    run(sql: string, params: unknown[]): Promise<void>;
+    transaction(fn: () => void | Promise<void>): Promise<void>;
+    close(): void;
+}
+export interface LibSQLConnectionDetails {
+    url: string;
+    authToken?: string;
+}
+/**
+ * Create a flint database client using @libsql/client.
+ *
+ * @example
+ * import { flint } from 'flint-orm/libsql'
+ * const db = flint({ url: 'libsql://your-db.turso.io', authToken: '...' })
+ */
+export declare function flint(details: LibSQLConnectionDetails): {
+    select: () => import("..").SelectStage1;
+    insert: <T extends import("..").AnyTable>(table: T) => import("..").InsertStage1<T>;
+    update: <T extends import("..").AnyTable>(table: T) => import("..").UpdateStage1<T>;
+    delete: <T extends import("..").AnyTable>(table: T) => import("../query/builder").DeleteBuilder<T, false, keyof import("..").InferRow<T>>;
+    leftJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    innerJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    batch: (queries: import("..").Executable[]) => Promise<void>;
+    count: <T extends import("..").AnyTable>(table: T, condition?: import("..").Condition) => Promise<number>;
+    countColumn: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number>;
+    sum: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    avg: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    min: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    max: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    $run(query: string, ...params: unknown[]): Promise<void>;
+    $executor: Executor;
+};

package/dist/drivers/turso-sync.d.ts

@@ -0,0 +1,44 @@
+import type { Database } from '@tursodatabase/sync';
+import type { Executor } from '../executor';
+/** Async executor backed by @tursodatabase/sync. */
+export declare class TursoSyncExecutor implements Executor {
+    #private;
+    constructor(db: Database);
+    all(sql: string, params: unknown[]): Promise<unknown[]>;
+    get(sql: string, params: unknown[]): Promise<unknown>;
+    run(sql: string, params: unknown[]): Promise<void>;
+    transaction(fn: () => void | Promise<void>): Promise<void>;
+    close(): void;
+}
+export interface TursoSyncConnectionDetails {
+    /** Local path for the synced database files. */
+    url: string;
+    /** Remote Turso database URL (libsql://...). */
+    syncUrl?: string;
+    /** Auth token for the remote database. */
+    authToken?: string;
+}
+/**
+ * Create a flint database client using @tursodatabase/sync.
+ *
+ * @example
+ * import { flint } from 'flint-orm/turso-sync'
+ * const db = flint({ url: './local.db', syncUrl: 'libsql://db.turso.io', authToken: '...' })
+ */
+export declare function flint(details: TursoSyncConnectionDetails): Promise<{
+    select: () => import("..").SelectStage1;
+    insert: <T extends import("..").AnyTable>(table: T) => import("..").InsertStage1<T>;
+    update: <T extends import("..").AnyTable>(table: T) => import("..").UpdateStage1<T>;
+    delete: <T extends import("..").AnyTable>(table: T) => import("../query/builder").DeleteBuilder<T, false, keyof import("..").InferRow<T>>;
+    leftJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    innerJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    batch: (queries: import("..").Executable[]) => Promise<void>;
+    count: <T extends import("..").AnyTable>(table: T, condition?: import("..").Condition) => Promise<number>;
+    countColumn: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number>;
+    sum: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    avg: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    min: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    max: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    $run(query: string, ...params: unknown[]): Promise<void>;
+    $executor: Executor;
+}>;

package/dist/drivers/turso.d.ts

@@ -0,0 +1,38 @@
+import type { Database } from '@tursodatabase/database';
+import type { Executor } from '../executor';
+/** Async executor backed by @tursodatabase/database. */
+export declare class TursoExecutor implements Executor {
+    #private;
+    constructor(db: Database);
+    all(sql: string, params: unknown[]): Promise<unknown[]>;
+    get(sql: string, params: unknown[]): Promise<unknown>;
+    run(sql: string, params: unknown[]): Promise<void>;
+    transaction(fn: () => void | Promise<void>): Promise<void>;
+    close(): void;
+}
+/**
+ * Create a flint database client using @tursodatabase/database.
+ *
+ * @example
+ * import { flint } from 'flint-orm/turso'
+ * const db = await flint({ url: './app.db' })
+ */
+export declare function flint(details: {
+    url: string;
+}): Promise<{
+    select: () => import("..").SelectStage1;
+    insert: <T extends import("..").AnyTable>(table: T) => import("..").InsertStage1<T>;
+    update: <T extends import("..").AnyTable>(table: T) => import("..").UpdateStage1<T>;
+    delete: <T extends import("..").AnyTable>(table: T) => import("../query/builder").DeleteBuilder<T, false, keyof import("..").InferRow<T>>;
+    leftJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    innerJoin: <Parent extends import("..").AnyTable>(parent: Parent) => import("../flint").JoinSelectStage1<Parent>;
+    batch: (queries: import("..").Executable[]) => Promise<void>;
+    count: <T extends import("..").AnyTable>(table: T, condition?: import("..").Condition) => Promise<number>;
+    countColumn: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number>;
+    sum: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    avg: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    min: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    max: <T extends import("..").AnyTable, C extends import("..").ColumnDef<any, any>>(table: T, column: C, condition?: import("..").Condition) => Promise<number | null>;
+    $run(query: string, ...params: unknown[]): Promise<void>;
+    $executor: Executor;
+}>;

package/dist/entries/better-sqlite3.d.ts

@@ -0,0 +1 @@
+export { flint } from '../drivers/better-sqlite3';

package/dist/entries/bun-sqlite.d.ts

@@ -0,0 +1 @@
+export { flint } from '../drivers/bun-sqlite';

package/dist/entries/config.d.ts

@@ -0,0 +1 @@
+export { defineConfig, type FlintConfig, type Driver, type DatabaseConfig } from '../config.js';

package/dist/entries/expressions.d.ts

@@ -0,0 +1,5 @@
+export { eq, and, or, gt, gte, lt, lte, neq, isIn, isNotIn, isNull, isNotNull, like, glob, between } from '../query/conditions';
+export type { Condition } from '../query/conditions';
+export { sql } from '../flint';
+export type { SQLExpression } from '../flint';
+export { count, countColumn, sum, avg, min, max } from '../query/aggregates';

package/dist/entries/libsql-web.d.ts

@@ -0,0 +1,2 @@
+export { flint } from '../drivers/libsql-web';
+export type { LibSQLWebConnectionDetails } from '../drivers/libsql-web';

package/dist/entries/libsql.d.ts

@@ -0,0 +1,2 @@
+export { flint } from '../drivers/libsql';
+export type { LibSQLConnectionDetails } from '../drivers/libsql';

package/dist/entries/table.d.ts

@@ -0,0 +1,4 @@
+export { text, integer, boolean, json, date, real } from '../schema/columns';
+export type { ColumnDef, IntegerColumnDef, DateColumnDef, DateColumnDefWithDefault, ForeignKeyAction } from '../schema/columns';
+export { table, index, snakeCase } from '../schema/table';
+export type { InferRow, InsertRow, TableDef, AnyTable, IndexDef, IndexBuilder } from '../schema/table';

package/dist/entries/turso-sync.d.ts

@@ -0,0 +1,2 @@
+export { flint } from '../drivers/turso-sync';
+export type { TursoSyncConnectionDetails } from '../drivers/turso-sync';

package/dist/entries/turso.d.ts

@@ -0,0 +1 @@
+export { flint } from '../drivers/turso';

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+/** Base error class for all flint-orm errors. */
+export declare class FlintError extends Error {
+    constructor(message: string);
+}
+/** Thrown when a value violates a column constraint or a validation rule fails. */
+export declare class FlintValidationError extends FlintError {
+    constructor(message: string);
+}
+/** Thrown when a SQL query fails to execute. */
+export declare class FlintQueryError extends FlintError {
+    readonly originalError?: Error;
+    constructor(message: string, originalError?: Error);
+}

package/dist/executor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A database executor that runs SQL and returns results.
+ * All methods return Promises for a uniform async API.
+ */
+export interface Executor {
+    /** Execute a query and return all matching rows. */
+    all(sql: string, params: unknown[]): Promise<unknown[]>;
+    /** Execute a query and return a single row or null. */
+    get(sql: string, params: unknown[]): Promise<unknown>;
+    /** Execute a statement (INSERT, UPDATE, DELETE, DDL). */
+    run(sql: string, params: unknown[]): Promise<void>;
+    /** Run a callback inside a transaction. */
+    transaction(fn: () => void | Promise<void>): Promise<void>;
+    /** Close the underlying database connection. No-op if already closed. */
+    close(): void;
+}

package/dist/flint.d.ts

@@ -0,0 +1,120 @@
+import type { Executor } from './executor';
+import { DeleteBuilder } from './query/builder';
+import type { Executable, SelectStage1, InsertStage1, UpdateStage1, JoinSelectStage1 } from './query/builder';
+import type { AnyTable } from './schema/table';
+import type { Condition } from './query/conditions';
+import type { ColumnDef } from './schema/columns';
+export type { Executable, SelectStage1, InsertStage1, UpdateStage1, JoinSelectStage1, JoinBuilder, SingleJoinBuilder } from './query/builder';
+export type { JoinResult } from './query/builder';
+/**
+ * A raw SQL expression with parameters.
+ */
+export interface SQLExpression {
+    sql: string;
+    params: unknown[];
+}
+/**
+ * Create a flint database client from an executor.
+ *
+ * This is the shared core — driver-specific entry points call this
+ * with their executor implementation.
+ *
+ * @example
+ * // Used internally by driver entry points:
+ * import { createClient } from '../flint'
+ * export function flint(details) {
+ *   const executor = new BunSqliteExecutor(new Database(details.url))
+ *   return createClient(executor)
+ * }
+ */
+export declare function createClient(executor: Executor): {
+    /**
+     * Start a SELECT query — call `.from(table)` next.
+     *
+     * @example
+     * const rows = db.select().from(users).execute()
+     */
+    select: () => SelectStage1;
+    /**
+     * Start an INSERT — call `.values(row)` next.
+     *
+     * @example
+     * db.insert(users).values({ id: "u1", name: "Alice" }).execute()
+     */
+    insert: <T extends AnyTable>(table: T) => InsertStage1<T>;
+    /**
+     * Start an UPDATE — call `.set(partial)` next.
+     *
+     * @example
+     * db.update(users).set({ name: "Bob" }).where(eq(users.id, "u1")).execute()
+     */
+    update: <T extends AnyTable>(table: T) => UpdateStage1<T>;
+    /**
+     * Start a DELETE — call `.where(condition)` next.
+     *
+     * @example
+     * db.delete(users).where(eq(users.id, "u1")).execute()
+     */
+    delete: <T extends AnyTable>(table: T) => DeleteBuilder<T, false, keyof import(".").InferRow<T>>;
+    /**
+     * Start a LEFT JOIN — call `.on(child)` next.
+     *
+     * @example
+     * db.leftJoin(users).on(posts).execute()
+     */
+    leftJoin: <Parent extends AnyTable>(parent: Parent) => JoinSelectStage1<Parent>;
+    /**
+     * Start an INNER JOIN — call `.on(child)` next.
+     *
+     * @example
+     * db.innerJoin(users).on(posts).execute()
+     */
+    innerJoin: <Parent extends AnyTable>(parent: Parent) => JoinSelectStage1<Parent>;
+    /**
+     * Run multiple queries atomically in a single transaction.
+     *
+     * @example
+     * db.batch([
+     *   db.insert(users).values({ id: "u1", name: "Alice" }),
+     *   db.insert(posts).values({ id: "p1", userId: "u1", title: "Hello" }),
+     * ])
+     */
+    batch: (queries: Executable[]) => Promise<void>;
+    /**
+     * Count all rows in a table, optionally filtered by a condition.
+     */
+    count: <T extends AnyTable>(table: T, condition?: Condition) => Promise<number>;
+    /**
+     * Count non-null values of a column, optionally filtered by a condition.
+     */
+    countColumn: <T extends AnyTable, C extends ColumnDef<any, any>>(table: T, column: C, condition?: Condition) => Promise<number>;
+    /**
+     * Sum non-null values of a column, optionally filtered by a condition.
+     */
+    sum: <T extends AnyTable, C extends ColumnDef<any, any>>(table: T, column: C, condition?: Condition) => Promise<number | null>;
+    /**
+     * Average non-null values of a column, optionally filtered by a condition.
+     */
+    avg: <T extends AnyTable, C extends ColumnDef<any, any>>(table: T, column: C, condition?: Condition) => Promise<number | null>;
+    /**
+     * Find the minimum non-null value of a column, optionally filtered by a condition.
+     */
+    min: <T extends AnyTable, C extends ColumnDef<any, any>>(table: T, column: C, condition?: Condition) => Promise<number | null>;
+    /**
+     * Find the maximum non-null value of a column, optionally filtered by a condition.
+     */
+    max: <T extends AnyTable, C extends ColumnDef<any, any>>(table: T, column: C, condition?: Condition) => Promise<number | null>;
+    /**
+     * Execute raw SQL directly against the database.
+     */
+    $run(query: string, ...params: unknown[]): Promise<void>;
+    /** Direct access to the underlying executor. */
+    $executor: Executor;
+};
+/**
+ * Tagged template for building parameterized SQL expressions.
+ *
+ * @example
+ * const expr = sql`name = ${"Alice"} AND age > ${18}`
+ */
+export declare function sql(strings: TemplateStringsArray, ...values: unknown[]): SQLExpression;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { sql, createClient } from './flint';
+export type { SQLExpression, Executable, SelectStage1, InsertStage1, UpdateStage1 } from './flint';
+export type { Executor } from './executor';
+export { text, integer, boolean, json, date, real } from './schema/columns';
+export type { ColumnDef, IntegerColumnDef, DateColumnDef, DateColumnDefWithDefault } from './schema/columns';
+export { table, index, snakeCase } from './schema/table';
+export type { InferRow, InsertRow, TableDef, AnyTable, IndexDef, IndexBuilder } from './schema/table';
+export { eq, and, or, gt, gte, lt, lte, neq, isIn, isNotIn, isNull, isNotNull, like, glob, between } from './query/conditions';
+export type { Condition } from './query/conditions';
+export { count, countColumn, sum, avg, min, max } from './query/aggregates';
+export { introspect } from './sqlite/introspect';

package/dist/migration/diff.d.ts

@@ -0,0 +1,15 @@
+import type { SchemaState, MigrationOperation } from './types.js';
+export declare class CancellationError extends Error {
+    constructor(message: string);
+}
+export declare function diffSchemas(previous: SchemaState, current: SchemaState): MigrationOperation[];
+export declare function emptyState(): SchemaState;
+export type RenamePrompt = (message: string, options: {
+    value: string;
+    label: string;
+    hint: string;
+}[]) => Promise<string | symbol>;
+export declare function resolveRenames(operations: MigrationOperation[], options?: {
+    interactive?: boolean;
+    prompt?: RenamePrompt;
+}): Promise<MigrationOperation[]>;

package/dist/migration/generate.d.ts

@@ -0,0 +1,18 @@
+import type { TableDef } from '../schema/table.js';
+import type { SchemaState, MigrationOperation } from './types.js';
+import type { RenamePrompt } from './diff.js';
+export interface GenerateResult {
+    folderName: string;
+    operations: MigrationOperation[];
+    sql: string;
+    state: SchemaState;
+}
+export interface GenerateOptions {
+    /** Migration folder name override. */
+    name?: string;
+    /** Whether to run interactive rename prompts. Defaults to true. */
+    interactive?: boolean;
+    /** Custom prompt function for rename resolution. Required when interactive is true. */
+    prompt?: RenamePrompt;
+}
+export declare function generate(tables: TableDef<any>[], migrationsDir: string, nameOrOptions?: string | GenerateOptions): Promise<GenerateResult>;

package/dist/migration/index.d.ts

@@ -0,0 +1,11 @@
+export { defineMigration } from './migration.js';
+export { serializeSchema } from './serialize.js';
+export { diffSchemas, emptyState, resolveRenames, CancellationError } from './diff.js';
+export type { RenamePrompt } from './diff.js';
+export { generateSQL } from './sql.js';
+export { generate } from './generate.js';
+export type { GenerateOptions } from './generate.js';
+export { migrate, getMigrationStatus } from './migrate.js';
+export type { MigrateOptions, MigrateResult, MigrationStatus } from './migrate.js';
+export { addTable, dropTable, renameTable, addColumn, dropColumn, renameColumn, createIndex, dropIndex, modifyColumn, modifyIndex, rebuildTable, } from './operations.js';
+export type { SchemaState, SerializedColumn, SerializedTable, SerializedIndex, MigrationOperation, MigrationFile, ModifyColumnOp, ModifyIndexOp, RebuildTableOp, } from './types.js';

package/dist/migration/migrate.d.ts

@@ -0,0 +1,52 @@
+import type { Executor } from '../executor.js';
+export interface MigrateOptions {
+    /** Path to the migrations directory. */
+    migrationsDir: string;
+    /** Dry run — show what would be applied without executing. */
+    dryRun?: boolean;
+}
+export interface MigrateResult {
+    /** Names of migrations that were applied. */
+    applied: string[];
+    /** Names of migrations that were skipped (already applied). */
+    skipped: string[];
+}
+/**
+ * Apply pending migrations to a database.
+ *
+ * Reads the migrations directory, filters out already-applied migrations,
+ * and applies the remaining ones in order within transactions.
+ *
+ * @param executor - The database executor (works with any driver)
+ * @param options - Migration options
+ * @returns Result with applied and skipped migration names
+ *
+ * @example
+ * import { flint } from 'flint-orm/bun-sqlite';
+ * import { migrate } from 'flint-orm/migration';
+ *
+ * const db = flint({ url: 'app.db' });
+ * const result = await migrate(db.$executor, { migrationsDir: './flint' });
+ * console.log(`Applied: ${result.applied.join(', ')}`);
+ */
+export declare function migrate(executor: Executor, options: MigrateOptions): Promise<MigrateResult>;
+export interface MigrationStatus {
+    /** Applied migration names with their timestamps. */
+    applied: {
+        name: string;
+        folderName: string;
+    }[];
+    /** Pending migration names. */
+    pending: {
+        name: string;
+        folderName: string;
+    }[];
+}
+/**
+ * Get the status of migrations — which are applied and which are pending.
+ *
+ * @param executor - The database executor (works with any driver)
+ * @param migrationsDir - Path to the migrations directory
+ * @returns Status object with applied and pending migrations
+ */
+export declare function getMigrationStatus(executor: Executor, migrationsDir: string): Promise<MigrationStatus>;