@gobing-ai/ts-db 0.1.0

package/dist/base-dao.js

@@ -0,0 +1,34 @@
+/**
+ * Abstract base DAO providing transaction and timestamp utilities to all entity DAOs.
+ */
+export class BaseDao {
+    db;
+    /**
+     * DB transaction utility for subclasses.
+     *
+     * Constructor is `protected` — instantiate through concrete DAO subclasses,
+     * not BaseDao directly. Tests must declare an explicit public constructor
+     * that calls `super(db)` to expose the protected constructor publicly.
+     */
+    constructor(db) {
+        this.db = db;
+    }
+    now() {
+        return Date.now();
+    }
+    /**
+     * Execute a function within a database transaction.
+     *
+     * Works uniformly on both D1 (async) and bun:sqlite (sync wrapped in promise).
+     * The callback receives a transaction-scoped DbClient.
+     *
+     * @param fn - Function to execute within the transaction.
+     * @returns The return value of `fn`.
+     */
+    async withTransaction(fn) {
+        // Drizzle's .transaction() works on both backends:
+        // - bun:sqlite: sync wrapped in a promise
+        // - D1: native async
+        return this.db.transaction(async (tx) => fn(tx));
+    }
+}

package/dist/embedded-migrations.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Embedded migration SQL — auto-generated from drizzle/ folder.
+ *
+ * This file bundles all migration SQL as inline strings so the compiled
+ * binary can apply migrations without needing the drizzle/ folder on disk.
+ *
+ * DO NOT EDIT MANUALLY. Regenerate with: bun run scripts/embed-migrations.ts
+ */
+export interface EmbeddedMigration {
+    tag: string;
+    sql: string;
+    hash: string;
+}
+export declare const embeddedMigrations: EmbeddedMigration[];
+//# sourceMappingURL=embedded-migrations.d.ts.map

package/dist/embedded-migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-migrations.d.ts","sourceRoot":"","sources":["../src/embedded-migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,iBAAiB;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,EAgBjD,CAAC"}

package/dist/embedded-migrations.js

@@ -0,0 +1,25 @@
+/**
+ * Embedded migration SQL — auto-generated from drizzle/ folder.
+ *
+ * This file bundles all migration SQL as inline strings so the compiled
+ * binary can apply migrations without needing the drizzle/ folder on disk.
+ *
+ * DO NOT EDIT MANUALLY. Regenerate with: bun run scripts/embed-migrations.ts
+ */
+export const embeddedMigrations = [
+    {
+        tag: '0000_init',
+        sql: "CREATE TABLE `queue_jobs` (\n\t`id` text PRIMARY KEY NOT NULL,\n\t`type` text NOT NULL,\n\t`payload` text NOT NULL,\n\t`status` text DEFAULT 'pending' NOT NULL,\n\t`attempts` integer DEFAULT 0 NOT NULL,\n\t`max_retries` integer DEFAULT 3 NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\t`next_retry_at` integer,\n\t`last_error` text,\n\t`processing_at` integer\n);\n",
+        hash: '558dea3834348925f79b4d30ca79d0afd0d990b2883341377d369444d50ce76e',
+    },
+    {
+        tag: '0001_salty_red_ghost',
+        sql: 'CREATE INDEX `queue_jobs_ready_idx` ON `queue_jobs` (`status`,`next_retry_at`,`created_at`);',
+        hash: 'f842da3f49edeec8a17bcab399669410db09996ab258dc4fa781357d0400ddbf',
+    },
+    {
+        tag: '0002_nasty_namora',
+        sql: 'ALTER TABLE `queue_jobs` ADD `expires_at` integer;',
+        hash: '7380f8c162352a61b15205af5a87e0e7313a499203dae98fe62151a1dc7fec0e',
+    },
+];

package/dist/entity-dao.d.ts

@@ -0,0 +1,143 @@
+import { type SQL } from 'drizzle-orm';
+import type { SQLiteColumn, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { DbClient } from './adapter';
+import { BaseDao } from './base-dao';
+/**
+ * Type for tables compatible with EntityDao.
+ * Must have standard columns: createdAt, updatedAt.
+ */
+export type EntityTable = SQLiteTable & {
+    createdAt: SQLiteColumn;
+    updatedAt: SQLiteColumn;
+};
+/**
+ * Type for tables with soft delete support.
+ */
+export type SoftDeletableTable = EntityTable & {
+    inUsed: SQLiteColumn;
+};
+/**
+ * Type for primary key columns.
+ */
+export type PKColumn = SQLiteColumn;
+/**
+ * Generic CRUD base class for entity DAOs.
+ *
+ * Provides standard create, read, update, delete operations with:
+ * - Type-safe public API using Drizzle's inference types
+ * - Automatic soft delete filtering (if table has `inUsed` column)
+ *
+ * @typeParam TTable - The table type (must extend EntityTable)
+ * @typeParam TPK - The primary key column type
+ *
+ * @example
+ * ```ts
+ * export class UsersDao extends EntityDao<typeof users, typeof users.id> {
+ *     constructor(db: DbClient) {
+ *         super(db, users, users.id, 'users');
+ *     }
+ *
+ *     // Add entity-specific methods here
+ *     async findByEmail(email: string) {
+ *         return this.findBy(users.email, email);
+ *     }
+ * }
+ * ```
+ */
+export declare class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> extends BaseDao {
+    readonly table: TTable;
+    protected readonly primaryKey: TPK;
+    protected readonly collectionName: string;
+    constructor(db: DbClient, table: TTable, primaryKey: TPK, collectionName: string);
+    /**
+     * Check if the table has soft delete support (inUsed column).
+     */
+    protected get hasSoftDelete(): boolean;
+    /**
+     * Build a where condition that filters out soft-deleted records.
+     * Returns undefined if the table doesn't support soft delete.
+     */
+    protected get activeCondition(): SQL | undefined;
+    /**
+     * Create a new record.
+     *
+     * `createdAt` and `updatedAt` are auto-filled if not provided.
+     *
+     * @param data - The data to insert (createdAt/updatedAt optional).
+     * @returns The created record.
+     */
+    create(data: Omit<TTable['$inferInsert'], 'createdAt' | 'updatedAt'> & {
+        createdAt?: number;
+        updatedAt?: number;
+    }): Promise<TTable['$inferSelect']>;
+    /**
+     * Find a record by its primary key.
+     *
+     * @param id - The primary key value.
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns The record if found, otherwise undefined.
+     */
+    findById(id: string | number, includeDeleted?: boolean): Promise<TTable['$inferSelect'] | undefined>;
+    /**
+     * Find all records.
+     *
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns Array of records.
+     */
+    findAll(includeDeleted?: boolean): Promise<TTable['$inferSelect'][]>;
+    /**
+     * Update a record by its primary key.
+     *
+     * @param id - The primary key value.
+     * @param data - The data to update.
+     * @returns The updated record if found, otherwise undefined.
+     */
+    update(id: string | number, data: Partial<TTable['$inferInsert']>): Promise<TTable['$inferSelect'] | undefined>;
+    /**
+     * Delete a record by its primary key.
+     *
+     * @param id - The primary key value.
+     * @param soft - Whether to perform a soft delete (default: true if table supports it).
+     * @returns The deleted record (for soft delete), otherwise undefined.
+     */
+    delete(id: string | number, soft?: boolean): Promise<TTable['$inferSelect'] | undefined>;
+    /**
+     * Find a record by a specific column value.
+     *
+     * @param column - The column to search.
+     * @param value - The value to match.
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns The record if found, otherwise undefined.
+     */
+    findBy<TCol extends SQLiteColumn>(column: TCol, value: TCol['_']['data'], includeDeleted?: boolean): Promise<TTable['$inferSelect'] | undefined>;
+    /**
+     * Find all records matching a specific column value.
+     *
+     * @param column - The column to search.
+     * @param value - The value to match.
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns Array of matching records.
+     */
+    findAllBy<TCol extends SQLiteColumn>(column: TCol, value: TCol['_']['data'], includeDeleted?: boolean): Promise<TTable['$inferSelect'][]>;
+    /**
+     * List records with pagination and optional filtering.
+     *
+     * @param options - List options (limit, offset, where).
+     * @returns Array of records.
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        where?: SQL;
+        includeDeleted?: boolean;
+    }): Promise<TTable['$inferSelect'][]>;
+    /**
+     * Count records in the table.
+     *
+     * @param where - Optional filter condition.
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns The count of matching records.
+     */
+    count(where?: SQL, includeDeleted?: boolean): Promise<number>;
+}
+//# sourceMappingURL=entity-dao.d.ts.map

package/dist/entity-dao.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-dao.d.ts","sourceRoot":"","sources":["../src/entity-dao.ts"],"names":[],"mappings":"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"}

package/dist/entity-dao.js

@@ -0,0 +1,218 @@
+import { and, count as countFn, eq } from 'drizzle-orm';
+import { BaseDao } from './base-dao.js';
+/**
+ * Generic CRUD base class for entity DAOs.
+ *
+ * Provides standard create, read, update, delete operations with:
+ * - Type-safe public API using Drizzle's inference types
+ * - Automatic soft delete filtering (if table has `inUsed` column)
+ *
+ * @typeParam TTable - The table type (must extend EntityTable)
+ * @typeParam TPK - The primary key column type
+ *
+ * @example
+ * ```ts
+ * export class UsersDao extends EntityDao<typeof users, typeof users.id> {
+ *     constructor(db: DbClient) {
+ *         super(db, users, users.id, 'users');
+ *     }
+ *
+ *     // Add entity-specific methods here
+ *     async findByEmail(email: string) {
+ *         return this.findBy(users.email, email);
+ *     }
+ * }
+ * ```
+ */
+export class EntityDao extends BaseDao {
+    table;
+    primaryKey;
+    collectionName;
+    constructor(db, table, primaryKey, collectionName) {
+        super(db);
+        this.table = table;
+        this.primaryKey = primaryKey;
+        this.collectionName = collectionName;
+    }
+    /**
+     * Check if the table has soft delete support (inUsed column).
+     */
+    get hasSoftDelete() {
+        return 'inUsed' in this.table;
+    }
+    /**
+     * Build a where condition that filters out soft-deleted records.
+     * Returns undefined if the table doesn't support soft delete.
+     */
+    get activeCondition() {
+        if (this.hasSoftDelete) {
+            return eq(this.table.inUsed, 1);
+        }
+        return undefined;
+    }
+    /**
+     * Create a new record.
+     *
+     * `createdAt` and `updatedAt` are auto-filled if not provided.
+     *
+     * @param data - The data to insert (createdAt/updatedAt optional).
+     * @returns The created record.
+     */
+    async create(data) {
+        const now = this.now();
+        const record = {
+            ...data,
+            createdAt: data.createdAt ?? now,
+            updatedAt: data.updatedAt ?? now,
+        };
+        await this.db.insert(this.table).values(record);
+        return record;
+    }
+    /**
+     * Find a record by its primary key.
+     *
+     * @param id - The primary key value.
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns The record if found, otherwise undefined.
+     */
+    async findById(id, includeDeleted = false) {
+        const conditions = [eq(this.primaryKey, id)];
+        if (!includeDeleted && this.activeCondition) {
+            conditions.push(this.activeCondition);
+        }
+        const result = await this.db
+            .select()
+            .from(this.table)
+            .where(and(...conditions));
+        return result[0];
+    }
+    /**
+     * Find all records.
+     *
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns Array of records.
+     */
+    async findAll(includeDeleted = false) {
+        const query = this.db.select().from(this.table);
+        if (!includeDeleted && this.activeCondition) {
+            return query.where(this.activeCondition);
+        }
+        return query;
+    }
+    /**
+     * Update a record by its primary key.
+     *
+     * @param id - The primary key value.
+     * @param data - The data to update.
+     * @returns The updated record if found, otherwise undefined.
+     */
+    async update(id, data) {
+        const now = this.now();
+        const updateData = {
+            ...data,
+            updatedAt: now,
+        };
+        await this.db.update(this.table).set(updateData).where(eq(this.primaryKey, id));
+        return this.findById(id);
+    }
+    /**
+     * Delete a record by its primary key.
+     *
+     * @param id - The primary key value.
+     * @param soft - Whether to perform a soft delete (default: true if table supports it).
+     * @returns The deleted record (for soft delete), otherwise undefined.
+     */
+    async delete(id, soft) {
+        const useSoftDelete = soft ?? this.hasSoftDelete;
+        if (useSoftDelete && this.hasSoftDelete) {
+            const now = this.now();
+            await this.db
+                .update(this.table)
+                .set({ inUsed: 0, updatedAt: now })
+                .where(eq(this.primaryKey, id));
+            return this.findById(id, true);
+        }
+        await this.db.delete(this.table).where(eq(this.primaryKey, id));
+        return undefined;
+    }
+    /**
+     * Find a record by a specific column value.
+     *
+     * @param column - The column to search.
+     * @param value - The value to match.
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns The record if found, otherwise undefined.
+     */
+    async findBy(column, value, includeDeleted = false) {
+        const conditions = [eq(column, value)];
+        if (!includeDeleted && this.activeCondition) {
+            conditions.push(this.activeCondition);
+        }
+        const result = await this.db
+            .select()
+            .from(this.table)
+            .where(and(...conditions));
+        return result[0];
+    }
+    /**
+     * Find all records matching a specific column value.
+     *
+     * @param column - The column to search.
+     * @param value - The value to match.
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns Array of matching records.
+     */
+    async findAllBy(column, value, includeDeleted = false) {
+        const conditions = [eq(column, value)];
+        if (!includeDeleted && this.activeCondition) {
+            conditions.push(this.activeCondition);
+        }
+        return this.db
+            .select()
+            .from(this.table)
+            .where(and(...conditions));
+    }
+    /**
+     * List records with pagination and optional filtering.
+     *
+     * @param options - List options (limit, offset, where).
+     * @returns Array of records.
+     */
+    async list(options = {}) {
+        const { limit = 100, offset = 0, where, includeDeleted = false } = options;
+        const conditions = [];
+        if (!includeDeleted && this.activeCondition) {
+            conditions.push(this.activeCondition);
+        }
+        if (where) {
+            conditions.push(where);
+        }
+        const query = this.db.select().from(this.table);
+        if (conditions.length > 0) {
+            return query
+                .where(and(...conditions))
+                .limit(limit)
+                .offset(offset);
+        }
+        return query.limit(limit).offset(offset);
+    }
+    /**
+     * Count records in the table.
+     *
+     * @param where - Optional filter condition.
+     * @param includeDeleted - Whether to include soft-deleted records.
+     * @returns The count of matching records.
+     */
+    async count(where, includeDeleted = false) {
+        const conditions = [];
+        if (!includeDeleted && this.activeCondition) {
+            conditions.push(this.activeCondition);
+        }
+        if (where) {
+            conditions.push(where);
+        }
+        const query = this.db.select({ value: countFn() }).from(this.table);
+        const result = conditions.length > 0 ? await query.where(and(...conditions)) : await query;
+        return result[0]?.value ?? 0;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { createDbAdapter, type DbAdapter, type DbAdapterConfig, type DbClient, type DbTable } from './adapter';
+export { BunSqliteAdapter, type BunSqliteOptions } from './adapters/bun-sqlite';
+export { D1Adapter } from './adapters/d1';
+export { BaseDao } from './base-dao';
+export { type EmbeddedMigration, embeddedMigrations } from './embedded-migrations';
+export { EntityDao, type EntityTable, type PKColumn, type SoftDeletableTable } from './entity-dao';
+export { applyMigrations, type MigrationOptions } from './migrate';
+export { QueueJobDao, type QueueJobRecord, type QueueStats } from './queue-job-dao';
+export { appendOnlyColumns, buildAppendOnlyColumns, buildStandardColumns, buildStandardColumnsWithSoftDelete, nowTimestamp, standardColumns, standardColumnsWithSoftDelete, } from './schema/common';
+export { queueJobs } from './schema/queue-jobs';
+export type { SpanContext } from './span-context';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/G,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,KAAK,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACnG,OAAO,EAAE,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EACH,iBAAiB,EACjB,sBAAsB,EACtB,oBAAoB,EACpB,kCAAkC,EAClC,YAAY,EACZ,eAAe,EACf,6BAA6B,GAChC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { createDbAdapter } from './adapter.js';
+export { BunSqliteAdapter } from './adapters/bun-sqlite.js';
+export { D1Adapter } from './adapters/d1.js';
+export { BaseDao } from './base-dao.js';
+export { embeddedMigrations } from './embedded-migrations.js';
+export { EntityDao } from './entity-dao.js';
+export { applyMigrations } from './migrate.js';
+export { QueueJobDao } from './queue-job-dao.js';
+export { appendOnlyColumns, buildAppendOnlyColumns, buildStandardColumns, buildStandardColumnsWithSoftDelete, nowTimestamp, standardColumns, standardColumnsWithSoftDelete, } from './schema/common.js';
+export { queueJobs } from './schema/queue-jobs.js';

package/dist/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "8E90F1FD5BA8710F64756E2164756E21",
+  "names": []
+}

package/dist/migrate.d.ts

@@ -0,0 +1,38 @@
+import type { FileSystem } from '@gobing-ai/ts-runtime';
+import type { DbAdapter } from './adapter';
+/**
+ * Find project root by walking up looking for bun.lock.
+ * @deprecated Use `FileSystem.getProjectRoot()` instead.
+ * @internal — only used for backward compatibility.
+ */
+/** @internal */
+export declare function findProjectRoot(_startDir: string): string;
+/**
+ * Options for configuring migration behaviour (folder path, table name).
+ */
+export interface MigrationOptions {
+    /** Path to migration SQL files. Default: `fs.resolve('drizzle')` */
+    migrationsFolder?: string;
+    /** Name of the migrations tracking table. Default: '__drizzle_migrations' */
+    migrationsTable?: string;
+    /** File system abstraction for path resolution. */
+    fs?: FileSystem;
+}
+/**
+ * Apply pending migrations using drizzle-orm's built-in migrator.
+ *
+ * Tracks applied migrations in the `__drizzle_migrations` table.
+ * Safe to call on every startup — already-applied migrations are skipped.
+ *
+ * Two migration strategies:
+ * 1. **File-based** (preferred): reads SQL from a `drizzle/` folder on disk.
+ * 2. **Embedded** (fallback): uses SQL bundled in the binary when no folder exists.
+ *
+ * Only works with BunSqliteAdapter. D1 migrations should use
+ * `wrangler d1 migrations apply` instead.
+ *
+ * @param adapter - A DbAdapter instance (must be BunSqliteAdapter).
+ * @param options - Optional migration folder and table name overrides.
+ */
+export declare function applyMigrations(adapter: DbAdapter, options?: MigrationOptions): Promise<void>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../src/migrate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C;;;;GAIG;AACH,gBAAgB;AAChB,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,oEAAoE;IACpE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,EAAE,CAAC,EAAE,UAAU,CAAC;CACnB;AA0ED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8CnG"}

package/dist/migrate.js

@@ -0,0 +1,131 @@
+import { resolve } from 'node:path';
+import { embeddedMigrations } from './embedded-migrations.js';
+/**
+ * Find project root by walking up looking for bun.lock.
+ * @deprecated Use `FileSystem.getProjectRoot()` instead.
+ * @internal — only used for backward compatibility.
+ */
+/** @internal */
+export function findProjectRoot(_startDir) {
+    return process.cwd();
+}
+/**
+ * Ensure the migration tracking table exists with proper SQLite types.
+ *
+ * drizzle-orm 0.45 generates `id SERIAL PRIMARY KEY` for the journal table,
+ * but SQLite doesn't recognize SERIAL as auto-increment. Pre-create with
+ * proper syntax so drizzle-orm's `CREATE TABLE IF NOT EXISTS` skips it.
+ */
+async function ensureJournalTable(adapter, table) {
+    await adapter.exec(`CREATE TABLE IF NOT EXISTS "${table}" (` +
+        'id INTEGER PRIMARY KEY AUTOINCREMENT, ' +
+        'hash text NOT NULL, ' +
+        'created_at numeric' +
+        ')');
+}
+function validateMigrationTableName(table) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table)) {
+        throw new Error(`Invalid migration journal table name: ${table}`);
+    }
+    return table;
+}
+/**
+ * Apply migrations from embedded SQL strings (for compiled binaries).
+ *
+ * Checks the journal table and applies only migrations that haven't run yet.
+ * Each migration is executed with adapter.exec() for file-based or adapter.run() for journal tracking.
+ */
+async function applyEmbeddedMigrations(adapter, journalTable) {
+    // Validate journal table name — this is an internal constant, never user input.
+    if (!/^__[a-z_]+$/.test(journalTable)) {
+        throw new Error(`Invalid migration journal table name: ${journalTable}`);
+    }
+    // Get already-applied hashes
+    const appliedHashes = new Set();
+    try {
+        const rows = await adapter.queryAll(`SELECT hash FROM "${journalTable}"`);
+        for (const row of rows) {
+            appliedHashes.add(row.hash);
+        }
+    }
+    catch {
+        // Journal table may not exist yet — will be created by ensureJournalTable
+    }
+    let applied = 0;
+    for (const migration of embeddedMigrations) {
+        if (appliedHashes.has(migration.hash))
+            continue;
+        console.info(`Applying embedded migration: ${migration.tag}`);
+        // Split on semicolons and execute each non-empty statement
+        const statements = migration.sql
+            .split(';')
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+        for (const stmt of statements) {
+            await adapter.exec(stmt);
+        }
+        // Record in journal
+        await adapter.run(`INSERT INTO "${journalTable}" (hash, created_at) VALUES (?, ?)`, migration.hash, Date.now());
+        applied++;
+    }
+    if (applied > 0) {
+        console.info(`Applied ${applied} embedded migration(s)`);
+    }
+}
+/**
+ * Apply pending migrations using drizzle-orm's built-in migrator.
+ *
+ * Tracks applied migrations in the `__drizzle_migrations` table.
+ * Safe to call on every startup — already-applied migrations are skipped.
+ *
+ * Two migration strategies:
+ * 1. **File-based** (preferred): reads SQL from a `drizzle/` folder on disk.
+ * 2. **Embedded** (fallback): uses SQL bundled in the binary when no folder exists.
+ *
+ * Only works with BunSqliteAdapter. D1 migrations should use
+ * `wrangler d1 migrations apply` instead.
+ *
+ * @param adapter - A DbAdapter instance (must be BunSqliteAdapter).
+ * @param options - Optional migration folder and table name overrides.
+ */
+export async function applyMigrations(adapter, options) {
+    const { BunSqliteAdapter } = await import('./adapters/bun-sqlite.js');
+    if (!(adapter instanceof BunSqliteAdapter)) {
+        console.warn('Skipping in-app migrations: only supported for bun-sqlite adapter');
+        return;
+    }
+    const table = validateMigrationTableName(options?.migrationsTable ?? '__drizzle_migrations');
+    await ensureJournalTable(adapter, table);
+    const folder = options?.migrationsFolder ?? resolve(findProjectRoot(process.cwd()), 'drizzle');
+    // File-based migrations: attempt if drizzle/ folder is accessible.
+    // Use FileSystem.exists when available, otherwise try and fall back to embedded.
+    const fs = options?.fs;
+    const tryFileBased = fs?.exists(folder) ?? true; // optimistic when no fs
+    if (tryFileBased) {
+        try {
+            const { migrate: drizzleMigrate } = await import('drizzle-orm/bun-sqlite/migrator');
+            console.info(`Applying database migrations from ${folder}`);
+            await drizzleMigrate(adapter.getDrizzleDb(), {
+                migrationsFolder: folder,
+                ...(options?.migrationsTable !== undefined ? { migrationsTable: options.migrationsTable } : {}),
+            });
+            console.info('Database migrations complete');
+            return;
+        }
+        catch (error) {
+            // If folder doesn't exist, fall through to embedded migrations.
+            // Any other error should be thrown.
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('journal') || message.includes('ENOENT') || message.includes('meta')) {
+                console.info(`File-based migrations unavailable, using embedded: ${message}`);
+            }
+            else {
+                console.error(`[MIGRATE] drizzleMigrate failed: ${message}`);
+                throw error;
+            }
+        }
+    }
+    // Fallback: embedded migrations (for compiled binaries)
+    console.info('No drizzle/ folder found — applying embedded migrations');
+    await applyEmbeddedMigrations(adapter, table);
+}