@casekit/orm 0.0.1-alpha.15 → 0.0.1-alpha.16

package/src/queries/findMany.ts

@@ -0,0 +1,134 @@
+import { dropRight, get, groupBy, set } from "lodash-es";
+import hash from "object-hash";
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../Connection";
+import { OrmError } from "../errors";
+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";
+
+export const findMany = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    query: BaseFindParams,
+) => {
+    const builder = buildFind(config, m, query);
+    const statement = findToSql(config, builder);
+    logger.info({
+        message: "Executing query",
+        sql: statement.text,
+        values: statement.values,
+    });
+
+    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)));
+
+    const fetchIncludedOneToManyRelations = getIncludedOneToManyRelations(
+        config,
+        m,
+        query,
+    ).map(({ model, relation, query, path }) => {
+        const pk = config.models[model].primaryKey;
+        const fk = ensureArray(relation.foreignKey);
+        const lateralBy = fk.map((c, index) => ({
+            column: c,
+            values: results.map((result) =>
+                get(result, [...dropRight(path, 1), pk[index]]),
+            ),
+        }));
+        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 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 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 lateralBy = fk.map((c, index) => ({
+            column: c,
+            values: results.map((result) =>
+                get(result, [...dropRight(path, 1), pk[index]]),
+            ),
+        }));
+
+        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 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/findOne.ts

@@ -0,0 +1,30 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../Connection";
+import { OrmError } from "../errors";
+import { BaseFindParams } from "./find/types/BaseFindParams";
+import { findMany } from "./findMany";
+
+export const findOne = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    query: BaseFindParams,
+) => {
+    const results = await findMany(conn, config, m, { ...query, limit: 2 });
+
+    if (results.length === 0) {
+        throw new OrmError("FindOne found zero records", {
+            model: [m, config.models[m]],
+            data: query,
+        });
+    }
+    if (results.length > 1) {
+        throw new OrmError("FindOne found too many records", {
+            model: [m, config.models[m]],
+            data: query,
+        });
+    }
+
+    return results[0];
+};

package/src/queries/middleware/Middleware.ts

@@ -0,0 +1,53 @@
+import { BaseConfiguration } from "../../schema/types/base/BaseConfiguration";
+import { BaseOrm } from "../../schema/types/base/BaseOrm";
+import { BaseDeleteParams } from "../delete/types/BaseDeleteParams";
+import { BaseUpdateParams } from "../update/types/BaseUpdateParams";
+import { ValuesMiddleware } from "./ValuesMiddleware";
+import { WhereMiddleware } from "./WhereMiddleware";
+
+export type Middleware = {
+    where?: WhereMiddleware;
+    values?: ValuesMiddleware;
+    find?: {
+        where?: WhereMiddleware;
+    };
+    create?: {
+        values?: ValuesMiddleware;
+    };
+    update?: {
+        set?: ValuesMiddleware;
+        where?: WhereMiddleware;
+    };
+    count?: {
+        where?: WhereMiddleware;
+    };
+    delete?: {
+        where?: WhereMiddleware;
+        deleteOne?: (
+            params: BaseDeleteParams,
+            meta: {
+                config: BaseConfiguration;
+                model: string;
+                deleteOne: (
+                    params: BaseDeleteParams,
+                ) => ReturnType<BaseOrm["deleteOne"]>;
+                updateOne: (
+                    params: BaseUpdateParams,
+                ) => ReturnType<BaseOrm["updateOne"]>;
+            },
+        ) => unknown;
+        deleteMany?: (
+            params: BaseDeleteParams,
+            meta: {
+                config: BaseConfiguration;
+                model: string;
+                deleteMany: (
+                    params: BaseDeleteParams,
+                ) => ReturnType<BaseOrm["deleteOne"]>;
+                updateMany: (
+                    params: BaseUpdateParams,
+                ) => ReturnType<BaseOrm["updateOne"]>;
+            },
+        ) => unknown;
+    };
+};

package/src/queries/middleware/ValuesMiddleware.ts

@@ -0,0 +1,9 @@
+import { BaseConfiguration } from "../../schema/types/base/BaseConfiguration";
+
+export type ValuesMiddleware = (
+    values: Record<string, unknown>,
+    meta: {
+        model: string;
+        config: BaseConfiguration;
+    },
+) => Record<string, unknown>;

package/src/queries/middleware/WhereMiddleware.ts

@@ -0,0 +1,16 @@
+import { BaseConfiguration } from "../../schema/types/base/BaseConfiguration";
+import { ModelName } from "../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { WhereClause } from "../clauses/WhereClause";
+
+export type WhereMiddleware = (
+    where:
+        | WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>
+        | undefined,
+    meta: {
+        model: string;
+        config: BaseConfiguration;
+    },
+) =>
+    | WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>
+    | undefined;

package/src/queries/update/buildUpdate.ts

@@ -0,0 +1,76 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { OrmError } from "../../errors";
+import { ModelName } from "../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { WhereClause } from "../clauses/WhereClause";
+import { tableAlias } from "../util/tableAlias";
+import { BaseUpdateParams } from "./types/BaseUpdateParams";
+
+export type UpdateBuilder = {
+    tableIndex: number;
+    table: { table: string; model: string; alias: string; schema: string };
+    where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
+    set: { name: string; value: unknown }[];
+    returning: { name: string; path: string; alias: string }[];
+};
+
+export const buildUpdate = (
+    config: BaseConfiguration,
+    m: string,
+    params: BaseUpdateParams,
+    _tableIndex = 0,
+): UpdateBuilder => {
+    const builder: UpdateBuilder = {
+        tableIndex: _tableIndex,
+        table: {
+            table: config.models[m].table,
+            schema: config.models[m].schema,
+            model: m,
+            alias: tableAlias(_tableIndex++),
+        },
+        where: config.middleware.update?.where
+            ? config.middleware.update.where(params.where, {
+                  config,
+                  model: m,
+              })!
+            : params.where!,
+        set: [],
+        returning: [],
+    };
+    let colIndex = 0;
+    const model = config.models[m];
+    const set = config.middleware.update?.set
+        ? config.middleware.update.set(params.set, {
+              config,
+              model: m,
+          })
+        : params.set;
+
+    if (set.length === 0) {
+        throw new OrmError("No updates provided for update operation", {
+            data: { m, model, params },
+        });
+    }
+
+    if (Object.keys(builder.where).length === 0) {
+        throw new OrmError("No where clause provided for update operation", {
+            data: { m, model, params },
+        });
+    }
+
+    for (const [k, v] of Object.entries(set)) {
+        builder.set.push({
+            name: model.columns[k]["name"],
+            value: v,
+        });
+    }
+    for (const f of params.returning ?? []) {
+        builder.returning.push({
+            name: model.columns[f]["name"],
+            path: f,
+            alias: `${builder.table.alias}_${colIndex++}`,
+        });
+    }
+    return builder;
+};

package/src/queries/update/tests/updateOne.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from "vitest";
+
+import { OrmError } from "../../../errors";
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+import { $like } from "../../clauses/where/operators";
+
+describe("updateOne", () => {
+    test("it updates a single record in the database", async () => {
+        await db.transact(
+            async (db) => {
+                const { users } = await seed(db, {
+                    users: [
+                        {
+                            username: "Stewart House",
+                            tenants: [{ name: "Popova Park", posts: 3 }],
+                        },
+                    ],
+                });
+
+                const user = users["Stewart House"];
+
+                const updated = await db.updateOne("user", {
+                    set: { username: "Stewart Home" },
+                    where: { username: "Stewart House" },
+                    returning: ["id", "username"],
+                });
+
+                expect(updated.id).toEqual(user.id);
+                expect(updated.username).toEqual("Stewart Home");
+
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    where: { username: { [$like]: "Stewart %" } },
+                });
+
+                expect(results).toEqual([updated]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("if no records are updated, it throws an error and rolls back to before the update", async () => {
+        await db.transact(
+            async (db) => {
+                const { users } = await seed(db, {
+                    users: [
+                        {
+                            username: "Stewart House",
+                            tenants: [{ name: "Popova Park", posts: 3 }],
+                        },
+                    ],
+                });
+
+                const user = users["Stewart House"];
+
+                await expect(
+                    db.updateOne("user", {
+                        set: { username: "Stewart Home" },
+                        where: { username: "Stewart Wrong" },
+                        returning: ["id", "username"],
+                    }),
+                ).rejects.toEqual(new OrmError("No rows updated"));
+
+                const result = await db.findOne("user", {
+                    select: ["id", "username"],
+                    where: { username: "Stewart House" },
+                });
+
+                expect(result).toEqual(user);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("if multiple records are updated, it throws an error and rolls back to before the update", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Stewart House",
+                            tenants: [{ name: "Popova Park", posts: 3 }],
+                        },
+                        {
+                            username: "Stewart Home",
+                            tenants: [{ name: "Popova Park", posts: 3 }],
+                        },
+                    ],
+                });
+
+                await expect(
+                    db.updateOne("user", {
+                        set: { joinedAt: new Date("2021-01-04") },
+                        where: { username: { [$like]: "Stewart %" } },
+                        returning: ["id", "username"],
+                    }),
+                ).rejects.toEqual(
+                    new OrmError(
+                        "More than one updated row for updateOne, rolling back",
+                    ),
+                );
+
+                const result = await db.findMany("user", {
+                    select: ["id", "username", "joinedAt"],
+                    where: { username: { [$like]: "Stewart %" } },
+                    orderBy: ["username"],
+                });
+
+                expect(result.map((u) => u.joinedAt)).not.toEqual([
+                    new Date("2021-01-04"),
+                    new Date("2021-01-04"),
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});

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

@@ -0,0 +1,10 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
+import { WhereClause } from "../../clauses/WhereClause";
+
+export type BaseUpdateParams = {
+    set: Record<string, unknown | null>;
+    where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
+    returning?: NonEmptyArray<string>;
+};

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

@@ -0,0 +1,16 @@
+import { ColumnType } from "../../../schema/types/helpers/ColumnType";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { ReturningClause } from "../../clauses/ReturningClause";
+import { UpdateParams } from "./UpdateParams";
+
+export type UpdateManyResult<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    P extends UpdateParams<Models, M>,
+> =
+    P["returning"] extends ReturningClause<Models[M]>
+        ? Readonly<{
+              [C in P["returning"][number]]: ColumnType<Models, M, C>;
+          }>[]
+        : number;

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

@@ -0,0 +1,16 @@
+import { ColumnType } from "../../../schema/types/helpers/ColumnType";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { ReturningClause } from "../../clauses/ReturningClause";
+import { UpdateParams } from "./UpdateParams";
+
+export type UpdateOneResult<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    P extends UpdateParams<Models, M>,
+> =
+    P["returning"] extends ReturningClause<Models[M]>
+        ? Readonly<{
+              [C in P["returning"][number]]: ColumnType<Models, M, C>;
+          }>
+        : number;

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

@@ -0,0 +1,14 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { ReturningClause } from "../../clauses/ReturningClause";
+import { WhereClause } from "../../clauses/WhereClause";
+import { UpdateValues } from "./UpdateValues";
+
+export type UpdateParams<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = {
+    set: UpdateValues<Models, M>;
+    where: WhereClause<Models, M>;
+    returning?: ReturningClause<Models[M]>;
+};

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

@@ -0,0 +1,12 @@
+import { ColumnName } from "../../../schema/types/helpers/ColumnName";
+import { ColumnType } from "../../../schema/types/helpers/ColumnType";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { Simplify } from "../../../types/util/Simplify";
+
+export type UpdateValues<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = Simplify<{
+    [C in ColumnName<Models[M]>]?: ColumnType<Models, M, C>;
+}>;

package/src/queries/update/updateResultSchema.ts

@@ -0,0 +1,23 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+import { ZodSchema, z } from "zod";
+
+import { BaseUpdateParams } from "./types/BaseUpdateParams";
+
+export const updateResultSchema = (
+    config: BaseConfiguration,
+    m: string,
+    params: BaseUpdateParams,
+) => {
+    if (!params.returning) return z.number();
+
+    const obj: Record<string, ZodSchema<unknown>> = {};
+
+    params.returning?.forEach((s) => {
+        const col = config.models[m].columns[s];
+        obj[s] = col.nullable
+            ? col.zodSchema.nullish().transform((x) => x ?? null)
+            : col.zodSchema;
+    });
+
+    return z.object(obj);
+};

package/src/queries/update/updateToSql.ts

@@ -0,0 +1,43 @@
+import pgfmt from "pg-format";
+
+import { BaseConfiguration } from "../../schema/types/base/BaseConfiguration";
+import { SQLStatement, sql } from "../../sql";
+import { buildWhereClauses } from "../clauses/where/buildWhereClauses";
+import { UpdateBuilder } from "./buildUpdate";
+
+export const updateToSql = (
+    config: BaseConfiguration,
+    m: string,
+    builder: UpdateBuilder,
+): SQLStatement => {
+    const { table, where, set, returning } = builder;
+
+    const frag = sql`UPDATE %I.%I AS %I\nSET`.withIdentifiers(
+        table.schema,
+        table.table,
+        table.alias,
+    );
+
+    const fields = set.map((field) => {
+        return sql`\n    %I = ${field.value}`.withIdentifiers(field.name);
+    });
+
+    frag.push(sql.splat(fields, ",\n"));
+
+    frag.push("\nWHERE\n    ");
+    frag.push(buildWhereClauses(config, table, where));
+
+    if (returning.length > 0) {
+        frag.push("\nRETURNING\n");
+        frag.push(
+            returning
+                .map((r) =>
+                    pgfmt(`    %I.%I as %I`, table.alias, r.name, r.alias),
+                )
+                .join(",\n"),
+        );
+    }
+    frag.push(";\n");
+
+    return frag;
+};

package/src/queries/updateMany.ts

@@ -0,0 +1,33 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../Connection";
+import { logger } from "../logger";
+import { buildUpdate } from "./update/buildUpdate";
+import { BaseUpdateParams } from "./update/types/BaseUpdateParams";
+import { updateToSql } from "./update/updateToSql";
+import { rowToObject } from "./util/rowToObject";
+
+export const updateMany = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    params: BaseUpdateParams,
+) => {
+    const builder = buildUpdate(config, m, params);
+    const statement = updateToSql(config, m, builder);
+    logger.info({
+        message: "Executing update",
+        sql: statement.text,
+        values: statement.values,
+    });
+
+    if (process.env.ORM_VERBOSE_LOGGING) {
+        console.log(statement.text);
+        console.log(statement.values);
+    }
+
+    const result = await conn.query(statement);
+    return params.returning
+        ? result.rows.map(rowToObject(builder.returning))
+        : result.rowCount ?? 0;
+};

package/src/queries/updateOne.ts

@@ -0,0 +1,33 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../Connection";
+import { OrmError } from "../errors";
+import { BaseUpdateParams } from "./update/types/BaseUpdateParams";
+import { updateMany } from "./updateMany";
+
+export const updateOne = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    params: BaseUpdateParams,
+) => {
+    return await conn.transact(async (conn) => {
+        const results = await updateMany(conn, config, m, params);
+
+        const updatedCount =
+            typeof results === "number" ? results : results?.length ?? 0;
+
+        if (updatedCount === 0) {
+            throw new OrmError("No rows updated", { data: { m, params } });
+        }
+
+        if (updatedCount > 1) {
+            throw new OrmError(
+                "More than one updated row for updateOne, rolling back",
+                { data: { m, params, updatedCount } },
+            );
+        }
+
+        return typeof results === "number" ? results : results[0];
+    });
+};