@bunnykit/orm 0.1.0

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

@@ -0,0 +1,88 @@
+import { Grammar } from "./Grammar.js";
+export class PostgresGrammar extends Grammar {
+    wrappers = { prefix: '"', suffix: '"' };
+    getType(column) {
+        switch (column.type) {
+            case "string":
+                return `VARCHAR(${column.length || 255})`;
+            case "text":
+                return "TEXT";
+            case "integer":
+                return "INTEGER";
+            case "bigInteger":
+                return "BIGINT";
+            case "smallInteger":
+                return "SMALLINT";
+            case "tinyInteger":
+                return "SMALLINT";
+            case "float":
+                return `REAL`;
+            case "double":
+                return `DOUBLE PRECISION`;
+            case "decimal":
+                return `DECIMAL(${column.precision || 8}, ${column.scale || 2})`;
+            case "boolean":
+                return "BOOLEAN";
+            case "date":
+                return "DATE";
+            case "dateTime":
+                return "TIMESTAMP(0) WITHOUT TIME ZONE";
+            case "time":
+                return "TIME(0) WITHOUT TIME ZONE";
+            case "timestamp":
+                return "TIMESTAMP(0) WITHOUT TIME ZONE";
+            case "json":
+                return "JSON";
+            case "jsonb":
+                return "JSONB";
+            case "binary":
+                return "BYTEA";
+            case "uuid":
+                return "UUID";
+            case "enum":
+                return `VARCHAR(255)`;
+            default:
+                return "TEXT";
+        }
+    }
+    modifyAutoIncrement(column) {
+        if (column.autoIncrement) {
+            return column.type === "bigInteger" ? " GENERATED ALWAYS AS IDENTITY" : " GENERATED ALWAYS AS IDENTITY";
+        }
+        return "";
+    }
+    getColumn(_blueprint, column) {
+        let sql = `${this.wrap(column.name)} ${this.getType(column)}`;
+        if (!column.nullable)
+            sql += " NOT NULL";
+        if (column.default !== undefined)
+            sql += ` DEFAULT ${this.getDefaultValue(column.default)}`;
+        if (column.autoIncrement)
+            sql += this.modifyAutoIncrement(column);
+        if (column.unique)
+            sql += " UNIQUE";
+        if (column.primary)
+            sql += " PRIMARY KEY";
+        return sql;
+    }
+    compileColumnRename(table, from, to) {
+        return `ALTER TABLE ${this.wrap(table)} RENAME COLUMN ${this.wrap(from)} TO ${this.wrap(to)}`;
+    }
+    compileDropColumn(table, columns) {
+        return `ALTER TABLE ${this.wrap(table)} ${columns.map((col) => `DROP COLUMN ${this.wrap(col)}`).join(", ")}`;
+    }
+    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(", ")})`;
+    }
+    compileCreate(blueprint, table) {
+        const columns = this.getColumns(blueprint).map((col) => `    ${col}`).join(",\n");
+        const sql = `CREATE TABLE ${this.wrap(table)} (\n${columns}\n)`;
+        return sql;
+    }
+    compileCreateIfNotExists(blueprint, table) {
+        const columns = this.getColumns(blueprint).map((col) => `    ${col}`).join(",\n");
+        const sql = `CREATE TABLE IF NOT EXISTS ${this.wrap(table)} (\n${columns}\n)`;
+        return sql;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Grammar } from "./Grammar.js";
+import type { ColumnDefinition } from "../../types/index.js";
+export declare class SQLiteGrammar extends Grammar {
+    protected wrappers: {
+        prefix: string;
+        suffix: string;
+    };
+    protected getType(column: ColumnDefinition): string;
+    protected modifyAutoIncrement(column: ColumnDefinition): string;
+    protected getColumn(_blueprint: any, column: ColumnDefinition): string;
+    compileColumnRename(table: string, from: string, to: string): string;
+    compileDropColumn(table: string, columns: string[]): 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

@@ -0,0 +1,108 @@
+import { Grammar } from "./Grammar.js";
+export class SQLiteGrammar extends Grammar {
+    wrappers = { prefix: '"', suffix: '"' };
+    getType(column) {
+        switch (column.type) {
+            case "string":
+                return "TEXT";
+            case "text":
+                return "TEXT";
+            case "integer":
+                return "INTEGER";
+            case "bigInteger":
+                return "INTEGER";
+            case "smallInteger":
+                return "INTEGER";
+            case "tinyInteger":
+                return "INTEGER";
+            case "float":
+            case "double":
+            case "decimal":
+                return "REAL";
+            case "boolean":
+                return "INTEGER";
+            case "date":
+            case "dateTime":
+            case "time":
+            case "timestamp":
+                return "TEXT";
+            case "json":
+            case "jsonb":
+                return "TEXT";
+            case "binary":
+                return "BLOB";
+            case "uuid":
+                return "TEXT";
+            case "enum":
+                return "TEXT";
+            default:
+                return "TEXT";
+        }
+    }
+    modifyAutoIncrement(column) {
+        if (column.autoIncrement)
+            return " PRIMARY KEY AUTOINCREMENT";
+        return "";
+    }
+    getColumn(_blueprint, column) {
+        let sql = `${this.wrap(column.name)} ${this.getType(column)}`;
+        if (column.autoIncrement)
+            sql += this.modifyAutoIncrement(column);
+        if (!column.nullable)
+            sql += " NOT NULL";
+        if (column.default !== undefined)
+            sql += ` DEFAULT ${this.getDefaultValue(column.default)}`;
+        if (column.unique && !column.autoIncrement)
+            sql += " UNIQUE";
+        return sql;
+    }
+    compileColumnRename(table, from, to) {
+        return `ALTER TABLE ${this.wrap(table)} RENAME COLUMN ${this.wrap(from)} TO ${this.wrap(to)}`;
+    }
+    compileDropColumn(table, columns) {
+        // SQLite 3.35.0+ supports dropping columns.
+        return columns.map((col) => `ALTER TABLE ${this.wrap(table)} DROP COLUMN ${this.wrap(col)}`);
+    }
+    compileForeignKeys(blueprint, table) {
+        // SQLite supports foreign keys inside CREATE TABLE only.
+        // For simplicity, ALTER TABLE ADD CONSTRAINT is not supported in SQLite.
+        // We'll add inline foreign keys in CREATE TABLE by overriding compileCreate.
+        return [];
+    }
+    compileCreate(blueprint, table) {
+        const columns = this.getColumns(blueprint).map((col) => `    ${col}`).join(",\n");
+        const fks = blueprint.foreignKeys
+            .map((fk) => {
+            let sql = `    FOREIGN KEY (${this.wrapArray(fk.columns).join(", ")}) REFERENCES ${this.wrap(fk.onTable)} (${this.wrapArray(fk.references).join(", ")})`;
+            if (fk.onDelete)
+                sql += ` ON DELETE ${fk.onDelete}`;
+            if (fk.onUpdate)
+                sql += ` ON UPDATE ${fk.onUpdate}`;
+            return sql;
+        })
+            .join(",\n");
+        let sql = `CREATE TABLE ${this.wrap(table)} (\n${columns}`;
+        if (fks)
+            sql += `,\n${fks}`;
+        sql += "\n)";
+        return sql;
+    }
+    compileCreateIfNotExists(blueprint, table) {
+        const columns = this.getColumns(blueprint).map((col) => `    ${col}`).join(",\n");
+        const fks = blueprint.foreignKeys
+            .map((fk) => {
+            let sql = `    FOREIGN KEY (${this.wrapArray(fk.columns).join(", ")}) REFERENCES ${this.wrap(fk.onTable)} (${this.wrapArray(fk.references).join(", ")})`;
+            if (fk.onDelete)
+                sql += ` ON DELETE ${fk.onDelete}`;
+            if (fk.onUpdate)
+                sql += ` ON UPDATE ${fk.onUpdate}`;
+            return sql;
+        })
+            .join(",\n");
+        let sql = `CREATE TABLE IF NOT EXISTS ${this.wrap(table)} (\n${columns}`;
+        if (fks)
+            sql += `,\n${fks}`;
+        sql += "\n)";
+        return sql;
+    }
+}

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

@@ -0,0 +1,29 @@
+import { Connection } from "../connection/Connection.js";
+export interface ModelDeclaration {
+    path: string;
+    className?: string;
+}
+export interface TypeGeneratorOptions {
+    outDir: string;
+    stubs?: boolean;
+    declarations?: boolean;
+    modelDeclarations?: Record<string, string | ModelDeclaration>;
+    modelDirectory?: string;
+    modelImportPrefix?: string;
+    singularModels?: boolean;
+}
+export declare class TypeGenerator {
+    private connection;
+    private options;
+    constructor(connection: Connection, options: TypeGeneratorOptions);
+    generate(): Promise<void>;
+    private getModelDeclaration;
+    private getConventionModelDeclaration;
+    private toModelClassName;
+    private singularizeTable;
+    private singularizeWord;
+    private getTables;
+    private getCurrentDatabase;
+    private getColumns;
+    private toClassName;
+}

package/dist/src/typegen/TypeGenerator.js

@@ -0,0 +1,171 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { TypeMapper } from "./TypeMapper.js";
+import { snakeCase } from "../utils.js";
+export class TypeGenerator {
+    connection;
+    options;
+    constructor(connection, options) {
+        this.connection = connection;
+        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("");
+                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(this.options.outDir, fileName);
+            await writeFile(filePath, lines.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) {
+        const declaration = this.options.modelDeclarations?.[table];
+        if (!declaration)
+            return this.getConventionModelDeclaration(table);
+        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;
+        if (!prefix)
+            return null;
+        const className = this.toModelClassName(table);
+        return {
+            path: `${prefix.replace(/\/$/, "")}/${className}`,
+            className,
+        };
+    }
+    toModelClassName(table, fallback) {
+        if (this.options.singularModels === false) {
+            return fallback || this.toClassName(table);
+        }
+        return this.toClassName(this.singularizeTable(table));
+    }
+    singularizeTable(table) {
+        return table
+            .split("_")
+            .map((part) => this.singularizeWord(part))
+            .join("_");
+    }
+    singularizeWord(word) {
+        if (word.endsWith("ies") && word.length > 3)
+            return `${word.slice(0, -3)}y`;
+        if (word.endsWith("ses") || word.endsWith("xes") || word.endsWith("zes") || word.endsWith("ches") || word.endsWith("shes")) {
+            return word.slice(0, -2);
+        }
+        if (word.endsWith("s") && !word.endsWith("ss"))
+            return word.slice(0, -1);
+        return word;
+    }
+    async getTables() {
+        const driver = this.connection.getDriverName();
+        let sql;
+        if (driver === "sqlite") {
+            sql = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_inner_sequence' AND name != 'migrations'`;
+        }
+        else if (driver === "mysql") {
+            sql = "SHOW TABLES";
+        }
+        else {
+            sql = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE'`;
+        }
+        const rows = await this.connection.query(sql);
+        if (driver === "sqlite") {
+            return rows.map((r) => r.name);
+        }
+        else if (driver === "mysql") {
+            const key = Object.keys(rows[0] ?? {})[0] ?? "Tables_in_" + (await this.getCurrentDatabase());
+            return rows.map((r) => r[key]);
+        }
+        else {
+            return rows.map((r) => r.table_name);
+        }
+    }
+    async getCurrentDatabase() {
+        const rows = await this.connection.query("SELECT DATABASE() as db");
+        return rows[0]?.db || "";
+    }
+    async getColumns(table) {
+        const driver = this.connection.getDriverName();
+        if (driver === "sqlite") {
+            const rows = await this.connection.query(`PRAGMA table_info(${table})`);
+            return rows.map((r) => ({
+                name: r.name,
+                type: r.type,
+                nullable: !r.notnull,
+                default: r.dflt_value,
+            }));
+        }
+        if (driver === "mysql") {
+            const rows = await this.connection.query(`SHOW COLUMNS FROM ${table}`);
+            return rows.map((r) => ({
+                name: r.Field,
+                type: r.Type,
+                nullable: r.Null === "YES",
+                default: r.Default,
+            }));
+        }
+        // postgres
+        const rows = await this.connection.query(`SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = '${table}' AND table_schema = 'public' ORDER BY ordinal_position`);
+        return rows.map((r) => ({
+            name: r.column_name,
+            type: r.data_type,
+            nullable: r.is_nullable === "YES",
+            default: r.column_default,
+        }));
+    }
+    toClassName(table) {
+        return table
+            .split("_")
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join("");
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare class TypeMapper {
+    static sqlToTsType(sqlType: string, nullable: boolean): string;
+    private static mapBaseType;
+}

package/dist/src/typegen/TypeMapper.js

@@ -0,0 +1,27 @@
+export class TypeMapper {
+    static sqlToTsType(sqlType, nullable) {
+        const base = this.mapBaseType(sqlType);
+        return nullable && base !== "any" ? `${base} | null` : base;
+    }
+    static mapBaseType(sqlType) {
+        const t = sqlType.toLowerCase();
+        // Integers & numbers
+        if (/int|serial|float|double|real|decimal|numeric/.test(t)) {
+            return "number";
+        }
+        // Boolean
+        if (/bool/.test(t)) {
+            return "boolean";
+        }
+        // JSON
+        if (/json/.test(t)) {
+            return "any";
+        }
+        // Binary / BLOB
+        if (/blob|bytea|binary|varbinary/.test(t)) {
+            return "Buffer";
+        }
+        // Default to string for everything else (varchar, text, char, date, enum, uuid, etc.)
+        return "string";
+    }
+}

package/dist/src/types/index.d.ts

@@ -0,0 +1,53 @@
+export type ColumnType = "string" | "text" | "integer" | "bigInteger" | "smallInteger" | "tinyInteger" | "float" | "double" | "decimal" | "boolean" | "date" | "dateTime" | "time" | "timestamp" | "json" | "jsonb" | "binary" | "uuid" | "enum";
+export interface ColumnDefinition {
+    name: string;
+    type: ColumnType;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    nullable: boolean;
+    default?: any;
+    autoIncrement: boolean;
+    primary: boolean;
+    unique: boolean;
+    index: boolean;
+    unsigned: boolean;
+    values?: string[];
+    comment?: string;
+}
+export interface IndexDefinition {
+    name: string;
+    columns: string[];
+    unique: boolean;
+}
+export interface ForeignKeyDefinition {
+    name?: string;
+    columns: string[];
+    references: string[];
+    onTable: string;
+    onDelete?: string;
+    onUpdate?: string;
+}
+export interface WhereClause {
+    type: "basic" | "in" | "null" | "raw" | "between" | "column" | "exists";
+    column: string;
+    operator?: string;
+    value?: any;
+    boolean: "and" | "or";
+    scope?: string;
+}
+export interface OrderClause {
+    column: string;
+    direction: "asc" | "desc";
+}
+export type ConnectionConfig = {
+    url: string;
+} | {
+    driver: "sqlite" | "mysql" | "postgres";
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    filename?: string;
+};

package/dist/src/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils.d.ts

@@ -0,0 +1 @@
+export declare function snakeCase(str: string): string;

package/dist/src/utils.js

@@ -0,0 +1,6 @@
+export function snakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, "_$1")
+        .toLowerCase()
+        .replace(/^_/, "");
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@bunnykit/orm",
+  "version": "0.1.0",
+  "description": "An Eloquent-inspired ORM for Bun's native SQL client supporting SQLite, MySQL, and PostgreSQL.",
+  "license": "MIT",
+  "packageManager": "bun@1.3.12",
+  "keywords": [
+    "bun",
+    "orm",
+    "eloquent",
+    "sqlite",
+    "mysql",
+    "postgresql",
+    "database"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bunnykit/orm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bunnykit/orm/issues"
+  },
+  "homepage": "https://github.com/bunnykit/orm#readme",
+  "main": "dist/src/index.js",
+  "module": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "type": "module",
+  "bin": {
+    "bunny": "dist/bin/bunny.js"
+  },
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "preinstall": "bun -e \"const ua = process.env.npm_config_user_agent || ''; if (!ua.startsWith('bun/')) { console.error('@bunnykit/orm is Bun-only. Install it with: bun add @bunnykit/orm'); process.exit(1); }\"",
+    "build": "tsc",
+    "prepack": "bun run build",
+    "migrate": "bun run bin/bunny.ts migrate",
+    "migrate:make": "bun run bin/bunny.ts migrate:make",
+    "migrate:rollback": "bun run bin/bunny.ts migrate:rollback",
+    "migrate:status": "bun run bin/bunny.ts migrate:status"
+  },
+  "dependencies": {},
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.4.0"
+  }
+}