@casekit/orm 0.0.1-alpha.14 → 0.0.1-alpha.16

package/src/queries/find/findToSql.test.ts

@@ -0,0 +1,123 @@
+import { unindent } from "@casekit/unindent";
+
+import * as uuid from "uuid";
+import { describe, expect, test } from "vitest";
+
+import { FindMany, db } from "../../test/db";
+import { $and, $ilike, $lte } from "../clauses/where/operators";
+import { buildFind } from "./buildFind";
+import { findToSql } from "./findToSql";
+
+describe("findToSql", () => {
+    test("it builds a valid query for simple selects", async () => {
+        const builder = buildFind(db.config, "post", {
+            select: ["id", "title"],
+        });
+        const statement = findToSql(db.config, builder);
+        expect(statement.text).toEqual(unindent`
+            SELECT
+                a.id AS a_0,
+                a.title AS a_1
+            FROM casekit.post a
+            WHERE 1 = 1
+        `);
+    });
+
+    test("it builds a valid query for included N:1 relations", async () => {
+        const builder = buildFind(db.config, "post", {
+            select: ["id", "title"],
+            include: {
+                author: { select: ["username"] },
+            },
+        } as FindMany<"post">);
+
+        const statement = findToSql(db.config, builder);
+        expect(statement.text).toEqual(unindent`
+            SELECT
+                a.id AS a_0,
+                a.title AS a_1,
+                b.username AS b_0,
+                b.id AS b_1
+            FROM casekit.post a
+            JOIN casekit."user" b
+                ON a.created_by_id = b.id
+            WHERE 1 = 1
+        `);
+    });
+
+    test("it builds a valid lateral query for 1:N relations", async () => {
+        const builder = buildFind(db.config, "post", {
+            select: ["id", "title"],
+            include: {
+                author: { select: ["username"] },
+            },
+            lateralBy: [{ column: "id", values: [uuid.v4()] }],
+        } as FindMany<"post">);
+
+        const statement = findToSql(db.config, builder);
+        expect(statement.text).toEqual(unindent`
+            SELECT d.* FROM (
+            SELECT UNNEST(ARRAY[$1]::uuid[]) AS id) c
+            JOIN LATERAL (
+            SELECT
+                a.id AS a_0,
+                a.title AS a_1,
+                b.username AS b_0,
+                b.id AS b_1
+            FROM casekit.post a
+            JOIN casekit."user" b
+                ON a.created_by_id = b.id
+            WHERE 1 = 1
+                AND a.id = c.id
+            ) d ON TRUE
+        `);
+    });
+
+    test("it allows specifying where clauses on both the top level table and N:1 relations", async () => {
+        const id1 = uuid.v4();
+        const id2 = uuid.v4();
+        const builder = buildFind(db.config, "post", {
+            select: ["id", "title"],
+            where: { title: { [$ilike]: "%cats%" } },
+            include: {
+                author: {
+                    select: ["username"],
+                    where: {
+                        [$and]: [
+                            { username: "Russell" },
+                            { joinedAt: { [$lte]: new Date(2024, 6, 4) } },
+                        ],
+                    },
+                },
+            },
+            lateralBy: [{ column: "id", values: [id1, id2] }],
+        } as FindMany<"post">);
+
+        const statement = findToSql(db.config, builder);
+        expect(statement.text).toEqual(unindent`
+            SELECT d.* FROM (
+            SELECT UNNEST(ARRAY[$1, $2]::uuid[]) AS id) c
+            JOIN LATERAL (
+            SELECT
+                a.id AS a_0,
+                a.title AS a_1,
+                b.username AS b_0,
+                b.id AS b_1
+            FROM casekit.post a
+            JOIN casekit."user" b
+                ON a.created_by_id = b.id
+                AND (((b.username = $3) AND (b.created_at <= $4)))
+            WHERE 1 = 1
+                AND (a.title ILIKE $5)
+                AND a.id = c.id
+            ) d ON TRUE
+        `);
+        expect(statement.values).toEqual([
+            id1,
+            id2,
+            "Russell",
+            new Date(2024, 6, 4),
+            "%cats%",
+        ]);
+    });
+});

package/src/queries/find/findToSql.ts

@@ -0,0 +1,141 @@
+import pgfmt from "pg-format";
+
+import { OrmError } from "../../errors";
+import { BaseConfiguration } from "../../schema/types/base/BaseConfiguration";
+import { SQLStatement, sql } from "../../sql";
+import { interleave } from "../../util/interleave";
+import { buildWhereClauses } from "../clauses/where/buildWhereClauses";
+import { hasConditions } from "../util/hasConditions";
+import { FindBuilder } from "./types/FindBuilder";
+
+export const findToSql = (
+    config: BaseConfiguration,
+    builder: FindBuilder,
+): SQLStatement => {
+    const frag = new SQLStatement();
+    const table = builder.table;
+
+    if (builder.lateralBy) {
+        const { columns, groupTable, itemTable } = builder.lateralBy;
+        frag.push(pgfmt(`SELECT %I.* FROM (\nSELECT `, itemTable));
+        columns.forEach((c, index) => {
+            frag.push(pgfmt(`UNNEST(ARRAY[`));
+
+            frag.push(
+                ...interleave(
+                    c.values.map((v) => sql`${v}`),
+                    sql`, `,
+                ),
+            );
+
+            frag.push(pgfmt(`]::%I[]) AS %I`, c.type, c.column));
+
+            if (index !== columns.length - 1) {
+                frag.push(pgfmt(", "));
+            }
+        });
+        frag.push(pgfmt(`) %I\nJOIN LATERAL (\n`, groupTable));
+    }
+
+    frag.push(
+        pgfmt(
+            `SELECT\n${builder.columns.map((c) => pgfmt(`    %I.%I AS %I`, c.table, c.name, c.alias)).join(",\n")}`,
+        ),
+    );
+
+    frag.push(pgfmt(`\nFROM %I.%I %I`, table.schema, table.table, table.alias));
+
+    for (const join of table.joins ?? []) {
+        if (join.from.columns.length !== join.to.columns.length) {
+            throw new OrmError(
+                "Number of foreign keys doesn't match number of primary keys in join",
+                { data: builder },
+            );
+        }
+
+        frag.push(join.type === "left" ? "\nLEFT JOIN" : "\nJOIN");
+        frag.push(
+            pgfmt(
+                " %I.%I %I\n    ON ",
+                join.to.schema,
+                join.to.table,
+                join.to.alias,
+            ),
+        );
+        frag.push(
+            join.from.columns
+                .map((from, i) =>
+                    pgfmt(
+                        "%I.%I = %I.%I",
+                        join.from.alias,
+                        from,
+                        join.to.alias,
+                        join.to.columns[i],
+                    ),
+                )
+                .join(" AND "),
+        );
+        if (hasConditions(join.where)) {
+            frag.push(
+                sql`\n    AND ${buildWhereClauses(config, join.to, join.where)}`,
+            );
+        }
+    }
+
+    frag.push(sql`\nWHERE 1 = 1`);
+
+    if (hasConditions(table.where)) {
+        frag.push(
+            sql`\n    AND ${buildWhereClauses(config, table, table.where)}`,
+        );
+    }
+
+    if (builder.lateralBy) {
+        const { groupTable, columns } = builder.lateralBy;
+        columns.forEach((c) => {
+            frag.push(
+                pgfmt(
+                    `\n    AND %I.%I = %I.%I`,
+                    table.alias,
+                    c.column,
+                    groupTable,
+                    c.column,
+                ),
+            );
+        });
+    }
+
+    if (builder.orderBy.length > 0) {
+        frag.push(pgfmt(`\nORDER BY `));
+        frag.push(
+            builder.orderBy
+                .map(({ table, column, direction }) =>
+                    pgfmt(
+                        `%I.%I ${direction === "asc" ? "ASC" : "DESC"}`,
+                        table,
+                        column,
+                    ),
+                )
+                .join(", "),
+        );
+    }
+
+    if (builder.limit !== undefined) {
+        frag.push(sql`\nLIMIT ${builder.limit}`);
+    }
+
+    if (builder.offset !== undefined) {
+        frag.push(sql`\nOFFSET ${builder.offset}`);
+    }
+
+    if (builder.for) {
+        frag.push(pgfmt(`\nFOR ${builder.for.toUpperCase()}`));
+    }
+
+    if (builder.lateralBy) {
+        const { itemTable } = builder.lateralBy;
+        frag.push(pgfmt(`\n) %I ON TRUE`, itemTable));
+    }
+
+    return frag;
+};

package/src/queries/find/getIncludedManyToManyRelations.ts

@@ -0,0 +1,49 @@
+import { BaseConfiguration } from "../../schema/types/base/BaseConfiguration";
+import { BaseFindParams } from "./types/BaseFindParams";
+
+export type ManyToManySubQuery = {
+    model: string;
+    name: string;
+    relation: {
+        model: string;
+        type: "N:N";
+        foreignKey: string | string[];
+        otherKey: string | string[];
+        through: string;
+    };
+    query: BaseFindParams;
+    path: string[];
+};
+
+export const getIncludedManyToManyRelations = (
+    config: BaseConfiguration,
+    m: string,
+    query: BaseFindParams,
+    path: string[] = [],
+) => {
+    const rels = config.relations[m];
+    const includedManyToManyRelations: ManyToManySubQuery[] = Object.entries(
+        query.include ?? {},
+    )
+        .filter(([r, _]) => rels[r].type === "N:N")
+        .map(([r, q]) => ({
+            model: m,
+            name: r,
+            relation: rels[r] as ManyToManySubQuery["relation"],
+            query: q!,
+            path: [...path, r],
+        }));
+
+    const joinedManyToManyRelations: ManyToManySubQuery[] = Object.entries(
+        query.include ?? {},
+    )
+        .filter(([r, _]) => rels[r].type === "N:1")
+        .flatMap(([r, q]) =>
+            getIncludedManyToManyRelations(config, rels[r].model, q!, [
+                ...path,
+                r,
+            ]),
+        );
+
+    return [...includedManyToManyRelations, ...joinedManyToManyRelations];
+};

package/src/queries/find/getIncludedOneToManyRelations.ts

@@ -0,0 +1,44 @@
+import { BaseConfiguration } from "../../schema/types/base/BaseConfiguration";
+import { BaseRelation } from "../../schema/types/base/BaseRelation";
+import { BaseFindParams } from "./types/BaseFindParams";
+
+export type OneToManySubQuery = {
+    model: string;
+    name: string;
+    relation: BaseRelation;
+    query: BaseFindParams;
+    path: string[];
+};
+
+export const getIncludedOneToManyRelations = (
+    config: BaseConfiguration,
+    m: string,
+    query: BaseFindParams,
+    path: string[] = [],
+) => {
+    const rels = config.relations[m];
+    const includedOneToManyRelations: OneToManySubQuery[] = Object.entries(
+        query.include ?? {},
+    )
+        .filter(([r, _]) => rels[r].type === "1:N")
+        .map(([r, q]) => ({
+            model: m,
+            name: r,
+            relation: rels[r],
+            query: q!,
+            path: [...path, r],
+        }));
+
+    const joinedOneToManyRelations: OneToManySubQuery[] = Object.entries(
+        query.include ?? {},
+    )
+        .filter(([r, _]) => rels[r].type === "N:1")
+        .flatMap(([r, q]) =>
+            getIncludedOneToManyRelations(config, rels[r].model, q!, [
+                ...path,
+                r,
+            ]),
+        );
+
+    return [...includedOneToManyRelations, ...joinedOneToManyRelations];
+};

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

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+
+describe("findMany", () => {
+    test("it can include N:1 -> 1:N relations", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "WFMA", posts: 1 },
+                                { name: "Popova Park", posts: 0 },
+                            ],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 2 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("post", {
+                    select: ["id", "title"],
+                    include: {
+                        author: {
+                            select: ["id", "username"],
+                            include: {
+                                posts: { select: ["id", "title"] },
+                            },
+                        },
+                    },
+                    limit: 2,
+                });
+
+                expect(
+                    results.map((p) => [
+                        p.author.username,
+                        p.author.posts.map((p) => p.title),
+                    ]),
+                ).toEqual([
+                    ["Russell", ["Post a"]],
+                    ["Dan", ["Post b", "Post c"]],
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("it can include N:1 -> N:N relations", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "WFMA", posts: 1 },
+                                { name: "Popova Park", posts: 0 },
+                            ],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 2 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("post", {
+                    select: ["id", "title"],
+                    include: {
+                        author: {
+                            select: ["id", "username"],
+                            include: {
+                                tenants: {
+                                    select: ["id", "name"],
+                                    orderBy: ["name"],
+                                },
+                            },
+                        },
+                    },
+                    limit: 2,
+                });
+
+                expect(
+                    results.map((p) => [
+                        p.author.username,
+                        p.author.tenants.map((t) => t.name),
+                    ]),
+                ).toEqual([
+                    ["Russell", ["Popova Park", "WFMA"]],
+                    ["Dan", ["WFMA"]],
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});

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

@@ -0,0 +1,75 @@
+import { assertType, describe, test } from "vitest";
+
+import { db } from "../../../test/db";
+
+describe("findMany", () => {
+    test("queries can have limits and offsets applied", () => {
+        assertType(
+            db.findMany("post", {
+                select: ["id", "content"],
+                limit: 2,
+                offset: 5,
+            }),
+        );
+    });
+
+    test("included N:1 relations cannot have limits applied", () => {
+        assertType(
+            db.findMany("post", {
+                select: ["id", "content"],
+                include: {
+                    author: {
+                        select: ["username"],
+                        // @ts-expect-error N:1 relations cannot have limits applied
+                        limit: 1,
+                    },
+                },
+            }),
+        );
+    });
+
+    test("included N:1 relations cannot have offsets applied", () => {
+        assertType(
+            db.findMany("post", {
+                select: ["id", "content"],
+                include: {
+                    author: {
+                        select: ["username"],
+                        // @ts-expect-error N:1 relations cannot have offsets applied
+                        offset: 1,
+                    },
+                },
+            }),
+        );
+    });
+
+    test("included 1:N relations can have limits and offsets applied", () => {
+        assertType(
+            db.findMany("user", {
+                select: ["id", "username"],
+                include: {
+                    posts: {
+                        select: ["title"],
+                        offset: 1,
+                        limit: 2,
+                    },
+                },
+            }),
+        );
+    });
+
+    test("included N:N relations can have offsets and limits applied", () => {
+        assertType(
+            db.findMany("user", {
+                select: ["id", "username"],
+                include: {
+                    tenants: {
+                        select: ["name"],
+                        offset: 1,
+                        limit: 2,
+                    },
+                },
+            }),
+        );
+    });
+});