@bunnykit/orm 0.1.0 → 0.1.1

package/README.md

@@ -1,5 +1,13 @@
 # Bunny
 
+> **Bun-only package.** Install with:
+>
+> ```bash
+> bun add @bunnykit/orm
+> ```
+>
+> npm, yarn, pnpm, and Node.js runtime usage are not supported.
+
 An **Eloquent-inspired ORM** built specifically for [Bun](https://bun.sh)'s native `bun:sql` client. Supports **SQLite**, **MySQL**, and **PostgreSQL** with full TypeScript typing, a chainable query builder, schema migrations, model observers, and polymorphic relations.
 
 ---
@@ -24,8 +32,6 @@ An **Eloquent-inspired ORM** built specifically for [Bun](https://bun.sh)'s nati
 bun add @bunnykit/orm
 ```
 
-> **Note:** This package is Bun-only. Install and run it with Bun >= 1.1; npm, yarn, pnpm, and Node.js runtime usage are not supported.
-
 ---
 
 ## Configuration
@@ -137,6 +143,16 @@ await user.save();
 await user.delete();
 ```
 
+### REPL
+
+Start an interactive Bunny session with the ORM already loaded:
+
+```bash
+bunny repl
+```
+
+The REPL exposes `Model`, `Schema`, `Connection`, and `db`. If no project config is present, it starts against an in-memory SQLite database so you can still experiment immediately.
+
 ---
 
 ## Schema Builder

package/dist/bin/bunny.js

@@ -4,8 +4,125 @@ import { Migrator } from "../src/migration/Migrator.js";
 import { MigrationCreator } from "../src/migration/MigrationCreator.js";
 import { TypeGenerator } from "../src/typegen/TypeGenerator.js";
 import { existsSync } from "fs";
+import { mkdir, writeFile, rm } from "fs/promises";
 import { join } from "path";
-async function loadConfig() {
+import { tmpdir } from "os";
+async function createReplBootstrap(config) {
+    const dir = join(tmpdir(), "bunny-repl");
+    await mkdir(dir, { recursive: true });
+    const bootstrapPath = join(dir, `bootstrap-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
+    const source = `
+    import {
+      BelongsTo,
+      BelongsToMany,
+      Blueprint,
+      Builder,
+      Connection,
+      Grammar,
+      HasMany,
+      HasManyThrough,
+      HasOne,
+      HasOneThrough,
+      Migration,
+      MigrationCreator,
+      Migrator,
+      MorphMany,
+      MorphMap,
+      MorphOne,
+      MorphTo,
+      MorphToMany,
+      MySqlGrammar,
+      ObserverRegistry,
+      PostgresGrammar,
+      Schema,
+      SQLiteGrammar,
+      TypeGenerator,
+      TypeMapper,
+      Model
+    } from "@bunnykit/orm";
+
+    const connection = new Connection(${JSON.stringify(config.connection)});
+    Model.setConnection(connection);
+    Schema.setConnection(connection);
+
+    Object.assign(globalThis, {
+      Connection,
+      Builder,
+      Blueprint,
+      Grammar,
+      SQLiteGrammar,
+      MySqlGrammar,
+      PostgresGrammar,
+      Model,
+      HasMany,
+      BelongsTo,
+      HasOne,
+      HasManyThrough,
+      HasOneThrough,
+      BelongsToMany,
+      MorphMap,
+      MorphTo,
+      MorphOne,
+      MorphMany,
+      MorphToMany,
+      ObserverRegistry,
+      Migration,
+      Migrator,
+      MigrationCreator,
+      TypeGenerator,
+      TypeMapper,
+      Schema,
+      db: connection,
+      connection,
+    });
+
+    console.log('Bunny REPL ready. Use Model, Schema, db, and your own imports.');
+  `;
+    await writeFile(bootstrapPath, source, "utf-8");
+    return bootstrapPath;
+}
+async function runRepl(config, replArgs) {
+    const bootstrapPath = await createReplBootstrap(config);
+    const proc = Bun.spawn(["bun", "repl", ...replArgs], {
+        terminal: {
+            cols: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+            data(_terminal, data) {
+                process.stdout.write(data);
+            },
+        },
+    });
+    const stdin = process.stdin;
+    const terminal = proc.terminal;
+    const restoreRawMode = stdin.isTTY && typeof stdin.setRawMode === "function";
+    if (restoreRawMode) {
+        stdin.setRawMode(true);
+    }
+    stdin.resume();
+    const onData = (chunk) => {
+        terminal.write(chunk);
+    };
+    stdin.on("data", onData);
+    const cleanup = async () => {
+        stdin.off("data", onData);
+        if (restoreRawMode) {
+            stdin.setRawMode(false);
+        }
+        terminal.close();
+        await rm(bootstrapPath, { force: true });
+    };
+    process.once("SIGINT", () => {
+        terminal.close();
+    });
+    process.once("SIGTERM", () => {
+        terminal.close();
+    });
+    terminal.write(`.load ${bootstrapPath}\n`);
+    const exitCode = await proc.exited;
+    await cleanup();
+    return exitCode;
+}
+async function loadConfig(allowFallback = false) {
     const configPath = join(process.cwd(), "bunny.config.ts");
     if (existsSync(configPath)) {
         const mod = await import(configPath);
@@ -39,6 +156,12 @@ async function loadConfig() {
             migrationsPath: process.env.MIGRATIONS_PATH || "./database/migrations",
         };
     }
+    if (allowFallback) {
+        return {
+            connection: { url: "sqlite://:memory:" },
+            migrationsPath: process.env.MIGRATIONS_PATH || "./database/migrations",
+        };
+    }
     throw new Error("No database configuration found. Create bunny.config.ts or set DATABASE_URL / DB_CONNECTION environment variables.");
 }
 async function main() {
@@ -73,6 +196,12 @@ async function main() {
         console.log(`Generated model type declarations in ${outDir}`);
         return;
     }
+    if (command === "repl") {
+        const config = await loadConfig(true);
+        const replArgs = args.slice(1);
+        const exitCode = await runRepl(config, replArgs);
+        process.exit(exitCode);
+    }
     const config = await loadConfig();
     const connection = new Connection(config.connection);
     const migrator = new Migrator(connection, config.migrationsPath, config.typesOutDir, {
@@ -100,6 +229,8 @@ async function main() {
         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 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");
     }
 }
 main().catch((err) => {

package/package.json

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