@bunnykit/orm 0.1.0

package/dist/src/schema/Blueprint.js

@@ -0,0 +1,200 @@
+export class ForeignKeyBuilder {
+    fk;
+    blueprint;
+    constructor(blueprint, columns, name) {
+        this.blueprint = blueprint;
+        this.fk = { name, columns, references: [], onTable: "" };
+        blueprint.foreignKeys.push(this.fk);
+    }
+    references(columns) {
+        this.fk.references = Array.isArray(columns) ? columns : [columns];
+        return this;
+    }
+    on(table) {
+        this.fk.onTable = table;
+        return this;
+    }
+    onDelete(action) {
+        this.fk.onDelete = action;
+        return this;
+    }
+    onUpdate(action) {
+        this.fk.onUpdate = action;
+        return this;
+    }
+}
+export class Blueprint {
+    table;
+    columns = [];
+    indexes = [];
+    foreignKeys = [];
+    commands = [];
+    currentColumn;
+    constructor(table) {
+        this.table = table;
+    }
+    addColumn(type, name, length) {
+        const column = {
+            name,
+            type,
+            length,
+            nullable: false,
+            autoIncrement: false,
+            primary: false,
+            unique: false,
+            index: false,
+            unsigned: false,
+        };
+        this.columns.push(column);
+        this.currentColumn = column;
+        return this;
+    }
+    increments(name = "id") {
+        const col = this.addColumn("integer", name);
+        col.currentColumn.autoIncrement = true;
+        col.currentColumn.primary = true;
+        col.currentColumn.unsigned = true;
+        return this;
+    }
+    bigIncrements(name = "id") {
+        const col = this.addColumn("bigInteger", name);
+        col.currentColumn.autoIncrement = true;
+        col.currentColumn.primary = true;
+        col.currentColumn.unsigned = true;
+        return this;
+    }
+    string(name, length = 255) {
+        return this.addColumn("string", name, length);
+    }
+    text(name) {
+        return this.addColumn("text", name);
+    }
+    integer(name) {
+        return this.addColumn("integer", name);
+    }
+    bigInteger(name) {
+        return this.addColumn("bigInteger", name);
+    }
+    smallInteger(name) {
+        return this.addColumn("smallInteger", name);
+    }
+    tinyInteger(name) {
+        return this.addColumn("tinyInteger", name);
+    }
+    float(name, precision = 8, scale = 2) {
+        this.addColumn("float", name);
+        this.currentColumn.precision = precision;
+        this.currentColumn.scale = scale;
+        return this;
+    }
+    double(name, precision = 8, scale = 2) {
+        this.addColumn("double", name);
+        this.currentColumn.precision = precision;
+        this.currentColumn.scale = scale;
+        return this;
+    }
+    decimal(name, precision = 8, scale = 2) {
+        this.addColumn("decimal", name);
+        this.currentColumn.precision = precision;
+        this.currentColumn.scale = scale;
+        return this;
+    }
+    boolean(name) {
+        return this.addColumn("boolean", name);
+    }
+    date(name) {
+        return this.addColumn("date", name);
+    }
+    dateTime(name) {
+        return this.addColumn("dateTime", name);
+    }
+    time(name) {
+        return this.addColumn("time", name);
+    }
+    timestamp(name) {
+        return this.addColumn("timestamp", name);
+    }
+    json(name) {
+        return this.addColumn("json", name);
+    }
+    jsonb(name) {
+        return this.addColumn("jsonb", name);
+    }
+    binary(name) {
+        return this.addColumn("binary", name);
+    }
+    uuid(name) {
+        return this.addColumn("uuid", name);
+    }
+    enum(name, values) {
+        this.addColumn("enum", name);
+        this.currentColumn.values = values;
+        return this;
+    }
+    nullable() {
+        if (this.currentColumn)
+            this.currentColumn.nullable = true;
+        return this;
+    }
+    default(value) {
+        if (this.currentColumn)
+            this.currentColumn.default = value;
+        return this;
+    }
+    unique() {
+        if (this.currentColumn) {
+            this.currentColumn.unique = true;
+        }
+        return this;
+    }
+    index() {
+        if (this.currentColumn) {
+            this.currentColumn.index = true;
+        }
+        return this;
+    }
+    primary() {
+        if (this.currentColumn) {
+            this.currentColumn.primary = true;
+        }
+        return this;
+    }
+    unsigned() {
+        if (this.currentColumn) {
+            this.currentColumn.unsigned = true;
+        }
+        return this;
+    }
+    comment(text) {
+        if (this.currentColumn) {
+            this.currentColumn.comment = text;
+        }
+        return this;
+    }
+    timestamps() {
+        this.timestamp("created_at").nullable();
+        this.timestamp("updated_at").nullable();
+    }
+    softDeletes() {
+        this.timestamp("deleted_at").nullable();
+    }
+    foreign(columns, name) {
+        const cols = Array.isArray(columns) ? columns : [columns];
+        return new ForeignKeyBuilder(this, cols, name);
+    }
+    dropColumn(column) {
+        this.commands.push({ name: "dropColumn", parameters: { column: Array.isArray(column) ? column : [column] } });
+    }
+    renameColumn(from, to) {
+        this.commands.push({ name: "renameColumn", parameters: { from, to } });
+    }
+    dropIndex(name) {
+        this.commands.push({ name: "dropIndex", parameters: { name } });
+    }
+    dropUnique(name) {
+        this.commands.push({ name: "dropUnique", parameters: { name } });
+    }
+    dropForeign(name) {
+        this.commands.push({ name: "dropForeign", parameters: { name } });
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Connection } from "../connection/Connection.js";
+import { Blueprint } from "./Blueprint.js";
+export declare class Schema {
+    static connection: Connection;
+    static setConnection(connection: Connection): void;
+    static getConnection(): Connection;
+    private static getGrammar;
+    static create(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
+    static createIfNotExists(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
+    static table(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
+    static drop(table: string): Promise<void>;
+    static dropIfExists(table: string): Promise<void>;
+    static rename(from: string, to: string): Promise<void>;
+    static hasTable(table: string): Promise<boolean>;
+    static hasColumn(table: string, column: string): Promise<boolean>;
+}

package/dist/src/schema/Schema.js

@@ -0,0 +1,135 @@
+import { Blueprint } from "./Blueprint.js";
+import { SQLiteGrammar } from "./grammars/SQLiteGrammar.js";
+import { MySqlGrammar } from "./grammars/MySqlGrammar.js";
+import { PostgresGrammar } from "./grammars/PostgresGrammar.js";
+export class Schema {
+    static connection;
+    static setConnection(connection) {
+        this.connection = connection;
+    }
+    static getConnection() {
+        if (!this.connection) {
+            throw new Error("No database connection set.");
+        }
+        return this.connection;
+    }
+    static getGrammar() {
+        const driver = this.getConnection().getDriverName();
+        switch (driver) {
+            case "sqlite":
+                return new SQLiteGrammar();
+            case "mysql":
+                return new MySqlGrammar();
+            case "postgres":
+                return new PostgresGrammar();
+        }
+    }
+    static async create(table, callback) {
+        const blueprint = new Blueprint(table);
+        callback(blueprint);
+        const grammar = this.getGrammar();
+        const sql = grammar.compileCreate(blueprint, table);
+        await this.getConnection().run(sql);
+        const indexes = grammar.compileIndexes(blueprint, table);
+        for (const indexSql of indexes) {
+            await this.getConnection().run(indexSql);
+        }
+    }
+    static async createIfNotExists(table, callback) {
+        const blueprint = new Blueprint(table);
+        callback(blueprint);
+        const grammar = this.getGrammar();
+        const sql = grammar.compileCreateIfNotExists(blueprint, table);
+        await this.getConnection().run(sql);
+        const indexes = grammar.compileIndexes(blueprint, table);
+        for (const indexSql of indexes) {
+            await this.getConnection().run(indexSql);
+        }
+    }
+    static async table(table, callback) {
+        const blueprint = new Blueprint(table);
+        callback(blueprint);
+        const grammar = this.getGrammar();
+        for (const command of blueprint.commands) {
+            if (command.name === "dropColumn") {
+                const sql = grammar.compileDropColumn(table, command.parameters.column);
+                if (Array.isArray(sql)) {
+                    for (const s of sql)
+                        await this.getConnection().run(s);
+                }
+                else {
+                    await this.getConnection().run(sql);
+                }
+            }
+            else if (command.name === "renameColumn") {
+                const sql = grammar.compileColumnRename(table, command.parameters.from, command.parameters.to);
+                await this.getConnection().run(sql);
+            }
+            else if (command.name === "dropIndex") {
+                await this.getConnection().run(`DROP INDEX ${grammar.wrap(command.parameters.name)}`);
+            }
+            else if (command.name === "dropUnique") {
+                await this.getConnection().run(`DROP INDEX ${grammar.wrap(command.parameters.name)}`);
+            }
+            else if (command.name === "dropForeign") {
+                await this.getConnection().run(`ALTER TABLE ${grammar.wrap(table)} DROP CONSTRAINT ${grammar.wrap(command.parameters.name)}`);
+            }
+        }
+        const addSqls = grammar.compileAdd(blueprint, table);
+        for (const sql of addSqls) {
+            await this.getConnection().run(sql);
+        }
+        const indexes = grammar.compileIndexes(blueprint, table);
+        for (const indexSql of indexes) {
+            await this.getConnection().run(indexSql);
+        }
+        const fks = grammar.compileForeignKeys(blueprint, table);
+        for (const fkSql of fks) {
+            await this.getConnection().run(fkSql);
+        }
+    }
+    static async drop(table) {
+        const grammar = this.getGrammar();
+        await this.getConnection().run(grammar.compileDrop(table));
+    }
+    static async dropIfExists(table) {
+        const grammar = this.getGrammar();
+        await this.getConnection().run(grammar.compileDropIfExists(table));
+    }
+    static async rename(from, to) {
+        const grammar = this.getGrammar();
+        await this.getConnection().run(grammar.compileRename(from, to));
+    }
+    static async hasTable(table) {
+        const driver = this.getConnection().getDriverName();
+        let sql;
+        if (driver === "sqlite") {
+            sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${table}'`;
+        }
+        else if (driver === "mysql") {
+            sql = `SHOW TABLES LIKE '${table}'`;
+        }
+        else {
+            sql = `SELECT * FROM information_schema.tables WHERE table_name = '${table}'`;
+        }
+        const result = await this.getConnection().query(sql);
+        return result.length > 0;
+    }
+    static async hasColumn(table, column) {
+        const driver = this.getConnection().getDriverName();
+        let sql;
+        if (driver === "sqlite") {
+            sql = `PRAGMA table_info(${table})`;
+            const result = await this.getConnection().query(sql);
+            return result.some((row) => row.name === column);
+        }
+        else if (driver === "mysql") {
+            sql = `SHOW COLUMNS FROM ${table} LIKE '${column}'`;
+        }
+        else {
+            sql = `SELECT column_name FROM information_schema.columns WHERE table_name = '${table}' AND column_name = '${column}'`;
+        }
+        const result = await this.getConnection().query(sql);
+        return result.length > 0;
+    }
+}

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

@@ -0,0 +1,26 @@
+import { Blueprint } from "../Blueprint.js";
+import type { ColumnDefinition, IndexDefinition, ForeignKeyDefinition } from "../../types/index.js";
+export declare abstract class Grammar {
+    protected wrappers: Record<string, string>;
+    wrap(value: string): string;
+    wrapArray(values: string[]): string[];
+    compileCreate(blueprint: Blueprint, table: string): string;
+    compileCreateIfNotExists(blueprint: Blueprint, table: string): string;
+    compileDrop(table: string): string;
+    compileDropIfExists(table: string): string;
+    compileRename(from: string, to: string): string;
+    compileAdd(blueprint: Blueprint, table: string): string[];
+    protected getColumns(blueprint: Blueprint): string[];
+    protected getColumn(_blueprint: Blueprint, column: ColumnDefinition): string;
+    protected abstract getType(column: ColumnDefinition): string;
+    protected modifyUnsigned(_column: ColumnDefinition): string;
+    protected modifyAutoIncrement(_column: ColumnDefinition): string;
+    protected modifyComment(_column: ColumnDefinition): string;
+    protected getDefaultValue(value: any): string;
+    compileIndexes(blueprint: Blueprint, table: string): string[];
+    protected compileIndex(table: string, index: IndexDefinition): string;
+    compileForeignKeys(blueprint: Blueprint, table: string): string[];
+    protected compileForeignKey(table: string, fk: ForeignKeyDefinition): string;
+    abstract compileColumnRename(table: string, from: string, to: string): string;
+    abstract compileDropColumn(table: string, columns: string[]): string | string[];
+}

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

@@ -0,0 +1,95 @@
+export class Grammar {
+    wrappers = { prefix: '"', suffix: '"' };
+    wrap(value) {
+        if (value.includes(".")) {
+            return value.split(".").map((v) => this.wrap(v)).join(".");
+        }
+        const { prefix, suffix } = this.wrappers;
+        return `${prefix}${value}${suffix}`;
+    }
+    wrapArray(values) {
+        return values.map((v) => this.wrap(v));
+    }
+    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");
+        return `CREATE TABLE IF NOT EXISTS ${this.wrap(table)} (\n${columns}\n)`;
+    }
+    compileDrop(table) {
+        return `DROP TABLE ${this.wrap(table)}`;
+    }
+    compileDropIfExists(table) {
+        return `DROP TABLE IF EXISTS ${this.wrap(table)}`;
+    }
+    compileRename(from, to) {
+        return `ALTER TABLE ${this.wrap(from)} RENAME TO ${this.wrap(to)}`;
+    }
+    compileAdd(blueprint, table) {
+        const columns = this.getColumns(blueprint);
+        return columns.map((col) => `ALTER TABLE ${this.wrap(table)} ADD COLUMN ${col}`);
+    }
+    getColumns(blueprint) {
+        return blueprint.columns.map((col) => this.getColumn(blueprint, col));
+    }
+    getColumn(_blueprint, column) {
+        let sql = `${this.wrap(column.name)} ${this.getType(column)}`;
+        if (column.unsigned)
+            sql += this.modifyUnsigned(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.comment)
+            sql += this.modifyComment(column);
+        return sql;
+    }
+    modifyUnsigned(_column) {
+        return "";
+    }
+    modifyAutoIncrement(_column) {
+        return "";
+    }
+    modifyComment(_column) {
+        return "";
+    }
+    getDefaultValue(value) {
+        if (value === null)
+            return "NULL";
+        if (typeof value === "boolean")
+            return value ? "1" : "0";
+        if (typeof value === "number")
+            return String(value);
+        if (typeof value === "string" && value.toUpperCase().includes("CURRENT_TIMESTAMP"))
+            return value;
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    compileIndexes(blueprint, table) {
+        const statements = [];
+        for (const index of blueprint.indexes) {
+            statements.push(this.compileIndex(table, index));
+        }
+        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(", ")})`;
+    }
+    compileForeignKeys(blueprint, table) {
+        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(", ")})`;
+        let full = sql;
+        if (fk.onDelete)
+            full += ` ON DELETE ${fk.onDelete}`;
+        if (fk.onUpdate)
+            full += ` ON UPDATE ${fk.onUpdate}`;
+        return full;
+    }
+}

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

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

@@ -0,0 +1,96 @@
+import { Grammar } from "./Grammar.js";
+export class MySqlGrammar extends Grammar {
+    wrappers = { prefix: "`", suffix: "`" };
+    getType(column) {
+        switch (column.type) {
+            case "string":
+                return `VARCHAR(${column.length || 255})`;
+            case "text":
+                return "TEXT";
+            case "integer":
+                return "INT";
+            case "bigInteger":
+                return "BIGINT";
+            case "smallInteger":
+                return "SMALLINT";
+            case "tinyInteger":
+                return "TINYINT";
+            case "float":
+                return `FLOAT(${column.precision || 8}, ${column.scale || 2})`;
+            case "double":
+                return `DOUBLE(${column.precision || 8}, ${column.scale || 2})`;
+            case "decimal":
+                return `DECIMAL(${column.precision || 8}, ${column.scale || 2})`;
+            case "boolean":
+                return "BOOLEAN";
+            case "date":
+                return "DATE";
+            case "dateTime":
+                return "DATETIME";
+            case "time":
+                return "TIME";
+            case "timestamp":
+                return "TIMESTAMP";
+            case "json":
+                return "JSON";
+            case "jsonb":
+                return "JSON";
+            case "binary":
+                return "BLOB";
+            case "uuid":
+                return "CHAR(36)";
+            case "enum":
+                return `ENUM('${(column.values || []).join("','")}')`;
+            default:
+                return "TEXT";
+        }
+    }
+    modifyUnsigned(column) {
+        return column.unsigned ? " UNSIGNED" : "";
+    }
+    modifyAutoIncrement(column) {
+        return column.autoIncrement ? " AUTO_INCREMENT" : "";
+    }
+    modifyComment(column) {
+        return column.comment ? ` COMMENT '${column.comment.replace(/'/g, "\\'")}'` : "";
+    }
+    getColumn(_blueprint, column) {
+        let sql = `${this.wrap(column.name)} ${this.getType(column)}`;
+        if (column.unsigned)
+            sql += this.modifyUnsigned(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";
+        if (column.comment)
+            sql += this.modifyComment(column);
+        return sql;
+    }
+    compileColumnRename(table, from, to) {
+        // MySQL requires full column definition for rename; simplified here.
+        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 `ALTER TABLE ${this.wrap(table)} ADD ${type} ${this.wrap(index.name)} (${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/PostgresGrammar.d.ts

@@ -0,0 +1,16 @@
+import { Grammar } from "./Grammar.js";
+import type { ColumnDefinition } from "../../types/index.js";
+export declare class PostgresGrammar 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;
+    compileIndex(table: string, index: any): string;
+    compileCreate(blueprint: any, table: string): string;
+    compileCreateIfNotExists(blueprint: any, table: string): string;
+}