@bunnykit/orm 0.1.13 → 0.1.15

package/README.md

@@ -354,6 +354,8 @@ await Schema.create("products", (table) => {
 | `jsonb(name)`              | JSONB (Postgres)                      |
 | `binary(name)`             | BLOB / BYTEA                          |
 | `uuid(name)`               | UUID                                  |
+| `foreignId(name)`          | Unsigned big integer foreign key      |
+| `foreignUuid(name)`        | UUID foreign key                      |
 | `enum(name, values)`       | ENUM                                  |
 
 ### Column Modifiers
@@ -376,6 +378,11 @@ await Schema.table("users", (table) => {
   table.timestamp("last_login").nullable();
 });
 
+// Change columns on MySQL/PostgreSQL
+await Schema.table("users", (table) => {
+  table.string("name", 150).nullable().change();
+});
+
 // Rename
 await Schema.rename("users", "customers");
 
@@ -413,6 +420,32 @@ await Schema.create("posts", (table) => {
 });
 ```
 
+Shortcut form:
+
+```ts
+await Schema.create("posts", (table) => {
+  table.increments("id");
+  table.foreignId("user_id").constrained().cascadeOnDelete();
+  table.string("title");
+  table.timestamps();
+});
+```
+
+Polymorphic column shortcuts:
+
+```ts
+await Schema.create("comments", (table) => {
+  table.increments("id");
+  table.uuidMorphs("commentable"); // commentable_type + UUID commentable_id + index
+  table.text("body");
+});
+
+await Schema.create("activity", (table) => {
+  table.increments("id");
+  table.nullableMorphs("subject"); // nullable subject_type + subject_id + index
+});
+```
+
 ---
 
 ## Query Builder
@@ -996,6 +1029,20 @@ class Video extends Model {
 }
 ```
 
+`morphTo` relations can be eager loaded:
+
+```ts
+const comments = await Comment.with("commentable").get();
+
+comments[0].getRelation("commentable"); // Post | Video | null
+```
+
+Relation names are inferred for `with(...)` when your model methods return relation objects, while raw strings still work for dynamic relation names:
+
+```ts
+await Post.with("comments").get();
+```
+
 ### Many-to-Many Polymorphic
 
 ```ts
@@ -1080,6 +1127,12 @@ bun run bunny migrate:rollback
 
 # Show migration status
 bun run bunny migrate:status
+
+# Dump the current database schema
+bun run bunny schema:dump ./database/schema.sql
+
+# Dump schema and mark configured migrations as ran
+bun run bunny schema:squash ./database/schema.sql
 ```
 
 ### Migration File Structure
@@ -1105,6 +1158,37 @@ export default class CreateUsersTable extends Migration {
 
 Migrations are tracked in a `migrations` table (auto-created on first run).
 
+### Migration Events
+
+Listen to migration lifecycle events when running migrations programmatically:
+
+```ts
+import { Migrator } from "@bunnykit/orm";
+
+Migrator.on("migrating", ({ migration }) => {
+  console.log(`Starting ${migration}`);
+});
+
+Migrator.on("migrated", ({ migration }) => {
+  console.log(`Finished ${migration}`);
+});
+```
+
+Available events: `migrating`, `migrated`, `rollingBack`, `rolledBack`, `schemaDumped`, and `schemaSquashed`.
+
+### Schema Dumps
+
+Programmatic schema dumps are available through the migrator:
+
+```ts
+const migrator = new Migrator(connection, "./database/migrations");
+
+await migrator.dumpSchema("./database/schema.sql");
+await migrator.squash("./database/schema.sql");
+```
+
+`squash()` writes the schema dump and marks the configured migration files as already ran in the migrations table.
+
 ### Auto Type Generation
 
 If you set `typesOutDir` in your config, types are **automatically regenerated** after every `migrate` and `migrate:rollback`.

package/dist/bin/bunny.js

@@ -414,7 +414,19 @@ async function main() {
     }
     const config = await loadConfig();
     const { connection } = configureBunny(config);
-    if (command === "migrate") {
+    if (command === "schema:dump" || command === "schema:squash") {
+        const outputPath = args[1] || "./database/schema.sql";
+        const migrator = new Migrator(connection, getDefaultMigrationsPath(config), config.typesOutDir, createTypeGeneratorOptions(config));
+        if (command === "schema:dump") {
+            await migrator.dumpSchema(outputPath);
+            console.log(`Schema dumped to ${outputPath}`);
+        }
+        else {
+            await migrator.squash(outputPath);
+            console.log(`Schema squashed to ${outputPath}`);
+        }
+    }
+    else if (command === "migrate") {
         await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
     }
     else if (command === "migrate:rollback") {
@@ -432,6 +444,8 @@ async function main() {
         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:status       Show migration status");
+        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");
         console.log("  bun run bunny repl                 Start a Bunny REPL with Model, Schema, and db loaded");
         console.log("                                     Falls back to in-memory SQLite when no config is present");

package/dist/src/connection/Connection.js

@@ -76,7 +76,6 @@ export class Connection {
         return `"${value.replace(/"/g, '""')}"`;
     }
     async query(sqlString) {
-        // Use unsafe for generated SQL strings
         return (await this.driver.unsafe(sqlString));
     }
     async run(sqlString) {

package/dist/src/connection/ConnectionManager.d.ts

@@ -21,15 +21,28 @@ export type TenantResolution = {
     setting?: string;
 };
 export type TenantResolver = (tenantId: string) => TenantResolution | Promise<TenantResolution>;
+export interface PoolConfig {
+    maxConnections?: number;
+    minConnections?: number;
+    idleTimeout?: number;
+}
 export declare class ConnectionManager {
     private static defaultConnection?;
     private static connections;
+    private static pools;
+    private static poolConfigs;
     private static tenantResolver?;
     private static tenantCache;
     static setDefault(connection: Connection): void;
     static getDefault(): Connection | undefined;
+    static setPoolConfig(name: string, config: PoolConfig): void;
+    static getPoolConfig(name: string): PoolConfig | undefined;
+    private static getPooledConnection;
+    private static releasePooledConnection;
     static add(name: string, connection: Connection | ConnectionConfig): Connection;
     static get(name: string): Connection | undefined;
+    static getPooled(name: string, config?: ConnectionConfig): Promise<Connection>;
+    static release(name: string, connection: Connection): void;
     static require(name: string): Connection;
     static setTenantResolver(resolver: TenantResolver): void;
     static resolveTenant(tenantId: string): Promise<ActiveTenantContext>;

package/dist/src/connection/ConnectionManager.js

@@ -2,6 +2,8 @@ import { Connection } from "./Connection.js";
 export class ConnectionManager {
     static defaultConnection;
     static connections = new Map();
+    static pools = new Map();
+    static poolConfigs = new Map();
     static tenantResolver;
     static tenantCache = new Map();
     static setDefault(connection) {
@@ -10,6 +12,67 @@ export class ConnectionManager {
     static getDefault() {
         return this.defaultConnection;
     }
+    static setPoolConfig(name, config) {
+        this.poolConfigs.set(name, { maxConnections: 10, minConnections: 1, idleTimeout: 30000, ...config });
+    }
+    static getPoolConfig(name) {
+        return this.poolConfigs.get(name);
+    }
+    static async getPooledConnection(name, config) {
+        const poolConfig = this.poolConfigs.get(name) || { maxConnections: 10, minConnections: 1, idleTimeout: 30000 };
+        let pool = this.pools.get(name);
+        if (!pool) {
+            pool = [];
+            this.pools.set(name, pool);
+        }
+        const now = Date.now();
+        const idleTimeout = poolConfig.idleTimeout || 30000;
+        while (pool.length > 0) {
+            const idx = pool.findIndex((c) => !c.inUse && (now - c.lastUsed) < idleTimeout);
+            if (idx === -1)
+                break;
+            const pooled = pool[idx];
+            pool.splice(idx, 1);
+            try {
+                pooled.connection.query("SELECT 1").catch(() => null);
+                pooled.inUse = true;
+                return pooled.connection;
+            }
+            catch {
+                await pooled.connection.close().catch(() => null);
+            }
+        }
+        if (pool.length < (poolConfig.maxConnections || 10)) {
+            const connection = new Connection(config);
+            pool.push({ connection, lastUsed: Date.now(), inUse: true });
+            return connection;
+        }
+        return new Promise((resolve, reject) => {
+            const checkInterval = setInterval(() => {
+                const available = pool.find((c) => !c.inUse);
+                if (available) {
+                    clearInterval(checkInterval);
+                    available.inUse = true;
+                    available.lastUsed = Date.now();
+                    resolve(available.connection);
+                }
+            }, 50);
+            setTimeout(() => {
+                clearInterval(checkInterval);
+                reject(new Error(`Connection pool exhausted for "${name}"`));
+            }, 30000);
+        });
+    }
+    static releasePooledConnection(name, connection) {
+        const pool = this.pools.get(name);
+        if (!pool)
+            return;
+        const pooled = pool.find((p) => p.connection === connection);
+        if (pooled) {
+            pooled.inUse = false;
+            pooled.lastUsed = Date.now();
+        }
+    }
     static add(name, connection) {
         const resolved = connection instanceof Connection ? connection : new Connection(connection);
         this.connections.set(name, resolved);
@@ -18,6 +81,18 @@ export class ConnectionManager {
     static get(name) {
         return this.connections.get(name);
     }
+    static async getPooled(name, config) {
+        if (config) {
+            return this.getPooledConnection(name, config);
+        }
+        const existing = this.connections.get(name);
+        if (existing)
+            return existing;
+        throw new Error(`No connection registered for "${name}". Use add() first or provide config.`);
+    }
+    static release(name, connection) {
+        this.releasePooledConnection(name, connection);
+    }
     static require(name) {
         const connection = this.get(name);
         if (!connection) {
@@ -93,9 +168,15 @@ export class ConnectionManager {
     }
     static async closeAll() {
         const connections = new Set(this.connections.values());
+        for (const pool of this.pools.values()) {
+            for (const { connection } of pool) {
+                connections.add(connection);
+            }
+        }
         if (this.defaultConnection)
             connections.add(this.defaultConnection);
         this.connections.clear();
+        this.pools.clear();
         this.tenantCache.clear();
         for (const connection of connections) {
             await connection.close();

package/dist/src/index.d.ts

@@ -14,7 +14,7 @@ export { MySqlGrammar } from "./schema/grammars/MySqlGrammar.js";
 export { PostgresGrammar } from "./schema/grammars/PostgresGrammar.js";
 export { Builder } from "./query/Builder.js";
 export { Model, HasMany, BelongsTo, HasOne, HasManyThrough, HasOneThrough } from "./model/Model.js";
-export type { ModelAttributeInput, ModelAttributes, ModelColumn, ModelColumnValue, ModelConstructor, GlobalScope, CastDefinition, CastsAttributes, } from "./model/Model.js";
+export type { ModelAttributeInput, ModelAttributes, ModelColumn, ModelColumnValue, ModelConstructor, ModelRelationName, GlobalScope, CastDefinition, CastsAttributes, } from "./model/Model.js";
 export { ModelNotFoundError } from "./model/ModelNotFoundError.js";
 export { ObserverRegistry, type ObserverContract } from "./model/Observer.js";
 export { MorphMap } from "./model/MorphMap.js";
@@ -22,6 +22,7 @@ export { MorphTo, MorphOne, MorphMany, MorphToMany } from "./model/MorphRelation
 export { BelongsToMany } from "./model/BelongsToMany.js";
 export { Migration } from "./migration/Migration.js";
 export { Migrator } from "./migration/Migrator.js";
+export type { MigrationEvent, MigrationEventListener, MigrationEventPayload } from "./migration/Migrator.js";
 export { MigrationCreator } from "./migration/MigrationCreator.js";
 export { TypeGenerator } from "./typegen/TypeGenerator.js";
 export { TypeMapper } from "./typegen/TypeMapper.js";

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

@@ -1,13 +1,24 @@
 import { Connection } from "../connection/Connection.js";
 import type { TypeGeneratorOptions } from "../typegen/TypeGenerator.js";
+export type MigrationEvent = "migrating" | "migrated" | "rollingBack" | "rolledBack" | "schemaDumped" | "schemaSquashed";
+export interface MigrationEventPayload {
+    migration?: string;
+    batch?: number;
+    path?: string;
+}
+export type MigrationEventListener = (payload: MigrationEventPayload) => void | Promise<void>;
 export declare class Migrator {
     private connection;
     private path;
     private typesOutDir?;
     private typeGeneratorOptions;
+    private static listeners;
     constructor(connection: Connection, path: string | string[], typesOutDir?: string | undefined, typeGeneratorOptions?: Omit<TypeGeneratorOptions, "outDir">);
     private getPaths;
     private ensureMigrationsTable;
+    static on(event: MigrationEvent, listener: MigrationEventListener): () => void;
+    static clearListeners(event?: MigrationEvent): void;
+    private emit;
     private getLastBatchNumber;
     private getMigrationFiles;
     run(): Promise<void>;
@@ -17,6 +28,9 @@ export declare class Migrator {
         migration: string;
         status: string;
     }[]>;
+    dumpSchema(path: string): Promise<string>;
+    squash(path: string): Promise<string>;
+    private getSchemaDumpSql;
     private resolve;
     private getRan;
 }

package/dist/src/migration/Migrator.js

@@ -1,5 +1,5 @@
 import { existsSync } from "fs";
-import { readdir } from "fs/promises";
+import { mkdir, readdir, writeFile } from "fs/promises";
 import { basename, join, relative, resolve } from "path";
 import { Schema } from "../schema/Schema.js";
 import { Builder } from "../query/Builder.js";
@@ -10,6 +10,7 @@ export class Migrator {
     path;
     typesOutDir;
     typeGeneratorOptions;
+    static listeners = new Map();
     constructor(connection, path, typesOutDir, typeGeneratorOptions = {}) {
         this.connection = connection;
         this.path = path;
@@ -30,6 +31,23 @@ export class Migrator {
             });
         }
     }
+    static on(event, listener) {
+        const listeners = this.listeners.get(event) || new Set();
+        listeners.add(listener);
+        this.listeners.set(event, listeners);
+        return () => listeners.delete(listener);
+    }
+    static clearListeners(event) {
+        if (event)
+            this.listeners.delete(event);
+        else
+            this.listeners.clear();
+    }
+    async emit(event, payload) {
+        for (const listener of Migrator.listeners.get(event) || []) {
+            await listener(payload);
+        }
+    }
     async getLastBatchNumber() {
         const result = await new Builder(this.connection, "migrations")
             .select("MAX(batch) as batch")
@@ -69,11 +87,13 @@ export class Migrator {
             for (const file of pending) {
                 const migration = await this.resolve(file.id);
                 console.log(`Migrating: ${file.id}`);
+                await this.emit("migrating", { migration: file.id, batch });
                 await migration.up();
                 await new Builder(this.connection, "migrations").insert({
                     migration: file.id,
                     batch,
                 });
+                await this.emit("migrated", { migration: file.id, batch });
                 console.log(`Migrated:  ${file.id}`);
             }
             await this.connection.commit();
@@ -103,10 +123,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 migration.down();
                 await new Builder(this.connection, "migrations")
                     .where("id", record.id)
                     .delete();
+                await this.emit("rolledBack", { migration: record.migration, batch });
                 console.log(`Rolled back:  ${record.migration}`);
             }
             await this.connection.commit();
@@ -139,6 +161,87 @@ export class Migrator {
             status: ran.has(file.id) || ran.has(file.fileName) ? "Ran" : "Pending",
         }));
     }
+    async dumpSchema(path) {
+        const sql = await this.getSchemaDumpSql();
+        await mkdir(resolve(path, ".."), { recursive: true });
+        await writeFile(path, sql, "utf-8");
+        await this.emit("schemaDumped", { path });
+        return sql;
+    }
+    async squash(path) {
+        const sql = await this.dumpSchema(path);
+        const files = await this.getMigrationFiles();
+        await this.ensureMigrationsTable();
+        const batch = (await this.getLastBatchNumber()) + 1;
+        await new Builder(this.connection, "migrations").delete();
+        for (const file of files) {
+            await new Builder(this.connection, "migrations").insert({
+                migration: file.id,
+                batch,
+            });
+        }
+        await this.emit("schemaSquashed", { path, batch });
+        return sql;
+    }
+    async getSchemaDumpSql() {
+        const driver = this.connection.getDriverName();
+        if (driver === "sqlite") {
+            const rows = await this.connection.query("SELECT sql FROM sqlite_master WHERE sql IS NOT NULL AND type IN ('table', 'index', 'trigger', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY type = 'table' DESC, name");
+            return rows.map((row) => `${String(row.sql).trim()};`).join("\n\n") + "\n";
+        }
+        if (driver === "mysql") {
+            const tables = await this.connection.query("SHOW TABLES");
+            const key = Object.keys(tables[0] ?? {})[0];
+            const statements = [];
+            for (const row of tables) {
+                const table = row[key];
+                const createRows = await this.connection.query(`SHOW CREATE TABLE ${table}`);
+                statements.push(`${createRows[0]["Create Table"]};`);
+            }
+            return statements.join("\n\n") + "\n";
+        }
+        const schema = this.connection.getSchema() || "public";
+        const tables = await this.connection.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${schema}' AND table_type = 'BASE TABLE' ORDER BY table_name`);
+        const statements = [];
+        for (const tableRow of tables) {
+            const table = tableRow.table_name;
+            const columns = await this.connection.query(`SELECT column_name, data_type, is_nullable, column_default, character_maximum_length, numeric_precision, numeric_scale
+         FROM information_schema.columns
+         WHERE table_schema = '${schema}' AND table_name = '${table}'
+         ORDER BY ordinal_position`);
+            const primaryKeys = await this.connection.query(`SELECT kcu.column_name
+         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
+          AND tc.table_name = kcu.table_name
+         WHERE tc.table_schema = '${schema}'
+           AND tc.table_name = '${table}'
+           AND tc.constraint_type = 'PRIMARY KEY'
+         ORDER BY kcu.ordinal_position`);
+            const pkColumns = primaryKeys.map((row) => row.column_name);
+            const columnSql = columns.map((column) => {
+                let type = String(column.data_type).toUpperCase();
+                if ((type === "CHARACTER VARYING" || type === "CHARACTER") && column.character_maximum_length) {
+                    type = `${type}(${column.character_maximum_length})`;
+                }
+                else if ((type === "NUMERIC" || type === "DECIMAL") && column.numeric_precision) {
+                    type = `${type}(${column.numeric_precision}${column.numeric_scale ? `, ${column.numeric_scale}` : ""})`;
+                }
+                let sql = `  "${column.column_name}" ${type}`;
+                if (column.is_nullable === "NO")
+                    sql += " NOT NULL";
+                if (column.column_default !== null && column.column_default !== undefined)
+                    sql += ` DEFAULT ${column.column_default}`;
+                return sql;
+            });
+            if (pkColumns.length > 0) {
+                columnSql.push(`  PRIMARY KEY (${pkColumns.map((column) => `"${column}"`).join(", ")})`);
+            }
+            statements.push(`CREATE TABLE "${schema}"."${table}" (\n${columnSql.join(",\n")}\n);`);
+        }
+        return statements.join("\n\n") + "\n";
+    }
     async resolve(file) {
         const normalized = toPosixPath(file);
         const candidates = new Set();

package/dist/src/model/Model.d.ts

@@ -13,6 +13,10 @@ export type ModelAttributes<T> = T extends {
 export type ModelColumn<T> = LiteralUnion<Extract<keyof ModelAttributes<T>, string>>;
 export type ModelColumnValue<T, K> = K extends keyof ModelAttributes<T> ? ModelAttributes<T>[K] : any;
 export type ModelAttributeInput<T> = Partial<ModelAttributes<T>> & Record<string, any>;
+export type ModelRelationValue = Relation<any> | MorphTo<any> | MorphOne<any> | MorphMany<any> | MorphToMany<any> | BelongsToMany<any>;
+export type ModelRelationName<T> = LiteralUnion<Extract<{
+    [K in keyof T]-?: T[K] extends (...args: any[]) => ModelRelationValue ? K : never;
+}[keyof T], string>>;
 export type CastDefinition = string | CastsAttributes | (new (...args: any[]) => CastsAttributes);
 export interface CastsAttributes {
     get(model: Model, key: string, value: any, attributes: Record<string, any>): any;
@@ -160,7 +164,7 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static inRandomOrder<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
     static lockForUpdate<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
     static sharedLock<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
-    static with<M extends ModelConstructor>(this: M, ...relations: string[]): Builder<InstanceType<M>>;
+    static with<M extends ModelConstructor>(this: M, ...relations: ModelRelationName<InstanceType<M>>[]): Builder<InstanceType<M>>;
     static withTrashed<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
     static onlyTrashed<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
     static withoutGlobalScope<M extends ModelConstructor>(this: M, scope: string): Builder<InstanceType<M>>;

package/dist/src/model/MorphRelations.d.ts

@@ -6,12 +6,18 @@ export declare class MorphTo<T extends Model = Model> {
     protected typeColumn: string;
     protected idColumn: string;
     protected typeMap?: Record<string, ModelConstructor>;
+    protected eagerModels: Model[];
     constructor(parent: Model, name: string, typeMap?: Record<string, ModelConstructor>);
     getResults(): Promise<T | null>;
+    private resolveRelated;
     private resolveAndFind;
+    private throwMissingMorph;
     addEagerConstraints(models: Model[]): void;
     getEager(): Promise<any[]>;
-    match(models: Model[], _results: any[], relationName: string): void;
+    match(models: Model[], results: Array<{
+        __morphType: string;
+        model: Model;
+    }>, relationName: string): void;
 }
 export declare class MorphOne<T extends Model = Model> {
     protected builder: Builder<T>;

package/dist/src/model/MorphRelations.js

@@ -6,6 +6,7 @@ export class MorphTo {
     typeColumn;
     idColumn;
     typeMap;
+    eagerModels = [];
     constructor(parent, name, typeMap) {
         this.parent = parent;
         this.name = name;
@@ -20,7 +21,7 @@ export class MorphTo {
             return null;
         return this.resolveAndFind(type, id);
     }
-    async resolveAndFind(type, id) {
+    resolveRelated(type) {
         let Related;
         if (this.typeMap) {
             Related = this.typeMap[type];
@@ -28,43 +29,55 @@ export class MorphTo {
         if (!Related) {
             Related = MorphMap.get(type);
         }
-        if (!Related) {
-            throw new Error(`No morph mapping found for type: ${type}. Register it with MorphMap.register() or pass a typeMap.`);
-        }
+        return Related;
+    }
+    async resolveAndFind(type, id) {
+        const Related = this.resolveRelated(type);
+        if (!Related)
+            this.throwMissingMorph(type);
         return Related.on(this.parent.getConnection()).find(id);
     }
+    throwMissingMorph(type) {
+        throw new Error(`No morph mapping found for type: ${type}. Register it with MorphMap.register() or pass a typeMap.`);
+    }
     addEagerConstraints(models) {
-        // MorphTo eager loading is handled separately in getEager
+        this.eagerModels = models;
     }
     async getEager() {
-        return []; // Results are assembled in match
-    }
-    match(models, _results, relationName) {
-        // Group models by type
-        const typeGroups = {};
-        for (const model of models) {
+        const results = [];
+        const groups = {};
+        for (const model of this.eagerModels) {
             const type = model.getAttribute(this.typeColumn);
             if (!type)
                 continue;
-            if (!typeGroups[type])
-                typeGroups[type] = [];
-            typeGroups[type].push(model);
+            if (!groups[type])
+                groups[type] = [];
+            groups[type].push(model);
         }
-        // For each type, find the related models
-        for (const [type, groupModels] of Object.entries(typeGroups)) {
-            const ids = groupModels.map((m) => m.getAttribute(this.idColumn)).filter((id) => id !== null && id !== undefined);
-            if (ids.length === 0)
-                continue;
-            let Related;
-            if (this.typeMap)
-                Related = this.typeMap[type];
-            if (!Related)
-                Related = MorphMap.get(type);
+        for (const [type, models] of Object.entries(groups)) {
+            const Related = this.resolveRelated(type);
             if (!Related)
+                this.throwMissingMorph(type);
+            const ids = [...new Set(models.map((model) => model.getAttribute(this.idColumn)).filter((id) => id !== null && id !== undefined))];
+            if (ids.length === 0)
                 continue;
-            const relatedModels = Related.whereIn(Related.primaryKey, ids).get();
-            // We need to execute this synchronously-ish... but it's async
-            // Actually, we can't do async in for...of without awaiting
+            const relatedModels = await Related.on(models[0].getConnection()).whereIn(Related.primaryKey, ids).get();
+            for (const model of relatedModels) {
+                results.push({ __morphType: type, model });
+            }
+        }
+        return results;
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.model.getAttribute(result.model.constructor.primaryKey);
+            dictionary[`${result.__morphType}:${String(key)}`] = result.model;
+        }
+        for (const model of models) {
+            const type = model.getAttribute(this.typeColumn);
+            const id = model.getAttribute(this.idColumn);
+            model.setRelation(relationName, dictionary[`${type}:${String(id)}`] || null);
         }
     }
 }

package/dist/src/query/Builder.d.ts

@@ -1,6 +1,6 @@
 import { Connection } from "../connection/Connection.js";
 import type { WhereClause, OrderClause, HavingClause, UnionClause } from "../types/index.js";
-import type { ModelAttributeInput, ModelColumn, ModelColumnValue, ModelConstructor } from "../model/Model.js";
+import type { ModelAttributeInput, ModelColumn, ModelColumnValue, ModelConstructor, ModelRelationName } from "../model/Model.js";
 type RelationConstraint = (query: Builder<any>) => void | Builder<any>;
 export interface Paginator<T> {
     data: T[];
@@ -30,6 +30,7 @@ export declare class Builder<T = Record<string, any>> {
     unions: UnionClause[];
     fromRaw?: string;
     updateJoins: string[];
+    bindings: any[];
     constructor(connection: Connection, table: string);
     private get grammar();
     setModel(model: ModelConstructor): this;
@@ -102,7 +103,7 @@ export declare class Builder<T = Record<string, any>> {
     crossJoin(table: string): this;
     union(query: Builder<T> | string, all?: boolean): this;
     unionAll(query: Builder<T> | string): this;
-    with(...relations: string[]): this;
+    with(...relations: ModelRelationName<T>[]): this;
     withoutGlobalScope(scope: string): this;
     withoutGlobalScopes(): this;
     withTrashed(): this;
@@ -157,7 +158,7 @@ export declare class Builder<T = Record<string, any>> {
     paginate(perPage?: number, page?: number): Promise<Paginator<T>>;
     chunk(count: number, callback: (items: T[]) => void | Promise<void>): Promise<void>;
     each(count: number, callback: (item: T) => void | Promise<void>): Promise<void>;
-    cursor(): AsyncGenerator<T>;
+    cursor(keyset?: Record<string, any>): AsyncGenerator<T>;
     lazy(count?: number): AsyncGenerator<T>;
     insert(data: ModelAttributeInput<T> | ModelAttributeInput<T>[]): Promise<any>;
     insertGetId(data: ModelAttributeInput<T>, idColumn?: ModelColumn<T>): Promise<any>;

package/dist/src/query/Builder.js

@@ -18,6 +18,7 @@ export class Builder {
     unions = [];
     fromRaw;
     updateJoins = [];
+    bindings = [];
     constructor(connection, table) {
         this.connection = connection;
         this.tableName = table;
@@ -455,6 +456,7 @@ export class Builder {
         cloned.unions = [...this.unions];
         cloned.fromRaw = this.fromRaw;
         cloned.updateJoins = [...this.updateJoins];
+        cloned.bindings = [...this.bindings];
         return cloned;
     }
     wrapColumn(value) {
@@ -697,14 +699,34 @@ export class Builder {
             }
         });
     }
-    async *cursor() {
-        let offset = 0;
-        while (true) {
-            const items = await this.clone().offset(offset).limit(1).get();
-            if (items.length === 0)
-                break;
-            yield items[0];
-            offset++;
+    async *cursor(keyset) {
+        const model = this.model;
+        const primaryKey = model ? model.primaryKey || "id" : "id";
+        const orderColumn = this.orders[0]?.column || primaryKey;
+        const orderDirection = this.orders[0]?.direction || "asc";
+        const builder = this.clone();
+        builder.orders = [{ column: orderColumn, direction: orderDirection }];
+        builder.offsetValue = undefined;
+        if (keyset) {
+            const op = orderDirection === "asc" ? ">" : "<";
+            builder.wheres.push({
+                type: "basic",
+                column: orderColumn,
+                operator: op,
+                value: keyset[orderColumn],
+                boolean: "and",
+                scope: undefined,
+            });
+        }
+        const items = await builder.limit(1).get();
+        if (items.length === 0)
+            return;
+        yield items[0];
+        const nextKeyset = items[0] && typeof items[0] === "object"
+            ? { [orderColumn]: items[0][orderColumn] }
+            : undefined;
+        if (nextKeyset) {
+            yield* this.cursor(nextKeyset);
         }
     }
     async *lazy(count = 1000) {

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

@@ -14,6 +14,10 @@ export declare class ForeignKeyBuilder {
     on(table: string): this;
     onDelete(action: string): this;
     onUpdate(action: string): this;
+    cascadeOnDelete(): this;
+    restrictOnDelete(): this;
+    nullOnDelete(): this;
+    cascadeOnUpdate(): this;
 }
 export declare class Blueprint {
     readonly table: string;
@@ -47,17 +51,29 @@ export declare class Blueprint {
     jsonb(name: string): this;
     binary(name: string): this;
     uuid(name: string): this;
+    foreignId(name: string): this;
+    foreignUuid(name: string): this;
     enum(name: string, values: string[]): this;
     nullable(): this;
     default(value: any): this;
     unique(): this;
     index(): this;
+    index(columns: string | string[], name?: string): this;
     primary(): this;
     unsigned(): this;
     comment(text: string): this;
+    change(): void;
     timestamps(): void;
     softDeletes(): void;
+    morphs(name: string): void;
+    nullableMorphs(name: string): void;
+    uuidMorphs(name: string): void;
+    nullableUuidMorphs(name: string): void;
     foreign(columns: string | string[], name?: string): ForeignKeyBuilder;
+    constrained(table?: string, column?: string): ForeignKeyBuilder;
+    cascadeOnDelete(): ForeignKeyBuilder;
+    uniqueIndex(columns: string | string[], name?: string): this;
+    private guessConstrainedTable;
     dropColumn(column: string | string[]): void;
     renameColumn(from: string, to: string): void;
     dropIndex(name: string): void;

package/dist/src/schema/Blueprint.js

@@ -22,6 +22,18 @@ export class ForeignKeyBuilder {
         this.fk.onUpdate = action;
         return this;
     }
+    cascadeOnDelete() {
+        return this.onDelete("cascade");
+    }
+    restrictOnDelete() {
+        return this.onDelete("restrict");
+    }
+    nullOnDelete() {
+        return this.onDelete("set null");
+    }
+    cascadeOnUpdate() {
+        return this.onUpdate("cascade");
+    }
 }
 export class Blueprint {
     table;
@@ -126,6 +138,12 @@ export class Blueprint {
     uuid(name) {
         return this.addColumn("uuid", name);
     }
+    foreignId(name) {
+        return this.bigInteger(name).unsigned();
+    }
+    foreignUuid(name) {
+        return this.uuid(name);
+    }
     enum(name, values) {
         this.addColumn("enum", name);
         this.currentColumn.values = values;
@@ -147,10 +165,24 @@ export class Blueprint {
         }
         return this;
     }
-    index() {
-        if (this.currentColumn) {
-            this.currentColumn.index = true;
+    index(columns, name) {
+        if (columns === undefined) {
+            if (this.currentColumn) {
+                this.currentColumn.index = true;
+                this.indexes.push({
+                    name: `${this.table}_${this.currentColumn.name}_index`,
+                    columns: [this.currentColumn.name],
+                    unique: false,
+                });
+            }
+            return this;
         }
+        const cols = Array.isArray(columns) ? columns : [columns];
+        this.indexes.push({
+            name: name || `${this.table}_${cols.join("_")}_index`,
+            columns: cols,
+            unique: false,
+        });
         return this;
     }
     primary() {
@@ -171,6 +203,12 @@ export class Blueprint {
         }
         return this;
     }
+    change() {
+        if (!this.currentColumn) {
+            throw new Error("change() must be called after a column definition.");
+        }
+        this.commands.push({ name: "change", parameters: { column: this.currentColumn } });
+    }
     timestamps() {
         this.timestamp("created_at").nullable();
         this.timestamp("updated_at").nullable();
@@ -178,10 +216,54 @@ export class Blueprint {
     softDeletes() {
         this.timestamp("deleted_at").nullable();
     }
+    morphs(name) {
+        this.string(`${name}_type`);
+        this.bigInteger(`${name}_id`).unsigned();
+        this.index([`${name}_type`, `${name}_id`], `${this.table}_${name}_type_${name}_id_index`);
+    }
+    nullableMorphs(name) {
+        this.string(`${name}_type`).nullable();
+        this.bigInteger(`${name}_id`).unsigned().nullable();
+        this.index([`${name}_type`, `${name}_id`], `${this.table}_${name}_type_${name}_id_index`);
+    }
+    uuidMorphs(name) {
+        this.string(`${name}_type`);
+        this.uuid(`${name}_id`);
+        this.index([`${name}_type`, `${name}_id`], `${this.table}_${name}_type_${name}_id_index`);
+    }
+    nullableUuidMorphs(name) {
+        this.string(`${name}_type`).nullable();
+        this.uuid(`${name}_id`).nullable();
+        this.index([`${name}_type`, `${name}_id`], `${this.table}_${name}_type_${name}_id_index`);
+    }
     foreign(columns, name) {
         const cols = Array.isArray(columns) ? columns : [columns];
         return new ForeignKeyBuilder(this, cols, name);
     }
+    constrained(table, column = "id") {
+        if (!this.currentColumn) {
+            throw new Error("constrained() must be called after a column definition.");
+        }
+        const localColumn = this.currentColumn.name;
+        const foreignTable = table || this.guessConstrainedTable(localColumn);
+        return this.foreign(localColumn).references(column).on(foreignTable);
+    }
+    cascadeOnDelete() {
+        return this.constrained().cascadeOnDelete();
+    }
+    uniqueIndex(columns, name) {
+        const cols = Array.isArray(columns) ? columns : [columns];
+        this.indexes.push({
+            name: name || `${this.table}_${cols.join("_")}_unique`,
+            columns: cols,
+            unique: true,
+        });
+        return this;
+    }
+    guessConstrainedTable(column) {
+        const base = column.endsWith("_id") ? column.slice(0, -3) : column;
+        return `${base}s`;
+    }
     dropColumn(column) {
         this.commands.push({ name: "dropColumn", parameters: { column: Array.isArray(column) ? column : [column] } });
     }

package/dist/src/schema/Schema.js

@@ -40,6 +40,10 @@ export class Schema {
         for (const indexSql of indexes) {
             await this.getConnection().run(indexSql);
         }
+        const fks = grammar.compileForeignKeys(blueprint, connection.qualifyTable(table));
+        for (const fkSql of fks) {
+            await this.getConnection().run(fkSql);
+        }
     }
     static async createIfNotExists(table, callback) {
         const blueprint = new Blueprint(table);
@@ -52,6 +56,10 @@ export class Schema {
         for (const indexSql of indexes) {
             await this.getConnection().run(indexSql);
         }
+        const fks = grammar.compileForeignKeys(blueprint, connection.qualifyTable(table));
+        for (const fkSql of fks) {
+            await this.getConnection().run(fkSql);
+        }
     }
     static async table(table, callback) {
         const blueprint = new Blueprint(table);
@@ -83,6 +91,16 @@ export class Schema {
             else if (command.name === "dropForeign") {
                 await this.getConnection().run(`ALTER TABLE ${grammar.wrap(table)} DROP CONSTRAINT ${grammar.wrap(command.parameters.name)}`);
             }
+            else if (command.name === "change") {
+                const sql = grammar.compileChange(qualifiedTable, command.parameters.column);
+                if (Array.isArray(sql)) {
+                    for (const s of sql)
+                        await this.getConnection().run(s);
+                }
+                else {
+                    await this.getConnection().run(sql);
+                }
+            }
         }
         const addSqls = grammar.compileAdd(blueprint, qualifiedTable);
         for (const sql of addSqls) {

package/dist/src/schema/grammars/Grammar.d.ts

@@ -23,4 +23,5 @@ export declare abstract class Grammar {
     protected compileForeignKey(table: string, fk: ForeignKeyDefinition): string;
     abstract compileColumnRename(table: string, from: string, to: string): string;
     abstract compileDropColumn(table: string, columns: string[]): string | string[];
+    abstract compileChange(table: string, column: ColumnDefinition): string | string[];
 }

package/dist/src/schema/grammars/Grammar.js

@@ -84,7 +84,8 @@ export class Grammar {
         return blueprint.foreignKeys.map((fk) => this.compileForeignKey(table, fk));
     }
     compileForeignKey(table, fk) {
-        const sql = `ALTER TABLE ${this.wrap(table)} ADD CONSTRAINT ${this.wrap(fk.name || "")} FOREIGN KEY (${this.wrapArray(fk.columns).join(", ")}) REFERENCES ${this.wrap(fk.onTable)} (${this.wrapArray(fk.references).join(", ")})`;
+        const constraint = fk.name ? ` CONSTRAINT ${this.wrap(fk.name)}` : "";
+        const sql = `ALTER TABLE ${this.wrap(table)} ADD${constraint} FOREIGN KEY (${this.wrapArray(fk.columns).join(", ")}) REFERENCES ${this.wrap(fk.onTable)} (${this.wrapArray(fk.references).join(", ")})`;
         let full = sql;
         if (fk.onDelete)
             full += ` ON DELETE ${fk.onDelete}`;

package/dist/src/schema/grammars/MySqlGrammar.d.ts

@@ -12,6 +12,7 @@ export declare class MySqlGrammar extends Grammar {
     protected getColumn(_blueprint: any, column: ColumnDefinition): string;
     compileColumnRename(table: string, from: string, to: string): string;
     compileDropColumn(table: string, columns: string[]): string;
+    compileChange(table: string, column: ColumnDefinition): string;
     compileIndex(table: string, index: any): string;
     compileCreate(blueprint: any, table: string): string;
     compileCreateIfNotExists(blueprint: any, table: string): string;

package/dist/src/schema/grammars/MySqlGrammar.js

@@ -79,6 +79,9 @@ export class MySqlGrammar extends Grammar {
     compileDropColumn(table, columns) {
         return `ALTER TABLE ${this.wrap(table)} ${columns.map((col) => `DROP COLUMN ${this.wrap(col)}`).join(", ")}`;
     }
+    compileChange(table, column) {
+        return `ALTER TABLE ${this.wrap(table)} MODIFY COLUMN ${this.getColumn({}, column)}`;
+    }
     compileIndex(table, index) {
         const type = index.unique ? "UNIQUE INDEX" : "INDEX";
         return `ALTER TABLE ${this.wrap(table)} ADD ${type} ${this.wrap(index.name)} (${this.wrapArray(index.columns).join(", ")})`;

package/dist/src/schema/grammars/PostgresGrammar.d.ts

@@ -10,6 +10,7 @@ export declare class PostgresGrammar extends Grammar {
     protected getColumn(_blueprint: any, column: ColumnDefinition): string;
     compileColumnRename(table: string, from: string, to: string): string;
     compileDropColumn(table: string, columns: string[]): string;
+    compileChange(table: string, column: ColumnDefinition): string[];
     compileIndex(table: string, index: any): string;
     compileCreate(blueprint: any, table: string): string;
     compileCreateIfNotExists(blueprint: any, table: string): string;

package/dist/src/schema/grammars/PostgresGrammar.js

@@ -71,6 +71,16 @@ export class PostgresGrammar extends Grammar {
     compileDropColumn(table, columns) {
         return `ALTER TABLE ${this.wrap(table)} ${columns.map((col) => `DROP COLUMN ${this.wrap(col)}`).join(", ")}`;
     }
+    compileChange(table, column) {
+        const statements = [
+            `ALTER TABLE ${this.wrap(table)} ALTER COLUMN ${this.wrap(column.name)} TYPE ${this.getType(column)}`,
+            `ALTER TABLE ${this.wrap(table)} ALTER COLUMN ${this.wrap(column.name)} ${column.nullable ? "DROP" : "SET"} NOT NULL`,
+        ];
+        if (column.default !== undefined) {
+            statements.push(`ALTER TABLE ${this.wrap(table)} ALTER COLUMN ${this.wrap(column.name)} SET DEFAULT ${this.getDefaultValue(column.default)}`);
+        }
+        return statements;
+    }
     compileIndex(table, index) {
         const type = index.unique ? "UNIQUE INDEX" : "INDEX";
         return `CREATE ${type} ${this.wrap(index.name)} ON ${this.wrap(table)} (${this.wrapArray(index.columns).join(", ")})`;

package/dist/src/schema/grammars/SQLiteGrammar.d.ts

@@ -10,6 +10,7 @@ export declare class SQLiteGrammar extends Grammar {
     protected getColumn(_blueprint: any, column: ColumnDefinition): string;
     compileColumnRename(table: string, from: string, to: string): string;
     compileDropColumn(table: string, columns: string[]): string | string[];
+    compileChange(_table: string, _column: ColumnDefinition): string | string[];
     compileForeignKeys(blueprint: any, table: string): string[];
     compileCreate(blueprint: any, table: string): string;
     compileCreateIfNotExists(blueprint: any, table: string): string;

package/dist/src/schema/grammars/SQLiteGrammar.js

@@ -65,6 +65,9 @@ export class SQLiteGrammar extends Grammar {
         // SQLite 3.35.0+ supports dropping columns.
         return columns.map((col) => `ALTER TABLE ${this.wrap(table)} DROP COLUMN ${this.wrap(col)}`);
     }
+    compileChange(_table, _column) {
+        throw new Error("Changing existing columns is not supported by the SQLite grammar.");
+    }
     compileForeignKeys(blueprint, table) {
         // SQLite supports foreign keys inside CREATE TABLE only.
         // For simplicity, ALTER TABLE ADD CONSTRAINT is not supported in SQLite.

package/package.json

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