@bunnykit/orm 0.1.0

package/dist/bin/bunny.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/bin/bunny.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env bun
+import { Connection } from "../src/connection/Connection.js";
+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 { join } from "path";
+async function loadConfig() {
+    const configPath = join(process.cwd(), "bunny.config.ts");
+    if (existsSync(configPath)) {
+        const mod = await import(configPath);
+        return mod.default || mod;
+    }
+    const jsConfigPath = join(process.cwd(), "bunny.config.js");
+    if (existsSync(jsConfigPath)) {
+        const mod = await import(jsConfigPath);
+        return mod.default || mod;
+    }
+    // Fallback to environment variables
+    const url = process.env.DATABASE_URL;
+    if (url) {
+        return {
+            connection: { url },
+            migrationsPath: process.env.MIGRATIONS_PATH || "./database/migrations",
+        };
+    }
+    const driver = process.env.DB_CONNECTION;
+    if (driver) {
+        return {
+            connection: {
+                driver,
+                host: process.env.DB_HOST,
+                port: process.env.DB_PORT ? Number(process.env.DB_PORT) : undefined,
+                database: process.env.DB_DATABASE,
+                username: process.env.DB_USERNAME,
+                password: process.env.DB_PASSWORD,
+                filename: process.env.DB_DATABASE,
+            },
+            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() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (command === "migrate:make") {
+        const name = args[1];
+        if (!name) {
+            console.error("Usage: bun run bunny migrate:make <name>");
+            process.exit(1);
+        }
+        const config = await loadConfig();
+        const creator = new MigrationCreator();
+        const path = await creator.create(name, config.migrationsPath);
+        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 generator = new TypeGenerator(connection, {
+            outDir,
+            stubs: config.typeStubs,
+            declarations: !config.typeStubs,
+            modelDeclarations: config.typeDeclarations,
+            modelDirectory: config.typeDeclarationModelsDir,
+            modelImportPrefix: config.typeDeclarationImportPrefix,
+            singularModels: config.typeDeclarationSingularModels,
+        });
+        await generator.generate();
+        console.log(`Generated model type declarations in ${outDir}`);
+        return;
+    }
+    const config = await loadConfig();
+    const connection = new Connection(config.connection);
+    const migrator = new Migrator(connection, config.migrationsPath, config.typesOutDir, {
+        declarations: !config.typeStubs,
+        stubs: config.typeStubs,
+        modelDeclarations: config.typeDeclarations,
+        modelDirectory: config.typeDeclarationModelsDir,
+        modelImportPrefix: config.typeDeclarationImportPrefix,
+        singularModels: config.typeDeclarationSingularModels,
+    });
+    if (command === "migrate") {
+        await migrator.run();
+    }
+    else if (command === "migrate:rollback") {
+        await migrator.rollback();
+    }
+    else if (command === "migrate:status") {
+        const status = await migrator.status();
+        console.table(status);
+    }
+    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: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");
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

@@ -0,0 +1,13 @@
+import { SQL } from "bun";
+import type { ConnectionConfig } from "../types/index.js";
+export declare class Connection {
+    readonly driver: SQL;
+    private driverName;
+    constructor(config: ConnectionConfig);
+    getDriverName(): "sqlite" | "mysql" | "postgres";
+    query(sqlString: string): Promise<any[]>;
+    run(sqlString: string): Promise<any>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}

package/dist/src/connection/Connection.js

@@ -0,0 +1,49 @@
+import { SQL } from "bun";
+export class Connection {
+    driver;
+    driverName;
+    constructor(config) {
+        let url;
+        if ("url" in config && config.url) {
+            url = config.url;
+        }
+        else if ("driver" in config) {
+            const c = config;
+            if (c.driver === "sqlite") {
+                url = `sqlite://${c.filename || c.database || ":memory:"}`;
+            }
+            else {
+                const protocol = c.driver === "mysql" ? "mysql" : "postgres";
+                url = `${protocol}://${c.username || ""}:${c.password || ""}@${c.host || "localhost"}:${c.port || (c.driver === "mysql" ? 3306 : 5432)}/${c.database || ""}`;
+            }
+        }
+        else {
+            throw new Error("Invalid connection configuration. Provide a url or driver config.");
+        }
+        this.driver = new SQL(url);
+        this.driverName = url.startsWith("sqlite")
+            ? "sqlite"
+            : url.startsWith("mysql")
+                ? "mysql"
+                : "postgres";
+    }
+    getDriverName() {
+        return this.driverName;
+    }
+    async query(sqlString) {
+        // Use unsafe for generated SQL strings
+        return (await this.driver.unsafe(sqlString));
+    }
+    async run(sqlString) {
+        return await this.driver.unsafe(sqlString);
+    }
+    async beginTransaction() {
+        await this.driver.unsafe("BEGIN");
+    }
+    async commit() {
+        await this.driver.unsafe("COMMIT");
+    }
+    async rollback() {
+        await this.driver.unsafe("ROLLBACK");
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,20 @@
+export { Connection } from "./connection/Connection.js";
+export type { ConnectionConfig } from "./types/index.js";
+export { Schema } from "./schema/Schema.js";
+export { Blueprint } from "./schema/Blueprint.js";
+export { Grammar } from "./schema/grammars/Grammar.js";
+export { SQLiteGrammar } from "./schema/grammars/SQLiteGrammar.js";
+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 { ModelConstructor, GlobalScope, CastDefinition, CastsAttributes } from "./model/Model.js";
+export { ObserverRegistry, type ObserverContract } from "./model/Observer.js";
+export { MorphMap } from "./model/MorphMap.js";
+export { MorphTo, MorphOne, MorphMany, MorphToMany } from "./model/MorphRelations.js";
+export { BelongsToMany } from "./model/BelongsToMany.js";
+export { Migration } from "./migration/Migration.js";
+export { Migrator } 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/index.js

@@ -0,0 +1,18 @@
+export { Connection } from "./connection/Connection.js";
+export { Schema } from "./schema/Schema.js";
+export { Blueprint } from "./schema/Blueprint.js";
+export { Grammar } from "./schema/grammars/Grammar.js";
+export { SQLiteGrammar } from "./schema/grammars/SQLiteGrammar.js";
+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 { ObserverRegistry } from "./model/Observer.js";
+export { MorphMap } from "./model/MorphMap.js";
+export { MorphTo, MorphOne, MorphMany, MorphToMany } from "./model/MorphRelations.js";
+export { BelongsToMany } from "./model/BelongsToMany.js";
+export { Migration } from "./migration/Migration.js";
+export { Migrator } 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/Migration.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Migration {
+    abstract up(): Promise<void>;
+    abstract down(): Promise<void>;
+}

package/dist/src/migration/Migration.js

@@ -0,0 +1,2 @@
+export class Migration {
+}

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

@@ -0,0 +1,5 @@
+export declare class MigrationCreator {
+    create(name: string, path: string): Promise<string>;
+    private snakeCase;
+    private toClassName;
+}

package/dist/src/migration/MigrationCreator.js

@@ -0,0 +1,39 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+export class MigrationCreator {
+    async create(name, path) {
+        await mkdir(path, { recursive: true });
+        const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+        const filename = `${timestamp}_${this.snakeCase(name)}.ts`;
+        const filePath = join(path, filename);
+        const stub = `import { Migration } from "@bunnykit/orm";
+import { Schema } from "@bunnykit/orm";
+
+export default class ${this.toClassName(name)} extends Migration {
+  async up(): Promise<void> {
+    // Schema.create("table_name", (table) => {
+    //   table.increments("id");
+    //   table.timestamps();
+    // });
+  }
+
+  async down(): Promise<void> {
+    // Schema.dropIfExists("table_name");
+  }
+}
+`;
+        await writeFile(filePath, stub, "utf-8");
+        return filePath;
+    }
+    snakeCase(str) {
+        return str
+            .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+            .replace(/^_/g, "");
+    }
+    toClassName(name) {
+        return name
+            .split(/[_\-]/)
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join("");
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Connection } from "../connection/Connection.js";
+import type { TypeGeneratorOptions } from "../typegen/TypeGenerator.js";
+export declare class Migrator {
+    private connection;
+    private path;
+    private typesOutDir?;
+    private typeGeneratorOptions;
+    constructor(connection: Connection, path: string, typesOutDir?: string | undefined, typeGeneratorOptions?: Omit<TypeGeneratorOptions, "outDir">);
+    private ensureMigrationsTable;
+    private getRan;
+    private getLastBatchNumber;
+    private getMigrationFiles;
+    run(): Promise<void>;
+    rollback(): Promise<void>;
+    private generateTypesIfNeeded;
+    status(): Promise<{
+        migration: string;
+        status: string;
+    }[]>;
+    private resolve;
+}

package/dist/src/migration/Migrator.js

@@ -0,0 +1,137 @@
+import { readdir } from "fs/promises";
+import { resolve } from "path";
+import { Schema } from "../schema/Schema.js";
+import { Builder } from "../query/Builder.js";
+import { TypeGenerator } from "../typegen/TypeGenerator.js";
+export class Migrator {
+    connection;
+    path;
+    typesOutDir;
+    typeGeneratorOptions;
+    constructor(connection, path, typesOutDir, typeGeneratorOptions = {}) {
+        this.connection = connection;
+        this.path = path;
+        this.typesOutDir = typesOutDir;
+        this.typeGeneratorOptions = typeGeneratorOptions;
+        Schema.setConnection(connection);
+    }
+    async ensureMigrationsTable() {
+        const exists = await Schema.hasTable("migrations");
+        if (!exists) {
+            await Schema.create("migrations", (table) => {
+                table.increments("id");
+                table.string("migration");
+                table.integer("batch");
+            });
+        }
+    }
+    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")
+            .first();
+        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));
+    }
+    async run() {
+        const ran = await this.getRan();
+        const files = await this.getMigrationFiles();
+        const pending = files.filter((f) => !ran.includes(f));
+        if (pending.length === 0) {
+            console.log("Nothing to migrate.");
+            return;
+        }
+        const batch = (await this.getLastBatchNumber()) + 1;
+        await this.connection.beginTransaction();
+        try {
+            for (const file of pending) {
+                const migration = await this.resolve(file);
+                console.log(`Migrating: ${file}`);
+                await migration.up();
+                await new Builder(this.connection, "migrations").insert({
+                    migration: file,
+                    batch,
+                });
+                console.log(`Migrated:  ${file}`);
+            }
+            await this.connection.commit();
+            await this.generateTypesIfNeeded();
+        }
+        catch (error) {
+            await this.connection.rollback();
+            throw error;
+        }
+    }
+    async rollback() {
+        const batch = await this.getLastBatchNumber();
+        if (batch === 0) {
+            console.log("Nothing to rollback.");
+            return;
+        }
+        const records = (await new Builder(this.connection, "migrations")
+            .where("batch", batch)
+            .orderBy("id", "desc")
+            .get());
+        if (records.length === 0) {
+            console.log("Nothing to rollback.");
+            return;
+        }
+        await this.connection.beginTransaction();
+        try {
+            for (const record of records) {
+                const migration = await this.resolve(record.migration);
+                console.log(`Rolling back: ${record.migration}`);
+                await migration.down();
+                await new Builder(this.connection, "migrations")
+                    .where("id", record.id)
+                    .delete();
+                console.log(`Rolled back:  ${record.migration}`);
+            }
+            await this.connection.commit();
+            await this.generateTypesIfNeeded();
+        }
+        catch (error) {
+            await this.connection.rollback();
+            throw error;
+        }
+    }
+    async generateTypesIfNeeded() {
+        if (!this.typesOutDir)
+            return;
+        const generator = new TypeGenerator(this.connection, {
+            declarations: true,
+            ...this.typeGeneratorOptions,
+            outDir: this.typesOutDir,
+        });
+        await generator.generate();
+        console.log(`Regenerated types in ${this.typesOutDir}`);
+    }
+    async status() {
+        const ran = await this.getRan();
+        const files = await this.getMigrationFiles();
+        return files.map((file) => ({
+            migration: file,
+            status: ran.includes(file) ? "Ran" : "Pending",
+        }));
+    }
+    async resolve(file) {
+        const fullPath = resolve(this.path, file);
+        const module = await import(fullPath);
+        const MigrationClass = module.default || Object.values(module)[0];
+        if (!MigrationClass) {
+            throw new Error(`Migration ${file} does not export a class.`);
+        }
+        return new MigrationClass();
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Builder } from "../query/Builder.js";
+import type { Model } from "./Model.js";
+export declare class BelongsToMany<T extends Model = Model> {
+    protected parent: Model;
+    protected related: typeof Model;
+    protected table: string;
+    protected foreignPivotKey: string;
+    protected relatedPivotKey: string;
+    protected parentKey: string;
+    protected relatedKey: string;
+    protected builder: Builder<T>;
+    constructor(parent: Model, related: typeof Model, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string);
+    protected addConstraints(): void;
+    getQuery(): Builder<T>;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], results: any[], relationName: string): void;
+    getResults(): Promise<T[]>;
+    qualifyRelatedColumn(column: string): string;
+    protected newExistenceQuery(parentTable: string, aggregate: string, callback?: (query: Builder<any>) => void | Builder<any>): Builder<any>;
+    getRelationExistenceSql(parentQuery: Builder<any>, callback?: (query: Builder<any>) => void | Builder<any>): string;
+    getRelationCountSql(parentQuery: Builder<any>, callback?: (query: Builder<any>) => void | Builder<any>): string;
+    getRelationAggregateSql(parentQuery: Builder<any>, aggregate: string, callback?: (query: Builder<any>) => void | Builder<any>): string;
+    attach(ids: any | any[], attributes?: Record<string, any>): Promise<void>;
+    detach(ids?: any | any[]): Promise<void>;
+    sync(ids: any | any[], detachMissing?: boolean): Promise<void>;
+}

package/dist/src/model/BelongsToMany.js

@@ -0,0 +1,118 @@
+import { Builder } from "../query/Builder.js";
+import { snakeCase } from "../utils.js";
+function defaultPivotTable(parent, related) {
+    const names = [snakeCase(parent.constructor.name), snakeCase(related.name)].sort();
+    return `${names[0]}_${names[1]}`;
+}
+export class BelongsToMany {
+    parent;
+    related;
+    table;
+    foreignPivotKey;
+    relatedPivotKey;
+    parentKey;
+    relatedKey;
+    builder;
+    constructor(parent, related, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+        this.parent = parent;
+        this.related = related;
+        this.table = table || defaultPivotTable(parent, related);
+        this.parentKey = parentKey || parent.constructor.primaryKey;
+        this.relatedKey = relatedKey || related.primaryKey;
+        this.foreignPivotKey = foreignPivotKey || `${snakeCase(parent.constructor.name)}_id`;
+        this.relatedPivotKey = relatedPivotKey || `${snakeCase(related.name)}_id`;
+        this.builder = related.query();
+        this.addConstraints();
+    }
+    addConstraints() {
+        const relatedTable = this.related.getTable();
+        this.builder.select(`${relatedTable}.*`);
+        this.builder.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
+        this.builder.where(`${this.table}.${this.foreignPivotKey}`, this.parent.getAttribute(this.parentKey));
+    }
+    getQuery() {
+        return this.builder;
+    }
+    addEagerConstraints(models) {
+        const keys = models.map((m) => m.getAttribute(this.parentKey));
+        this.builder = this.related.query();
+        const relatedTable = this.related.getTable();
+        this.builder.select(`${relatedTable}.*`, `${this.table}.${this.foreignPivotKey}`);
+        this.builder.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
+        this.builder.whereIn(`${this.table}.${this.foreignPivotKey}`, keys);
+    }
+    async getEager() {
+        return this.builder.get();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.foreignPivotKey];
+            if (!dictionary[key])
+                dictionary[key] = [];
+            delete result.$attributes[this.foreignPivotKey];
+            dictionary[key].push(result);
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.parentKey);
+            model.setRelation(relationName, dictionary[key] || []);
+        }
+    }
+    async getResults() {
+        return this.builder.get();
+    }
+    qualifyRelatedColumn(column) {
+        return column.includes(".") ? column : `${this.related.getTable()}.${column}`;
+    }
+    newExistenceQuery(parentTable, aggregate, callback) {
+        const relatedTable = this.related.getTable();
+        const query = this.related.query().select(aggregate);
+        query.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
+        query.whereColumn(`${this.table}.${this.foreignPivotKey}`, "=", `${parentTable}.${this.parentKey}`);
+        if (callback)
+            callback(query);
+        return query;
+    }
+    getRelationExistenceSql(parentQuery, callback) {
+        return this.newExistenceQuery(parentQuery.tableName, "1", callback).toSql();
+    }
+    getRelationCountSql(parentQuery, callback) {
+        return this.getRelationAggregateSql(parentQuery, "COUNT(*)", callback);
+    }
+    getRelationAggregateSql(parentQuery, aggregate, callback) {
+        return this.newExistenceQuery(parentQuery.tableName, aggregate, callback).toSql();
+    }
+    async attach(ids, attributes) {
+        const idList = Array.isArray(ids) ? ids : [ids];
+        const records = idList.map((id) => ({
+            [this.foreignPivotKey]: this.parent.getAttribute(this.parentKey),
+            [this.relatedPivotKey]: id,
+            ...attributes,
+        }));
+        await new Builder(this.related.getConnection(), this.table).insert(records);
+    }
+    async detach(ids) {
+        const builder = new Builder(this.related.getConnection(), this.table)
+            .where(this.foreignPivotKey, this.parent.getAttribute(this.parentKey));
+        if (ids !== undefined) {
+            builder.whereIn(this.relatedPivotKey, Array.isArray(ids) ? ids : [ids]);
+        }
+        await builder.delete();
+    }
+    async sync(ids, detachMissing = true) {
+        const idList = Array.isArray(ids) ? ids : [ids];
+        const current = await new Builder(this.related.getConnection(), this.table)
+            .where(this.foreignPivotKey, this.parent.getAttribute(this.parentKey))
+            .pluck(this.relatedPivotKey);
+        const currentSet = new Set(current);
+        const newSet = new Set(idList);
+        if (detachMissing) {
+            const toDetach = current.filter((id) => !newSet.has(id));
+            if (toDetach.length > 0)
+                await this.detach(toDetach);
+        }
+        const toAttach = idList.filter((id) => !currentSet.has(id));
+        if (toAttach.length > 0)
+            await this.attach(toAttach);
+    }
+}