@bunnykit/orm 0.1.0

package/dist/src/query/Builder.js

@@ -0,0 +1,466 @@
+export class Builder {
+    connection;
+    tableName;
+    columns = ["*"];
+    wheres = [];
+    orders = [];
+    groups = [];
+    havings = [];
+    limitValue;
+    offsetValue;
+    joins = [];
+    distinctFlag = false;
+    model;
+    eagerLoads = [];
+    constructor(connection, table) {
+        this.connection = connection;
+        this.tableName = table;
+    }
+    setModel(model) {
+        this.model = model;
+        return this;
+    }
+    table(table) {
+        this.tableName = table;
+        return this;
+    }
+    select(...columns) {
+        this.columns = columns;
+        return this;
+    }
+    distinct() {
+        this.distinctFlag = true;
+        return this;
+    }
+    where(column, operator, value, boolean = "and", scope) {
+        if (typeof column === "object" && column !== null) {
+            for (const [key, val] of Object.entries(column)) {
+                this.where(key, "=", val, boolean, scope);
+            }
+            return this;
+        }
+        if (value === undefined) {
+            value = operator;
+            operator = "=";
+        }
+        this.wheres.push({ type: "basic", column, operator, value, boolean, scope });
+        return this;
+    }
+    orWhere(column, operator, value) {
+        return this.where(column, operator, value, "or");
+    }
+    whereIn(column, values, boolean = "and", scope) {
+        this.wheres.push({ type: "in", column, value: values, boolean, scope });
+        return this;
+    }
+    whereNotIn(column, values, boolean = "and", scope) {
+        this.wheres.push({ type: "in", column, value: values, boolean, operator: "NOT IN", scope });
+        return this;
+    }
+    whereNull(column, boolean = "and", scope) {
+        this.wheres.push({ type: "null", column, boolean, scope });
+        return this;
+    }
+    whereNotNull(column, boolean = "and", scope) {
+        this.wheres.push({ type: "null", column, boolean, operator: "NOT NULL", scope });
+        return this;
+    }
+    whereBetween(column, values, boolean = "and", scope) {
+        this.wheres.push({ type: "between", column, value: values, boolean, scope });
+        return this;
+    }
+    whereNotBetween(column, values, boolean = "and", scope) {
+        this.wheres.push({ type: "between", column, value: values, boolean, operator: "NOT BETWEEN", scope });
+        return this;
+    }
+    whereRaw(sql, boolean = "and", scope) {
+        this.wheres.push({ type: "raw", column: sql, boolean, scope });
+        return this;
+    }
+    whereColumn(first, operator, second, boolean = "and") {
+        this.wheres.push({ type: "column", column: first, operator, value: second, boolean });
+        return this;
+    }
+    whereExists(sql, boolean = "and", not = false) {
+        this.wheres.push({ type: "exists", column: sql, boolean, operator: not ? "NOT EXISTS" : "EXISTS" });
+        return this;
+    }
+    orderBy(column, direction = "asc") {
+        this.orders.push({ column, direction });
+        return this;
+    }
+    groupBy(...columns) {
+        this.groups.push(...columns);
+        return this;
+    }
+    having(column, operator, value) {
+        this.havings.push(`${this.wrap(column)} ${operator} ${this.escape(value)}`);
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    forPage(page, perPage = 15) {
+        return this.offset((page - 1) * perPage).limit(perPage);
+    }
+    join(table, first, operator, second, type = "INNER") {
+        const joinSql = `${type} JOIN ${this.wrap(table)} ON ${this.wrap(first)} ${operator} ${this.wrap(second)}`;
+        this.joins.push(joinSql);
+        return this;
+    }
+    leftJoin(table, first, operator, second) {
+        return this.join(table, first, operator, second, "LEFT");
+    }
+    rightJoin(table, first, operator, second) {
+        return this.join(table, first, operator, second, "RIGHT");
+    }
+    with(...relations) {
+        this.eagerLoads.push(...relations);
+        return this;
+    }
+    withoutGlobalScope(scope) {
+        this.wheres = this.wheres.filter((where) => where.scope !== scope);
+        return this;
+    }
+    withoutGlobalScopes() {
+        this.wheres = this.wheres.filter((where) => !where.scope);
+        return this;
+    }
+    withTrashed() {
+        return this.withoutGlobalScope("softDeletes");
+    }
+    onlyTrashed() {
+        this.withTrashed();
+        const model = this.model;
+        if (model?.softDeletes) {
+            this.whereNotNull(model.getQualifiedDeletedAtColumn());
+        }
+        return this;
+    }
+    scope(name, ...args) {
+        if (!this.model) {
+            throw new Error(`Cannot apply scope "${name}" without a model`);
+        }
+        const method = `scope${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+        const scope = this.model[method] || this.model.scopes?.[name];
+        if (typeof scope !== "function") {
+            throw new Error(`Scope "${name}" is not defined on model ${this.model.name}`);
+        }
+        const result = scope.call(this.model, this, ...args);
+        return (result || this);
+    }
+    has(relationName, operator = ">=", count = 1, callback) {
+        if (typeof operator === "function") {
+            callback = operator;
+            operator = ">=";
+            count = 1;
+        }
+        const relation = this.getModelRelation(relationName);
+        if (operator === ">=" && count === 1) {
+            return this.whereExists(relation.getRelationExistenceSql(this, callback));
+        }
+        if ((operator === "<" || operator === "=") && count <= 0) {
+            return this.whereExists(relation.getRelationExistenceSql(this, callback), "and", true);
+        }
+        return this.whereRaw(`(${relation.getRelationCountSql(this, callback)}) ${operator} ${this.escape(count)}`);
+    }
+    orHas(relationName, operator = ">=", count = 1, callback) {
+        if (typeof operator === "function") {
+            callback = operator;
+            operator = ">=";
+            count = 1;
+        }
+        const relation = this.getModelRelation(relationName);
+        if (operator === ">=" && count === 1) {
+            return this.whereExists(relation.getRelationExistenceSql(this, callback), "or");
+        }
+        if ((operator === "<" || operator === "=") && count <= 0) {
+            return this.whereExists(relation.getRelationExistenceSql(this, callback), "or", true);
+        }
+        return this.whereRaw(`(${relation.getRelationCountSql(this, callback)}) ${operator} ${this.escape(count)}`, "or");
+    }
+    whereHas(relationName, callback, operator = ">=", count = 1) {
+        return this.has(relationName, operator, count, callback);
+    }
+    orWhereHas(relationName, callback, operator = ">=", count = 1) {
+        return this.orHas(relationName, operator, count, callback);
+    }
+    doesntHave(relationName, callback) {
+        return this.has(relationName, "<", 1, callback);
+    }
+    whereDoesntHave(relationName, callback) {
+        return this.doesntHave(relationName, callback);
+    }
+    withCount(relationName, alias) {
+        const relation = this.getModelRelation(relationName);
+        this.addSelect(`(${relation.getRelationCountSql(this)}) as ${alias || `${relationName}_count`}`);
+        return this;
+    }
+    withSum(relationName, column, alias) {
+        return this.withAggregate(relationName, column, "SUM", alias);
+    }
+    withAvg(relationName, column, alias) {
+        return this.withAggregate(relationName, column, "AVG", alias);
+    }
+    withMin(relationName, column, alias) {
+        return this.withAggregate(relationName, column, "MIN", alias);
+    }
+    withMax(relationName, column, alias) {
+        return this.withAggregate(relationName, column, "MAX", alias);
+    }
+    addSelect(...columns) {
+        if (this.columns.length === 1 && this.columns[0] === "*") {
+            this.columns = [`${this.tableName}.*`];
+        }
+        this.columns.push(...columns);
+        return this;
+    }
+    clone() {
+        const cloned = new Builder(this.connection, this.tableName);
+        cloned.columns = [...this.columns];
+        cloned.wheres = [...this.wheres];
+        cloned.orders = [...this.orders];
+        cloned.groups = [...this.groups];
+        cloned.havings = [...this.havings];
+        cloned.limitValue = this.limitValue;
+        cloned.offsetValue = this.offsetValue;
+        cloned.joins = [...this.joins];
+        cloned.distinctFlag = this.distinctFlag;
+        cloned.model = this.model;
+        cloned.eagerLoads = [...this.eagerLoads];
+        return cloned;
+    }
+    wrapColumn(value) {
+        return this.wrap(value);
+    }
+    escapeValue(value) {
+        return this.escape(value);
+    }
+    wrap(value) {
+        if (value.includes(" as ")) {
+            const [column, alias] = value.split(/\s+as\s+/i);
+            return `${this.wrap(column)} AS ${this.wrapValue(alias)}`;
+        }
+        if (value.includes(".")) {
+            return value.split(".").map((v) => this.wrapValue(v)).join(".");
+        }
+        return this.wrapValue(value);
+    }
+    wrapValue(value) {
+        const driver = this.connection.getDriverName();
+        const char = driver === "mysql" ? "`" : '"';
+        if (value === "*")
+            return value;
+        return `${char}${value}${char}`;
+    }
+    escape(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, "''")}'`;
+    }
+    compileWheres() {
+        if (this.wheres.length === 0)
+            return "";
+        const clauses = this.wheres.map((where, index) => {
+            const prefix = index === 0 ? "WHERE" : where.boolean.toUpperCase();
+            if (where.type === "basic") {
+                return `${prefix} ${this.wrap(where.column)} ${where.operator} ${this.escape(where.value)}`;
+            }
+            else if (where.type === "in") {
+                const op = where.operator === "NOT IN" ? "NOT IN" : "IN";
+                return `${prefix} ${this.wrap(where.column)} ${op} (${where.value.map((v) => this.escape(v)).join(", ")})`;
+            }
+            else if (where.type === "null") {
+                const op = where.operator === "NOT NULL" ? "IS NOT NULL" : "IS NULL";
+                return `${prefix} ${this.wrap(where.column)} ${op}`;
+            }
+            else if (where.type === "between") {
+                const op = where.operator === "NOT BETWEEN" ? "NOT BETWEEN" : "BETWEEN";
+                return `${prefix} ${this.wrap(where.column)} ${op} ${this.escape(where.value[0])} AND ${this.escape(where.value[1])}`;
+            }
+            else if (where.type === "raw") {
+                return `${prefix} ${where.column}`;
+            }
+            else if (where.type === "column") {
+                return `${prefix} ${this.wrap(where.column)} ${where.operator} ${this.wrap(where.value)}`;
+            }
+            else if (where.type === "exists") {
+                return `${prefix} ${where.operator} (${where.column})`;
+            }
+            return "";
+        });
+        return clauses.join(" ");
+    }
+    compileOrders() {
+        if (this.orders.length === 0)
+            return "";
+        return `ORDER BY ${this.orders.map((o) => `${this.wrap(o.column)} ${o.direction.toUpperCase()}`).join(", ")}`;
+    }
+    compileGroups() {
+        if (this.groups.length === 0)
+            return "";
+        return `GROUP BY ${this.groups.map((c) => this.wrap(c)).join(", ")}`;
+    }
+    compileHavings() {
+        if (this.havings.length === 0)
+            return "";
+        return `HAVING ${this.havings.join(" AND ")}`;
+    }
+    compileLimit() {
+        if (this.limitValue === undefined)
+            return "";
+        return `LIMIT ${this.limitValue}`;
+    }
+    compileOffset() {
+        if (this.offsetValue === undefined)
+            return "";
+        return `OFFSET ${this.offsetValue}`;
+    }
+    compileColumns() {
+        return this.columns.map((c) => (this.isRawColumn(c) ? c : this.wrap(c))).join(", ");
+    }
+    isRawColumn(column) {
+        return column.includes("(") || /\s+as\s+/i.test(column) || /^[0-9]+$/.test(column);
+    }
+    toSql() {
+        const distinct = this.distinctFlag ? "DISTINCT " : "";
+        let sql = `SELECT ${distinct}${this.compileColumns()} FROM ${this.wrap(this.tableName)}`;
+        if (this.joins.length > 0)
+            sql += " " + this.joins.join(" ");
+        sql += " " + this.compileWheres();
+        sql += " " + this.compileGroups();
+        sql += " " + this.compileHavings();
+        sql += " " + this.compileOrders();
+        sql += " " + this.compileLimit();
+        sql += " " + this.compileOffset();
+        return sql.replace(/\s+/g, " ").trim();
+    }
+    async get() {
+        const results = await this.connection.query(this.toSql());
+        const rows = Array.from(results);
+        if (this.model) {
+            const models = rows.map((row) => {
+                const instance = new this.model(row);
+                instance.$exists = true;
+                instance.$original = { ...row };
+                return instance;
+            });
+            if (this.eagerLoads.length > 0) {
+                await this.model.eagerLoadRelations(models, this.eagerLoads);
+            }
+            return models;
+        }
+        return rows;
+    }
+    async first() {
+        const results = await this.limit(1).get();
+        return results[0] || null;
+    }
+    async find(id, column = "id") {
+        return this.where(column, id).first();
+    }
+    async pluck(column) {
+        const results = await this.select(column).get();
+        return results.map((row) => row[column]);
+    }
+    async aggregate(sql, alias) {
+        const model = this.model;
+        this.model = undefined;
+        const result = await this.select(`${sql} as ${alias}`).first();
+        this.model = model;
+        return result ? result[alias] : null;
+    }
+    async count(column = "*") {
+        return Number(await this.aggregate(`COUNT(${column})`, "count") ?? 0);
+    }
+    async sum(column) {
+        return Number(await this.aggregate(`SUM(${column})`, "sum") ?? 0);
+    }
+    async avg(column) {
+        return Number(await this.aggregate(`AVG(${column})`, "avg") ?? 0);
+    }
+    async min(column) {
+        return await this.aggregate(`MIN(${column})`, "min");
+    }
+    async max(column) {
+        return await this.aggregate(`MAX(${column})`, "max");
+    }
+    async paginate(perPage = 15, page = 1) {
+        const total = await this.clone().count();
+        const data = await this.clone().forPage(page, perPage).get();
+        return {
+            data,
+            current_page: page,
+            per_page: perPage,
+            total,
+            last_page: Math.max(1, Math.ceil(total / perPage)),
+            from: total === 0 ? 0 : (page - 1) * perPage + 1,
+            to: total === 0 ? 0 : Math.min(page * perPage, total),
+        };
+    }
+    async insert(data) {
+        const records = Array.isArray(data) ? data : [data];
+        if (records.length === 0)
+            return;
+        const columns = Object.keys(records[0]);
+        const values = records.map((record) => {
+            return `(${columns.map((col) => this.escape(record[col])).join(", ")})`;
+        });
+        const sql = `INSERT INTO ${this.wrap(this.tableName)} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")}`;
+        return await this.connection.run(sql);
+    }
+    async insertGetId(data, idColumn = "id") {
+        const result = await this.insert(data);
+        return result?.lastInsertRowid ?? result?.insertId ?? null;
+    }
+    async update(data) {
+        const sets = Object.entries(data)
+            .map(([key, value]) => `${this.wrap(key)} = ${this.escape(value)}`)
+            .join(", ");
+        const sql = `UPDATE ${this.wrap(this.tableName)} SET ${sets} ${this.compileWheres()}`;
+        return await this.connection.run(sql.trim());
+    }
+    async delete() {
+        const sql = `DELETE FROM ${this.wrap(this.tableName)} ${this.compileWheres()}`;
+        return await this.connection.run(sql.trim());
+    }
+    async restore() {
+        const model = this.model;
+        if (!model?.softDeletes) {
+            throw new Error("restore() is only available for soft deleting models");
+        }
+        return this.withTrashed().update({ [model.deletedAtColumn]: null });
+    }
+    async exists() {
+        const result = await this.select("1 as exists_check").limit(1).get();
+        return result.length > 0;
+    }
+    getModelRelation(relationName) {
+        if (!this.model) {
+            throw new Error(`Cannot query relation "${relationName}" without a model`);
+        }
+        const instance = new this.model();
+        const relation = instance[relationName]?.();
+        if (!relation) {
+            throw new Error(`Relation "${relationName}" is not defined on model ${this.model.name}`);
+        }
+        return relation;
+    }
+    withAggregate(relationName, column, fn, alias) {
+        const relation = this.getModelRelation(relationName);
+        const defaultAlias = `${relationName}_${fn.toLowerCase()}_${column.replace(/\W+/g, "_")}`;
+        this.addSelect(`(${relation.getRelationAggregateSql(this, `${fn}(${relation.qualifyRelatedColumn(column)})`)}) as ${alias || defaultAlias}`);
+        return this;
+    }
+}

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

@@ -0,0 +1,66 @@
+import type { ColumnDefinition, IndexDefinition } from "../types/index.js";
+export declare class ForeignKeyBuilder {
+    fk: {
+        name?: string;
+        columns: string[];
+        references: string[];
+        onTable: string;
+        onDelete?: string;
+        onUpdate?: string;
+    };
+    blueprint: Blueprint;
+    constructor(blueprint: Blueprint, columns: string[], name?: string);
+    references(columns: string | string[]): this;
+    on(table: string): this;
+    onDelete(action: string): this;
+    onUpdate(action: string): this;
+}
+export declare class Blueprint {
+    readonly table: string;
+    columns: ColumnDefinition[];
+    indexes: IndexDefinition[];
+    foreignKeys: any[];
+    commands: {
+        name: string;
+        parameters?: Record<string, any>;
+    }[];
+    private currentColumn?;
+    constructor(table: string);
+    private addColumn;
+    increments(name?: string): this;
+    bigIncrements(name?: string): this;
+    string(name: string, length?: number): this;
+    text(name: string): this;
+    integer(name: string): this;
+    bigInteger(name: string): this;
+    smallInteger(name: string): this;
+    tinyInteger(name: string): this;
+    float(name: string, precision?: number, scale?: number): this;
+    double(name: string, precision?: number, scale?: number): this;
+    decimal(name: string, precision?: number, scale?: number): this;
+    boolean(name: string): this;
+    date(name: string): this;
+    dateTime(name: string): this;
+    time(name: string): this;
+    timestamp(name: string): this;
+    json(name: string): this;
+    jsonb(name: string): this;
+    binary(name: string): this;
+    uuid(name: string): this;
+    enum(name: string, values: string[]): this;
+    nullable(): this;
+    default(value: any): this;
+    unique(): this;
+    index(): this;
+    primary(): this;
+    unsigned(): this;
+    comment(text: string): this;
+    timestamps(): void;
+    softDeletes(): void;
+    foreign(columns: string | string[], name?: string): ForeignKeyBuilder;
+    dropColumn(column: string | string[]): void;
+    renameColumn(from: string, to: string): void;
+    dropIndex(name: string): void;
+    dropUnique(name: string): void;
+    dropForeign(name: string): void;
+}