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

package/src/queries/find/tests/findMany.select.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { db } from "../../../test/db";
-import { seed } from "../../../test/seed";
-
-describe("findMany", () => {
-    test("it can select fields from the model", async () => {
-        await db.transact(
-            async (db) => {
-                const { posts } = await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [{ name: "WFMA", posts: 1 }],
-                        },
-                    ],
-                });
-                const results = await db.findMany("post", {
-                    select: ["id", "title"],
-                });
-
-                expect(results.find((r) => r.id === posts[0].id)).toEqual({
-                    id: posts[0].id,
-                    title: posts[0].title,
-                });
-            },
-            { rollback: true },
-        );
-    });
-
-    test("it can select fields from N:1 relations", async () => {
-        await db.transact(
-            async (db) => {
-                const { posts, users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [{ name: "WFMA", posts: 1 }],
-                        },
-                    ],
-                });
-                const results = await db.findMany("post", {
-                    select: ["id", "title"],
-                    include: { author: { select: ["id", "username"] } },
-                });
-
-                expect(results.find((r) => r.id === posts[0].id)).toEqual({
-                    id: posts[0].id,
-                    title: posts[0].title,
-                    author: {
-                        id: users["Russell"].id,
-                        username: users["Russell"].username,
-                    },
-                });
-            },
-            { rollback: true },
-        );
-    });
-
-    test("it can select fields from 1:N relations", async () => {
-        await db.transact(
-            async (db) => {
-                const { posts, users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [
-                                { name: "WFMA", posts: 1 },
-                                { name: "Popova Park", posts: 1 },
-                            ],
-                        },
-                    ],
-                });
-                const user = users["Russell"];
-
-                const results = await db.findMany("user", {
-                    select: ["id", "username"],
-                    include: {
-                        posts: {
-                            select: ["id", "title", "content"],
-                            orderBy: ["title"],
-                        },
-                    },
-                });
-
-                expect(results.find((r) => r.id === user.id)).toEqual({
-                    id: user.id,
-                    username: user.username,
-                    posts: [
-                        {
-                            id: posts[0].id,
-                            title: posts[0].title,
-                            content: posts[0].content,
-                        },
-                        {
-                            id: posts[1].id,
-                            title: posts[1].title,
-                            content: posts[1].content,
-                        },
-                    ],
-                });
-            },
-            { rollback: true },
-        );
-    });
-
-    test("it can select fields from N:N relations", async () => {
-        await db.transact(
-            async (db) => {
-                const { tenants, users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [
-                                { name: "Popova Park", posts: 0 },
-                                { name: "WFMA", posts: 0 },
-                            ],
-                        },
-                    ],
-                });
-                const user = users["Russell"];
-                const result = await db.findMany("user", {
-                    select: ["id", "username"],
-                    include: {
-                        tenants: { select: ["id", "name"], orderBy: ["name"] },
-                    },
-                });
-
-                expect(result).toEqual([
-                    {
-                        id: user.id,
-                        username: user.username,
-                        tenants: [
-                            {
-                                id: tenants["Popova Park"].id,
-                                name: tenants["Popova Park"].name,
-                            },
-                            {
-                                id: tenants["WFMA"].id,
-                                name: tenants["WFMA"].name,
-                            },
-                        ],
-                    },
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("primary keys are not returned unless specified in the select clause", async () => {
-        await db.transact(
-            async (db) => {
-                const { tenants, users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [
-                                { name: "Popova Park", posts: 0 },
-                                { name: "WFMA", posts: 0 },
-                            ],
-                        },
-                    ],
-                });
-                const user = users["Russell"];
-                const wfma = tenants["WFMA"];
-                const popovapark = tenants["Popova Park"];
-
-                const result = await db.findMany("user", {
-                    select: ["username"],
-                    include: {
-                        tenants: { select: ["name"], orderBy: ["name"] },
-                    },
-                });
-
-                expect(result).toEqual([
-                    {
-                        username: user.username,
-                        tenants: [
-                            { name: popovapark.name },
-                            { name: wfma.name },
-                        ],
-                    },
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-});

package/src/queries/find/tests/findMany.too-deep.test-d.ts

@@ -1,154 +0,0 @@
-import { assertType, describe, test } from "vitest";
-
-import { db } from "../../../test/db";
-import { $and, $gt, $ilike, $not, $or } from "../../clauses/where/operators";
-
-describe("findMany", () => {
-    test("up to a point, deeply nested clauses don't cause type errors", async () => {
-        assertType(
-            await db.findMany("user", {
-                select: ["username"],
-                include: {
-                    tenants: {
-                        select: ["name"],
-                        orderBy: ["name"],
-                        include: {
-                            tenancies: {
-                                select: ["id"],
-                                where: { createdAt: { [$gt]: new Date() } },
-                            },
-                            users: {
-                                select: ["username", "id"],
-                                where: {
-                                    id: "abc",
-                                    deletedAt: { [$gt]: new Date() },
-                                },
-                                include: {
-                                    tenants: {
-                                        select: ["name"],
-                                        where: {
-                                            [$or]: [
-                                                { name: "a" },
-                                                { name: "b" },
-                                                {
-                                                    [$and]: [
-                                                        {
-                                                            [$or]: [
-                                                                { name: "c" },
-                                                                { name: "d" },
-                                                            ],
-                                                        },
-                                                        {
-                                                            [$or]: [
-                                                                { name: "e" },
-                                                                { name: "f" },
-                                                            ],
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                        include: {
-                                            tenancies: {
-                                                select: ["id"],
-                                                where: {
-                                                    [$or]: [
-                                                        {
-                                                            createdAt: {
-                                                                [$gt]: new Date(),
-                                                            },
-                                                        },
-                                                        {
-                                                            [$and]: [
-                                                                {
-                                                                    createdAt: {
-                                                                        [$not]: null,
-                                                                    },
-                                                                },
-                                                            ],
-                                                        },
-                                                    ],
-                                                },
-                                                include: {
-                                                    tenant: {
-                                                        select: ["id"],
-                                                        where: {
-                                                            name: "abc",
-                                                        },
-                                                        include: {
-                                                            users: {
-                                                                select: [
-                                                                    "username",
-                                                                ],
-                                                                where: {
-                                                                    username: {
-                                                                        [$ilike]:
-                                                                            "Russell",
-                                                                    },
-                                                                },
-                                                            },
-                                                            posts: {
-                                                                select: [
-                                                                    "id",
-                                                                    "title",
-                                                                ],
-                                                                where: {
-                                                                    publishedAt:
-                                                                        {
-                                                                            [$not]: null,
-                                                                        },
-                                                                },
-                                                                include: {
-                                                                    author: {
-                                                                        select: [
-                                                                            "id",
-                                                                            "username",
-                                                                        ],
-                                                                        include:
-                                                                            {
-                                                                                posts: {
-                                                                                    select: [
-                                                                                        "id",
-                                                                                        "title",
-                                                                                    ],
-                                                                                    where: {
-                                                                                        publishedAt:
-                                                                                            {
-                                                                                                [$not]: null,
-                                                                                            },
-                                                                                    },
-                                                                                    include:
-                                                                                        {
-                                                                                            author: {
-                                                                                                select: [
-                                                                                                    "id",
-                                                                                                    "username",
-                                                                                                ],
-                                                                                            },
-                                                                                        },
-                                                                                },
-                                                                            },
-                                                                        where: {
-                                                                            username:
-                                                                                "Russell",
-                                                                        },
-                                                                    },
-                                                                },
-                                                            },
-                                                        },
-                                                    },
-                                                },
-                                            },
-                                        },
-                                        orderBy: ["name"],
-                                    },
-                                },
-                                orderBy: ["joinedAt"],
-                            },
-                        },
-                    },
-                },
-            }),
-        );
-    });
-});

package/src/queries/find/tests/findMany.where.test-d.ts

@@ -1,85 +0,0 @@
-import { assertType, describe, test } from "vitest";
-
-import { db } from "../../../test/db";
-import { $gte, $ilike, $like, $not, $or } from "../../clauses/where/operators";
-
-describe("findMany", () => {
-    test("where clauses can only refer to fields that exist on the model", async () => {
-        assertType(
-            await db.findMany("post", {
-                select: ["id", "title", "content"],
-                where: {
-                    title: "I like cats",
-                    // @ts-expect-error 'wrong' is not a field on the post model
-                    wrong: 2,
-                },
-            }),
-        );
-    });
-
-    test("where clauses allow conditions to be grouped using logical operators", async () => {
-        assertType(
-            await db.findMany("post", {
-                select: ["id", "title", "content"],
-                where: {
-                    title: { [$like]: "I like %" },
-                    [$or]: [
-                        { title: { [$ilike]: "%dogs" } },
-                        { title: { [$ilike]: "%cats" } },
-                    ],
-                },
-            }),
-        );
-    });
-
-    test("where clauses can be applied to N:1 relations", async () => {
-        assertType(
-            await db.findMany("post", {
-                select: ["id", "title", "content"],
-                include: {
-                    author: {
-                        select: ["id", "username"],
-                        where: {
-                            username: "Russell",
-                            joinedAt: { [$gte]: new Date("2021-01-01") },
-                        },
-                    },
-                },
-            }),
-        );
-    });
-
-    test("where clauses can be applied to 1:N relations", async () => {
-        assertType(
-            await db.findMany("user", {
-                select: ["id", "username"],
-                include: {
-                    posts: {
-                        select: ["id", "title"],
-                        where: {
-                            publishedAt: { [$gte]: new Date("2021-01-01") },
-                        },
-                    },
-                },
-            }),
-        );
-    });
-
-    test("where clauses can be applied to N:N relations", async () => {
-        assertType(
-            await db.findMany("user", {
-                select: ["id", "username"],
-                include: {
-                    tenants: {
-                        select: ["id", "name"],
-                        where: {
-                            [$not]: {
-                                name: { [$like]: "% (Archived)" },
-                            },
-                        },
-                    },
-                },
-            }),
-        );
-    });
-});

package/src/queries/find/tests/findMany.where.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { db } from "../../../test/db";
-import { seed } from "../../../test/seed";
-import { $in } from "../../clauses/where/operators";
-
-describe("findMany", () => {
-    test("it can apply where clauses to queries", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [{ name: "Popova Park", posts: 6 }],
-                        },
-                    ],
-                });
-                const result = await db.findMany("post", {
-                    select: ["title"],
-                    where: { title: { [$in]: ["Post a", "Post c"] } },
-                    orderBy: ["title"],
-                });
-                expect(result).toEqual([
-                    { title: "Post a" },
-                    { title: "Post c" },
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("clauses applied to N:1 models apply to the whole query", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [{ name: "Popova Park", posts: 2 }],
-                        },
-                    ],
-                });
-                expect(
-                    await db.findMany("post", {
-                        select: ["title"],
-                        include: {
-                            author: {
-                                select: ["username"],
-                                where: { username: "Fairooz" },
-                            },
-                        },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([]);
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title"],
-                        include: {
-                            author: {
-                                select: ["username"],
-                                where: { username: "Russell" },
-                            },
-                        },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([
-                    { title: "Post a", author: { username: "Russell" } },
-                    { title: "Post b", author: { username: "Russell" } },
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-});