@casekit/orm 0.0.1-alpha.12 → 0.0.1-alpha.13

package/src/queries/find/findToSql.ts

@@ -1,141 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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,
-                    },
-                },
-            }),
-        );
-    });
-});

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

@@ -1,176 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { db } from "../../../test/db";
-import { seed } from "../../../test/seed";
-
-describe("findMany", () => {
-    test("it can limit the number of rows returned", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [{ name: "WFMA", posts: 0 }],
-                        },
-                        {
-                            username: "Dan",
-                            tenants: [{ name: "WFMA", posts: 0 }],
-                        },
-                        {
-                            username: "Fairooz",
-                            tenants: [{ name: "WFMA", posts: 0 }],
-                        },
-                    ],
-                });
-                const results = await db.findMany("user", {
-                    select: ["id", "username"],
-                    orderBy: ["username"],
-                    limit: 2,
-                });
-
-                expect(results.map((r) => r.username)).toEqual([
-                    "Dan",
-                    "Fairooz",
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("offsets can be applied", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [{ name: "WFMA", posts: 0 }],
-                        },
-                        {
-                            username: "Dan",
-                            tenants: [{ name: "WFMA", posts: 0 }],
-                        },
-                        {
-                            username: "Fairooz",
-                            tenants: [{ name: "WFMA", posts: 0 }],
-                        },
-                    ],
-                });
-                const results = await db.findMany("user", {
-                    select: ["id", "username"],
-                    orderBy: ["username"],
-                    limit: 1,
-                    offset: 2,
-                });
-
-                expect(results.map((r) => r.username)).toEqual(["Russell"]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("1:N relations can have limits and offsets applied", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [{ name: "WFMA", posts: 3 }],
-                        },
-                        {
-                            username: "Dan",
-                            tenants: [{ name: "WFMA", posts: 5 }],
-                        },
-                        {
-                            username: "Fairooz",
-                            tenants: [{ name: "WFMA", posts: 2 }],
-                        },
-                    ],
-                });
-                const results = await db.findMany("user", {
-                    select: ["id", "username"],
-                    orderBy: ["username"],
-                    include: {
-                        posts: {
-                            select: ["title"],
-                            orderBy: ["title"],
-                            limit: 2,
-                            offset: 1,
-                        },
-                    },
-                });
-
-                expect(
-                    results.map((r) => [
-                        r.username,
-                        r.posts.map((p) => p.title),
-                    ]),
-                ).toEqual([
-                    ["Dan", ["Post e", "Post f"]],
-                    ["Fairooz", ["Post j"]],
-                    ["Russell", ["Post b", "Post c"]],
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("N:N relations can have limits and offsets applied", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Russell",
-                            tenants: [
-                                { name: "WFMA", posts: 0 },
-                                { name: "Popova Park", posts: 0 },
-                                { name: "LRF", posts: 0 },
-                            ],
-                        },
-                        {
-                            username: "Dan",
-                            tenants: [
-                                { name: "Popova Park", posts: 0 },
-                                { name: "LRF", posts: 0 },
-                            ],
-                        },
-                        {
-                            username: "Fairooz",
-                            tenants: [
-                                { name: "WFMA", posts: 0 },
-                                { name: "LRF", posts: 0 },
-                            ],
-                        },
-                    ],
-                });
-                const results = await db.findMany("user", {
-                    select: ["id", "username"],
-                    orderBy: ["username"],
-                    include: {
-                        tenants: {
-                            select: ["name"],
-                            orderBy: ["name"],
-                            limit: 2,
-                            offset: 1,
-                        },
-                    },
-                });
-
-                expect(
-                    results.map((r) => [
-                        r.username,
-                        r.tenants.map((p) => p.name),
-                    ]),
-                ).toEqual([
-                    ["Dan", ["Popova Park"]],
-                    ["Fairooz", ["WFMA"]],
-                    ["Russell", ["Popova Park", "WFMA"]],
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-});