@casekit/orm2 0.0.0-20250322230249

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

@@ -0,0 +1,105 @@
+import { assertType, describe, expectTypeOf, test } from "vitest";
+import { models } from "@casekit/orm2-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/orm2-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.middleware.test.d.ts

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

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

@@ -0,0 +1,72 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi, } from "vitest";
+import { config } from "@casekit/orm2-fixtures";
+import { $in } from "../operators.js";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("orm.updateMany: middleware", () => {
+    const logger = mockLogger();
+    let db;
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        db = orm({ ...config, logger });
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    describe("updateMany middleware", () => {
+        test("it allows overriding the orm's updateMany method", async () => {
+            await db.transact(async (db) => {
+                // Create test users to update
+                await db.createMany("user", {
+                    values: [
+                        {
+                            id: 1,
+                            name: "Test User 1",
+                            email: "test1@example.com",
+                            role: "user",
+                        },
+                        {
+                            id: 2,
+                            name: "Test User 2",
+                            email: "test2@example.com",
+                            role: "user",
+                        },
+                    ],
+                    returning: ["id"],
+                });
+                const stub = vi.fn();
+                const dbWithMiddleware = db.middleware([
+                    {
+                        updateMany: (db, table, query) => {
+                            stub("called stub in middleware 1");
+                            return db.updateMany(table, query);
+                        },
+                    },
+                    {
+                        updateMany: (db, table, query) => {
+                            stub("called stub in middleware 2");
+                            return db.updateMany(table, query);
+                        },
+                    },
+                ]);
+                const result = await dbWithMiddleware.updateMany("user", {
+                    where: { id: { [$in]: [1, 2] } },
+                    set: { role: "admin" },
+                    returning: ["id", "name", "role"],
+                });
+                expect(result).toHaveLength(2);
+                expect(result).toEqual(expect.arrayContaining([
+                    expect.objectContaining({ id: 1, role: "admin" }),
+                    expect.objectContaining({ id: 2, role: "admin" }),
+                ]));
+                expect(stub.mock.calls).toEqual([
+                    ["called stub in middleware 1"],
+                    ["called stub in middleware 2"],
+                ]);
+            }, { rollback: true });
+        });
+    });
+});

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

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