@casekit/orm 0.0.1-alpha.7 → 0.0.1-alpha.9

package/src/queries/find/buildFind.ts

@@ -14,27 +14,29 @@ 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: [],
+        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 +66,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)}`,
             );
         }
     }

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/find/types/FindManyParams.ts

@@ -12,12 +12,12 @@ export type FindManyParams<
     Relations extends LooseRelationsDefinitions<Models>,
     M extends ModelName<Models>,
 > = {
-    select: SelectClause<Models, M>;
+    select: SelectClause<Models[M]>;
     include?: IncludeClause<Models, Relations, M>;
     where?: WhereClause<Models, M>;
     limit?: number;
     offset?: number;
     orderBy?: NonEmptyArray<
-        ColumnName<Models, M> | [ColumnName<Models, M>, "asc" | "desc"]
+        ColumnName<Models[M]> | [ColumnName<Models[M]>, "asc" | "desc"]
     >;
 };

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

@@ -10,7 +10,7 @@ export type FindOneParams<
     Relations extends LooseRelationsDefinitions<Models>,
     M extends ModelName<Models>,
 > = {
-    select: SelectClause<Models, M>;
+    select: SelectClause<Models[M]>;
     where?: WhereClause<Models, M>;
     include?: IncludeClause<Models, Relations, M>;
 };

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/types/UpdateManyResult.ts

@@ -9,7 +9,7 @@ export type UpdateManyResult<
     M extends ModelName<Models>,
     P extends UpdateParams<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/update/types/UpdateOneResult.ts

@@ -9,7 +9,7 @@ export type UpdateOneResult<
     M extends ModelName<Models>,
     P extends UpdateParams<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/update/types/UpdateParams.ts

@@ -10,5 +10,5 @@ export type UpdateParams<
 > = {
     values: UpdateValues<Models, M>;
     where: WhereClause<Models, M>;
-    returning?: ReturningClause<Models, M>;
+    returning?: ReturningClause<Models[M]>;
 };

package/src/queries/update/types/UpdateValues.ts

@@ -8,5 +8,5 @@ export type UpdateValues<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
 > = Simplify<{
-    [C in ColumnName<Models, M>]?: ColumnType<Models, M, C>;
+    [C in ColumnName<Models[M]>]?: ColumnType<Models, M, C>;
 }>;

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/helpers/ColumnName.ts

@@ -1,7 +1,6 @@
-import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
-import { ModelName } from "./ModelName";
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
 
-export type ColumnName<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = Extract<keyof Models[M]["columns"], string>;
+export type ColumnName<Model extends LooseModelDefinition> = Extract<
+    keyof Model["columns"],
+    string
+>;

package/src/schema/types/helpers/ColumnType.ts

@@ -8,7 +8,7 @@ import { ModelName } from "./ModelName";
 type NonNullableColumnType<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
-    C extends ColumnName<Models, M>,
+    C extends ColumnName<Models[M]>,
 > =
     Models[M]["columns"][C]["zodSchema"] extends z.ZodType<unknown>
         ? z.infer<Models[M]["columns"][C]["zodSchema"]>
@@ -17,7 +17,7 @@ type NonNullableColumnType<
 export type ColumnType<
     Models extends LooseModelDefinitions,
     M extends ModelName<Models>,
-    C extends ColumnName<Models, M>,
+    C extends ColumnName<Models[M]>,
 > = Models[M]["columns"][C]["nullable"] extends true
     ? NonNullableColumnType<Models, M, C> | null
     : NonNullableColumnType<Models, M, C>;

package/src/schema/types/helpers/Columns.ts

@@ -1,7 +1,3 @@
-import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
-import { ModelName } from "./ModelName";
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
 
-export type Columns<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = Models[M]["columns"];
+export type Columns<Model extends LooseModelDefinition> = Model["columns"];

package/src/schema/types/helpers/HasDefault.ts

@@ -1,13 +1,11 @@
-import { LooseModelDefinitions } from "../loose/LooseModelDefinitions";
+import { LooseModelDefinition } from "../loose/LooseModelDefinition";
 import { Columns } from "./Columns";
-import { ModelName } from "./ModelName";
 
 export type HasDefault<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-    C extends keyof Columns<Models, M>,
-> = null extends Columns<Models, M>[C]["default"]
+    Model extends LooseModelDefinition,
+    C extends keyof Columns<Model>,
+> = null extends Columns<Model>[C]["default"]
     ? false
-    : undefined extends Columns<Models, M>[C]["default"]
+    : undefined extends Columns<Model>[C]["default"]
       ? false
       : true;