@bunnykit/orm 0.1.4 → 0.1.6

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

@@ -0,0 +1,19 @@
+export declare abstract class Grammar {
+    abstract wrap(value: string): string;
+    wrapArray(values: string[]): string[];
+    escape(value: any): string;
+    abstract compileRandomOrder(): string;
+    compileOffset(offset: number, _limit?: number): string;
+    compileLock(lockMode?: string): string;
+    abstract compileDateWhere(type: string, column: string, operator: string, value: any): string;
+    abstract compileInsertOrIgnore(table: string, columns: string[], values: string[]): string;
+    abstract compileUpsert(table: string, columns: string[], values: string[], uniqueBy: string[], updateColumns: string[]): string;
+    compileUpdate(table: string, sets: string[], wheres: string, joins?: string[]): string;
+    compileDelete(table: string, wheres: string, joins?: string[], limit?: number): string;
+    abstract compileJsonContains(column: string, value: any): string;
+    abstract compileJsonLength(column: string, operator: string, value: any): string;
+    compileLike(column: string, value: string, not: boolean): string;
+    abstract compileRegexp(column: string, value: string, not: boolean): string;
+    abstract compileFullText(columns: string[], value: string): string;
+    abstract compileExplain(sql: string): string;
+}

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

@@ -0,0 +1,47 @@
+export class Grammar {
+    wrapArray(values) {
+        return values.map((v) => this.wrap(v));
+    }
+    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, "''")}'`;
+    }
+    compileOffset(offset, _limit) {
+        return `OFFSET ${offset}`;
+    }
+    compileLock(lockMode) {
+        return lockMode ? ` ${lockMode}` : "";
+    }
+    compileUpdate(table, sets, wheres, joins) {
+        let sql = `UPDATE ${table}`;
+        if (joins && joins.length > 0) {
+            sql += ` ${joins.join(" ")}`;
+        }
+        sql += ` SET ${sets.join(", ")}`;
+        if (wheres)
+            sql += ` ${wheres}`;
+        return sql.trim();
+    }
+    compileDelete(table, wheres, joins, limit) {
+        let sql = `DELETE FROM ${table}`;
+        if (joins && joins.length > 0) {
+            sql += ` ${joins.join(" ")}`;
+        }
+        if (wheres)
+            sql += ` ${wheres}`;
+        if (limit !== undefined)
+            sql += ` LIMIT ${limit}`;
+        return sql.trim();
+    }
+    compileLike(column, value, not) {
+        const op = not ? "NOT LIKE" : "LIKE";
+        return `${column} ${op} ${this.escape(value)}`;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Grammar } from "./Grammar.js";
+export declare class MySqlGrammar extends Grammar {
+    wrap(value: string): string;
+    compileRandomOrder(): string;
+    compileDateWhere(type: string, column: string, operator: string, value: any): string;
+    compileInsertOrIgnore(table: string, columns: string[], values: string[]): string;
+    compileUpsert(table: string, columns: string[], values: string[], _uniqueBy: string[], updateColumns: string[]): string;
+    compileJsonContains(column: string, value: any): string;
+    compileJsonLength(column: string, operator: string, value: any): string;
+    compileRegexp(column: string, value: string, not: boolean): string;
+    compileFullText(columns: string[], value: string): string;
+    compileExplain(sql: string): string;
+}

package/dist/src/query/grammars/MySqlGrammar.js

@@ -0,0 +1,59 @@
+import { Grammar } from "./Grammar.js";
+export class MySqlGrammar extends Grammar {
+    wrap(value) {
+        if (value.includes(" as ")) {
+            const [column, alias] = value.split(/\s+as\s+/i);
+            return `${this.wrap(column)} AS ${this.wrap(alias)}`;
+        }
+        if (value.includes(".")) {
+            return value.split(".").map((v) => this.wrap(v)).join(".");
+        }
+        if (value === "*")
+            return value;
+        return `\`${value}\``;
+    }
+    compileRandomOrder() {
+        return "ORDER BY RAND()";
+    }
+    compileDateWhere(type, column, operator, value) {
+        switch (type) {
+            case "date":
+                return `DATE(${column}) ${operator} ${this.escape(value)}`;
+            case "day":
+                return `DAY(${column}) ${operator} ${this.escape(value)}`;
+            case "month":
+                return `MONTH(${column}) ${operator} ${this.escape(value)}`;
+            case "year":
+                return `YEAR(${column}) ${operator} ${this.escape(value)}`;
+            case "time":
+                return `TIME(${column}) ${operator} ${this.escape(value)}`;
+            default:
+                return `${column} ${operator} ${this.escape(value)}`;
+        }
+    }
+    compileInsertOrIgnore(table, columns, values) {
+        return `INSERT IGNORE INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")}`;
+    }
+    compileUpsert(table, columns, values, _uniqueBy, updateColumns) {
+        const updateCols = updateColumns
+            .map((c) => `${this.wrap(c)} = VALUES(${this.wrap(c)})`)
+            .join(", ");
+        return `INSERT INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")} ON DUPLICATE KEY UPDATE ${updateCols}`;
+    }
+    compileJsonContains(column, value) {
+        return `JSON_CONTAINS(${column}, ${this.escape(JSON.stringify(value))})`;
+    }
+    compileJsonLength(column, operator, value) {
+        return `JSON_LENGTH(${column}) ${operator} ${this.escape(value)}`;
+    }
+    compileRegexp(column, value, not) {
+        const op = not ? "NOT REGEXP" : "REGEXP";
+        return `${column} ${op} ${this.escape(value)}`;
+    }
+    compileFullText(columns, value) {
+        return `MATCH (${columns.join(", ")}) AGAINST (${this.escape(value)})`;
+    }
+    compileExplain(sql) {
+        return `EXPLAIN ${sql}`;
+    }
+}

package/dist/src/query/grammars/PostgresGrammar.d.ts

@@ -0,0 +1,13 @@
+import { Grammar } from "./Grammar.js";
+export declare class PostgresGrammar extends Grammar {
+    wrap(value: string): string;
+    compileRandomOrder(): string;
+    compileDateWhere(type: string, column: string, operator: string, value: any): string;
+    compileInsertOrIgnore(table: string, columns: string[], values: string[]): string;
+    compileUpsert(table: string, columns: string[], values: string[], uniqueBy: string[], updateColumns: string[]): string;
+    compileJsonContains(column: string, value: any): string;
+    compileJsonLength(column: string, operator: string, value: any): string;
+    compileRegexp(column: string, value: string, not: boolean): string;
+    compileFullText(columns: string[], value: string): string;
+    compileExplain(sql: string): string;
+}

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

@@ -0,0 +1,62 @@
+import { Grammar } from "./Grammar.js";
+export class PostgresGrammar extends Grammar {
+    wrap(value) {
+        if (value.includes(" as ")) {
+            const [column, alias] = value.split(/\s+as\s+/i);
+            return `${this.wrap(column)} AS ${this.wrap(alias)}`;
+        }
+        if (value.includes(".")) {
+            return value.split(".").map((v) => this.wrap(v)).join(".");
+        }
+        if (value === "*")
+            return value;
+        return `"${value}"`;
+    }
+    compileRandomOrder() {
+        return "ORDER BY RANDOM()";
+    }
+    compileDateWhere(type, column, operator, value) {
+        switch (type) {
+            case "date":
+                return `(${column})::date ${operator} ${this.escape(value)}`;
+            case "day":
+                return `EXTRACT(DAY FROM ${column}) ${operator} ${this.escape(value)}`;
+            case "month":
+                return `EXTRACT(MONTH FROM ${column}) ${operator} ${this.escape(value)}`;
+            case "year":
+                return `EXTRACT(YEAR FROM ${column}) ${operator} ${this.escape(value)}`;
+            case "time":
+                return `(${column})::time ${operator} ${this.escape(value)}`;
+            default:
+                return `${column} ${operator} ${this.escape(value)}`;
+        }
+    }
+    compileInsertOrIgnore(table, columns, values) {
+        return `INSERT INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")} ON CONFLICT DO NOTHING`;
+    }
+    compileUpsert(table, columns, values, uniqueBy, updateColumns) {
+        const updateCols = updateColumns
+            .map((c) => `${this.wrap(c)} = EXCLUDED.${this.wrap(c)}`)
+            .join(", ");
+        return `INSERT INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")} ON CONFLICT (${uniqueBy.map((c) => this.wrap(c)).join(", ")}) DO UPDATE SET ${updateCols}`;
+    }
+    compileJsonContains(column, value) {
+        return `${column} @> ${this.escape(JSON.stringify([value]))}`;
+    }
+    compileJsonLength(column, operator, value) {
+        return `jsonb_array_length(${column}) ${operator} ${this.escape(value)}`;
+    }
+    compileRegexp(column, value, not) {
+        const op = not ? "!~" : "~";
+        return `${column} ${op} ${this.escape(value)}`;
+    }
+    compileFullText(columns, value) {
+        const cols = columns.length > 1
+            ? `concat_ws(' ', ${columns.join(", ")})`
+            : columns[0];
+        return `to_tsvector('english', ${cols}) @@ plainto_tsquery('english', ${this.escape(value)})`;
+    }
+    compileExplain(sql) {
+        return `EXPLAIN (FORMAT JSON) ${sql}`;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Grammar } from "./Grammar.js";
+export declare class SQLiteGrammar extends Grammar {
+    wrap(value: string): string;
+    compileRandomOrder(): string;
+    compileOffset(offset: number, limit?: number): string;
+    compileDateWhere(type: string, column: string, operator: string, value: any): string;
+    compileInsertOrIgnore(table: string, columns: string[], values: string[]): string;
+    compileUpsert(table: string, columns: string[], values: string[], uniqueBy: string[], updateColumns: string[]): string;
+    compileJsonContains(column: string, value: any): string;
+    compileJsonLength(column: string, operator: string, value: any): string;
+    compileRegexp(column: string, value: string, not: boolean): string;
+    compileFullText(columns: string[], value: string): string;
+    compileExplain(sql: string): string;
+}

package/dist/src/query/grammars/SQLiteGrammar.js

@@ -0,0 +1,63 @@
+import { Grammar } from "./Grammar.js";
+export class SQLiteGrammar extends Grammar {
+    wrap(value) {
+        if (value.includes(" as ")) {
+            const [column, alias] = value.split(/\s+as\s+/i);
+            return `${this.wrap(column)} AS ${this.wrap(alias)}`;
+        }
+        if (value.includes(".")) {
+            return value.split(".").map((v) => this.wrap(v)).join(".");
+        }
+        if (value === "*")
+            return value;
+        return `"${value}"`;
+    }
+    compileRandomOrder() {
+        return "ORDER BY RANDOM()";
+    }
+    compileOffset(offset, limit) {
+        const limitSql = limit === undefined ? "LIMIT -1 " : "";
+        return `${limitSql}OFFSET ${offset}`;
+    }
+    compileDateWhere(type, column, operator, value) {
+        switch (type) {
+            case "date":
+                return `date(${column}) ${operator} ${this.escape(value)}`;
+            case "day":
+                return `CAST(strftime('%d', ${column}) AS INTEGER) ${operator} ${this.escape(value)}`;
+            case "month":
+                return `CAST(strftime('%m', ${column}) AS INTEGER) ${operator} ${this.escape(value)}`;
+            case "year":
+                return `CAST(strftime('%Y', ${column}) AS INTEGER) ${operator} ${this.escape(value)}`;
+            case "time":
+                return `time(${column}) ${operator} ${this.escape(value)}`;
+            default:
+                return `${column} ${operator} ${this.escape(value)}`;
+        }
+    }
+    compileInsertOrIgnore(table, columns, values) {
+        return `INSERT OR IGNORE INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")}`;
+    }
+    compileUpsert(table, columns, values, uniqueBy, updateColumns) {
+        const updateCols = updateColumns
+            .map((c) => `${this.wrap(c)} = excluded.${this.wrap(c)}`)
+            .join(", ");
+        return `INSERT INTO ${table} (${columns.map((c) => this.wrap(c)).join(", ")}) VALUES ${values.join(", ")} ON CONFLICT(${uniqueBy.map((c) => this.wrap(c)).join(", ")}) DO UPDATE SET ${updateCols}`;
+    }
+    compileJsonContains(column, value) {
+        return `${column} IN (SELECT value FROM json_each(${column})) AND ${this.escape(value)} IN (SELECT value FROM json_each(${column}))`;
+    }
+    compileJsonLength(column, operator, value) {
+        return `(SELECT COUNT(*) FROM json_each(${column})) ${operator} ${this.escape(value)}`;
+    }
+    compileRegexp(column, value, not) {
+        const op = not ? "NOT REGEXP" : "REGEXP";
+        return `${column} ${op} ${this.escape(value)}`;
+    }
+    compileFullText(columns, value) {
+        return columns.map((c) => `${this.wrap(c)} LIKE ${this.escape(`%${value}%`)}`).join(" OR ");
+    }
+    compileExplain(sql) {
+        return `EXPLAIN QUERY PLAN ${sql}`;
+    }
+}

package/dist/src/schema/Schema.js

@@ -2,16 +2,21 @@ import { Blueprint } from "./Blueprint.js";
 import { SQLiteGrammar } from "./grammars/SQLiteGrammar.js";
 import { MySqlGrammar } from "./grammars/MySqlGrammar.js";
 import { PostgresGrammar } from "./grammars/PostgresGrammar.js";
+import { ConnectionManager } from "../connection/ConnectionManager.js";
+import { TenantContext } from "../connection/TenantContext.js";
 export class Schema {
     static connection;
     static setConnection(connection) {
         this.connection = connection;
+        ConnectionManager.setDefault(connection);
     }
     static getConnection() {
-        if (!this.connection) {
+        const tenantConnection = TenantContext.current()?.connection;
+        const connection = tenantConnection || this.connection || ConnectionManager.getDefault();
+        if (!connection) {
             throw new Error("No database connection set.");
         }
-        return this.connection;
+        return connection;
     }
     static getGrammar() {
         const driver = this.getConnection().getDriverName();
@@ -28,9 +33,10 @@ export class Schema {
         const blueprint = new Blueprint(table);
         callback(blueprint);
         const grammar = this.getGrammar();
-        const sql = grammar.compileCreate(blueprint, table);
+        const connection = this.getConnection();
+        const sql = grammar.compileCreate(blueprint, connection.qualifyTable(table));
         await this.getConnection().run(sql);
-        const indexes = grammar.compileIndexes(blueprint, table);
+        const indexes = grammar.compileIndexes(blueprint, connection.qualifyTable(table));
         for (const indexSql of indexes) {
             await this.getConnection().run(indexSql);
         }
@@ -39,9 +45,10 @@ export class Schema {
         const blueprint = new Blueprint(table);
         callback(blueprint);
         const grammar = this.getGrammar();
-        const sql = grammar.compileCreateIfNotExists(blueprint, table);
+        const connection = this.getConnection();
+        const sql = grammar.compileCreateIfNotExists(blueprint, connection.qualifyTable(table));
         await this.getConnection().run(sql);
-        const indexes = grammar.compileIndexes(blueprint, table);
+        const indexes = grammar.compileIndexes(blueprint, connection.qualifyTable(table));
         for (const indexSql of indexes) {
             await this.getConnection().run(indexSql);
         }
@@ -50,9 +57,11 @@ export class Schema {
         const blueprint = new Blueprint(table);
         callback(blueprint);
         const grammar = this.getGrammar();
+        const connection = this.getConnection();
+        const qualifiedTable = connection.qualifyTable(table);
         for (const command of blueprint.commands) {
             if (command.name === "dropColumn") {
-                const sql = grammar.compileDropColumn(table, command.parameters.column);
+                const sql = grammar.compileDropColumn(qualifiedTable, command.parameters.column);
                 if (Array.isArray(sql)) {
                     for (const s of sql)
                         await this.getConnection().run(s);
@@ -62,7 +71,7 @@ export class Schema {
                 }
             }
             else if (command.name === "renameColumn") {
-                const sql = grammar.compileColumnRename(table, command.parameters.from, command.parameters.to);
+                const sql = grammar.compileColumnRename(qualifiedTable, command.parameters.from, command.parameters.to);
                 await this.getConnection().run(sql);
             }
             else if (command.name === "dropIndex") {
@@ -75,33 +84,38 @@ export class Schema {
                 await this.getConnection().run(`ALTER TABLE ${grammar.wrap(table)} DROP CONSTRAINT ${grammar.wrap(command.parameters.name)}`);
             }
         }
-        const addSqls = grammar.compileAdd(blueprint, table);
+        const addSqls = grammar.compileAdd(blueprint, qualifiedTable);
         for (const sql of addSqls) {
             await this.getConnection().run(sql);
         }
-        const indexes = grammar.compileIndexes(blueprint, table);
+        const indexes = grammar.compileIndexes(blueprint, qualifiedTable);
         for (const indexSql of indexes) {
             await this.getConnection().run(indexSql);
         }
-        const fks = grammar.compileForeignKeys(blueprint, table);
+        const fks = grammar.compileForeignKeys(blueprint, qualifiedTable);
         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));
+        const connection = this.getConnection();
+        await connection.run(grammar.compileDrop(connection.qualifyTable(table)));
     }
     static async dropIfExists(table) {
         const grammar = this.getGrammar();
-        await this.getConnection().run(grammar.compileDropIfExists(table));
+        const connection = this.getConnection();
+        await connection.run(grammar.compileDropIfExists(connection.qualifyTable(table)));
     }
     static async rename(from, to) {
         const grammar = this.getGrammar();
-        await this.getConnection().run(grammar.compileRename(from, to));
+        const connection = this.getConnection();
+        await connection.run(grammar.compileRename(connection.qualifyTable(from), connection.qualifyTable(to)));
     }
     static async hasTable(table) {
-        const driver = this.getConnection().getDriverName();
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        const schema = connection.getSchema() || "public";
         let sql;
         if (driver === "sqlite") {
             sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${table}'`;
@@ -110,41 +124,45 @@ export class Schema {
             sql = `SHOW TABLES LIKE '${table}'`;
         }
         else {
-            sql = `SELECT * FROM information_schema.tables WHERE table_name = '${table}'`;
+            sql = `SELECT * FROM information_schema.tables WHERE table_schema = '${schema}' AND table_name = '${table}'`;
         }
-        const result = await this.getConnection().query(sql);
+        const result = await connection.query(sql);
         return result.length > 0;
     }
     static async hasColumn(table, column) {
-        const driver = this.getConnection().getDriverName();
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        const schema = connection.getSchema() || "public";
         let sql;
         if (driver === "sqlite") {
             sql = `PRAGMA table_info(${table})`;
-            const result = await this.getConnection().query(sql);
+            const result = await connection.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}'`;
+            sql = `SELECT column_name FROM information_schema.columns WHERE table_schema = '${schema}' AND table_name = '${table}' AND column_name = '${column}'`;
         }
-        const result = await this.getConnection().query(sql);
+        const result = await connection.query(sql);
         return result.length > 0;
     }
     static async getColumn(table, column) {
-        const driver = this.getConnection().getDriverName();
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        const schema = connection.getSchema() || "public";
         if (driver === "sqlite") {
-            const rows = await this.getConnection().query(`PRAGMA table_info(${table})`);
+            const rows = await connection.query(`PRAGMA table_info(${table})`);
             const row = rows.find((item) => item.name === column);
             return row ? { name: row.name, type: row.type, primary: row.pk > 0, autoIncrement: false } : null;
         }
         if (driver === "mysql") {
-            const rows = await this.getConnection().query(`SHOW COLUMNS FROM ${table} LIKE '${column}'`);
+            const rows = await connection.query(`SHOW COLUMNS FROM ${table} LIKE '${column}'`);
             const row = rows[0];
             return row ? { name: row.Field, type: row.Type, primary: row.Key === "PRI", autoIncrement: String(row.Extra || "").toLowerCase().includes("auto_increment") } : null;
         }
-        const rows = await this.getConnection().query(`SELECT c.column_name, c.data_type, COALESCE(tc.constraint_type = 'PRIMARY KEY', false) AS primary_key
+        const rows = await connection.query(`SELECT c.column_name, c.data_type, COALESCE(tc.constraint_type = 'PRIMARY KEY', false) AS primary_key
        FROM information_schema.columns c
        LEFT JOIN information_schema.key_column_usage kcu
          ON c.table_schema = kcu.table_schema
@@ -153,7 +171,7 @@ export class Schema {
        LEFT JOIN information_schema.table_constraints tc
          ON kcu.table_schema = tc.table_schema
         AND kcu.constraint_name = tc.constraint_name
-       WHERE c.table_schema = 'public'
+       WHERE c.table_schema = '${schema}'
          AND c.table_name = '${table}'
          AND c.column_name = '${column}'`);
         const row = rows[0];

package/dist/src/typegen/TypeGenerator.js

@@ -119,7 +119,8 @@ export class TypeGenerator {
             sql = "SHOW TABLES";
         }
         else {
-            sql = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE'`;
+            const schema = this.connection.getSchema() || "public";
+            sql = `SELECT table_name FROM information_schema.tables WHERE table_schema = '${schema}' AND table_type = 'BASE TABLE'`;
         }
         const rows = await this.connection.query(sql);
         if (driver === "sqlite") {
@@ -174,7 +175,8 @@ export class TypeGenerator {
             }));
         }
         // 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`);
+        const schema = this.connection.getSchema() || "public";
+        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 = '${schema}' ORDER BY ordinal_position`);
         return rows.map((r) => ({
             name: r.column_name,
             type: r.data_type,

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

@@ -40,8 +40,17 @@ export interface OrderClause {
     column: string;
     direction: "asc" | "desc";
 }
+export interface HavingClause {
+    sql: string;
+    boolean: "and" | "or";
+}
+export interface UnionClause {
+    query: string;
+    all: boolean;
+}
 export type ConnectionConfig = {
     url: string;
+    schema?: string;
 } | {
     driver: "sqlite" | "mysql" | "postgres";
     host?: string;
@@ -50,4 +59,5 @@ export type ConnectionConfig = {
     username?: string;
     password?: string;
     filename?: string;
+    schema?: string;
 };

package/package.json

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