@casekit/orm 0.0.1-alpha.9 → 0.0.1-release-candidate.2

package/build/tests/orm.restrict.test-d.d.ts

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

package/build/tests/orm.restrict.test-d.js

@@ -0,0 +1,105 @@
+import { assertType, describe, expectTypeOf, test } from "vitest";
+import { models } from "@casekit/orm-fixtures";
+import { orm } from "../orm.js";
+const db = orm({ models });
+describe("restrict types", () => {
+    test("allows querying allowed models", () => {
+        const restricted = db.restrict(["user", "post"]);
+        // Should allow querying user model
+        assertType(restricted.findOne("user", {
+            select: ["id", "name"],
+        }));
+        // Should allow querying post model with relation to allowed model
+        assertType(restricted.findOne("post", {
+            select: ["id", "title"],
+            include: {
+                author: { select: ["id", "name"] },
+            },
+        }));
+    });
+    test("prevents querying disallowed models", () => {
+        const restricted = db.restrict(["user"]);
+        assertType(
+        // @ts-expect-error - post model is not allowed
+        restricted.findOne("post", {
+            select: ["id", "title"],
+        }));
+    });
+    test("prevents querying disallowed relations", () => {
+        const restricted = db.restrict(["user", "friendship"]);
+        assertType(restricted.findOne("user", {
+            select: ["id", "name"],
+            include: {
+                // @ts-expect-error post model is not allowed
+                posts: { select: ["id", "title"] },
+            },
+        }));
+    });
+    test("allowing through model also allows N:N relations", () => {
+        const restricted = db.restrict(["user", "friendship"]);
+        assertType(restricted.findOne("user", {
+            select: ["id", "name"],
+            include: {
+                friends: { select: ["id", "name"] },
+            },
+        }));
+        expectTypeOf(restricted.findOne("user", {
+            select: ["id", "name"],
+            include: {
+                friends: { select: ["id", "name"] },
+            },
+        })).resolves.toEqualTypeOf();
+    });
+    test("restricting a model such that it has no relations prevents any include clauses on that model", () => {
+        const restricted = db.restrict(["user"]);
+        assertType(restricted.findOne("user", {
+            select: ["id", "name"],
+            // @ts-expect-error user has no allowed relations
+            include: {
+                posts: { select: ["id", "title"] },
+            },
+        }));
+    });
+    test("disallowing through model prevents N:N relations", () => {
+        const restricted = db.restrict(["user", "post"]);
+        assertType(restricted.findOne("user", {
+            select: ["id", "name"],
+            include: {
+                // @ts-expect-error friendship is not allowed
+                friends: { select: ["id", "name"] },
+            },
+        }));
+    });
+    test("respects return types of queries on restricted orm", () => {
+        const restricted = db.restrict(["user"]);
+        expectTypeOf(restricted.findOne("user", {
+            select: ["id", "name", "role"],
+        })).resolves.toEqualTypeOf();
+    });
+    test("restricting twice maintains most restrictive set", () => {
+        const restricted = db.restrict(["user", "post"]).restrict(["user"]);
+        // Should allow user queries
+        assertType(restricted.findOne("user", {
+            select: ["id", "name"],
+        }));
+        // Should prevent post queries
+        assertType(
+        // @ts-expect-error - post model is not allowed after second restriction
+        restricted.findOne("post", {
+            select: ["id", "title"],
+        }));
+    });
+    test("empty restriction set creates unusable orm", () => {
+        const restricted = db.restrict([]);
+        assertType(
+        // @ts-expect-error - no models are allowed
+        restricted.findOne("user", {
+            select: ["id", "name"],
+        }));
+        assertType(
+        // @ts-expect-error - no models are allowed
+        restricted.findOne("post", {
+            select: ["id", "title"],
+        }));
+    });
+});

package/build/tests/orm.restrict.test.d.ts

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

package/build/tests/orm.restrict.test.js

@@ -0,0 +1,259 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { config } from "@casekit/orm-fixtures";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("orm.restrict", () => {
+    const logger = mockLogger();
+    const db = orm({ ...config, logger });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("foo", () => {
+        let x = {
+            foo: 2,
+            bar: 4,
+        };
+        expect(x.foo).toEqual(2);
+        x = {
+            ...x,
+            get foo() {
+                throw new Error("haha");
+            },
+        };
+        expect(() => x.foo).toThrow();
+    });
+    //     test("it allows querying permitted models", async () => {
+    //         await db.restrict(["user", "post"]).transact(
+    //             async (db) => {
+    //                 // Create a user
+    //                 const user = await db.createOne("user", {
+    //                     values: {
+    //                         name: "Test User",
+    //                         email: "test@example.com",
+    //                         role: "user",
+    //                     },
+    //                     returning: ["id", "name"],
+    //                 });
+    //                 // Create a post for that user
+    //                 await db.createOne("post", {
+    //                     values: {
+    //                         title: "Test Post",
+    //                         content: "Test Content",
+    //                         authorId: user.id,
+    //                     },
+    //                 });
+    //                 // Should be able to query both models
+    //                 const result = await db.findOne("user", {
+    //                     select: ["id", "name"],
+    //                     include: {
+    //                         posts: {
+    //                             select: ["id", "title"],
+    //                         },
+    //                     },
+    //                     where: { id: user.id },
+    //                 });
+    //                 expect(result.name).toBe("Test User");
+    //                 expect(result.posts).toHaveLength(1);
+    //                 expect(result.posts[0]!.title).toBe("Test Post");
+    //             },
+    //             { rollback: true },
+    //         );
+    //     });
+    //     test("if an unpermitted model is queried despite the type error, it throws an exception", async () => {
+    //         await expect(
+    //             db.restrict(["user"]).transact(
+    //                 async (db) => {
+    //                     // @ts-expect-error - post model should not be accessible
+    //                     await db.findOne("post", {
+    //                         select: ["id"],
+    //                     });
+    //                 },
+    //                 { rollback: true },
+    //             ),
+    //         ).rejects.toThrow(
+    //             'Model "post" is not permitted in this restricted ORM instance',
+    //         );
+    //     });
+    //     test("if an unpermitted relation is queried despite the type error, it throws an exception", async () => {
+    //         await expect(
+    //             db.restrict(["user", "post"]).transact(
+    //                 async (db) => {
+    //                     await db.findOne("user", {
+    //                         select: ["id"],
+    //                         include: {
+    //                             // @ts-expect-error - color relation should not be accessible
+    //                             backgroundColor: {
+    //                                 select: ["hex"],
+    //                             },
+    //                         },
+    //                     });
+    //                 },
+    //                 { rollback: true },
+    //             ),
+    //         ).rejects.toThrow(
+    //             'Relation "backgroundColor" references model "color" which is not permitted in this restricted ORM instance',
+    //         );
+    //     });
+    //     test("it throws if called inside a transaction", async () => {
+    //         await expect(
+    //             db.transact(
+    //                 async (db) => {
+    //                     const restrictedDb = db.restrict(["user"]);
+    //                     await restrictedDb.findOne("user", { select: ["id"] });
+    //                 },
+    //                 { rollback: true },
+    //             ),
+    //         ).rejects.toThrowError("Cannot create restricted ORM in a transaction");
+    //     });
+    //     test("allows querying through permitted N:1 relations", async () => {
+    //         await db.restrict(["post", "user"]).transact(
+    //             async (db) => {
+    //                 const user = await db.createOne("user", {
+    //                     values: {
+    //                         name: "Test User",
+    //                         email: "test@example.com",
+    //                         role: "user",
+    //                     },
+    //                     returning: ["id"],
+    //                 });
+    //                 await db.createOne("post", {
+    //                     values: {
+    //                         title: "Test Post",
+    //                         content: "Content",
+    //                         authorId: user.id,
+    //                     },
+    //                 });
+    //                 const result = await db.findOne("post", {
+    //                     select: ["id", "title"],
+    //                     include: {
+    //                         author: {
+    //                             select: ["name"],
+    //                         },
+    //                     },
+    //                     where: { authorId: user.id },
+    //                 });
+    //                 expect(result.author.name).toBe("Test User");
+    //             },
+    //             { rollback: true },
+    //         );
+    //     });
+    //     test("allows querying through permitted 1:N relations", async () => {
+    //         await db.restrict(["user", "post"]).transact(
+    //             async (db) => {
+    //                 const user = await db.createOne("user", {
+    //                     values: {
+    //                         name: "Test User",
+    //                         email: "test@example.com",
+    //                         role: "user",
+    //                     },
+    //                     returning: ["id"],
+    //                 });
+    //                 await db.createOne("post", {
+    //                     values: {
+    //                         title: "Test Post",
+    //                         content: "Content",
+    //                         authorId: user.id,
+    //                     },
+    //                 });
+    //                 const result = await db.findOne("user", {
+    //                     select: ["id", "name"],
+    //                     include: {
+    //                         posts: {
+    //                             select: ["title"],
+    //                         },
+    //                     },
+    //                     where: { id: user.id },
+    //                 });
+    //                 expect(result.posts[0]!.title).toBe("Test Post");
+    //             },
+    //             { rollback: true },
+    //         );
+    //     });
+    //     test("allows querying through permitted N:N relations", async () => {
+    //         await db.restrict(["user", "post", "friendship"]).transact(
+    //             async (db) => {
+    //                 const [stewart, lynne] = await db.createMany("user", {
+    //                     values: [
+    //                         {
+    //                             name: "Stewart Home",
+    //                             email: "stewarthome@example.com",
+    //                             role: "user",
+    //                         },
+    //                         {
+    //                             name: "Lynne Tillman",
+    //                             email: "lynnetillman@example.com",
+    //                             role: "admin",
+    //                         },
+    //                     ],
+    //                     returning: ["id", "name"],
+    //                 });
+    //                 await db.createMany("friendship", {
+    //                     values: [
+    //                         {
+    //                             userId: stewart!.id,
+    //                             friendId: lynne!.id,
+    //                         },
+    //                     ],
+    //                 });
+    //                 const result = await db.findOne("user", {
+    //                     select: ["id"],
+    //                     include: {
+    //                         friends: {
+    //                             select: ["id", "name"],
+    //                         },
+    //                     },
+    //                     where: { id: stewart!.id },
+    //                 });
+    //                 expect(result.friends[0]!.name).toBe("Lynne Tillman");
+    //             },
+    //             { rollback: true },
+    //         );
+    //     });
+    //     test("restricting to no models results in an unusable ORM", async () => {
+    //         const restrictedDb = db.restrict([]);
+    //         // Should have no accessible models
+    //         await expect(
+    //             restrictedDb.transact(
+    //                 async (db) => {
+    //                     // @ts-expect-error - no models should be accessible
+    //                     await db.findOne("user", {
+    //                         select: ["id"],
+    //                     });
+    //                 },
+    //                 { rollback: true },
+    //             ),
+    //         ).rejects.toThrow(
+    //             'Model "user" is not permitted in this restricted ORM instance',
+    //         );
+    //     });
+    //     test("restricting twice maintains the most restrictive set", async () => {
+    //         await db
+    //             .restrict(["user", "post", "friendship"])
+    //             .restrict(["user", "friendship"])
+    //             .transact(
+    //                 async (db) => {
+    //                     // Should be able to query user
+    //                     await db.findOne("user", {
+    //                         select: ["id"],
+    //                     });
+    //                     // Should not be able to query post or like
+    //                     await expect(
+    //                         // @ts-expect-error - post should not be accessible
+    //                         db.findOne("post", {
+    //                             select: ["id"],
+    //                         }),
+    //                     ).rejects.toThrow('Model "post" is not permitted');
+    //                     await expect(
+    //                         // @ts-expect-error - like should not be accessible
+    //                         db.findOne("like", {
+    //                             select: ["id"],
+    //                         }),
+    //                     ).rejects.toThrow('Model "like" is not permitted');
+    //                 },
+    //                 { rollback: true },
+    //             );
+    //     });
+});

package/build/tests/orm.transact.test.d.ts

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

package/build/tests/orm.transact.test.js

@@ -0,0 +1,48 @@
+import * as uuid from "uuid";
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { orm } from "../orm.js";
+describe("orm.transact()", () => {
+    test("rolling back a transaction on error", async () => {
+        // create a unique table name in case this test fails and
+        // the table is not dropped
+        const table = sql.ident(`test_${uuid.v4()}`);
+        const db = orm({ models: {} });
+        await db.connect();
+        try {
+            await db.query `CREATE TABLE ${table} (id SERIAL PRIMARY KEY)`;
+            await db.transact(async (db) => {
+                await db.query `INSERT INTO ${table} DEFAULT VALUES`;
+                throw new Error("rollback");
+            });
+        }
+        catch (e) {
+            expect(e.message).toBe("rollback");
+            const result = await db.query `SELECT * FROM ${table}`;
+            expect(result).toEqual([]);
+            await db.query `DROP TABLE ${table}`;
+        }
+        finally {
+            await db.close();
+        }
+    });
+    test("committing a transaction on successful completion of the callback", async () => {
+        // create a unique table name in case this test fails and
+        // the table is not dropped
+        const table = sql.ident(`test_${uuid.v4()}`);
+        const db = orm({ models: {} });
+        await db.connect();
+        try {
+            await db.query `CREATE TABLE ${table} (id SERIAL PRIMARY KEY)`;
+            await db.transact(async (db) => {
+                await db.query `INSERT INTO ${table} DEFAULT VALUES`;
+            });
+            const result = await db.query `SELECT * FROM ${table}`;
+            expect(result).toEqual([{ id: 1 }]);
+            await db.query `DROP TABLE ${table}`;
+        }
+        finally {
+            await db.close();
+        }
+    });
+});

package/build/tests/orm.updateMany.test.d.ts

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

package/build/tests/orm.updateMany.test.js

@@ -0,0 +1,210 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { $in } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("updateMany", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("updates multiple records with specified values", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, role: "user" }),
+                    factory.user({ id: 2, role: "user" }),
+                    factory.user({ id: 3, role: "admin" }),
+                ],
+            });
+            const updated = await db.updateMany("user", {
+                set: { role: "admin" },
+                where: { role: "user" },
+            });
+            expect(updated).toBe(2);
+            const users = await db.findMany("user", {
+                select: ["id", "role"],
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 1, role: "admin" },
+                { id: 2, role: "admin" },
+                { id: 3, role: "admin" },
+            ]);
+        }, { rollback: true });
+    });
+    test("returns 0 when no records match update criteria", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, role: "admin" }),
+                    factory.user({ id: 2, role: "admin" }),
+                ],
+            });
+            const updated = await db.updateMany("user", {
+                set: { role: "user" },
+                where: { id: 3 },
+            });
+            expect(updated).toBe(0);
+        }, { rollback: true });
+    });
+    test("updates json fields correctly", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({
+                        id: 1,
+                        preferences: { theme: "light" },
+                    }),
+                    factory.user({
+                        id: 2,
+                        preferences: { theme: "light" },
+                    }),
+                ],
+            });
+            await db.updateMany("user", {
+                set: { preferences: { theme: "dark" } },
+                where: { id: { [$in]: [1, 2] } },
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "preferences"],
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 1, preferences: { theme: "dark" } },
+                { id: 2, preferences: { theme: "dark" } },
+            ]);
+        }, { rollback: true });
+    });
+    test("updates array fields correctly", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({
+                    id: 1,
+                }),
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        tags: ["old"],
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 2,
+                        tags: ["old"],
+                        authorId: 1,
+                    }),
+                ],
+            });
+            await db.updateMany("post", {
+                set: { tags: ["new"] },
+                where: { id: { [$in]: [1] } },
+            });
+            const posts = await db.findMany("post", {
+                select: ["id", "tags"],
+                orderBy: ["id"],
+            });
+            expect(posts).toEqual([
+                { id: 1, tags: ["new"] },
+                { id: 2, tags: ["old"] },
+            ]);
+        }, { rollback: true });
+    });
+    test("handles null values in updates", 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: new Date("2024-01-21"),
+                    }),
+                ],
+            });
+            await db.updateMany("user", {
+                set: { deletedAt: null },
+                where: { id: { [$in]: [2] } },
+            });
+            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("throws error when updating non-existent model", async () => {
+        await db.transact(async (db) => {
+            await expect(
+            // @ts-expect-error - Testing runtime behavior
+            db.updateMany("invalid", {
+                set: { field: "value" },
+                where: { id: 1 },
+            })).rejects.toThrow('Model "invalid" not found');
+        }, { rollback: true });
+    });
+    test("throws error when updating with non-existent field", async () => {
+        await db.transact(async (db) => {
+            await expect(db.updateMany("user", {
+                // @ts-expect-error - Testing runtime behavior
+                set: { nonexistent: "value" },
+                where: { id: 1 },
+            })).rejects.toThrow('Field "nonexistent" not found in model "user"');
+        }, { rollback: true });
+    });
+    test("handles special characters in update values", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Original" }),
+                    factory.user({ id: 2, name: "Original" }),
+                ],
+            });
+            await db.updateMany("user", {
+                set: { name: "O'Connor; DROP TABLE users;" },
+                where: { id: { [$in]: [1, 2] } },
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 1, name: "O'Connor; DROP TABLE users;" },
+                { id: 2, name: "O'Connor; DROP TABLE users;" },
+            ]);
+        }, { rollback: true });
+    });
+    test("handles large text values in updates", async () => {
+        await db.transact(async (db) => {
+            const longText = "a".repeat(10000);
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Original" }),
+                    factory.user({ id: 2, name: "Original" }),
+                ],
+            });
+            await db.updateMany("user", {
+                set: { name: longText },
+                where: { id: { [$in]: [1, 2] } },
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                { id: 1, name: longText },
+                { id: 2, name: longText },
+            ]);
+        }, { rollback: true });
+    });
+});

package/build/tests/orm.updateOne.test.d.ts

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