@casekit/orm2 0.0.0-20250322230249

package/build/tests/orm.findMany.offsetLimit.test.js

@@ -0,0 +1,108 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { createTestDB } from "./util/db.js";
+describe("findMany: offset and limit", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("uses offset to skip records", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Bob" }),
+                    factory.user({ id: 3, name: "Charlie" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                offset: 1,
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 2, name: "Bob" },
+                { id: 3, name: "Charlie" },
+            ]);
+        }, { rollback: true });
+    });
+    test("uses limit to restrict number of records", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Bob" }),
+                    factory.user({ id: 3, name: "Charlie" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                limit: 2,
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 1, name: "Alice" },
+                { id: 2, name: "Bob" },
+            ]);
+        }, { rollback: true });
+    });
+    test("combines offset and limit", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Bob" }),
+                    factory.user({ id: 3, name: "Charlie" }),
+                    factory.user({ id: 4, name: "Dave" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                offset: 1,
+                limit: 2,
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 2, name: "Bob" },
+                { id: 3, name: "Charlie" },
+            ]);
+        }, { rollback: true });
+    });
+    test("handles offset beyond available records", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Bob" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                offset: 5,
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([]);
+        }, { rollback: true });
+    });
+    test("throws error for negative offset", async () => {
+        await db.transact(async (db) => {
+            await expect(db.findMany("user", {
+                select: ["id", "name"],
+                offset: -1,
+            })).rejects.toThrow("OFFSET must not be negative");
+        }, { rollback: true });
+    });
+    test("throws error for negative limit", async () => {
+        await db.transact(async (db) => {
+            await expect(db.findMany("user", {
+                select: ["id", "name"],
+                limit: -1,
+            })).rejects.toThrow("LIMIT must not be negative");
+        }, { rollback: true });
+    });
+});

package/build/tests/orm.findMany.orderBy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/orm.findMany.orderBy.test.js

@@ -0,0 +1,304 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { createTestDB } from "./util/db.js";
+describe("findMany: orderBy", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("orders by a single column ascending by default", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Charlie" }),
+                    factory.user({ id: 2, name: "Alice" }),
+                    factory.user({ id: 3, name: "Bob" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                orderBy: ["name"],
+            });
+            expect(users).toEqual([
+                { id: 2, name: "Alice" },
+                { id: 3, name: "Bob" },
+                { id: 1, name: "Charlie" },
+            ]);
+        }, { rollback: true });
+    });
+    test("orders by a single column with explicit direction", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Bob" }),
+                    factory.user({ id: 3, name: "Charlie" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                orderBy: [["name", "desc"]],
+            });
+            expect(users).toEqual([
+                { id: 3, name: "Charlie" },
+                { id: 2, name: "Bob" },
+                { id: 1, name: "Alice" },
+            ]);
+        }, { rollback: true });
+    });
+    test("orders by multiple columns", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, role: "admin", name: "Charlie" }),
+                    factory.user({ id: 2, role: "user", name: "Alice" }),
+                    factory.user({ id: 3, role: "admin", name: "Bob" }),
+                    factory.user({ id: 4, role: "user", name: "Bob" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name", "role"],
+                orderBy: [["role", "desc"], "name"],
+            });
+            expect(users).toEqual([
+                { id: 2, role: "user", name: "Alice" },
+                { id: 4, role: "user", name: "Bob" },
+                { id: 3, role: "admin", name: "Bob" },
+                { id: 1, role: "admin", name: "Charlie" },
+            ]);
+        }, { rollback: true });
+    });
+    test("handles null values in ordering", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({
+                        id: 1,
+                        name: "Alice",
+                        deletedAt: new Date("2024-01-01"),
+                    }),
+                    factory.user({ id: 2, name: "Bob", deletedAt: null }),
+                    factory.user({
+                        id: 3,
+                        name: "Charlie",
+                        deletedAt: new Date("2023-12-31"),
+                    }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name", "deletedAt"],
+                orderBy: ["deletedAt"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 3,
+                    name: "Charlie",
+                    deletedAt: new Date("2023-12-31"),
+                },
+                { id: 1, name: "Alice", deletedAt: new Date("2024-01-01") },
+                { id: 2, name: "Bob", deletedAt: null },
+            ]);
+        }, { rollback: true });
+    });
+    test("orders json fields", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, preferences: { theme: "dark" } }),
+                    factory.user({
+                        id: 2,
+                        preferences: { theme: "light" },
+                    }),
+                    factory.user({ id: 3, preferences: { theme: "auto" } }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "preferences"],
+                orderBy: ["preferences"],
+            });
+            expect(users).toEqual([
+                { id: 3, preferences: { theme: "auto" } },
+                { id: 1, preferences: { theme: "dark" } },
+                { id: 2, preferences: { theme: "light" } },
+            ]);
+        }, { rollback: true });
+    });
+    test("throws error when ordering by non-existent field", async () => {
+        await db.transact(async (db) => {
+            await expect(db.findMany("user", {
+                select: ["id"],
+                // @ts-expect-error - Testing runtime behavior
+                orderBy: ["nonexistentField"],
+            })).rejects.toThrow('Field "nonexistentField" not found in model "user"');
+        }, { rollback: true });
+    });
+    test("orders by array fields", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1, name: "Charlie" }),
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        tags: ["dev", "javascript"],
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 2,
+                        tags: ["dev"],
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 3,
+                        tags: ["javascript", "typescript"],
+                        authorId: 1,
+                    }),
+                ],
+            });
+            const posts = await db.findMany("post", {
+                select: ["id", "tags"],
+                orderBy: ["tags"],
+            });
+            expect(posts).toEqual([
+                { id: 2, tags: ["dev"] },
+                { id: 1, tags: ["dev", "javascript"] },
+                { id: 3, tags: ["javascript", "typescript"] },
+            ]);
+        }, { rollback: true });
+    });
+    test("orders by N:1 relation field ascending", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Charlie" }),
+                    factory.user({ id: 2, name: "Alice" }),
+                    factory.user({ id: 3, name: "Bob" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        title: "Post 1",
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 2,
+                        title: "Post 2",
+                        authorId: 2,
+                    }),
+                    factory.post({
+                        id: 3,
+                        title: "Post 3",
+                        authorId: 3,
+                    }),
+                ],
+            });
+            const posts = await db.findMany("post", {
+                select: ["id", "title"],
+                include: { author: { select: ["name"] } },
+                orderBy: ["author.name"],
+            });
+            expect(posts).toEqual([
+                { id: 2, title: "Post 2", author: { name: "Alice" } },
+                { id: 3, title: "Post 3", author: { name: "Bob" } },
+                { id: 1, title: "Post 1", author: { name: "Charlie" } },
+            ]);
+        }, { rollback: true });
+    });
+    test("orders by N:1 relation field descending", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Charlie" }),
+                    factory.user({ id: 2, name: "Alice" }),
+                    factory.user({ id: 3, name: "Bob" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        title: "Post 1",
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 2,
+                        title: "Post 2",
+                        authorId: 2,
+                    }),
+                    factory.post({
+                        id: 3,
+                        title: "Post 3",
+                        authorId: 3,
+                    }),
+                ],
+            });
+            const posts = await db.findMany("post", {
+                select: ["id", "title"],
+                include: { author: { select: ["name"] } },
+                orderBy: [["author.name", "desc"]],
+            });
+            expect(posts).toEqual([
+                { id: 1, title: "Post 1", author: { name: "Charlie" } },
+                { id: 3, title: "Post 3", author: { name: "Bob" } },
+                { id: 2, title: "Post 2", author: { name: "Alice" } },
+            ]);
+        }, { rollback: true });
+    });
+    test("orders by mix of direct and N:1 relation fields", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Alice" }),
+                    factory.user({ id: 3, name: "Bob" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        title: "First Post",
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 2,
+                        title: "Another Post",
+                        authorId: 2,
+                    }),
+                    factory.post({
+                        id: 3,
+                        title: "Last Post",
+                        authorId: 3,
+                    }),
+                    factory.post({
+                        id: 4,
+                        title: "New Post",
+                        authorId: 1,
+                    }),
+                ],
+            });
+            const posts = await db.findMany("post", {
+                select: ["id", "title"],
+                include: { author: { select: ["name"] } },
+                orderBy: [
+                    ["author.name", "asc"],
+                    ["title", "desc"],
+                ],
+            });
+            expect(posts).toEqual([
+                { id: 4, title: "New Post", author: { name: "Alice" } },
+                { id: 1, title: "First Post", author: { name: "Alice" } },
+                { id: 2, title: "Another Post", author: { name: "Alice" } },
+                { id: 3, title: "Last Post", author: { name: "Bob" } },
+            ]);
+        }, { rollback: true });
+    });
+});

package/build/tests/orm.findMany.select.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/orm.findMany.select.test.js

@@ -0,0 +1,278 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { createTestDB } from "./util/db.js";
+describe("findMany: select", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("selected fields are returned", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Lynne Tillman" }),
+                    factory.user({ id: 2, name: "Stewart Home" }),
+                    factory.user({ id: 3, name: "Chinua Achebe" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 1, name: "Lynne Tillman" },
+                { id: 2, name: "Stewart Home" },
+                { id: 3, name: "Chinua Achebe" },
+            ]);
+        }, { rollback: true });
+    });
+    test("primary key will not be returned if it is not selected", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Lynne Tillman" }),
+                    factory.user({ id: 2, name: "Stewart Home" }),
+                ],
+            });
+            const selectedUsers = await db.findMany("user", {
+                select: ["name"],
+                orderBy: ["id"],
+            });
+            expect(selectedUsers).toEqual([
+                { name: "Lynne Tillman" },
+                { name: "Stewart Home" },
+            ]);
+        }, { rollback: true });
+    });
+    test("enum fields can be selected", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, role: "user" }),
+                    factory.user({ id: 2, role: "admin" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "role"],
+                orderBy: ["role"],
+            });
+            expect(users).toEqual([
+                { id: 2, role: "admin" },
+                { id: 1, role: "user" },
+            ]);
+        }, { rollback: true });
+    });
+    test("array fields can be selected", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, role: "user" }),
+                    factory.user({ id: 2, role: "admin" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 3,
+                        tags: ["foo", "bar"],
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 4,
+                        tags: ["baz"],
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 5,
+                        tags: [],
+                        authorId: 2,
+                    }),
+                ],
+            });
+            const posts = await db.findMany("post", {
+                select: ["id", "tags"],
+                orderBy: ["id"],
+            });
+            expect(posts).toEqual([
+                { id: 3, tags: ["foo", "bar"] },
+                { id: 4, tags: ["baz"] },
+                { id: 5, tags: [] },
+            ]);
+        }, { rollback: true });
+    });
+    test("json fields can be selected", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, role: "user" }),
+                    factory.user({ id: 2, role: "admin" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 3,
+                        authorId: 1,
+                        metadata: {
+                            foo: "a",
+                            bar: [
+                                { baz: "good", quux: true },
+                                { baz: "bad", quux: false },
+                            ],
+                        },
+                    }),
+                    factory.post({
+                        id: 4,
+                        authorId: 1,
+                        metadata: {
+                            foo: "b",
+                            bar: [],
+                        },
+                    }),
+                    factory.post({
+                        id: 5,
+                        authorId: 2,
+                        metadata: {
+                            foo: "c",
+                            bar: [{ baz: "indifferent", quux: true }],
+                        },
+                    }),
+                ],
+            });
+            const posts = await db.findMany("post", {
+                select: ["metadata"],
+                orderBy: ["id"],
+            });
+            expect(posts).toEqual([
+                {
+                    metadata: {
+                        foo: "a",
+                        bar: [
+                            { baz: "good", quux: true },
+                            { baz: "bad", quux: false },
+                        ],
+                    },
+                },
+                { metadata: { foo: "b", bar: [] } },
+                {
+                    metadata: {
+                        foo: "c",
+                        bar: [{ baz: "indifferent", quux: true }],
+                    },
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("returns empty array when no records match", async () => {
+        await db.transact(async (db) => {
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+            });
+            expect(users).toEqual([]);
+        }, { rollback: true });
+    });
+    test("handles null values in selected fields correctly", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({
+                        id: 1,
+                        deletedAt: new Date("2024-01-21"),
+                    }),
+                    factory.user({ id: 2, deletedAt: null }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "deletedAt"],
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 1, deletedAt: new Date("2024-01-21") },
+                { id: 2, deletedAt: null },
+            ]);
+        }, { rollback: true });
+    });
+    test("can select all available fields", async () => {
+        await db.transact(async (db) => {
+            const user = factory.user({
+                id: 1,
+                name: "Test User",
+                email: "test@example.com",
+                role: "user",
+                preferences: { theme: "dark" },
+                createdAt: new Date(),
+                deletedAt: null,
+            });
+            await db.createOne("user", { values: user });
+            const users = await db.findMany("user", {
+                select: [
+                    "id",
+                    "name",
+                    "email",
+                    "role",
+                    "preferences",
+                    "createdAt",
+                    "deletedAt",
+                ],
+            });
+            expect(users[0]).toEqual(user);
+        }, { rollback: true });
+    });
+    test("throws error when selecting from non-existent model", async () => {
+        await db.transact(async (db) => {
+            await expect(
+            // @ts-expect-error - Testing runtime behavior
+            db.findMany("invalid", {
+                select: ["id"],
+            })).rejects.toThrow(`Model "invalid" not found`);
+        }, { rollback: true });
+    });
+    test("throws error when selecting non-existent field", async () => {
+        await db.transact(async (db) => {
+            await expect(db.findMany("user", {
+                // @ts-expect-error - Testing runtime behavior
+                select: ["id", "nonexistentField"],
+            })).rejects.toThrow(`Field "nonexistentField" not found in model "user"`);
+        }, { rollback: true });
+    });
+    test("handles special characters in selected field values", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "O'Connor" }),
+                    factory.user({
+                        id: 2,
+                        name: "User; DROP TABLE users;",
+                    }),
+                    factory.user({ id: 3, name: "User with spaces" }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 1, name: "O'Connor" },
+                { id: 2, name: "User; DROP TABLE users;" },
+                { id: 3, name: "User with spaces" },
+            ]);
+        }, { rollback: true });
+    });
+    test("handles large text values in selected fields", async () => {
+        await db.transact(async (db) => {
+            const longText = "a".repeat(10000);
+            await db.createOne("user", {
+                values: factory.user({ id: 1, name: longText }),
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+            });
+            expect(users).toEqual([{ id: 1, name: longText }]);
+        }, { rollback: true });
+    });
+});