@bunnykit/orm 0.1.0 → 0.1.2

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
@@ -46,7 +52,15 @@ export default {
     // username: "root",
     // password: "secret",
   },
-  migrationsPath: "./database/migrations",
+  migrationsPath: ["./database/migrations", "./database/tenant-migrations"],
+  modelsPath: ["./src/models", "./src/admin/models"],
+  // Optional legacy type output directory
+  typesOutDir: "./src/generated/model-types",
+  // Optional typegen overrides
+  typeDeclarationImportPrefix: "../models",
+  typeDeclarations: {
+    admin_users: { path: "../AdminAccount", className: "AdminAccount" },
+  },
 };
 ```
 
@@ -54,7 +68,9 @@ Or use environment variables:
 
 ```bash
 export DATABASE_URL="sqlite://app.db"
-export MIGRATIONS_PATH="./database/migrations"
+export MIGRATIONS_PATH="./database/migrations,./database/tenant-migrations"
+export MODELS_PATH="./src/models,./src/admin/models"
+export TYPES_OUT_DIR="./src/generated/model-types"
 ```
 
 ---
@@ -137,6 +153,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`, `db`, and a `Models` map. Any model files under `modelsPath` are loaded automatically and also registered by class name on the global scope. If no project config is present, it starts against an in-memory SQLite database so you can still experiment immediately.
+
 ---
 
 ## Schema Builder
@@ -683,6 +709,9 @@ ObserverRegistry.register(User, {
 # Create a new migration file
 bun run bunny migrate:make CreateUsersTable
 
+# Create in a specific folder
+bun run bunny migrate:make CreateUsersTable ./database/tenant-migrations
+
 # Run all pending migrations
 bun run bunny migrate
 
@@ -718,12 +747,14 @@ Migrations are tracked in a `migrations` table (auto-created on first run).
 
 ### Auto Type Generation
 
-If you set `typesOutDir` in your config, types are **automatically regenerated** after every `migrate` and `migrate:rollback`:
+If you set `typesOutDir` in your config, types are **automatically regenerated** after every `migrate` and `migrate:rollback`.
+
+If you set `modelsPath`, Bunny writes declaration files into a `types/` folder next to each model root and regenerates those files after migrations too:
 
 ```bash
 bun run bunny migrate
 # → Migrated: 2026xxxx_create_users_table.ts
-# → Regenerated types in ./src/generated/models
+# → Regenerated types in ./src/models/types, ./src/admin/models/types
 ```
 
 No extra step needed — your models stay in sync with the schema automatically.
@@ -798,6 +829,9 @@ user.email = "a@example.com";  // ✅ typed setter
 # Generate into default directory (./generated/models)
 bun run bunny types:generate
 
+# Generate into model-local ./types folders when modelsPath is configured
+bun run bunny types:generate
+
 # Generate into a custom directory
 bun run bunny types:generate ./src/generated
 ```
@@ -807,23 +841,26 @@ Or configure in `bunny.config.ts`:
 ```ts
 export default {
   connection: { url: "sqlite://app.db" },
-  migrationsPath: "./database/migrations",
-  typesOutDir: "./src/generated/model-types", // auto-regenerate .d.ts files on every migration
+  migrationsPath: ["./database/migrations", "./database/tenant-migrations"],
+  modelsPath: ["./src/models", "./src/admin/models"],
+  // Optional legacy output directory, still supported when you do not want
+  // the generated files beside each model root:
+  typesOutDir: "./src/generated/model-types",
+  // Optional override for custom module resolution when using typesOutDir:
   typeDeclarationImportPrefix: "../models",
-  // Optional overrides for non-conventional model names or paths:
   typeDeclarations: {
-    admin_users: { path: "../models/AdminAccount", className: "AdminAccount" },
+    admin_users: { path: "../AdminAccount", className: "AdminAccount" },
   },
 };
 ```
 
-With `typeDeclarationImportPrefix`, Bunny conventionally maps tables to singular PascalCase model modules:
+With `modelsPath`, Bunny conventionally maps tables to singular PascalCase model modules and writes the generated declarations into `types/` beside each model root:
 
 | Table | Generated augmentation |
 |-------|------------------------|
-| `users` | `../models/User` / `User` |
-| `blog_posts` | `../models/BlogPost` / `BlogPost` |
-| `categories` | `../models/Category` / `Category` |
+| `users` | `../User` / `User` |
+| `blog_posts` | `../BlogPost` / `BlogPost` |
+| `categories` | `../Category` / `Category` |
 
 Set `typeDeclarationSingularModels: false` if your model classes use plural names.
 
@@ -832,7 +869,7 @@ Set `typeDeclarationSingularModels: false` if your model classes use plural name
 For each table, Bunny generates an `Attributes` interface. If you configure `typeDeclarations`, it also augments your real model class:
 
 ```ts
-// generated/model-types/users.d.ts
+// src/models/types/users.d.ts
 export interface UsersAttributes {
   id: number;
   name: string;
@@ -840,7 +877,7 @@ export interface UsersAttributes {
   created_at: string;
 }
 
-declare module "../models/User" {
+declare module "../User" {
   interface User extends UsersAttributes {}
 }
 ```

package/dist/bin/bunny.js

@@ -4,8 +4,201 @@ 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, rm, writeFile } from "fs/promises";
 import { join } from "path";
-async function loadConfig() {
+import { normalizePathList } from "../src/utils.js";
+function parseEnvPathSetting(value) {
+    if (!value)
+        return undefined;
+    const paths = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    if (paths.length === 0)
+        return undefined;
+    return paths.length === 1 ? paths[0] : paths;
+}
+async function createReplBootstrap(config) {
+    const tmpRoot = process.env.BUNNY_REPL_TMPDIR || "/private/tmp";
+    const dir = join(tmpRoot, "bunny-repl");
+    await mkdir(dir, { recursive: true });
+    const bootstrapPath = join(dir, `bootstrap-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
+    const modelRoots = normalizePathList(config.modelsPath || config.typeDeclarationModelsDir);
+    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";
+    import { existsSync } from "fs";
+    import { readdir } from "fs/promises";
+    import { basename, extname, join, resolve } from "path";
+    import { pathToFileURL } from "url";
+
+    const connection = new Connection(${JSON.stringify(config.connection)});
+    Model.setConnection(connection);
+    Schema.setConnection(connection);
+
+    const modelRoots = ${JSON.stringify(modelRoots)};
+
+    async function walkFiles(dir) {
+      const entries = await readdir(dir, { withFileTypes: true });
+      const files = [];
+      for (const entry of entries) {
+        if (entry.name === "types") continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          files.push(...await walkFiles(fullPath));
+          continue;
+        }
+        if (!entry.isFile()) continue;
+        const name = entry.name;
+        if (name.endsWith(".d.ts") || name.endsWith(".test.ts") || name.endsWith(".spec.ts")) continue;
+        if (![".ts", ".js", ".mts", ".mjs", ".cts", ".cjs"].includes(extname(name))) continue;
+        files.push(fullPath);
+      }
+      return files;
+    }
+
+    async function loadModels(roots) {
+      const loaded = {};
+      for (const root of roots) {
+        const resolvedRoot = resolve(process.cwd(), root);
+        if (!existsSync(resolvedRoot)) continue;
+        const files = await walkFiles(resolvedRoot);
+        for (const file of files.sort()) {
+          const mod = await import(pathToFileURL(file).href);
+          for (const [exportName, exported] of Object.entries(mod)) {
+            if (exportName === "default") continue;
+            if (typeof exported === "function" && exported.prototype instanceof Model) {
+              const modelName = exportName;
+              loaded[modelName] = exported;
+              globalThis[modelName] = exported;
+            }
+          }
+          if (typeof mod.default === "function" && mod.default.prototype instanceof Model) {
+            const modelName = mod.default.name || basename(file, extname(file));
+            loaded[modelName] = mod.default;
+            globalThis[modelName] = mod.default;
+          }
+        }
+      }
+      globalThis.Models = loaded;
+      return loaded;
+    }
+
+    const loadedModels = await loadModels(modelRoots);
+
+    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,
+      Models: loadedModels,
+    });
+
+    console.log(\`Bunny REPL ready. Loaded \${Object.keys(loadedModels).length} model classes from modelsPath.\`);
+  `;
+    await writeFile(bootstrapPath, source, "utf-8");
+    return bootstrapPath;
+}
+async function runRepl(config, replArgs) {
+    const bootstrapPath = await createReplBootstrap(config);
+    await mkdir("/private/tmp/bunny-repl-cache", { recursive: true });
+    const proc = Bun.spawn(["bun", "repl", ...replArgs], {
+        env: {
+            ...process.env,
+            TMPDIR: "/private/tmp",
+            TEMP: "/private/tmp",
+            TMP: "/private/tmp",
+            BUN_RUNTIME_TRANSPILER_CACHE_PATH: "/private/tmp/bunny-repl-cache",
+        },
+        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);
@@ -21,7 +214,8 @@ async function loadConfig() {
     if (url) {
         return {
             connection: { url },
-            migrationsPath: process.env.MIGRATIONS_PATH || "./database/migrations",
+            migrationsPath: parseEnvPathSetting(process.env.MIGRATIONS_PATH) || "./database/migrations",
+            modelsPath: parseEnvPathSetting(process.env.MODELS_PATH),
         };
     }
     const driver = process.env.DB_CONNECTION;
@@ -36,7 +230,15 @@ async function loadConfig() {
                 password: process.env.DB_PASSWORD,
                 filename: process.env.DB_DATABASE,
             },
-            migrationsPath: process.env.MIGRATIONS_PATH || "./database/migrations",
+            migrationsPath: parseEnvPathSetting(process.env.MIGRATIONS_PATH) || "./database/migrations",
+            modelsPath: parseEnvPathSetting(process.env.MODELS_PATH),
+        };
+    }
+    if (allowFallback) {
+        return {
+            connection: { url: "sqlite://:memory:" },
+            migrationsPath: parseEnvPathSetting(process.env.MIGRATIONS_PATH) || "./database/migrations",
+            modelsPath: parseEnvPathSetting(process.env.MODELS_PATH),
         };
     }
     throw new Error("No database configuration found. Create bunny.config.ts or set DATABASE_URL / DB_CONNECTION environment variables.");
@@ -47,41 +249,58 @@ async function main() {
     if (command === "migrate:make") {
         const name = args[1];
         if (!name) {
-            console.error("Usage: bun run bunny migrate:make <name>");
+            console.error("Usage: bun run bunny migrate:make <name> [directory]");
             process.exit(1);
         }
         const config = await loadConfig();
         const creator = new MigrationCreator();
-        const path = await creator.create(name, config.migrationsPath);
+        const migrationRoots = normalizePathList(config.migrationsPath);
+        const targetPath = args[2] || migrationRoots[0] || "./database/migrations";
+        const path = await creator.create(name, targetPath);
         console.log(`Created migration: ${path}`);
         return;
     }
     if (command === "types:generate") {
         const config = await loadConfig();
         const connection = new Connection(config.connection);
-        const outDir = args[1] || config.typesOutDir || "./generated/models";
+        const modelRoots = normalizePathList(config.modelsPath || config.typeDeclarationModelsDir);
+        const explicitOutDir = args[1];
+        const useModelTypesFolder = !explicitOutDir && !config.typesOutDir && modelRoots.length > 0;
+        const outDir = explicitOutDir || config.typesOutDir || (useModelTypesFolder ? join(modelRoots[0], "types") : "./generated/models");
         const generator = new TypeGenerator(connection, {
             outDir,
             stubs: config.typeStubs,
             declarations: !config.typeStubs,
             modelDeclarations: config.typeDeclarations,
-            modelDirectory: config.typeDeclarationModelsDir,
+            modelDirectory: !useModelTypesFolder ? modelRoots[0] : undefined,
+            modelDirectories: useModelTypesFolder ? modelRoots : undefined,
             modelImportPrefix: config.typeDeclarationImportPrefix,
             singularModels: config.typeDeclarationSingularModels,
+            declarationDirName: "types",
         });
         await generator.generate();
-        console.log(`Generated model type declarations in ${outDir}`);
+        const outputLabel = useModelTypesFolder ? modelRoots.map((root) => join(root, "types")).join(", ") : outDir;
+        console.log(`Generated model type declarations in ${outputLabel}`);
         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 modelRoots = normalizePathList(config.modelsPath || config.typeDeclarationModelsDir);
     const migrator = new Migrator(connection, config.migrationsPath, config.typesOutDir, {
         declarations: !config.typeStubs,
         stubs: config.typeStubs,
         modelDeclarations: config.typeDeclarations,
-        modelDirectory: config.typeDeclarationModelsDir,
+        modelDirectory: modelRoots[0],
+        modelDirectories: modelRoots.length > 1 ? modelRoots : undefined,
         modelImportPrefix: config.typeDeclarationImportPrefix,
         singularModels: config.typeDeclarationSingularModels,
+        declarationDirName: "types",
     });
     if (command === "migrate") {
         await migrator.run();
@@ -96,10 +315,12 @@ async function main() {
     else {
         console.log("Usage:");
         console.log("  bun run bunny migrate              Run pending migrations");
-        console.log("  bun run bunny migrate:make <name>  Create a new migration");
+        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 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/dist/src/migration/Migrator.d.ts

@@ -5,9 +5,9 @@ export declare class Migrator {
     private path;
     private typesOutDir?;
     private typeGeneratorOptions;
-    constructor(connection: Connection, path: string, typesOutDir?: string | undefined, typeGeneratorOptions?: Omit<TypeGeneratorOptions, "outDir">);
+    constructor(connection: Connection, path: string | string[], typesOutDir?: string | undefined, typeGeneratorOptions?: Omit<TypeGeneratorOptions, "outDir">);
+    private getPaths;
     private ensureMigrationsTable;
-    private getRan;
     private getLastBatchNumber;
     private getMigrationFiles;
     run(): Promise<void>;
@@ -18,4 +18,5 @@ export declare class Migrator {
         status: string;
     }[]>;
     private resolve;
+    private getRan;
 }

package/dist/src/migration/Migrator.js

@@ -1,8 +1,10 @@
+import { existsSync } from "fs";
 import { readdir } from "fs/promises";
-import { resolve } from "path";
+import { basename, join, relative, resolve } from "path";
 import { Schema } from "../schema/Schema.js";
 import { Builder } from "../query/Builder.js";
 import { TypeGenerator } from "../typegen/TypeGenerator.js";
+import { normalizePathList, toPosixPath } from "../utils.js";
 export class Migrator {
     connection;
     path;
@@ -15,6 +17,9 @@ export class Migrator {
         this.typeGeneratorOptions = typeGeneratorOptions;
         Schema.setConnection(connection);
     }
+    getPaths() {
+        return normalizePathList(this.path);
+    }
     async ensureMigrationsTable() {
         const exists = await Schema.hasTable("migrations");
         if (!exists) {
@@ -25,13 +30,6 @@ export class Migrator {
             });
         }
     }
-    async getRan() {
-        await this.ensureMigrationsTable();
-        const results = await new Builder(this.connection, "migrations")
-            .orderBy("id", "asc")
-            .get();
-        return results.map((row) => row.migration);
-    }
     async getLastBatchNumber() {
         const result = await new Builder(this.connection, "migrations")
             .select("MAX(batch) as batch")
@@ -39,15 +37,28 @@ export class Migrator {
         return result?.batch || 0;
     }
     async getMigrationFiles() {
-        const files = await readdir(this.path);
-        return files
-            .filter((f) => f.endsWith(".ts") || f.endsWith(".js"))
-            .sort((a, b) => a.localeCompare(b));
+        const files = [];
+        for (const path of this.getPaths()) {
+            if (!existsSync(path))
+                continue;
+            const entries = await readdir(path);
+            for (const fileName of entries) {
+                if (!fileName.endsWith(".ts") && !fileName.endsWith(".js"))
+                    continue;
+                const fullPath = resolve(path, fileName);
+                files.push({
+                    id: toPosixPath(relative(process.cwd(), fullPath)),
+                    fileName,
+                    fullPath,
+                });
+            }
+        }
+        return files.sort((a, b) => a.fileName.localeCompare(b.fileName) || a.id.localeCompare(b.id));
     }
     async run() {
         const ran = await this.getRan();
         const files = await this.getMigrationFiles();
-        const pending = files.filter((f) => !ran.includes(f));
+        const pending = files.filter((f) => !ran.has(f.id) && !ran.has(f.fileName));
         if (pending.length === 0) {
             console.log("Nothing to migrate.");
             return;
@@ -56,14 +67,14 @@ export class Migrator {
         await this.connection.beginTransaction();
         try {
             for (const file of pending) {
-                const migration = await this.resolve(file);
-                console.log(`Migrating: ${file}`);
+                const migration = await this.resolve(file.id);
+                console.log(`Migrating: ${file.id}`);
                 await migration.up();
                 await new Builder(this.connection, "migrations").insert({
-                    migration: file,
+                    migration: file.id,
                     batch,
                 });
-                console.log(`Migrated:  ${file}`);
+                console.log(`Migrated:  ${file.id}`);
             }
             await this.connection.commit();
             await this.generateTypesIfNeeded();
@@ -107,31 +118,63 @@ export class Migrator {
         }
     }
     async generateTypesIfNeeded() {
-        if (!this.typesOutDir)
+        const modelDirectories = normalizePathList(this.typeGeneratorOptions.modelDirectories || this.typeGeneratorOptions.modelDirectory);
+        if (!this.typesOutDir && modelDirectories.length === 0)
             return;
+        const outDir = this.typesOutDir || join(modelDirectories[0], this.typeGeneratorOptions.declarationDirName || "types");
         const generator = new TypeGenerator(this.connection, {
             declarations: true,
             ...this.typeGeneratorOptions,
-            outDir: this.typesOutDir,
+            outDir,
         });
         await generator.generate();
-        console.log(`Regenerated types in ${this.typesOutDir}`);
+        const label = this.typesOutDir || modelDirectories.map((dir) => join(dir, this.typeGeneratorOptions.declarationDirName || "types")).join(", ");
+        console.log(`Regenerated types in ${label}`);
     }
     async status() {
         const ran = await this.getRan();
         const files = await this.getMigrationFiles();
         return files.map((file) => ({
-            migration: file,
-            status: ran.includes(file) ? "Ran" : "Pending",
+            migration: file.id,
+            status: ran.has(file.id) || ran.has(file.fileName) ? "Ran" : "Pending",
         }));
     }
     async resolve(file) {
-        const fullPath = resolve(this.path, file);
-        const module = await import(fullPath);
+        const normalized = toPosixPath(file);
+        const candidates = new Set();
+        if (normalized.includes("/")) {
+            candidates.add(resolve(process.cwd(), normalized));
+        }
+        else {
+            for (const path of this.getPaths()) {
+                candidates.add(resolve(path, normalized));
+            }
+        }
+        const matches = [...candidates].filter((candidate) => existsSync(candidate));
+        if (matches.length === 0) {
+            throw new Error(`Migration ${file} could not be found in the configured migration paths.`);
+        }
+        if (matches.length > 1) {
+            throw new Error(`Migration ${file} is ambiguous across multiple migration paths.`);
+        }
+        const module = await import(matches[0]);
         const MigrationClass = module.default || Object.values(module)[0];
         if (!MigrationClass) {
             throw new Error(`Migration ${file} does not export a class.`);
         }
         return new MigrationClass();
     }
+    async getRan() {
+        await this.ensureMigrationsTable();
+        const results = await new Builder(this.connection, "migrations")
+            .orderBy("id", "asc")
+            .get();
+        const ran = new Set();
+        for (const row of results) {
+            const migration = toPosixPath(String(row.migration));
+            ran.add(migration);
+            ran.add(basename(migration));
+        }
+        return ran;
+    }
 }

package/dist/src/typegen/TypeGenerator.d.ts

@@ -9,8 +9,10 @@ export interface TypeGeneratorOptions {
     declarations?: boolean;
     modelDeclarations?: Record<string, string | ModelDeclaration>;
     modelDirectory?: string;
+    modelDirectories?: string[];
     modelImportPrefix?: string;
     singularModels?: boolean;
+    declarationDirName?: string;
 }
 export declare class TypeGenerator {
     private connection;
@@ -23,6 +25,7 @@ export declare class TypeGenerator {
     private singularizeTable;
     private singularizeWord;
     private getTables;
+    private getDeclarationTargets;
     private getCurrentDatabase;
     private getColumns;
     private toClassName;

package/dist/src/typegen/TypeGenerator.js

@@ -1,7 +1,7 @@
 import { mkdir, writeFile } from "fs/promises";
 import { join } from "path";
 import { TypeMapper } from "./TypeMapper.js";
-import { snakeCase } from "../utils.js";
+import { normalizePathList, snakeCase } from "../utils.js";
 export class TypeGenerator {
     connection;
     options;
@@ -10,71 +10,75 @@ export class TypeGenerator {
         this.options = options;
     }
     async generate() {
-        await mkdir(this.options.outDir, { recursive: true });
         const tables = await this.getTables();
-        for (const table of tables) {
-            const columns = await this.getColumns(table);
-            const className = this.toClassName(table);
-            const interfaceName = `${className}Attributes`;
-            const lines = [];
-            const declarationOnly = this.options.declarations ?? !this.options.stubs;
-            if (!declarationOnly) {
-                lines.push(`import { Model } from "@bunnykit/orm";`);
-                lines.push("");
-            }
-            lines.push(`export interface ${interfaceName} {`);
-            for (const col of columns) {
-                const tsType = TypeMapper.sqlToTsType(col.type, col.nullable);
-                lines.push(`  ${col.name}${col.nullable ? "?" : ""}: ${tsType};`);
-            }
-            lines.push("}");
-            lines.push("");
-            const modelDeclaration = this.getModelDeclaration(table, className);
-            if (declarationOnly && modelDeclaration) {
-                lines.push(`declare module "${modelDeclaration.path}" {`);
-                lines.push(`  interface ${modelDeclaration.className} extends ${interfaceName} {}`);
-                lines.push("}");
-                lines.push("");
-            }
-            if (!declarationOnly && this.options.stubs) {
-                lines.push(`export class ${className}Base extends Model<${interfaceName}> {`);
-                lines.push(`  static table = "${table}";`);
-                lines.push("");
+        const declarationOnly = this.options.declarations ?? !this.options.stubs;
+        const targets = declarationOnly
+            ? this.getDeclarationTargets()
+            : [{ outDir: this.options.outDir }];
+        for (const target of targets) {
+            await mkdir(target.outDir, { recursive: true });
+            for (const table of tables) {
+                const columns = await this.getColumns(table);
+                const className = this.toClassName(table);
+                const interfaceName = `${className}Attributes`;
+                const lines = [];
+                if (!declarationOnly) {
+                    lines.push(`import { Model } from "@bunnykit/orm";`);
+                    lines.push("");
+                }
+                lines.push(`export interface ${interfaceName} {`);
                 for (const col of columns) {
                     const tsType = TypeMapper.sqlToTsType(col.type, col.nullable);
-                    lines.push(`  get ${col.name}(): ${tsType} {`);
-                    lines.push(`    return this.getAttribute("${col.name}");`);
-                    lines.push(`  }`);
-                    lines.push(`  set ${col.name}(value: ${tsType}) {`);
-                    lines.push(`    this.setAttribute("${col.name}", value);`);
-                    lines.push(`  }`);
-                    lines.push("");
+                    lines.push(`  ${col.name}${col.nullable ? "?" : ""}: ${tsType};`);
                 }
                 lines.push("}");
+                lines.push("");
+                const modelDeclaration = this.getModelDeclaration(table, className, target.modelImportPrefix);
+                if (declarationOnly && modelDeclaration) {
+                    lines.push(`declare module "${modelDeclaration.path}" {`);
+                    lines.push(`  interface ${modelDeclaration.className} extends ${interfaceName} {}`);
+                    lines.push("}");
+                    lines.push("");
+                }
+                if (!declarationOnly && this.options.stubs) {
+                    lines.push(`export class ${className}Base extends Model<${interfaceName}> {`);
+                    lines.push(`  static table = "${table}";`);
+                    lines.push("");
+                    for (const col of columns) {
+                        const tsType = TypeMapper.sqlToTsType(col.type, col.nullable);
+                        lines.push(`  get ${col.name}(): ${tsType} {`);
+                        lines.push(`    return this.getAttribute("${col.name}");`);
+                        lines.push(`  }`);
+                        lines.push(`  set ${col.name}(value: ${tsType}) {`);
+                        lines.push(`    this.setAttribute("${col.name}", value);`);
+                        lines.push(`  }`);
+                        lines.push("");
+                    }
+                    lines.push("}");
+                }
+                const fileName = `${snakeCase(className)}.${declarationOnly ? "d.ts" : "ts"}`;
+                const filePath = join(target.outDir, fileName);
+                await writeFile(filePath, lines.join("\n") + "\n", "utf-8");
             }
-            const fileName = `${snakeCase(className)}.${declarationOnly ? "d.ts" : "ts"}`;
-            const filePath = join(this.options.outDir, fileName);
-            await writeFile(filePath, lines.join("\n") + "\n", "utf-8");
+            const indexLines = tables.map((table) => {
+                const className = this.toClassName(table);
+                const fileName = snakeCase(className);
+                return `export * from "./${fileName}";`;
+            });
+            await writeFile(join(target.outDir, `index.${declarationOnly ? "d.ts" : "ts"}`), indexLines.join("\n") + "\n", "utf-8");
         }
-        const declarationOnly = this.options.declarations ?? !this.options.stubs;
-        const indexLines = tables.map((table) => {
-            const className = this.toClassName(table);
-            const fileName = snakeCase(className);
-            return `export * from "./${fileName}";`;
-        });
-        await writeFile(join(this.options.outDir, `index.${declarationOnly ? "d.ts" : "ts"}`), indexLines.join("\n") + "\n", "utf-8");
     }
-    getModelDeclaration(table, fallbackClassName) {
+    getModelDeclaration(table, fallbackClassName, modelImportPrefix) {
         const declaration = this.options.modelDeclarations?.[table];
         if (!declaration)
-            return this.getConventionModelDeclaration(table);
+            return this.getConventionModelDeclaration(table, modelImportPrefix);
         if (typeof declaration === "string") {
             return { path: declaration, className: this.toModelClassName(table, fallbackClassName) };
         }
         return { path: declaration.path, className: declaration.className || this.toModelClassName(table, fallbackClassName) };
     }
-    getConventionModelDeclaration(table) {
-        const prefix = this.options.modelImportPrefix || this.options.modelDirectory;
+    getConventionModelDeclaration(table, modelImportPrefix) {
+        const prefix = modelImportPrefix || this.options.modelImportPrefix || this.options.modelDirectory;
         if (!prefix)
             return null;
         const className = this.toModelClassName(table);
@@ -129,6 +133,22 @@ export class TypeGenerator {
             return rows.map((r) => r.table_name);
         }
     }
+    getDeclarationTargets() {
+        const modelDirectories = normalizePathList(this.options.modelDirectories || this.options.modelDirectory);
+        if (modelDirectories.length === 0) {
+            return [
+                {
+                    outDir: this.options.outDir,
+                    modelImportPrefix: this.options.modelImportPrefix || this.options.modelDirectory || "",
+                },
+            ];
+        }
+        const declarationDirName = this.options.declarationDirName || "types";
+        return modelDirectories.map((dir) => ({
+            outDir: join(dir, declarationDirName),
+            modelImportPrefix: this.options.modelImportPrefix || "..",
+        }));
+    }
     async getCurrentDatabase() {
         const rows = await this.connection.query("SELECT DATABASE() as db");
         return rows[0]?.db || "";

package/dist/src/utils.d.ts

@@ -1 +1,3 @@
 export declare function snakeCase(str: string): string;
+export declare function normalizePathList(value?: string | string[]): string[];
+export declare function toPosixPath(value: string): string;

package/dist/src/utils.js

@@ -4,3 +4,12 @@ export function snakeCase(str) {
         .toLowerCase()
         .replace(/^_/, "");
 }
+export function normalizePathList(value) {
+    if (!value)
+        return [];
+    const values = Array.isArray(value) ? value : [value];
+    return values.map((item) => item.trim()).filter((item) => item.length > 0);
+}
+export function toPosixPath(value) {
+    return value.replace(/\\/g, "/");
+}

package/package.json

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