@casekit/orm 0.0.1-alpha.1 → 0.0.1-alpha.11

package/src/queries/delete/deleteResultSchema.ts

@@ -14,7 +14,9 @@ export const deleteResultSchema = (
 
     params.returning?.forEach((s) => {
         const col = config.models[m].columns[s];
-        obj[s] = col.nullable ? col.zodSchema.nullable() : col.zodSchema;
+        obj[s] = col.nullable
+            ? col.zodSchema.nullish().transform((x) => x ?? null)
+            : col.zodSchema;
     });
 
     return z.object(obj);

package/src/queries/delete/deleteToSql.ts

@@ -16,7 +16,7 @@ export const deleteToSql = (
 
     const frag = sql`DELETE FROM %I.%I AS %I`.withIdentifiers(
         table.schema,
-        table.name,
+        table.table,
         table.alias,
     );
 

package/src/queries/delete/types/DeleteManyResult.ts

@@ -9,7 +9,7 @@ export type DeleteManyResult<
     M extends ModelName<Models>,
     P extends DeleteParams<Models, M>,
 > =
-    P["returning"] extends ReturningClause<Models, M>
+    P["returning"] extends ReturningClause<Models[M]>
         ? Readonly<{
               [C in P["returning"][number]]: ColumnType<Models, M, C>;
           }>[]

package/src/queries/delete/types/DeleteOneResult.ts

@@ -9,7 +9,7 @@ export type DeleteOneResult<
     M extends ModelName<Models>,
     P extends DeleteParams<Models, M>,
 > =
-    P["returning"] extends ReturningClause<Models, M>
+    P["returning"] extends ReturningClause<Models[M]>
         ? Readonly<{
               [C in P["returning"][number]]: ColumnType<Models, M, C>;
           }>

package/src/queries/delete/types/DeleteParams.ts

@@ -8,5 +8,5 @@ export type DeleteParams<
     M extends ModelName<Models>,
 > = {
     where: WhereClause<Models, M>;
-    returning?: ReturningClause<Models, M>;
+    returning?: ReturningClause<Models[M]>;
 };

package/src/queries/deleteMany.ts

@@ -21,8 +21,10 @@ export const deleteMany = async (
         values: statement.values,
     });
 
-    if (process.env.NODE_ENV === "test" && !process.env.CI)
+    if (process.env.ORM_VERBOSE_LOGGING) {
         console.log(statement.text);
+        console.log(statement.values);
+    }
 
     const result = await conn.query(statement);
     return params.returning

package/src/queries/find/buildFind.ts

@@ -14,27 +14,30 @@ export const buildFind = (
     _tableIndex = 0,
 ): FindBuilder => {
     const builder: FindBuilder = {
-        tableIndex: _tableIndex,
         columns: [],
-        tables: [],
+        table: {
+            table: config.models[m]["table"],
+            model: m,
+            schema: config.models[m]["schema"],
+            alias: tableAlias(_tableIndex++),
+            where: config.middleware.find?.where
+                ? config.middleware.find.where(query.where, {
+                      config,
+                      model: m,
+                  })
+                : query.where,
+            joins: [],
+        },
         orderBy: [],
+        for: query.for,
+        tableIndex: _tableIndex,
     };
 
     const model = config.models[m];
 
-    const alias = tableAlias(builder.tableIndex++);
+    const alias = builder.table.alias;
     let colIndex = 0;
 
-    builder.tables.push({
-        name: config.models[m]["table"],
-        model: m,
-        schema: config.models[m]["schema"],
-        alias: alias,
-        where: config.middleware.find?.where
-            ? config.middleware.find.where(query.where, { config, model: m })
-            : query.where,
-    });
-
     // make sure we always select the model's primary key,
     // and if necessary the foreign key for a lateral join
     // - we'll strip them out later
@@ -64,34 +67,38 @@ export const buildFind = (
                 [...path, r],
                 builder.tableIndex++,
             );
-            const [joinedTable, ...otherTables] = joinBuilder.tables;
-            builder.tables.push({
-                ...joinedTable,
-                joins: [
-                    ...(joinedTable.joins ?? []),
-                    {
-                        from: {
-                            table: alias,
-                            columns: ensureArray(relation.foreignKey).map(
-                                (c) => model.columns[c].name,
-                            ),
-                        },
-                        to: {
-                            table: joinedTable.alias,
-                            columns: joinedModel.primaryKey.map(
-                                (c) => joinedModel.columns[c].name,
-                            ),
-                        },
+            const joinedTable = joinBuilder.table;
+            builder.table.joins.push(
+                {
+                    from: {
+                        schema: config.models[m].schema,
+                        table: config.models[m].table,
+                        alias,
+                        model: m,
+                        columns: ensureArray(relation.foreignKey).map(
+                            (c) => model.columns[c].name,
+                        ),
                     },
-                ],
-            });
+                    to: {
+                        schema: joinedModel.schema,
+                        table: joinedTable.table,
+                        alias: joinedTable.alias,
+                        model: relation.model,
+                        columns: joinedModel.primaryKey.map(
+                            (c) => joinedModel.columns[c].name,
+                        ),
+                    },
+                    type: relation.optional ? "left" : "inner",
+                    where: joinedTable.where,
+                },
+                ...joinedTable.joins,
+            );
             // this is admittedly a bit weird,
             // we wouldn't expect N:1 relations to specify
             // ordering, skipping, and limiting, and typescript
             // prevents users from doing this, but
             // we rely on them being present as part of the N:N
             // implementation
-            builder.tables.push(...otherTables);
             builder.columns.push(...joinBuilder.columns);
             builder.orderBy.push(...joinBuilder.orderBy);
             builder.limit = min([builder.limit, joinBuilder.limit]);

package/src/queries/find/findResultSchema.ts

@@ -12,13 +12,20 @@ export const findResultSchema = (
 
     query.select.forEach((field) => {
         const col = config.models[m].columns[field];
-        obj[field] = col.nullable ? col.zodSchema.nullable() : col.zodSchema;
+        obj[field] = col.nullable
+            ? col.zodSchema.nullish().transform((x) => x ?? null)
+            : col.zodSchema;
     });
 
     for (const [field, subquery] of Object.entries(query.include || {})) {
         const relation = config.relations[m][field];
         const schema = findResultSchema(config, relation.model, subquery!);
-        obj[field] = relation.type === "N:1" ? schema : z.array(schema);
+        obj[field] =
+            relation.type === "N:1"
+                ? relation.optional
+                    ? schema.nullish().transform((x) => x ?? null)
+                    : schema
+                : z.array(schema);
     }
 
     return z.object(obj);

package/src/queries/find/findToSql.ts

@@ -13,7 +13,7 @@ export const findToSql = (
     builder: FindBuilder,
 ): SQLStatement => {
     const frag = new SQLStatement();
-    const [table, ...joinedTables] = builder.tables;
+    const table = builder.table;
 
     if (builder.lateralBy) {
         const { columns, groupTable, itemTable } = builder.lateralBy;
@@ -43,46 +43,41 @@ export const findToSql = (
         ),
     );
 
-    frag.push(pgfmt(`\nFROM %I.%I %I`, table.schema, table.name, table.alias));
+    frag.push(pgfmt(`\nFROM %I.%I %I`, table.schema, table.table, table.alias));
 
-    for (const joinedTable of joinedTables) {
-        if (!joinedTable.joins)
-            throw new OrmError("Joined table without join clauses", {
-                data: builder,
-            });
+    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(
-                "\nJOIN %I.%I %I\n    ON ",
-                joinedTable.schema,
-                joinedTable.name,
-                joinedTable.alias,
+                " %I.%I %I\n    ON ",
+                join.to.schema,
+                join.to.table,
+                join.to.alias,
             ),
         );
         frag.push(
-            joinedTable.joins
-                .flatMap((join) => {
-                    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 },
-                        );
-                    }
-
-                    return join.from.columns.map((from, i) =>
-                        pgfmt(
-                            "%I.%I = %I.%I",
-                            table.alias,
-                            from,
-                            joinedTable.alias,
-                            join.to.columns[i],
-                        ),
-                    );
-                })
+            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(joinedTable.where)) {
+        if (hasConditions(join.where)) {
             frag.push(
-                sql`\n    AND ${buildWhereClauses(config, joinedTable, joinedTable.where)}`,
+                sql`\n    AND ${buildWhereClauses(config, join.to, join.where)}`,
             );
         }
     }
@@ -133,6 +128,10 @@ export const findToSql = (
         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));

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.nullable-relations.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+
+describe("findMany", () => {
+    test("optional N:1 relations don't prevent records being returned", 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: {
+                        reviewedBy: {
+                            select: ["id", "username"],
+                            include: {
+                                posts: { select: ["id", "title"] },
+                                invitedBy: { select: ["id", "username"] },
+                            },
+                        },
+                    },
+                    orderBy: ["title"],
+                    limit: 2,
+                });
+
+                expect(results.map((p) => [p.title, p.reviewedBy])).toEqual([
+                    ["Post a", null],
+                    ["Post b", null],
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("optional N:1 relations are returned if they exist", async () => {
+        await db.transact(
+            async (db) => {
+                const { users } = 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 }],
+                        },
+                    ],
+                });
+                await db.updateOne("user", {
+                    where: { id: users["Dan"].id },
+                    set: {
+                        invitedById: users["Russell"].id,
+                    },
+                });
+                const results = await db.findMany("user", {
+                    select: ["username"],
+                    include: {
+                        invitedBy: {
+                            select: ["username"],
+                        },
+                        tenants: {
+                            select: ["name"],
+                            orderBy: ["name"],
+                        },
+                        reviewedPosts: {
+                            select: ["title"],
+                        },
+                        invitedUsers: {
+                            select: ["username"],
+                        },
+                    },
+                    orderBy: ["username"],
+                });
+                expect(results).toEqual([
+                    {
+                        username: "Dan",
+                        invitedBy: { username: "Russell" },
+                        tenants: [{ name: "WFMA" }],
+                        reviewedPosts: [],
+                        invitedUsers: [],
+                    },
+                    {
+                        username: "Fairooz",
+                        invitedBy: null,
+                        tenants: [{ name: "WFMA" }],
+                        reviewedPosts: [],
+                        invitedUsers: [],
+                    },
+                    {
+                        username: "Russell",
+                        invitedBy: null,
+                        tenants: [{ name: "Popova Park" }, { name: "WFMA" }],
+                        reviewedPosts: [],
+                        invitedUsers: [{ username: "Dan" }],
+                    },
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});