@apisr/drizzle-model 0.0.3 → 2.0.0

package/tests/base/count.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import { model } from "tests/base";
+import { db } from "tests/db";
+import * as schema from "tests/schema";
+import { esc } from "@/model";
+
+const userModel = model("user", {});
+const postsModel = model("userPosts", {});
+
+describe("count", () => {
+	test("returns total row count", async () => {
+		const count = await userModel.count();
+		const rows = await db.select().from(schema.user);
+
+		expect(count).toBeNumber();
+		expect(count).toBe((rows as any[]).length);
+	});
+
+	test("respects where clause", async () => {
+		const count = await userModel.where({ name: esc("Alex") }).count();
+
+		expect(count).toBeNumber();
+		expect(count).toBeGreaterThanOrEqual(0);
+	});
+
+	test("returns 0 for no matches", async () => {
+		const count = await userModel
+			.where({ name: esc("__nonexistent_user_name__") })
+			.count();
+
+		expect(count).toBe(0);
+	});
+
+	test("reflects inserted rows", async () => {
+		const before = await postsModel.count();
+
+		await postsModel.insert({
+			title: "Count check",
+			featured: false,
+			userId: 1,
+		});
+
+		const after = await postsModel.count();
+
+		expect(after).toBe(before + 1);
+	});
+});

package/tests/base/delete.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import { eq } from "drizzle-orm";
+import { model } from "tests/base";
+import { db } from "tests/db";
+import * as schema from "tests/schema";
+import { esc } from "@/model";
+
+const postsModel = model("userPosts", {});
+
+async function seedPost(title: string) {
+	const [row] = (await postsModel
+		.insert({ title, featured: false, userId: 1 })
+		.return()) as any[];
+	return row;
+}
+
+describe("delete", () => {
+	test("deletes matching rows — return", async () => {
+		const seed = await seedPost("Delete seed");
+
+		const rows = (await postsModel
+			.where({ id: esc(seed.id) })
+			.delete()
+			.return()) as any[];
+
+		expect(rows).toBeArray();
+		expect(rows[0].id).toBe(seed.id);
+
+		const remaining = await db
+			.select()
+			.from(schema.userPosts)
+			.where(eq(schema.userPosts.id, seed.id));
+
+		expect(remaining).toHaveLength(0);
+	});
+
+	test("returnFirst — returns the deleted row", async () => {
+		const seed = await seedPost("Delete returnFirst");
+
+		const row = (await postsModel
+			.where({ id: esc(seed.id) })
+			.delete()
+			.returnFirst()) as any;
+
+		expect(row).toBeDefined();
+		expect(row.id).toBe(seed.id);
+		expect(row.title).toBe("Delete returnFirst");
+	});
+
+	test("return > omit — removes specified fields", async () => {
+		const seed = await seedPost("Delete omit");
+
+		const rows = (await postsModel
+			.where({ id: esc(seed.id) })
+			.delete()
+			.return()
+			.omit({ likes: true, views: true })) as any[];
+
+		expect(rows[0].likes).toBeUndefined();
+		expect(rows[0].views).toBeUndefined();
+		expect(rows[0].title).toBe("Delete omit");
+	});
+
+	test("returnFirst > safe — success", async () => {
+		const seed = await seedPost("Delete safe");
+
+		const result = await postsModel
+			.where({ id: esc(seed.id) })
+			.delete()
+			.returnFirst()
+			.safe();
+
+		expect(result.error).toBeUndefined();
+		expect(result.data).toBeDefined();
+		expect((result.data as any).id).toBe(seed.id);
+	});
+
+	test("row is gone after delete", async () => {
+		const seed = await seedPost("Delete verify gone");
+
+		await postsModel.where({ id: esc(seed.id) }).delete();
+
+		const remaining = await db
+			.select()
+			.from(schema.userPosts)
+			.where(eq(schema.userPosts.id, seed.id));
+
+		expect(remaining).toHaveLength(0);
+	});
+});

package/tests/base/find.test.ts

@@ -0,0 +1,209 @@
+import { describe, expect, test } from "bun:test";
+import { eq } from "drizzle-orm";
+import { model } from "tests/base";
+import { db } from "tests/db";
+import * as schema from "tests/schema";
+import { esc } from "@/model";
+
+const userModel = model("user", {});
+const userModelFormat = model("user", {
+	format({ secretField, isVerified, ...rest }) {
+		return {
+			...rest,
+			isVerified: !!isVerified,
+			customField: "Hello World" as const,
+		};
+	},
+});
+
+describe("find", () => {
+	// -----------------------------------------------------------------------
+	// findFirst
+	// -----------------------------------------------------------------------
+
+	describe("findFirst", () => {
+		test("returns a single row", async () => {
+			const user = await userModel.findFirst();
+
+			expect(user).toBeDefined();
+			expect(user.id).toBeNumber();
+		});
+
+		test("where — equality", async () => {
+			const user = await userModel.where({ name: esc("Alex") }).findFirst();
+
+			expect(user).toBeDefined();
+			expect(user.name).toBe("Alex");
+		});
+
+		test("where — like operator", async () => {
+			const user = await userModel.where({ name: { like: "An%" } }).findFirst();
+
+			expect(user).toBeDefined();
+			expect(user.name.startsWith("An")).toBe(true);
+		});
+
+		test("where — or combinator", async () => {
+			const user = await userModel
+				.where({ name: { or: [esc("Alex"), esc("Anna")] } })
+				.findFirst();
+
+			expect(user).toBeDefined();
+			expect(["Alex", "Anna"]).toContain(user.name);
+		});
+
+		test("select — picks only specified fields", async () => {
+			const user = await userModel.findFirst().select({
+				name: true,
+				age: true,
+			});
+
+			expect(user.name).toBeDefined();
+			expect(user.age).toBeDefined();
+			// @ts-expect-error
+			expect(user.email).toBeUndefined();
+		});
+
+		test("exclude — removes specified fields", async () => {
+			const user = await userModel.findFirst().exclude({
+				name: true,
+			});
+
+			// @ts-expect-error
+			expect(user.name).toBeUndefined();
+			expect(user.id).toBeDefined();
+		});
+
+		test("format — applies format function", async () => {
+			const user = await userModelFormat.findFirst();
+
+			expect(user.customField).toBe("Hello World");
+			// @ts-expect-error
+			expect(user.secretField).toBeUndefined();
+			expect(typeof user.isVerified).toBe("boolean");
+		});
+
+		test("raw — skips format", async () => {
+			const user = await userModelFormat.findFirst().raw();
+
+			expect(user.secretField).toBeDefined();
+		});
+
+		test("matches raw drizzle query", async () => {
+			const user = await userModel.where({ name: esc("Alex") }).findFirst();
+
+			const [expected] = await db
+				.select()
+				.from(schema.user)
+				.where(eq(schema.user.name, "Alex"))
+				.limit(1);
+
+			expect(user).toEqual(expected as any);
+		});
+
+		test("safe — wraps result in { data, error }", async () => {
+			const result = await userModel.findFirst().safe();
+
+			expect(result.error).toBeUndefined();
+			expect(result.data).toBeDefined();
+			expect((result.data as any).id).toBeNumber();
+		});
+	});
+
+	// -----------------------------------------------------------------------
+	// findMany
+	// -----------------------------------------------------------------------
+
+	describe("findMany", () => {
+		test("returns all rows", async () => {
+			const users = await userModel.findMany();
+			const expected = await db.select().from(schema.user);
+
+			expect(users).toBeArray();
+			expect(users).toHaveLength((expected as any[]).length);
+		});
+
+		test("where — equality", async () => {
+			const users = await userModel.where({ name: esc("Alex") }).findMany();
+
+			expect(users).toBeArray();
+			for (const user of users) {
+				expect(user.name).toBe("Alex");
+			}
+		});
+
+		test("where — multiple filters (AND)", async () => {
+			const users = await userModel
+				.where({
+					name: esc("Alex"),
+					isVerified: esc(false),
+				})
+				.findMany();
+
+			for (const user of users) {
+				expect(user.name).toBe("Alex");
+				expect(user.isVerified).toBe(false);
+			}
+		});
+
+		test("where — gte operator", async () => {
+			const users = await userModel.where({ age: { gte: esc(18) } }).findMany();
+
+			for (const user of users) {
+				expect(user.age).toBeGreaterThanOrEqual(18);
+			}
+		});
+
+		test("select — picks only specified fields", async () => {
+			const users = await userModel.findMany().select({
+				name: true,
+				age: true,
+			});
+
+			for (const user of users) {
+				expect(user.name).toBeDefined();
+				expect(user.age).toBeDefined();
+				// @ts-expect-error
+				expect(user.email).toBeUndefined();
+			}
+		});
+
+		test("exclude — removes specified fields", async () => {
+			const users = await userModel.findMany().exclude({
+				name: true,
+			});
+
+			for (const user of users) {
+				// @ts-expect-error
+				expect(user.name).toBeUndefined();
+				expect(user.id).toBeDefined();
+			}
+		});
+
+		test("format — applies format function", async () => {
+			const users = await userModelFormat.findMany();
+
+			for (const user of users) {
+				expect(user.customField).toBe("Hello World");
+				// @ts-expect-error
+				expect(user.secretField).toBeUndefined();
+			}
+		});
+
+		test("raw — skips format", async () => {
+			const users = await userModelFormat.findMany().raw();
+
+			for (const user of users) {
+				expect(user.secretField).toBeDefined();
+			}
+		});
+
+		test("safe — wraps result in { data, error }", async () => {
+			const result = await userModel.findMany().safe();
+
+			expect(result.error).toBeUndefined();
+			expect(result.data).toBeDefined();
+			expect(result.data).toBeArray();
+		});
+	});
+});

package/tests/base/insert.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, test } from "bun:test";
+import { eq, inArray } from "drizzle-orm";
+import { model } from "tests/base";
+import { db } from "tests/db";
+import * as schema from "tests/schema";
+
+const postsModel = model("userPosts", {});
+const userModel = model("user", {});
+
+function uid(): string {
+	return `${Date.now()}-${Math.random()}`;
+}
+
+describe("insert", () => {
+	test("single row — no return", async () => {
+		await postsModel.insert({
+			title: "Insert no-return",
+			featured: false,
+			userId: 1,
+		});
+	});
+
+	test("single row — return", async () => {
+		const rows = await postsModel
+			.insert({
+				title: "Insert return",
+				featured: true,
+				userId: 1,
+			})
+			.return();
+
+		expect(rows).toBeArray();
+		expect((rows as any[])[0].title).toBe("Insert return");
+		expect((rows as any[])[0].featured).toBe(true);
+	});
+
+	test("single row — returnFirst", async () => {
+		const row = await postsModel
+			.insert({
+				title: "Insert returnFirst",
+				featured: false,
+				userId: 1,
+			})
+			.returnFirst();
+
+		expect(row).toBeDefined();
+		expect((row as any).id).toBeNumber();
+		expect((row as any).title).toBe("Insert returnFirst");
+	});
+
+	test("single row — matches raw drizzle", async () => {
+		const [inserted] = (await postsModel
+			.insert({
+				title: "Insert drizzle check",
+				featured: null,
+				userId: 1,
+			})
+			.return()) as any[];
+
+		const [expected] = await db
+			.select()
+			.from(schema.userPosts)
+			.where(eq(schema.userPosts.id, inserted.id));
+
+		expect(inserted).toEqual(expected as any);
+	});
+
+	test("single row with defaults", async () => {
+		const row = (await postsModel
+			.insert({
+				title: "Insert defaults",
+				userId: 1,
+			})
+			.returnFirst()) as any;
+
+		expect(row.likes).toBe(0);
+		expect(row.views).toBe(0);
+		expect(row.description).toBeNull();
+		expect(row.featured).toBeNull();
+	});
+
+	test("multiple rows — return", async () => {
+		const rows = (await postsModel
+			.insert([
+				{ title: "Bulk 1", featured: false, userId: 1 },
+				{ title: "Bulk 2", featured: true, userId: 1 },
+			])
+			.return()) as any[];
+
+		const ids = rows.map((r) => r.id);
+		const expected = await db
+			.select()
+			.from(schema.userPosts)
+			.where(inArray(schema.userPosts.id, ids));
+
+		expect(rows).toHaveLength(2);
+		expect(rows[0].title).toBe("Bulk 1");
+		expect(rows[1].title).toBe("Bulk 2");
+		expect(rows.sort((a, b) => a.id - b.id)).toEqual(
+			(expected as any[]).sort((a, b) => a.id - b.id)
+		);
+	});
+
+	test("return > omit — removes specified fields", async () => {
+		const rows = (await userModel
+			.insert({
+				email: `${uid()}@test.com`,
+				name: "Omit test",
+				age: 99,
+				secretField: 42,
+			})
+			.return()
+			.omit({ age: true, secretField: true })) as any[];
+
+		for (const row of rows) {
+			expect(row.age).toBeUndefined();
+			expect(row.secretField).toBeUndefined();
+			expect(row.name).toBe("Omit test");
+		}
+	});
+
+	test("returnFirst > omit — removes specified fields", async () => {
+		const row = (await userModel
+			.insert({
+				email: `${uid()}@test.com`,
+				name: "Omit first test",
+				age: 55,
+				secretField: 7,
+			})
+			.returnFirst()
+			.omit({ age: true, secretField: true })) as any;
+
+		expect(row.age).toBeUndefined();
+		expect(row.secretField).toBeUndefined();
+		expect(row.name).toBe("Omit first test");
+	});
+
+	test("returnFirst > safe — success", async () => {
+		const result = await userModel
+			.insert({
+				email: `${uid()}@test.com`,
+				name: "Safe test",
+				age: 20,
+			})
+			.returnFirst()
+			.safe();
+
+		expect(result.error).toBeUndefined();
+		expect(result.data).toBeDefined();
+		expect((result.data as any).name).toBe("Safe test");
+	});
+});

package/tests/base/safe.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test";
+import { model } from "tests/base";
+import { esc } from "@/model";
+
+const userModel = model("user", {});
+
+function uid(): string {
+	return `${Date.now()}-${Math.random()}`;
+}
+
+describe("safe", () => {
+	describe("query — safe()", () => {
+		test("findFirst — success returns { data, error: undefined }", async () => {
+			const result = await userModel.findFirst().safe();
+
+			expect(result.error).toBeUndefined();
+			expect(result.data).toBeDefined();
+			expect((result.data as any).id).toBeNumber();
+		});
+
+		test("findMany — success returns { data, error: undefined }", async () => {
+			const result = await userModel.findMany().safe();
+
+			expect(result.error).toBeUndefined();
+			expect(result.data).toBeArray();
+		});
+
+		test("findFirst with where — success", async () => {
+			const result = await userModel
+				.where({ name: esc("Alex") })
+				.findFirst()
+				.safe();
+
+			expect(result.error).toBeUndefined();
+			expect(result.data).toBeDefined();
+		});
+	});
+
+	describe("mutation — safe()", () => {
+		test("insert > returnFirst > safe — success", async () => {
+			const result = await userModel
+				.insert({
+					email: `${uid()}@safe.com`,
+					name: "Safe insert",
+					age: 25,
+				})
+				.returnFirst()
+				.safe();
+
+			expect(result.error).toBeUndefined();
+			expect(result.data).toBeDefined();
+			expect((result.data as any).name).toBe("Safe insert");
+		});
+
+		test("insert > return > safe — success", async () => {
+			const result = await userModel
+				.insert({
+					email: `${uid()}@safe.com`,
+					name: "Safe array insert",
+					age: 30,
+				})
+				.return()
+				.safe();
+
+			expect(result.error).toBeUndefined();
+			expect(result.data).toBeDefined();
+		});
+
+		test("insert > safe — error on duplicate email", async () => {
+			const email = `${uid()}@safe-dup.com`;
+
+			await userModel.insert({
+				email,
+				name: "First",
+				age: 20,
+			});
+
+			const result = await userModel
+				.insert({
+					email,
+					name: "Duplicate",
+					age: 20,
+				})
+				.returnFirst()
+				.safe();
+
+			expect(result.error).toBeDefined();
+			expect(result.data).toBeUndefined();
+		});
+	});
+});

package/tests/base/update.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test";
+import { eq } from "drizzle-orm";
+import { model } from "tests/base";
+import { db } from "tests/db";
+import * as schema from "tests/schema";
+import { esc } from "@/model";
+
+const postsModel = model("userPosts", {});
+
+async function seedPost(title: string) {
+	const [row] = (await postsModel
+		.insert({ title, featured: false, userId: 1 })
+		.return()) as any[];
+	return row;
+}
+
+describe("update", () => {
+	test("updates matching rows — return", async () => {
+		const seed = await seedPost("Update seed");
+
+		const rows = (await postsModel
+			.where({ id: esc(seed.id) })
+			.update({ title: "Updated title", featured: true })
+			.return()) as any[];
+
+		expect(rows).toBeArray();
+		expect(rows[0].id).toBe(seed.id);
+		expect(rows[0].title).toBe("Updated title");
+		expect(rows[0].featured).toBe(true);
+	});
+
+	test("matches raw drizzle after update", async () => {
+		const seed = await seedPost("Update drizzle check");
+
+		await postsModel
+			.where({ id: esc(seed.id) })
+			.update({ title: "Verified update" })
+			.return();
+
+		const [expected] = await db
+			.select()
+			.from(schema.userPosts)
+			.where(eq(schema.userPosts.id, seed.id));
+
+		expect((expected as any).title).toBe("Verified update");
+	});
+
+	test("returnFirst — returns single object", async () => {
+		const seed = await seedPost("Update returnFirst");
+
+		const row = (await postsModel
+			.where({ id: esc(seed.id) })
+			.update({ title: "First updated" })
+			.returnFirst()) as any;
+
+		expect(row).toBeDefined();
+		expect(row.id).toBe(seed.id);
+		expect(row.title).toBe("First updated");
+	});
+
+	test("return > omit — removes specified fields", async () => {
+		const seed = await seedPost("Update omit");
+
+		const rows = (await postsModel
+			.where({ id: esc(seed.id) })
+			.update({ title: "Omitted update" })
+			.return()
+			.omit({ likes: true, views: true })) as any[];
+
+		expect(rows[0].likes).toBeUndefined();
+		expect(rows[0].views).toBeUndefined();
+		expect(rows[0].title).toBe("Omitted update");
+	});
+
+	test("returnFirst > safe — success", async () => {
+		const seed = await seedPost("Update safe");
+
+		const result = await postsModel
+			.where({ id: esc(seed.id) })
+			.update({ title: "Safe updated" })
+			.returnFirst()
+			.safe();
+
+		expect(result.error).toBeUndefined();
+		expect(result.data).toBeDefined();
+		expect((result.data as any).title).toBe("Safe updated");
+	});
+});