@casekit/orm 0.0.1-alpha.6 → 0.0.1-alpha.8

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 },
+                    values: {
+                        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 },
+        );
+    });
+});

package/src/queries/find/types/FindBuilder.ts

@@ -12,12 +12,12 @@ export type FindBuilder = {
         path: string[];
     }[];
 
-    tables: {
-        name: string;
+    table: {
+        table: string;
         model: string;
         schema: string;
         alias: string;
-        joins?: Join[];
+        joins: Join[];
         conditions?: WhereClause<
             LooseModelDefinitions,
             ModelName<LooseModelDefinitions>
@@ -26,7 +26,7 @@ export type FindBuilder = {
             LooseModelDefinitions,
             ModelName<LooseModelDefinitions>
         >;
-    }[];
+    };
 
     lateralBy?: {
         groupTable: string;
@@ -49,6 +49,23 @@ export type FindBuilder = {
     offset?: number;
 };
 export type Join = {
-    from: { table: string; columns: string[] };
-    to: { table: string; columns: string[] };
+    from: {
+        schema: string;
+        table: string;
+        alias: string;
+        model: string;
+        columns: string[];
+    };
+    to: {
+        schema: string;
+        table: string;
+        alias: string;
+        model: string;
+        columns: string[];
+    };
+    where?: WhereClause<
+        LooseModelDefinitions,
+        ModelName<LooseModelDefinitions>
+    >;
+    type?: "inner" | "left";
 };

package/src/queries/findMany.ts

@@ -27,7 +27,10 @@ export const findMany = async (
         values: statement.values,
     });
 
-    if (!process.env.CI) console.log(statement.text);
+    if (process.env.ORM_VERBOSE_LOGGING) {
+        console.log(statement.text);
+        console.log(statement.values);
+    }
 
     const results = await conn
         .query(statement)
@@ -38,7 +41,6 @@ export const findMany = async (
         m,
         query,
     ).map(({ model, relation, query, path }) => {
-        console.log("Fetching 1:N relation");
         const pk = config.models[model].primaryKey;
         const fk = ensureArray(relation.foreignKey);
         const lateralBy = fk.map((c, index) => ({
@@ -55,11 +57,14 @@ export const findMany = async (
                 return hash(fk.map((c) => result[c]));
             });
             for (const result of results) {
-                const key = hash(
-                    pk.map((c) => get(result, [...dropRight(path, 1), c])),
-                );
-                console.log([...path]);
-                set(result, [...path], lookup[key] ?? []);
+                const parent =
+                    path.length === 1
+                        ? result
+                        : get(result, dropRight(path, 1));
+                if (parent !== undefined) {
+                    const key = hash(pk.map((c) => get(parent, c)));
+                    set(result, path, lookup[key] ?? []);
+                }
             }
         });
     });
@@ -69,7 +74,6 @@ export const findMany = async (
         m,
         query,
     ).map(({ model, relation, query, path }) => {
-        console.log("Fetching N:N relation");
         const joinFrom = Object.entries(config.relations[model]).find(
             ([, rel]) => rel.type === "1:N" && rel.model === relation.through,
         )?.[0];
@@ -102,15 +106,19 @@ export const findMany = async (
                 return hash(fk.map((c) => result[c]));
             });
             for (const result of results) {
-                const key = hash(
-                    pk.map((c) => get(result, [...dropRight(path, 1), c])),
-                );
-                console.log([...path]);
-                set(
-                    result,
-                    [...path],
-                    (lookup[key] ?? []).map((r) => r[joinTo] ?? []),
-                );
+                const parent =
+                    path.length === 1
+                        ? result
+                        : get(result, dropRight(path, 1));
+
+                if (parent !== undefined) {
+                    const key = hash(pk.map((c) => get(parent, c)));
+                    set(
+                        result,
+                        path,
+                        (lookup[key] ?? []).map((r) => r[joinTo] ?? []),
+                    );
+                }
             }
         });
     });

package/src/queries/update/buildUpdate.ts

@@ -9,7 +9,7 @@ import { BaseUpdateParams } from "./types/BaseUpdateParams";
 
 export type UpdateBuilder = {
     tableIndex: number;
-    table: { name: string; model: string; alias: string; schema: string };
+    table: { table: string; model: string; alias: string; schema: string };
     where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
     values: { name: string; value: unknown }[];
     returning: { name: string; path: string; alias: string }[];
@@ -24,7 +24,7 @@ export const buildUpdate = (
     const builder: UpdateBuilder = {
         tableIndex: _tableIndex,
         table: {
-            name: config.models[m].table,
+            table: config.models[m].table,
             schema: config.models[m].schema,
             model: m,
             alias: tableAlias(_tableIndex++),

package/src/queries/update/updateResultSchema.ts

@@ -14,7 +14,9 @@ export const updateResultSchema = (
 
     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/update/updateToSql.ts

@@ -14,7 +14,7 @@ export const updateToSql = (
 
     const frag = sql`UPDATE %I.%I AS %I\nSET`.withIdentifiers(
         table.schema,
-        table.name,
+        table.table,
         table.alias,
     );
 

package/src/queries/updateMany.ts

@@ -21,7 +21,10 @@ export const updateMany = async (
         values: statement.values,
     });
 
-    if (!process.env.CI) console.log(statement.text);
+    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/util/rowToObject.ts

@@ -5,5 +5,9 @@ export type ColumnMapping = { path: string | string[]; alias: string };
 export const rowToObject =
     (columns: ColumnMapping[]) =>
     (row: Record<string, unknown>): Record<string, unknown> => {
-        return columns.reduce((acc, c) => set(acc, c.path, row[c.alias]), {});
+        return columns.reduce(
+            (acc, c) =>
+                row[c.alias] !== null ? set(acc, c.path, row[c.alias]) : acc,
+            {},
+        );
     };

package/src/schema/types/base/BaseRelation.ts

@@ -10,6 +10,7 @@ export type BaseRelation =
           model: string;
           type: "N:1";
           foreignKey: string | string[];
+          optional?: boolean;
       }
     | {
           model: string;

package/src/schema/types/loose/LooseRelationDefinition.ts

@@ -1,6 +1,6 @@
 export type LooseRelationDefinition =
     | { model: string; type: "1:N"; foreignKey: string }
-    | { model: string; type: "N:1"; foreignKey: string }
+    | { model: string; type: "N:1"; foreignKey: string; optional?: true }
     | {
           model: string;
           type: "N:N";

package/src/schema/types/relations/OneToManyRelation.ts

@@ -7,5 +7,6 @@ export type OneToManyRelation<Models extends LooseModelDefinitions> = {
         model: M2;
         type: "1:N";
         foreignKey: ColumnName<Models, M2> | ColumnName<Models, M2>[];
+        optional?: boolean;
     };
 }[ModelName<Models>];

package/src/test/db/models/post.model.ts

@@ -15,6 +15,12 @@ export const post = {
             type: "uuid",
             references: { table: "user", column: "id" },
         },
+        reviewedById: {
+            name: "reviewed_by_id",
+            type: "uuid",
+            nullable: true,
+            references: { table: "user", column: "id" },
+        },
         publishedAt: { type: "timestamp", nullable: true },
         tags: { type: "text[][][][]", nullable: true },
         tenantId: {

package/src/test/db/models/post.relations.ts

@@ -7,6 +7,12 @@ export const post = {
         type: "N:1",
         foreignKey: "authorId",
     },
+    reviewedBy: {
+        model: "user",
+        type: "N:1",
+        foreignKey: "reviewedById",
+        optional: true,
+    },
     tenant: {
         model: "tenant",
         type: "N:1",

package/src/test/db/models/user.model.ts

@@ -7,6 +7,12 @@ export const user = {
     columns: {
         id: { type: "uuid", default: sql`uuid_generate_v4()` },
         username: { zodSchema: z.string(), type: "text" },
+        invitedById: {
+            name: "invited_by_id",
+            type: "uuid",
+            nullable: true,
+            references: { table: "user", column: "id" },
+        },
         joinedAt: {
             name: "created_at",
             zodSchema: z.date(),

package/src/test/db/models/user.relations.ts

@@ -7,6 +7,22 @@ export const user = {
         model: "post",
         foreignKey: "authorId",
     },
+    reviewedPosts: {
+        type: "1:N",
+        model: "post",
+        foreignKey: "reviewedById",
+    },
+    invitedBy: {
+        type: "N:1",
+        model: "user",
+        foreignKey: "invitedById",
+        optional: true,
+    },
+    invitedUsers: {
+        type: "1:N",
+        model: "user",
+        foreignKey: "invitedById",
+    },
     tenancies: {
         type: "1:N",
         model: "tenantUser",