@casekit/orm 0.0.1-alpha.2 → 0.0.1-alpha.21

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

package/src/queries/find/tests/middleware.find.where.test.ts

@@ -21,14 +21,14 @@ export const timestamps: Middleware = {
         },
     },
     update: {
-        values: (values, { model, config }) => {
+        set: (set, { model, config }) => {
             if ("updatedAt" in config.models[model].columns) {
                 return {
                     updatedAt: new Date(),
-                    ...values,
+                    ...set,
                 };
             } else {
-                return values;
+                return set;
             }
         },
     },
@@ -50,7 +50,7 @@ export const softdelete: Middleware = {
             if ("deletedAt" in config.models[model].columns) {
                 return updateOne({
                     ...params,
-                    values: {
+                    set: {
                         deletedAt: new Date(),
                     },
                 });
@@ -60,7 +60,7 @@ export const softdelete: Middleware = {
             if ("deletedAt" in config.models[model].columns) {
                 return updateMany({
                     ...params,
-                    values: {
+                    set: {
                         deletedAt: new Date(),
                     },
                 });
@@ -110,7 +110,7 @@ describe("middleware.find.where", () => {
                 ).toEqual([{ title: "Post a" }, { title: "Post b" }]);
 
                 await db.updateMany("post", {
-                    values: { deletedAt: new Date() },
+                    set: { deletedAt: new Date() },
                     where: { authorId: lynne.id },
                 });
 
@@ -158,7 +158,7 @@ describe("middleware.find.where", () => {
                 ).toEqual([{ title: "Post a" }, { title: "Post b" }]);
 
                 await db.updateOne("user", {
-                    values: { deletedAt: new Date() },
+                    set: { deletedAt: new Date() },
                     where: { id: lynne.id },
                 });
 
@@ -206,7 +206,7 @@ describe("middleware.find.where", () => {
                 ).toEqual([{ title: "Post a" }, { title: "Post b" }]);
 
                 await db.updateOne("post", {
-                    values: { deletedAt: new Date() },
+                    set: { deletedAt: new Date() },
                     where: { title: "Post a" },
                 });
 
@@ -260,7 +260,7 @@ describe("middleware.find.where", () => {
                 ]);
 
                 await db.updateOne("user", {
-                    values: { deletedAt: new Date() },
+                    set: { deletedAt: new Date() },
                     where: { username: "Lynne Tillman" },
                 });
 
@@ -311,7 +311,7 @@ describe("middleware.find.where", () => {
                 ).toEqual([{ title: "Post a" }, { title: "Post b" }]);
 
                 await db.updateMany("post", {
-                    values: { deletedAt: new Date() },
+                    set: { deletedAt: new Date() },
                     where: { authorId: lynne.id },
                 });
 
@@ -360,11 +360,11 @@ describe("middleware.find.where", () => {
                 ]);
 
                 await db.updateMany("post", {
-                    values: { title: "Post AAAAAA" },
+                    set: { title: "Post AAAAAA" },
                     where: { authorId: lynne.id, title: "Post a" },
                 });
                 await db.updateMany("post", {
-                    values: { deletedAt: new Date() },
+                    set: { deletedAt: new Date() },
                     where: { authorId: lynne.id, title: "Post b" },
                 });
 

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

@@ -5,7 +5,7 @@ import { WhereClause } from "../../clauses/WhereClause";
 
 export type BaseFindParams = {
     select: string[];
-    include?: Partial<Record<string, BaseFindParams>>;
+    include?: Partial<Record<string, Omit<BaseFindParams, "for">>>;
     where?: WhereClause<
         LooseModelDefinitions,
         ModelName<LooseModelDefinitions>
@@ -13,5 +13,6 @@ export type BaseFindParams = {
     limit?: number;
     offset?: number;
     lateralBy?: LateralByClause;
+    for?: "update" | "no key update" | "share" | "key share";
     orderBy?: (string | [string, "asc" | "desc"])[];
 };

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;
@@ -38,6 +38,8 @@ export type FindBuilder = {
         }[];
     };
 
+    for?: "update" | "no key update" | "share" | "key share";
+
     orderBy: {
         table: string;
         column: string;
@@ -49,6 +51,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,13 @@ 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"]
     >;
+    for?: "update" | "no key update" | "share" | "key share";
 };

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

@@ -1,6 +1,7 @@
 import { ModelName } from "../../../schema/types/helpers/ModelName";
 import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
 import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
+import { Simplify } from "../../../types/util/Simplify";
 import { FindManyParams } from "./FindManyParams";
 import { FindOneResult } from "./FindOneResult";
 
@@ -9,4 +10,4 @@ export type FindManyResult<
     Relations extends LooseRelationsDefinitions<Models>,
     M extends ModelName<Models>,
     Q extends FindManyParams<Models, Relations, M>,
-> = FindOneResult<Models, Relations, M, Q>[];
+> = Simplify<FindOneResult<Models, Relations, M, Q>[]>;

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

@@ -10,7 +10,8 @@ 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>;
+    for?: "update" | "no key update" | "share" | "key share";
 };

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

@@ -9,6 +9,9 @@ import { IncludedRelationQuery } from "../../clauses/include/IncludedRelationQue
 import { FindManyParams } from "./FindManyParams";
 import { FindOneParams } from "./FindOneParams";
 
+/**
+ * this is a mess and needs refactoring
+ */
 export type FindOneResult<
     Models extends LooseModelDefinitions,
     Relations extends LooseRelationsDefinitions<Models>,
@@ -32,19 +35,51 @@ export type FindOneResult<
                       Relations,
                       M,
                       Q
-                  >]: Relations[M][R] extends { type: "N:1" }
-                      ? FindOneResult<
-                            Models,
-                            Relations,
-                            IncludedRelationModel<Models, Relations, M, R>,
-                            IncludedRelationQuery<Models, Relations, M, R, Q>
-                        >
-                      : FindOneResult<
-                            Models,
-                            Relations,
-                            IncludedRelationModel<Models, Relations, M, R>,
-                            IncludedRelationQuery<Models, Relations, M, R, Q>
-                        >[];
+                      // for each optional N:1 relation
+                  >]: Relations[M][R] extends {
+                      type: "N:1";
+                      optional: true;
+                  }
+                      ? // if its foreign key is optional, the included relation
+                        // needs to be optional too
+                        // TODO this currently doesn't work for compound primary keys
+                        // need to figure out a way to make it work,
+                        // and also to refactor this mess to be more readable
+                        | FindOneResult<
+                                  Models,
+                                  Relations,
+                                  IncludedRelationModel<
+                                      Models,
+                                      Relations,
+                                      M,
+                                      R
+                                  >,
+                                  IncludedRelationQuery<
+                                      Models,
+                                      Relations,
+                                      M,
+                                      R,
+                                      Q
+                                  >
+                              >
+                            | undefined
+                      : Relations[M][R] extends {
+                              type: "N:1";
+                          }
+                        ? // otherwise the included relation is required
+                          FindOneResult<
+                              Models,
+                              Relations,
+                              IncludedRelationModel<Models, Relations, M, R>,
+                              IncludedRelationQuery<Models, Relations, M, R, Q>
+                          >
+                        : // for other types of relation, the included relation is an array
+                          FindOneResult<
+                              Models,
+                              Relations,
+                              IncludedRelationModel<Models, Relations, M, R>,
+                              IncludedRelationQuery<Models, Relations, M, R, Q>
+                          >[];
               })
     >
 >;

package/src/queries/findMany.ts

@@ -1,4 +1,12 @@
-import { groupBy } from "lodash-es";
+import {
+    dropRight,
+    get,
+    groupBy,
+    isEqual,
+    mergeWith,
+    set,
+    uniqWith,
+} from "lodash-es";
 import hash from "object-hash";
 import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
 
@@ -8,6 +16,8 @@ import { logger } from "../logger";
 import { ensureArray } from "../util/ensureArray";
 import { buildFind } from "./find/buildFind";
 import { findToSql } from "./find/findToSql";
+import { getIncludedManyToManyRelations } from "./find/getIncludedManyToManyRelations";
+import { getIncludedOneToManyRelations } from "./find/getIncludedOneToManyRelations";
 import { BaseFindParams } from "./find/types/BaseFindParams";
 import { rowToObject } from "./util/rowToObject";
 
@@ -25,89 +35,139 @@ export const findMany = 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 results = await conn
         .query(statement)
         .then((result) => result.rows.map(rowToObject(builder.columns)));
 
-    for (const [r, subquery] of Object.entries(query.include ?? {})) {
-        const relation = config.relations[m]![r];
-        if (relation.type === "1:N") {
-            const relation = config.relations[m][r];
-
-            const pk = config.models[m].primaryKey;
-            const fk = ensureArray(relation.foreignKey);
-
-            const lateralBy = fk.map((c, index) => ({
-                column: c,
-                values: results.map((result) => result[pk[index]]),
-            }));
-
-            const subqueryResults = await findMany(
-                conn,
-                config,
-                relation.model,
-                { ...subquery!, lateralBy },
-            );
-
+    const fetchIncludedOneToManyRelations = getIncludedOneToManyRelations(
+        config,
+        m,
+        query,
+    ).map(({ model, relation, query, path }) => {
+        const pk = config.models[model].primaryKey;
+        const fk = ensureArray(relation.foreignKey);
+
+        const lateralValues = mergeWith(
+            Object.fromEntries(fk.map((c) => [c, []])),
+            ...uniqWith(
+                results.map((result) => {
+                    return Object.fromEntries(
+                        fk.map((c, index) => [
+                            c,
+                            [get(result, [...dropRight(path, 1), pk[index]])],
+                        ]),
+                    );
+                }),
+                isEqual,
+            ),
+            (a: unknown[], b: unknown[]) => a.concat(b),
+        );
+
+        const lateralBy = fk.map((c) => ({
+            column: c,
+            values: lateralValues[c],
+        }));
+
+        return findMany(conn, config, relation.model, {
+            ...query,
+            for: builder.for,
+            lateralBy,
+        }).then((subqueryResults) => {
             const lookup = groupBy(subqueryResults, (result) => {
                 return hash(fk.map((c) => result[c]));
             });
-
             for (const result of results) {
-                const key = hash(pk.map((c) => result[c]));
-                result[r] = lookup[key] ?? [];
-            }
-        } else if (relation.type === "N:N") {
-            const joinFrom = Object.entries(config.relations[m]).find(
-                ([, rel]) =>
-                    rel.type === "1:N" && rel.model === relation.through,
-            )?.[0];
-
-            const joinTo = Object.entries(
-                config.relations[relation.through],
-            ).find(
-                ([, rel]) => rel.type === "N:1" && rel.model === relation.model,
-            )?.[0];
-
-            if (joinFrom === undefined || joinTo === undefined) {
-                throw new OrmError(
-                    "Both sides of a N:N relation must be defined",
-                    { data: { joinFrom, joinTo, query } },
-                );
+                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] ?? []);
+                }
             }
+        });
+    });
 
-            const pk = config.models[m].primaryKey;
-            const fk = ensureArray(relation.foreignKey);
-            const lateralBy = fk.map((c, index) => ({
-                column: c,
-                values: results.map((result) => result[pk[index]]),
-            }));
-
-            const subqueryResults = await findMany(
-                conn,
-                config,
-                relation.through,
-                {
-                    select: ensureArray(relation.foreignKey),
-                    include: { [joinTo]: subquery! },
-                    lateralBy,
-                },
-            );
+    const fetchIncludedManyToManyRelations = getIncludedManyToManyRelations(
+        config,
+        m,
+        query,
+    ).map(({ model, relation, query, path }) => {
+        const joinFrom = Object.entries(config.relations[model]).find(
+            ([, rel]) => rel.type === "1:N" && rel.model === relation.through,
+        )?.[0];
+
+        const joinTo = Object.entries(config.relations[relation.through]).find(
+            ([, rel]) => rel.type === "N:1" && rel.model === relation.model,
+        )?.[0];
+
+        if (joinFrom === undefined || joinTo === undefined) {
+            throw new OrmError("Both sides of a N:N relation must be defined", {
+                data: { joinFrom, joinTo, query },
+            });
+        }
+
+        const pk = config.models[model].primaryKey;
+        const fk = ensureArray(relation.foreignKey);
+
+        const lateralValues = mergeWith(
+            Object.fromEntries(fk.map((c) => [c, []])),
+            ...uniqWith(
+                results.map((result) => {
+                    return Object.fromEntries(
+                        fk.map((c, index) => [
+                            c,
+                            [get(result, [...dropRight(path, 1), pk[index]])],
+                        ]),
+                    );
+                }),
+                isEqual,
+            ),
+            (a: unknown[], b: unknown[]) => a.concat(b),
+        );
+
+        const lateralBy = fk.map((c) => ({
+            column: c,
+            values: lateralValues[c],
+        }));
+
+        return findMany(conn, config, relation.through, {
+            select: ensureArray(relation.foreignKey),
+            include: { [joinTo]: query },
+            for: builder.for,
+            lateralBy,
+        }).then((subqueryResults) => {
             const lookup = groupBy(subqueryResults, (result) => {
                 return hash(fk.map((c) => result[c]));
             });
-
             for (const result of results) {
-                const key = hash(pk.map((c) => result[c]));
-                result[r] = (lookup[key] ?? []).map(
-                    (relation) => relation[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] ?? []),
+                    );
+                }
             }
-        }
-    }
+        });
+    });
+
+    await Promise.all([
+        ...fetchIncludedOneToManyRelations,
+        ...fetchIncludedManyToManyRelations,
+    ]);
 
     return results;
 };

package/src/queries/middleware/Middleware.ts

@@ -15,7 +15,7 @@ export type Middleware = {
         values?: ValuesMiddleware;
     };
     update?: {
-        values?: ValuesMiddleware;
+        set?: ValuesMiddleware;
         where?: WhereMiddleware;
     };
     count?: {