@bunnykit/orm 0.1.25 → 0.1.26

package/README.md

@@ -23,7 +23,8 @@ An **Eloquent-inspired ORM** built specifically for [Bun](https://bun.sh)'s nati
 - 🧬 **Eloquent-style Models** — Property attributes, defaults, casts, dirty tracking, soft deletes, scopes, find-or-fail, first-or-create
 - 🔗 **Relations** — Standard, many-to-many, polymorphic, through, one-of-many, and relation queries
 - 👁️ **Observers** — Lifecycle hooks (`creating`, `created`, `updating`, `updated`, etc.)
-- 🚀 **Migrations & CLI** — Create, run, and rollback migrations from the command line
+- 🚀 **Migrations & CLI** — Create, run, reset, refresh, and inspect migrations from the command line
+- 🌱 **Seeders & Factories** — Run all seeders or target one seeder by name/file, plus lightweight model factories
 - 💬 **REPL** — Inspect models and run queries interactively with `bunny repl`
 - ⚡ **Streaming** — `chunk`, `cursor`, `each`, and `lazy` for memory-efficient large dataset processing
 
@@ -71,6 +72,7 @@ export default {
   //   }),
   //   listTenants: async () => await getAllTenantIds(),
   // },
+  seedersPath: "./database/seeders",
   modelsPath: ["./src/models", "./src/admin/models"],
   // Optional legacy type output directory
   // typesOutDir: "./src/generated/model-types",
@@ -87,6 +89,7 @@ Or use environment variables:
 ```bash
 export DATABASE_URL="sqlite://app.db"
 export MIGRATIONS_PATH="./database/migrations,./database/tenant-migrations"
+export SEEDERS_PATH="./database/seeders"
 export MODELS_PATH="./src/models,./src/admin/models"
 export TYPES_OUT_DIR="./src/generated/model-types"
 ```
@@ -1108,6 +1111,84 @@ ObserverRegistry.register(User, {
 
 ---
 
+## Seeders and Factories
+
+Set `seedersPath` in `bunny.config.ts` to define the default directory used by `db:seed`:
+
+```ts
+export default {
+  connection: { url: "sqlite://app.db" },
+  seedersPath: "./database/seeders",
+};
+```
+
+`seedersPath` can also be an array:
+
+```ts
+export default {
+  connection: { url: "sqlite://app.db" },
+  seedersPath: ["./database/seeders", "./modules/demo/seeders"],
+};
+```
+
+Create a seeder by extending `Seeder`:
+
+```ts
+import { Seeder } from "@bunnykit/orm";
+import { User } from "../models/User";
+
+export default class UserSeeder extends Seeder {
+  async run(): Promise<void> {
+    await User.create({ name: "Ada Lovelace", email: "ada@example.test" });
+  }
+}
+```
+
+Run every seeder in `seedersPath`:
+
+```bash
+bun run bunny db:seed
+```
+
+Run one seeder by class/file name from `seedersPath`:
+
+```bash
+bun run bunny db:seed UserSeeder
+```
+
+Run one seeder by direct file path:
+
+```bash
+bun run bunny db:seed ./database/seeders/UserSeeder.ts
+```
+
+Programmatic seeding is available through `SeederRunner`:
+
+```ts
+import { SeederRunner } from "@bunnykit/orm";
+
+await new SeederRunner(connection).runTarget("UserSeeder", "./database/seeders");
+await new SeederRunner(connection).runFile("./database/seeders/UserSeeder.ts");
+```
+
+Factories can create raw attributes, unsaved models, or persisted records:
+
+```ts
+import { factory } from "@bunnykit/orm";
+import { User } from "../models/User";
+
+const users = factory(User, (sequence) => ({
+  name: `User ${sequence}`,
+  email: `user${sequence}@example.test`,
+}));
+
+const attributes = users.raw();
+const model = users.make();
+const created = await users.count(3).state({ role: "admin" }).create();
+```
+
+---
+
 ## Migrations
 
 ### CLI Commands
@@ -1125,9 +1206,27 @@ bun run bunny migrate
 # Rollback the last batch
 bun run bunny migrate:rollback
 
+# Rollback all migrations
+bun run bunny migrate:reset
+
+# Reset and rerun migrations
+bun run bunny migrate:refresh
+
+# Drop all tables and rerun migrations
+bun run bunny migrate:fresh
+
 # Show migration status
 bun run bunny migrate:status
 
+# Run all seeders in seedersPath
+bun run bunny db:seed
+
+# Run one seeder by name from seedersPath
+bun run bunny db:seed UserSeeder
+
+# Run one seeder by direct file path
+bun run bunny db:seed ./database/seeders/UserSeeder.ts
+
 # Dump the current database schema
 bun run bunny schema:dump ./database/schema.sql
 

package/dist/bin/bunny.js

@@ -5,6 +5,7 @@ import { TenantContext } from "../src/connection/TenantContext.js";
 import { configureBunny } from "../src/config/BunnyConfig.js";
 import { Migrator } from "../src/migration/Migrator.js";
 import { MigrationCreator } from "../src/migration/MigrationCreator.js";
+import { SeederRunner } from "../src/seeding/Seeder.js";
 import { TypeGenerator } from "../src/typegen/TypeGenerator.js";
 import { existsSync } from "fs";
 import { mkdir, rm, writeFile } from "fs/promises";
@@ -64,6 +65,18 @@ async function runMigratorCommand(command, migrator, statusLabel) {
         await migrator.rollback();
         return;
     }
+    if (command === "migrate:reset") {
+        await migrator.reset();
+        return;
+    }
+    if (command === "migrate:refresh") {
+        await migrator.refresh();
+        return;
+    }
+    if (command === "migrate:fresh") {
+        await migrator.fresh();
+        return;
+    }
     const status = await migrator.status();
     if (statusLabel) {
         console.log(statusLabel);
@@ -338,6 +351,7 @@ async function loadConfig(allowFallback = false) {
         return {
             connection: { url },
             migrationsPath: parseEnvPathSetting(process.env.MIGRATIONS_PATH) || "./database/migrations",
+            seedersPath: parseEnvPathSetting(process.env.SEEDERS_PATH),
             modelsPath: parseEnvPathSetting(process.env.MODELS_PATH),
         };
     }
@@ -354,6 +368,7 @@ async function loadConfig(allowFallback = false) {
                 filename: process.env.DB_DATABASE,
             },
             migrationsPath: parseEnvPathSetting(process.env.MIGRATIONS_PATH) || "./database/migrations",
+            seedersPath: parseEnvPathSetting(process.env.SEEDERS_PATH),
             modelsPath: parseEnvPathSetting(process.env.MODELS_PATH),
         };
     }
@@ -361,6 +376,7 @@ async function loadConfig(allowFallback = false) {
         return {
             connection: { url: "sqlite://:memory:" },
             migrationsPath: parseEnvPathSetting(process.env.MIGRATIONS_PATH) || "./database/migrations",
+            seedersPath: parseEnvPathSetting(process.env.SEEDERS_PATH),
             modelsPath: parseEnvPathSetting(process.env.MODELS_PATH),
         };
     }
@@ -432,9 +448,29 @@ async function main() {
     else if (command === "migrate:rollback") {
         await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
     }
+    else if (command === "migrate:reset") {
+        await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
+    }
+    else if (command === "migrate:refresh") {
+        await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
+    }
+    else if (command === "migrate:fresh") {
+        await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
+    }
     else if (command === "migrate:status") {
         await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
     }
+    else if (command === "db:seed") {
+        const target = args[1];
+        const seederPath = config.seedersPath || "./database/seeders";
+        const runner = new SeederRunner(connection);
+        if (target) {
+            await runner.runTarget(target, seederPath);
+        }
+        else {
+            await runner.runPaths(seederPath);
+        }
+    }
     else {
         console.log("Usage:");
         console.log("  bun run bunny migrate              Run landlord migrations, then all tenant migrations when configured");
@@ -443,7 +479,12 @@ async function main() {
         console.log("  bun run bunny migrate --tenant <id> Run one tenant's migrations only");
         console.log("  bun run bunny migrate:make <name> [dir] Create a new migration");
         console.log("  bun run bunny migrate:rollback     Rollback the last batch");
+        console.log("  bun run bunny migrate:reset        Rollback all migrations");
+        console.log("  bun run bunny migrate:refresh      Reset and rerun migrations");
+        console.log("  bun run bunny migrate:fresh        Drop all tables and rerun migrations");
         console.log("  bun run bunny migrate:status       Show migration status");
+        console.log("  bun run bunny db:seed              Run seeders from seedersPath");
+        console.log("  bun run bunny db:seed <seeder>     Run one seeder by file path or name");
         console.log("  bun run bunny schema:dump [path]   Dump the current database schema");
         console.log("  bun run bunny schema:squash [path] Dump schema and mark configured migrations as ran");
         console.log("  bun run bunny types:generate [dir] Generate model type declarations from DB schema");

package/dist/src/config/BunnyConfig.d.ts

@@ -5,6 +5,7 @@ import type { ConnectionConfig } from "../types/index.js";
 export interface BunnyConfig {
     connection: ConnectionConfig;
     migrationsPath?: string | string[];
+    seedersPath?: string | string[];
     migrations?: {
         landlord?: string | string[];
         tenant?: string | string[];

package/dist/src/index.d.ts

@@ -27,3 +27,6 @@ export type { MigrationEvent, MigrationEventListener, MigrationEventPayload, Mig
 export { MigrationCreator } from "./migration/MigrationCreator.js";
 export { TypeGenerator } from "./typegen/TypeGenerator.js";
 export { TypeMapper } from "./typegen/TypeMapper.js";
+export { Seeder, SeederRunner } from "./seeding/Seeder.js";
+export { Factory, factory } from "./seeding/Factory.js";
+export type { FactoryDefinition, FactoryState } from "./seeding/Factory.js";

package/dist/src/index.js

@@ -21,3 +21,5 @@ export { Migrator } from "./migration/Migrator.js";
 export { MigrationCreator } from "./migration/MigrationCreator.js";
 export { TypeGenerator } from "./typegen/TypeGenerator.js";
 export { TypeMapper } from "./typegen/TypeMapper.js";
+export { Seeder, SeederRunner } from "./seeding/Seeder.js";
+export { Factory, factory } from "./seeding/Factory.js";

package/dist/src/migration/Migrator.d.ts

@@ -4,6 +4,8 @@ export interface MigrationStatusRow {
     migration: string;
     status: string;
     tenant: string | null;
+    checksum?: string;
+    storedChecksum?: string | null;
 }
 export interface MigratorOptions {
     tenantId?: string | null;
@@ -39,13 +41,20 @@ export declare class Migrator {
     private emit;
     private getLastBatchNumber;
     private getMigrationFiles;
+    private checksumFile;
     run(): Promise<void>;
-    rollback(): Promise<void>;
+    rollback(steps?: number): Promise<void>;
+    private getRollbackBatches;
+    reset(): Promise<void>;
+    refresh(): Promise<void>;
+    fresh(): Promise<void>;
     private generateTypesIfNeeded;
     status(): Promise<MigrationStatusRow[]>;
     dumpSchema(path: string): Promise<string>;
     squash(path: string): Promise<string>;
     private getSchemaDumpSql;
+    private dropAllTables;
     private resolve;
     private getRan;
+    private getRanRecords;
 }

package/dist/src/migration/Migrator.js

@@ -1,5 +1,6 @@
+import { createHash } from "node:crypto";
 import { existsSync } from "fs";
-import { mkdir, readdir, writeFile } from "fs/promises";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
 import { basename, join, relative, resolve } from "path";
 import { Schema } from "../schema/Schema.js";
 import { Builder } from "../query/Builder.js";
@@ -30,6 +31,7 @@ export class Migrator {
                 table.increments("id");
                 table.string("migration");
                 table.string("tenant").nullable().index();
+                table.string("checksum").nullable();
                 table.integer("batch");
             });
             return;
@@ -39,6 +41,11 @@ export class Migrator {
                 table.string("tenant").nullable().index();
             });
         }
+        if (!(await Schema.hasColumn("migrations", "checksum"))) {
+            await Schema.table("migrations", (table) => {
+                table.string("checksum").nullable();
+            });
+        }
     }
     getTenantId() {
         return this.options.tenantId ?? null;
@@ -134,11 +141,16 @@ export class Migrator {
                     id: toPosixPath(relative(process.cwd(), fullPath)),
                     fileName,
                     fullPath,
+                    checksum: await this.checksumFile(fullPath),
                 });
             }
         }
         return files.sort((a, b) => a.fileName.localeCompare(b.fileName) || a.id.localeCompare(b.id));
     }
+    async checksumFile(path) {
+        const contents = await readFile(path);
+        return createHash("sha256").update(contents).digest("hex");
+    }
     async run() {
         await this.ensureMigrationsTable();
         const locked = await this.acquireLock();
@@ -160,6 +172,7 @@ export class Migrator {
                 await new Builder(this.connection, "migrations").insert({
                     migration: file.id,
                     tenant: this.getTenantId(),
+                    checksum: file.checksum,
                     batch,
                 });
                 await this.emit("migrated", { migration: file.id, batch });
@@ -177,17 +190,17 @@ export class Migrator {
                 await this.releaseLock();
         }
     }
-    async rollback() {
+    async rollback(steps = 1) {
         await this.ensureMigrationsTable();
         const locked = await this.acquireLock();
         try {
-            const batch = await this.getLastBatchNumber();
-            if (batch === 0) {
+            const batches = await this.getRollbackBatches(steps);
+            if (batches.length === 0) {
                 console.log("Nothing to rollback.");
                 return;
             }
             const records = (await this.scopedMigrations()
-                .where("batch", batch)
+                .whereIn("batch", batches)
                 .orderBy("id", "desc")
                 .get());
             if (records.length === 0) {
@@ -198,12 +211,12 @@ export class Migrator {
             for (const record of records) {
                 const migration = await this.resolve(record.migration);
                 console.log(`Rolling back: ${record.migration}`);
-                await this.emit("rollingBack", { migration: record.migration, batch });
+                await this.emit("rollingBack", { migration: record.migration, batch: record.batch });
                 await migration.down();
                 await new Builder(this.connection, "migrations")
                     .where("id", record.id)
                     .delete();
-                await this.emit("rolledBack", { migration: record.migration, batch });
+                await this.emit("rolledBack", { migration: record.migration, batch: record.batch });
                 console.log(`Rolled back:  ${record.migration}`);
             }
             await this.connection.commit();
@@ -218,6 +231,36 @@ export class Migrator {
                 await this.releaseLock();
         }
     }
+    async getRollbackBatches(steps) {
+        await this.ensureMigrationsTable();
+        const rows = await this.scopedMigrations()
+            .select("batch")
+            .orderBy("batch", "desc")
+            .get();
+        const batches = [];
+        for (const row of rows) {
+            const batch = Number(row.batch);
+            if (!Number.isFinite(batch) || batches.includes(batch))
+                continue;
+            batches.push(batch);
+            if (batches.length >= steps)
+                break;
+        }
+        return batches;
+    }
+    async reset() {
+        while ((await this.getLastBatchNumber()) > 0) {
+            await this.rollback();
+        }
+    }
+    async refresh() {
+        await this.reset();
+        await this.run();
+    }
+    async fresh() {
+        await this.dropAllTables();
+        await this.run();
+    }
     async generateTypesIfNeeded() {
         const modelDirectories = normalizePathList(this.typeGeneratorOptions.modelDirectories || this.typeGeneratorOptions.modelDirectory);
         if (!this.typesOutDir && modelDirectories.length === 0)
@@ -234,14 +277,20 @@ export class Migrator {
     }
     async status() {
         await this.ensureMigrationsTable();
-        const ran = await this.getRan();
+        const ran = await this.getRanRecords();
         const files = await this.getMigrationFiles();
         const tenant = this.getTenantId();
-        return files.map((file) => ({
-            migration: file.id,
-            status: ran.has(file.id) || ran.has(file.fileName) ? "Ran" : "Pending",
-            tenant,
-        }));
+        return files.map((file) => {
+            const record = ran.get(file.id) || ran.get(file.fileName);
+            const storedChecksum = record?.checksum ?? null;
+            return {
+                migration: file.id,
+                status: !record ? "Pending" : storedChecksum && storedChecksum !== file.checksum ? "Changed" : "Ran",
+                tenant,
+                checksum: file.checksum,
+                storedChecksum,
+            };
+        });
     }
     async dumpSchema(path) {
         const sql = await this.getSchemaDumpSql();
@@ -262,6 +311,7 @@ export class Migrator {
                 await new Builder(this.connection, "migrations").insert({
                     migration: file.id,
                     tenant: this.getTenantId(),
+                    checksum: file.checksum,
                     batch,
                 });
             }
@@ -332,6 +382,42 @@ export class Migrator {
         }
         return statements.join("\n\n") + "\n";
     }
+    async dropAllTables() {
+        const driver = this.connection.getDriverName();
+        const grammar = this.connection.getGrammar();
+        if (driver === "sqlite") {
+            await this.connection.run("PRAGMA foreign_keys = OFF");
+            try {
+                const rows = await this.connection.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'");
+                for (const row of rows) {
+                    await this.connection.run(`DROP TABLE IF EXISTS ${grammar.wrap(String(row.name))}`);
+                }
+            }
+            finally {
+                await this.connection.run("PRAGMA foreign_keys = ON");
+            }
+            return;
+        }
+        if (driver === "mysql") {
+            const tables = await this.connection.query("SHOW TABLES");
+            const key = Object.keys(tables[0] ?? {})[0];
+            await this.connection.run("SET FOREIGN_KEY_CHECKS = 0");
+            try {
+                for (const row of tables) {
+                    await this.connection.run(`DROP TABLE IF EXISTS ${grammar.wrap(String(row[key]))}`);
+                }
+            }
+            finally {
+                await this.connection.run("SET FOREIGN_KEY_CHECKS = 1");
+            }
+            return;
+        }
+        const schema = this.connection.getSchema() || "public";
+        const tables = await this.connection.query("SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE'", [schema]);
+        for (const row of tables) {
+            await this.connection.run(`DROP TABLE IF EXISTS ${grammar.wrap(`${schema}.${row.table_name}`)} CASCADE`);
+        }
+    }
     async resolve(file) {
         const normalized = toPosixPath(file);
         const candidates = new Set();
@@ -358,16 +444,25 @@ export class Migrator {
         return new MigrationClass();
     }
     async getRan() {
+        const results = await this.getRanRecords();
+        const ran = new Set();
+        for (const migration of results.keys()) {
+            ran.add(migration);
+            ran.add(basename(migration));
+        }
+        return ran;
+    }
+    async getRanRecords() {
         await this.ensureMigrationsTable();
         const results = await this.scopedMigrations()
             .orderBy("id", "asc")
             .get();
-        const ran = new Set();
+        const records = new Map();
         for (const row of results) {
             const migration = toPosixPath(String(row.migration));
-            ran.add(migration);
-            ran.add(basename(migration));
+            records.set(migration, row);
+            records.set(basename(migration), row);
         }
-        return ran;
+        return records;
     }
 }

package/dist/src/schema/Schema.d.ts

@@ -1,5 +1,19 @@
 import { Connection } from "../connection/Connection.js";
 import { Blueprint } from "./Blueprint.js";
+export interface SchemaIndex {
+    name: string;
+    columns: string[];
+    unique: boolean;
+    primary?: boolean;
+}
+export interface SchemaForeignKey {
+    name?: string;
+    columns: string[];
+    references: string[];
+    onTable: string;
+    onDelete?: string;
+    onUpdate?: string;
+}
 export declare class Schema {
     static connection: Connection;
     static setConnection(connection: Connection): void;
@@ -17,6 +31,12 @@ export declare class Schema {
     static rename(from: string, to: string): Promise<void>;
     static hasTable(table: string): Promise<boolean>;
     static hasColumn(table: string, column: string): Promise<boolean>;
+    static getIndexes(table: string): Promise<SchemaIndex[]>;
+    static hasIndex(table: string, indexOrColumns: string | string[]): Promise<boolean>;
+    static getForeignKeys(table: string): Promise<SchemaForeignKey[]>;
+    static hasForeignKey(table: string, keyOrColumns: string | string[]): Promise<boolean>;
+    private static groupIndexRows;
+    private static groupForeignKeyRows;
     static getColumn(table: string, column: string): Promise<{
         name: string;
         type: string;

package/dist/src/schema/Schema.js

@@ -198,6 +198,164 @@ export class Schema {
         const result = await connection.query(sql, bindings);
         return result.length > 0;
     }
+    static async getIndexes(table) {
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        const grammar = this.getGrammar();
+        const schema = connection.getSchema() || "public";
+        if (driver === "sqlite") {
+            const indexes = await connection.query(`PRAGMA index_list(${grammar.wrap(table)})`);
+            const results = [];
+            for (const index of indexes) {
+                const name = String(index.name);
+                const columns = await connection.query(`PRAGMA index_info(${grammar.wrap(name)})`);
+                results.push({
+                    name,
+                    columns: columns.map((row) => String(row.name)),
+                    unique: Number(index.unique) === 1,
+                    primary: String(index.origin || "") === "pk",
+                });
+            }
+            return results;
+        }
+        if (driver === "mysql") {
+            const rows = await connection.query(`SELECT index_name, column_name, non_unique
+         FROM information_schema.statistics
+         WHERE table_schema = DATABASE() AND table_name = ?
+         ORDER BY index_name, seq_in_index`, [table]);
+            return this.groupIndexRows(rows, "index_name", "column_name", (row) => Number(row.non_unique) === 0);
+        }
+        const rows = await connection.query(`SELECT
+         i.relname AS index_name,
+         a.attname AS column_name,
+         ix.indisunique AS is_unique,
+         ix.indisprimary AS is_primary,
+         k.ordinality
+       FROM pg_class t
+       JOIN pg_namespace n ON n.oid = t.relnamespace
+       JOIN pg_index ix ON t.oid = ix.indrelid
+       JOIN pg_class i ON i.oid = ix.indexrelid
+       JOIN unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ordinality) ON true
+       JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+       WHERE n.nspname = $1 AND t.relname = $2
+       ORDER BY i.relname, k.ordinality`, [schema, table]);
+        return this.groupIndexRows(rows, "index_name", "column_name", (row) => !!row.is_unique, (row) => !!row.is_primary);
+    }
+    static async hasIndex(table, indexOrColumns) {
+        const expectedColumns = Array.isArray(indexOrColumns) ? indexOrColumns : undefined;
+        const indexes = await this.getIndexes(table);
+        if (!expectedColumns) {
+            return indexes.some((index) => index.name === indexOrColumns);
+        }
+        return indexes.some((index) => (index.columns.length === expectedColumns.length &&
+            index.columns.every((column, indexPosition) => column === expectedColumns[indexPosition])));
+    }
+    static async getForeignKeys(table) {
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        const grammar = this.getGrammar();
+        const schema = connection.getSchema() || "public";
+        if (driver === "sqlite") {
+            const rows = await connection.query(`PRAGMA foreign_key_list(${grammar.wrap(table)})`);
+            const grouped = new Map();
+            for (const row of rows) {
+                const key = String(row.id);
+                const fk = grouped.get(key) || {
+                    name: undefined,
+                    columns: [],
+                    references: [],
+                    onTable: String(row.table),
+                    onDelete: row.on_delete ? String(row.on_delete).toLowerCase() : undefined,
+                    onUpdate: row.on_update ? String(row.on_update).toLowerCase() : undefined,
+                };
+                fk.columns.push(String(row.from));
+                fk.references.push(String(row.to));
+                grouped.set(key, fk);
+            }
+            return [...grouped.values()];
+        }
+        if (driver === "mysql") {
+            const rows = await connection.query(`SELECT
+           k.constraint_name,
+           k.column_name,
+           k.referenced_table_name,
+           k.referenced_column_name,
+           rc.delete_rule,
+           rc.update_rule,
+           k.ordinal_position
+         FROM information_schema.key_column_usage k
+         JOIN information_schema.referential_constraints rc
+           ON rc.constraint_schema = k.constraint_schema
+          AND rc.constraint_name = k.constraint_name
+         WHERE k.table_schema = DATABASE()
+           AND k.table_name = ?
+           AND k.referenced_table_name IS NOT NULL
+         ORDER BY k.constraint_name, k.ordinal_position`, [table]);
+            return this.groupForeignKeyRows(rows, "constraint_name", "column_name", "referenced_table_name", "referenced_column_name", "delete_rule", "update_rule");
+        }
+        const rows = await connection.query(`SELECT
+         tc.constraint_name,
+         kcu.column_name,
+         ccu.table_name AS referenced_table_name,
+         ccu.column_name AS referenced_column_name,
+         rc.delete_rule,
+         rc.update_rule,
+         kcu.ordinal_position
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+       JOIN information_schema.constraint_column_usage ccu
+         ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+       JOIN information_schema.referential_constraints rc
+         ON rc.constraint_name = tc.constraint_name
+        AND rc.constraint_schema = tc.table_schema
+       WHERE tc.constraint_type = 'FOREIGN KEY'
+         AND tc.table_schema = $1
+         AND tc.table_name = $2
+       ORDER BY tc.constraint_name, kcu.ordinal_position`, [schema, table]);
+        return this.groupForeignKeyRows(rows, "constraint_name", "column_name", "referenced_table_name", "referenced_column_name", "delete_rule", "update_rule");
+    }
+    static async hasForeignKey(table, keyOrColumns) {
+        const expectedColumns = Array.isArray(keyOrColumns) ? keyOrColumns : undefined;
+        const foreignKeys = await this.getForeignKeys(table);
+        if (!expectedColumns) {
+            return foreignKeys.some((fk) => fk.name === keyOrColumns);
+        }
+        return foreignKeys.some((fk) => (fk.columns.length === expectedColumns.length &&
+            fk.columns.every((column, indexPosition) => column === expectedColumns[indexPosition])));
+    }
+    static groupIndexRows(rows, nameKey, columnKey, unique, primary = () => false) {
+        const grouped = new Map();
+        for (const row of rows) {
+            const name = String(row[nameKey]);
+            const index = grouped.get(name) || { name, columns: [], unique: unique(row), primary: primary(row) };
+            index.columns.push(String(row[columnKey]));
+            index.unique = index.unique || unique(row);
+            index.primary = index.primary || primary(row);
+            grouped.set(name, index);
+        }
+        return [...grouped.values()];
+    }
+    static groupForeignKeyRows(rows, nameKey, columnKey, tableKey, referenceKey, deleteKey, updateKey) {
+        const grouped = new Map();
+        for (const row of rows) {
+            const name = String(row[nameKey]);
+            const fk = grouped.get(name) || {
+                name,
+                columns: [],
+                references: [],
+                onTable: String(row[tableKey]),
+                onDelete: row[deleteKey] ? String(row[deleteKey]).toLowerCase() : undefined,
+                onUpdate: row[updateKey] ? String(row[updateKey]).toLowerCase() : undefined,
+            };
+            fk.columns.push(String(row[columnKey]));
+            fk.references.push(String(row[referenceKey]));
+            grouped.set(name, fk);
+        }
+        return [...grouped.values()];
+    }
     static async getColumn(table, column) {
         const connection = this.getConnection();
         const driver = connection.getDriverName();

package/dist/src/seeding/Factory.d.ts

@@ -0,0 +1,19 @@
+import type { ModelAttributeInput, ModelConstructor } from "../model/Model.js";
+import { Model } from "../model/Model.js";
+export type FactoryDefinition<T extends Model> = (sequence: number) => ModelAttributeInput<T>;
+export type FactoryState<T extends Model> = ModelAttributeInput<T> | ((attributes: ModelAttributeInput<T>, sequence: number) => ModelAttributeInput<T>);
+export declare class Factory<T extends Model> {
+    private model;
+    private definition;
+    private amount;
+    private states;
+    constructor(model: ModelConstructor<T>, definition: FactoryDefinition<T>);
+    count(amount: number): Factory<T>;
+    state(state: FactoryState<T>): Factory<T>;
+    make(overrides?: ModelAttributeInput<T>): T | T[];
+    create(overrides?: ModelAttributeInput<T>): Promise<T | T[]>;
+    raw(overrides?: ModelAttributeInput<T>): ModelAttributeInput<T> | ModelAttributeInput<T>[];
+    private attributesFor;
+    private clone;
+}
+export declare function factory<T extends Model>(model: ModelConstructor<T>, definition: FactoryDefinition<T>): Factory<T>;

package/dist/src/seeding/Factory.js

@@ -0,0 +1,56 @@
+export class Factory {
+    model;
+    definition;
+    amount = 1;
+    states = [];
+    constructor(model, definition) {
+        this.model = model;
+        this.definition = definition;
+    }
+    count(amount) {
+        const next = this.clone();
+        next.amount = Math.max(0, amount);
+        return next;
+    }
+    state(state) {
+        const next = this.clone();
+        next.states = [...next.states, state];
+        return next;
+    }
+    make(overrides = {}) {
+        const models = Array.from({ length: this.amount }, (_, index) => {
+            const attributes = this.attributesFor(index + 1, overrides);
+            return new this.model(attributes);
+        });
+        return this.amount === 1 ? models[0] : models;
+    }
+    async create(overrides = {}) {
+        const records = Array.from({ length: this.amount }, (_, index) => this.attributesFor(index + 1, overrides));
+        const models = [];
+        for (const attributes of records) {
+            models.push(await this.model.create(attributes));
+        }
+        return this.amount === 1 ? models[0] : models;
+    }
+    raw(overrides = {}) {
+        const records = Array.from({ length: this.amount }, (_, index) => this.attributesFor(index + 1, overrides));
+        return this.amount === 1 ? records[0] : records;
+    }
+    attributesFor(sequence, overrides) {
+        let attributes = { ...this.definition(sequence) };
+        for (const state of this.states) {
+            const next = typeof state === "function" ? state(attributes, sequence) : state;
+            attributes = { ...attributes, ...next };
+        }
+        return { ...attributes, ...overrides };
+    }
+    clone() {
+        const next = new Factory(this.model, this.definition);
+        next.amount = this.amount;
+        next.states = [...this.states];
+        return next;
+    }
+}
+export function factory(model, definition) {
+    return new Factory(model, definition);
+}

package/dist/src/seeding/Seeder.d.ts

@@ -0,0 +1,16 @@
+import { Connection } from "../connection/Connection.js";
+export declare abstract class Seeder {
+    protected connection: Connection;
+    constructor(connection?: Connection);
+    abstract run(): Promise<void> | void;
+    protected call(seeders: (Seeder | (new (connection?: Connection) => Seeder))[]): Promise<void>;
+}
+export declare class SeederRunner {
+    private connection;
+    constructor(connection?: Connection);
+    run(seeders: (Seeder | (new (connection?: Connection) => Seeder))[]): Promise<void>;
+    runPaths(paths: string | string[]): Promise<void>;
+    runFile(file: string): Promise<void>;
+    runTarget(target: string, searchPaths?: string | string[]): Promise<void>;
+    private getSeederFiles;
+}

package/dist/src/seeding/Seeder.js

@@ -0,0 +1,80 @@
+import { existsSync } from "fs";
+import { readdir, stat } from "fs/promises";
+import { basename, extname, resolve } from "path";
+import { pathToFileURL } from "url";
+import { Schema } from "../schema/Schema.js";
+import { normalizePathList, toPosixPath } from "../utils.js";
+export class Seeder {
+    connection;
+    constructor(connection = Schema.getConnection()) {
+        this.connection = connection;
+    }
+    async call(seeders) {
+        for (const seeder of seeders) {
+            const instance = typeof seeder === "function" ? new seeder(this.connection) : seeder;
+            await instance.run();
+        }
+    }
+}
+export class SeederRunner {
+    connection;
+    constructor(connection = Schema.getConnection()) {
+        this.connection = connection;
+    }
+    async run(seeders) {
+        for (const seeder of seeders) {
+            const instance = typeof seeder === "function" ? new seeder(this.connection) : seeder;
+            await instance.run();
+        }
+    }
+    async runPaths(paths) {
+        const files = await this.getSeederFiles(paths);
+        for (const file of files) {
+            await this.runFile(file);
+        }
+    }
+    async runFile(file) {
+        const resolved = resolve(file);
+        const module = await import(pathToFileURL(resolved).href);
+        const SeederClass = module.default || Object.values(module)[0];
+        if (!SeederClass) {
+            throw new Error(`Seeder ${file} does not export a class.`);
+        }
+        await this.run([SeederClass]);
+    }
+    async runTarget(target, searchPaths = "./database/seeders") {
+        const resolved = resolve(target);
+        if (existsSync(resolved) && (await stat(resolved)).isFile()) {
+            await this.runFile(resolved);
+            return;
+        }
+        const files = await this.getSeederFiles(searchPaths);
+        const normalizedTarget = target.replace(/\.(ts|js|mts|mjs|cts|cjs)$/i, "");
+        const match = files.find((file) => {
+            const name = basename(file, extname(file));
+            return name === normalizedTarget || file.endsWith(target) || file.endsWith(`${target}.ts`) || file.endsWith(`${target}.js`);
+        });
+        if (!match) {
+            throw new Error(`Seeder "${target}" could not be found in ${normalizePathList(searchPaths).join(", ")}.`);
+        }
+        await this.runFile(match);
+    }
+    async getSeederFiles(paths) {
+        const files = [];
+        for (const path of normalizePathList(paths)) {
+            const root = resolve(path);
+            if (!existsSync(root))
+                continue;
+            for (const entry of await readdir(root, { withFileTypes: true })) {
+                if (!entry.isFile())
+                    continue;
+                if (entry.name.endsWith(".d.ts") || entry.name.endsWith(".test.ts") || entry.name.endsWith(".spec.ts"))
+                    continue;
+                if (![".ts", ".js", ".mts", ".mjs", ".cts", ".cjs"].includes(extname(entry.name)))
+                    continue;
+                files.push(toPosixPath(resolve(root, entry.name)));
+            }
+        }
+        return files.sort((a, b) => basename(a).localeCompare(basename(b)) || a.localeCompare(b));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunnykit/orm",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "An Eloquent-inspired ORM for Bun's native SQL client supporting SQLite, MySQL, and PostgreSQL.",
   "license": "MIT",
   "packageManager": "bun@1.3.12",