@buenojs/bueno 0.8.3 → 0.8.5

package/tests/unit/orm/compiler.test.ts

@@ -0,0 +1,220 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { Database } from "../../../src/database";
+import { Model } from "../../../src/database/orm/model";
+import { setDefaultDatabase, clearDefaultDatabase, clearModelDatabaseRegistry } from "../../../src/database/orm";
+
+let db: Database;
+
+class User extends Model {
+	static table = "users";
+	static timestamps = false;
+	fillable = ["name", "email", "age", "status"];
+}
+
+beforeEach(async () => {
+	db = new Database({ url: ":memory:" });
+	await db.connect();
+	setDefaultDatabase(db);
+	clearModelDatabaseRegistry();
+	await db.raw("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, email TEXT, age INTEGER, status TEXT)");
+});
+
+afterEach(async () => {
+	clearDefaultDatabase();
+	clearModelDatabaseRegistry();
+	await db.close();
+});
+
+describe("QueryCompiler (via OrmQueryBuilder)", () => {
+	describe("SELECT compilation", () => {
+		test("simple SELECT * FROM table", async () => {
+			await User.create({ name: "John" });
+			const results = await User.all();
+			expect(results.length).toBe(1);
+		});
+
+		test("SELECT with columns", async () => {
+			await User.create({ name: "John", email: "john@example.com" });
+			const results = await User.query().select("name", "email").get();
+			expect(results[0]).toHaveProperty("name");
+			expect(results[0]).toHaveProperty("email");
+		});
+
+		test("SELECT DISTINCT", async () => {
+			await User.create({ name: "John", email: "john@example.com" });
+			await User.create({ name: "John", email: "jane@example.com" });
+			const results = await User.query().select("name").distinct().get();
+			expect(results.length).toBe(1);
+		});
+
+		test("WHERE with equality", async () => {
+			await User.create({ name: "John", status: "active" });
+			await User.create({ name: "Jane", status: "inactive" });
+			const results = await User.query().where("status", "active").get();
+			expect(results.length).toBe(1);
+			expect(results[0].name).toBe("John");
+		});
+
+		test("WHERE with comparison operators", async () => {
+			await User.create({ name: "John", age: 25 });
+			await User.create({ name: "Jane", age: 30 });
+			const results = await User.query().where("age", ">", 28).get();
+			expect(results.length).toBe(1);
+			expect(results[0].age).toBe(30);
+		});
+
+		test("WHERE IN with array", async () => {
+			await User.create({ name: "John", status: "active" });
+			await User.create({ name: "Jane", status: "pending" });
+			await User.create({ name: "Bob", status: "inactive" });
+			const results = await User.query().whereIn("status", ["active", "pending"]).get();
+			expect(results.length).toBe(2);
+		});
+
+		test("WHERE IS NULL", async () => {
+			await User.create({ name: "John", email: null });
+			await User.create({ name: "Jane", email: "jane@example.com" });
+			const results = await User.query().whereNull("email").get();
+			expect(results.length).toBe(1);
+			expect(results[0].name).toBe("John");
+		});
+
+		test("WHERE IS NOT NULL", async () => {
+			await User.create({ name: "John", email: null });
+			await User.create({ name: "Jane", email: "jane@example.com" });
+			const results = await User.query().whereNotNull("email").get();
+			expect(results.length).toBe(1);
+			expect(results[0].email).toBe("jane@example.com");
+		});
+
+		test("WHERE BETWEEN", async () => {
+			await User.create({ name: "John", age: 25 });
+			await User.create({ name: "Jane", age: 30 });
+			await User.create({ name: "Bob", age: 35 });
+			const results = await User.query().whereBetween("age", [27, 32]).get();
+			expect(results.length).toBe(1);
+			expect(results[0].age).toBe(30);
+		});
+
+		test("WHERE RAW", async () => {
+			await User.create({ name: "John", age: 25 });
+			await User.create({ name: "Jane", age: 30 });
+			const results = await User.query().whereRaw("age > 27").get();
+			expect(results.length).toBe(1);
+		});
+
+		test("OR WHERE", async () => {
+			await User.create({ name: "John", status: "admin" });
+			await User.create({ name: "Jane", status: "moderator" });
+			await User.create({ name: "Bob", status: "user" });
+			const results = await User.query().where("status", "admin").orWhere("status", "moderator").get();
+			expect(results.length).toBe(2);
+		});
+
+		test("ORDER BY ASC", async () => {
+			await User.create({ name: "Charlie" });
+			await User.create({ name: "Alice" });
+			await User.create({ name: "Bob" });
+			const results = await User.query().orderBy("name", "asc").get();
+			expect(results[0].name).toBe("Alice");
+			expect(results[2].name).toBe("Charlie");
+		});
+
+		test("ORDER BY DESC", async () => {
+			await User.create({ name: "Charlie" });
+			await User.create({ name: "Alice" });
+			const results = await User.query().orderBy("name", "desc").get();
+			expect(results[0].name).toBe("Charlie");
+			expect(results[1].name).toBe("Alice");
+		});
+
+		test("LIMIT", async () => {
+			await User.create({ name: "John" });
+			await User.create({ name: "Jane" });
+			await User.create({ name: "Bob" });
+			const results = await User.query().limit(2).get();
+			expect(results.length).toBe(2);
+		});
+
+		test("LIMIT and OFFSET", async () => {
+			for (let i = 1; i <= 5; i++) {
+				await User.create({ name: `User${i}` });
+			}
+			const results = await User.query().orderBy("id").limit(2).offset(2).get();
+			expect(results.length).toBe(2);
+		});
+	});
+
+	describe("COUNT compilation", () => {
+		test("count all", async () => {
+			await User.create({ name: "John" });
+			await User.create({ name: "Jane" });
+			const count = await User.query().count();
+			expect(count).toBe(2);
+		});
+
+		test("count with WHERE clause", async () => {
+			await User.create({ name: "John", status: "active" });
+			await User.create({ name: "Jane", status: "inactive" });
+			const count = await User.query().where("status", "active").count();
+			expect(count).toBe(1);
+		});
+	});
+
+	describe("EXISTS compilation", () => {
+		test("exists returns true when record exists", async () => {
+			await User.create({ name: "John" });
+			const exists = await User.query().where("name", "John").exists();
+			expect(exists).toBe(true);
+		});
+
+		test("exists returns false when no record matches", async () => {
+			const exists = await User.query().where("name", "NonExistent").exists();
+			expect(exists).toBe(false);
+		});
+	});
+
+	describe("INSERT compilation", () => {
+		test("single row insert", async () => {
+			const result = await User.create({ name: "John", email: "john@example.com" });
+			expect(result.id).toBeDefined();
+			expect(result.name).toBe("John");
+		});
+
+		test("batch insert", async () => {
+			const user1 = await User.create({ name: "John", email: "john@example.com" });
+			const user2 = await User.create({ name: "Jane", email: "jane@example.com" });
+			expect(user1.id).toBeDefined();
+			expect(user2.id).toBeDefined();
+			expect(user1.name).toBe("John");
+			expect(user2.name).toBe("Jane");
+		});
+	});
+
+	describe("UPDATE compilation", () => {
+		test("update with WHERE clause", async () => {
+			const user = await User.create({ name: "John" });
+			user.name = "Jane";
+			await user.save();
+			const updated = await User.find(user.id!);
+			expect(updated!.name).toBe("Jane");
+		});
+	});
+
+	describe("DELETE compilation", () => {
+		test("delete with WHERE clause", async () => {
+			const user = await User.create({ name: "John" });
+			await user.delete();
+			const found = await User.find(user.id!);
+			expect(found).toBeNull();
+		});
+	});
+
+	describe("Placeholder dialect handling", () => {
+		test("SQLite uses ? placeholders", async () => {
+			await User.create({ name: "Test", status: "active" });
+			const results = await User.query().where("status", "active").get();
+			expect(results.length).toBe(1);
+		});
+	});
+});

package/tests/unit/orm/eager-loading.test.ts

@@ -0,0 +1,285 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { Database } from "../../../src/database";
+import { Model } from "../../../src/database/orm/model";
+import { setDefaultDatabase, clearDefaultDatabase, clearModelDatabaseRegistry } from "../../../src/database/orm";
+
+let db: Database;
+
+class User extends Model {
+	static table = "users";
+	static timestamps = false;
+	fillable = ["name"];
+
+	override posts() {
+		return this.hasMany(Post, "user_id");
+	}
+
+	override profile() {
+		return this.hasOne(Profile, "user_id");
+	}
+}
+
+class Post extends Model {
+	static table = "posts";
+	static timestamps = false;
+	fillable = ["user_id", "title"];
+
+	override author() {
+		return this.belongsTo(User, "user_id");
+	}
+
+	override comments() {
+		return this.hasMany(Comment, "post_id");
+	}
+}
+
+class Comment extends Model {
+	static table = "comments";
+	static timestamps = false;
+	fillable = ["post_id", "body"];
+
+	override post() {
+		return this.belongsTo(Post, "post_id");
+	}
+}
+
+class Profile extends Model {
+	static table = "profiles";
+	static timestamps = false;
+	fillable = ["user_id", "bio"];
+
+	override user() {
+		return this.belongsTo(User, "user_id");
+	}
+}
+
+beforeEach(async () => {
+	db = new Database({ url: ":memory:" });
+	await db.connect();
+	setDefaultDatabase(db);
+	clearModelDatabaseRegistry();
+
+	await db.raw(`
+		CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT)
+	`);
+	await db.raw(`
+		CREATE TABLE posts (id INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER, title TEXT)
+	`);
+	await db.raw(`
+		CREATE TABLE comments (id INTEGER PRIMARY KEY AUTOINCREMENT, post_id INTEGER, body TEXT)
+	`);
+	await db.raw(`
+		CREATE TABLE profiles (id INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER, bio TEXT)
+	`);
+});
+
+afterEach(async () => {
+	clearDefaultDatabase();
+	clearModelDatabaseRegistry();
+	await db.close();
+});
+
+describe("Eager Loading", () => {
+	describe("simple eager load", () => {
+		test("with('posts').get() loads posts into users", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Post 1" });
+			await Post.create({ user_id: user.id, title: "Post 2" });
+
+			const users = await User.query().with("posts").get();
+			expect(users.length).toBe(1);
+			expect((users[0] as any)._relations.has("posts")).toBe(true);
+			expect(users[0].posts).toEqual(expect.any(Array));
+			expect(users[0].posts.length).toBe(2);
+		});
+
+		test("with('posts').first() loads posts into user", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Post 1" });
+
+			const foundUser = await User.query().with("posts").first();
+			expect(foundUser).not.toBeNull();
+			expect(foundUser!.posts).toEqual(expect.any(Array));
+			expect(foundUser!.posts.length).toBe(1);
+		});
+
+		test("user with no relations returns empty array", async () => {
+			const user = await User.create({ name: "John" });
+			const users = await User.query().with("posts").get();
+			expect(users[0].posts).toEqual([]);
+		});
+	});
+
+	describe("BelongsTo eager load", () => {
+		test("with('author').get() loads author into posts", async () => {
+			const user = await User.create({ name: "John" });
+			const post = await Post.create({ user_id: user.id, title: "Post 1" });
+
+			const posts = await Post.query().with("author").get();
+			expect(posts.length).toBe(1);
+			expect(posts[0].author).not.toBeNull();
+			expect(posts[0].author!.name).toBe("John");
+		});
+
+		test("post with null foreign key returns null", async () => {
+			await Post.create({ user_id: null, title: "Post 1" });
+
+			const posts = await Post.query().with("author").get();
+			expect(posts[0].author).toBeNull();
+		});
+	});
+
+	describe("nested eager load", () => {
+		test("with('posts.comments').get() loads nested relations", async () => {
+			const user = await User.create({ name: "John" });
+			const post = await Post.create({ user_id: user.id, title: "Post 1" });
+			await Comment.create({ post_id: post.id, body: "Comment 1" });
+			await Comment.create({ post_id: post.id, body: "Comment 2" });
+
+			const users = await User.query().with("posts.comments").get();
+			expect(users.length).toBe(1);
+			expect(users[0].posts).toEqual(expect.any(Array));
+			expect(users[0].posts.length).toBe(1);
+			expect(users[0].posts[0].comments).toEqual(expect.any(Array));
+			expect(users[0].posts[0].comments.length).toBe(2);
+		});
+
+		test("nested eager load with multiple levels", async () => {
+			const user = await User.create({ name: "John" });
+			const post = await Post.create({ user_id: user.id, title: "Post 1" });
+			await Comment.create({ post_id: post.id, body: "Comment 1" });
+
+			const users = await User.query().with("posts.comments").get();
+			expect(users[0].posts[0].comments[0].body).toBe("Comment 1");
+		});
+
+		test("nested eager load with empty relations", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Post 1" });
+
+			const users = await User.query().with("posts.comments").get();
+			expect(users[0].posts[0].comments).toEqual([]);
+		});
+	});
+
+	describe("constrained eager load", () => {
+		test("with('posts', callback) applies constraint", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Published" });
+			await Post.create({ user_id: user.id, title: "Draft" });
+
+			const users = await User.query()
+				.with("posts", (q) => q.where("title", "Published"))
+				.get();
+			expect(users[0].posts.length).toBe(1);
+			expect(users[0].posts[0].title).toBe("Published");
+		});
+
+		test("constraint on nested relation", async () => {
+			const user = await User.create({ name: "John" });
+			const post = await Post.create({ user_id: user.id, title: "Post 1" });
+			await Comment.create({ post_id: post.id, body: "Keep this" });
+			await Comment.create({ post_id: post.id, body: "Filter this" });
+
+			const users = await User.query()
+				.with("posts.comments", (q) => q.where("body", "Keep this"))
+				.get();
+			expect(users[0].posts[0].comments.length).toBe(1);
+			expect(users[0].posts[0].comments[0].body).toBe("Keep this");
+		});
+	});
+
+	describe("multiple eager loads", () => {
+		test("with() called multiple times loads all relations", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Post 1" });
+			await Profile.create({ user_id: user.id, bio: "Developer" });
+
+			const users = await User.query().with("posts").with("profile").get();
+			expect(users[0].posts).toEqual(expect.any(Array));
+			expect(users[0].profile).not.toBeNull();
+		});
+
+		test("multiple relations on same parent", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Post 1" });
+			await Profile.create({ user_id: user.id, bio: "Developer" });
+
+			const users = await User.query().with("posts").with("profile").get();
+			expect((users[0] as any)._relations.has("posts")).toBe(true);
+			expect((users[0] as any)._relations.has("profile")).toBe(true);
+		});
+	});
+
+	describe("eager load with filtering", () => {
+		test("where() before with() filters parent", async () => {
+			await User.create({ name: "John" });
+			const user2 = await User.create({ name: "Jane" });
+			await Post.create({ user_id: user2.id, title: "Post 1" });
+
+			const users = await User.query().where("name", "Jane").with("posts").get();
+			expect(users.length).toBe(1);
+			expect(users[0].name).toBe("Jane");
+			expect(users[0].posts.length).toBe(1);
+		});
+
+		test("constraint narrows child relations without filtering parent", async () => {
+			const user1 = await User.create({ name: "John" });
+			const user2 = await User.create({ name: "Jane" });
+			await Post.create({ user_id: user1.id, title: "Published" });
+			await Post.create({ user_id: user1.id, title: "Draft" });
+			await Post.create({ user_id: user2.id, title: "Published" });
+
+			const users = await User.query()
+				.with("posts", (q) => q.where("title", "Published"))
+				.get();
+			expect(users.length).toBe(2);
+			expect(users[0].posts.length).toBe(1);
+			expect(users[1].posts.length).toBe(1);
+		});
+	});
+
+	describe("eager load return value", () => {
+		test("get() with eager loading returns Model instances", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Post 1" });
+
+			const users = await User.query().with("posts").get();
+			expect(users[0] instanceof User).toBe(true);
+			expect(users[0].posts[0] instanceof Post).toBe(true);
+		});
+
+		test("first() with eager loading returns Model instance", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Post 1" });
+
+			const foundUser = await User.query().with("posts").first();
+			expect(foundUser instanceof User).toBe(true);
+			expect(foundUser!.posts[0] instanceof Post).toBe(true);
+		});
+	});
+
+	describe("edge cases", () => {
+		test("eager load with no results", async () => {
+			const users = await User.query().with("posts").get();
+			expect(users.length).toBe(0);
+		});
+
+		test("eager load same relation twice", async () => {
+			const user = await User.create({ name: "John" });
+			await Post.create({ user_id: user.id, title: "Post 1" });
+
+			const users = await User.query().with("posts").with("posts").get();
+			expect(users[0].posts.length).toBe(1);
+		});
+
+		test("complex nested eager load chain", async () => {
+			const user = await User.create({ name: "John" });
+			const post = await Post.create({ user_id: user.id, title: "Post 1" });
+			const comment = await Comment.create({ post_id: post.id, body: "Comment 1" });
+
+			const users = await User.query().with("posts.comments").get();
+			expect(users[0].posts[0].comments[0].id).toBe(comment.id);
+		});
+	});
+});

package/tests/unit/orm/hooks.test.ts

@@ -0,0 +1,191 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { HookRunner } from "../../../src/database/orm/hooks";
+import { Model } from "../../../src/database/orm/model";
+
+describe("HookRunner", () => {
+	describe("on() + run()", () => {
+		test("callback called with correct model argument", async () => {
+			let called = false;
+			let capturedModel: Model | null = null;
+
+			const runner = new HookRunner();
+			runner.on("saving", (model) => {
+				called = true;
+				capturedModel = model;
+			});
+
+			const model = new Model();
+			await runner.run("saving", model);
+
+			expect(called).toBe(true);
+			expect(capturedModel).toBe(model);
+		});
+
+		test("multiple callbacks run in order", async () => {
+			const order: number[] = [];
+
+			const runner = new HookRunner();
+			runner.on("saving", () => order.push(1));
+			runner.on("saving", () => order.push(2));
+			runner.on("saving", () => order.push(3));
+
+			const model = new Model();
+			await runner.run("saving", model);
+
+			expect(order).toEqual([1, 2, 3]);
+		});
+
+		test("returning false aborts remaining callbacks", async () => {
+			const order: number[] = [];
+
+			const runner = new HookRunner();
+			runner.on("saving", () => {
+				order.push(1);
+				return false;
+			});
+			runner.on("saving", () => order.push(2));
+			runner.on("saving", () => order.push(3));
+
+			const model = new Model();
+			const result = await runner.run("saving", model);
+
+			expect(result).toBe(false);
+			expect(order).toEqual([1]);
+		});
+
+		test("returning void/undefined continues, run returns true", async () => {
+			const runner = new HookRunner();
+			let callback1Called = false;
+			let callback2Called = false;
+
+			runner.on("saving", () => {
+				callback1Called = true;
+			});
+			runner.on("saving", () => {
+				callback2Called = true;
+			});
+
+			const model = new Model();
+			const result = await runner.run("saving", model);
+
+			expect(result).toBe(true);
+			expect(callback1Called).toBe(true);
+			expect(callback2Called).toBe(true);
+		});
+
+		test("async callbacks awaited correctly", async () => {
+			let order: number[] = [];
+
+			const runner = new HookRunner();
+			runner.on("saving", async () => {
+				await new Promise((resolve) => setTimeout(resolve, 10));
+				order.push(1);
+			});
+			runner.on("saving", () => order.push(2));
+
+			const model = new Model();
+			await runner.run("saving", model);
+
+			expect(order).toEqual([1, 2]);
+		});
+
+		test("async callback returning false aborts", async () => {
+			const order: number[] = [];
+
+			const runner = new HookRunner();
+			runner.on("saving", async () => {
+				await new Promise((resolve) => setTimeout(resolve, 5));
+				order.push(1);
+				return false;
+			});
+			runner.on("saving", () => order.push(2));
+
+			const model = new Model();
+			const result = await runner.run("saving", model);
+
+			expect(result).toBe(false);
+			expect(order).toEqual([1]);
+		});
+
+		test("hook name isolation - different hooks don't affect each other", async () => {
+			const savingCalled = { count: 0 };
+			const updatingCalled = { count: 0 };
+
+			const runner = new HookRunner();
+			runner.on("saving", () => savingCalled.count++);
+			runner.on("updating", () => updatingCalled.count++);
+
+			const model = new Model();
+			await runner.run("saving", model);
+
+			expect(savingCalled.count).toBe(1);
+			expect(updatingCalled.count).toBe(0);
+		});
+
+		test("multiple hook types", async () => {
+			const calls: string[] = [];
+
+			const runner = new HookRunner();
+			runner.on("creating", () => calls.push("creating"));
+			runner.on("created", () => calls.push("created"));
+			runner.on("updating", () => calls.push("updating"));
+			runner.on("updated", () => calls.push("updated"));
+
+			const model = new Model();
+			await runner.run("creating", model);
+			await runner.run("created", model);
+			await runner.run("updating", model);
+			await runner.run("updated", model);
+
+			expect(calls).toEqual(["creating", "created", "updating", "updated"]);
+		});
+	});
+
+	describe("Model.on() (static registration)", () => {
+		test("Model.on() registers callback", async () => {
+			class TestModel extends Model {
+				table = "test";
+			}
+
+			let called = false;
+			TestModel.on("saving", () => {
+				called = true;
+			});
+
+			const callbacks = TestModel.getHookCallbacks("saving");
+			expect(callbacks.length > 0).toBe(true);
+		});
+
+		test("Model.getHookCallbacks() returns array", async () => {
+			class TestModel2 extends Model {
+				static table = "test";
+			}
+
+			TestModel2.on("saving", () => {});
+			TestModel2.on("saving", () => {});
+
+			const callbacks = TestModel2.getHookCallbacks("saving");
+			expect(Array.isArray(callbacks)).toBe(true);
+			expect(callbacks.length).toBe(2);
+		});
+
+		test("static hooks isolated per model", async () => {
+			class ModelA extends Model {
+				table = "a";
+			}
+
+			class ModelB extends Model {
+				table = "b";
+			}
+
+			ModelA.on("saving", () => {});
+			ModelB.on("saving", () => {});
+
+			const aCallbacks = ModelA.getHookCallbacks("saving");
+			const bCallbacks = ModelB.getHookCallbacks("saving");
+
+			expect(aCallbacks.length).toBe(1);
+			expect(bCallbacks.length).toBe(1);
+		});
+	});
+});