@casekit/orm 0.0.1-alpha.0

package/src/queries/findMany.ts

@@ -0,0 +1,113 @@
+import { groupBy } 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 { 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.NODE_ENV === "test" && !process.env.CI)
+        console.log(statement.text);
+
+    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 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 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 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] ?? [],
+                );
+            }
+        }
+    }
+
+    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?: {
+        values?: 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: { name: string; model: string; alias: string; schema: string };
+    where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
+    values: { 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: {
+            name: 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!,
+        values: [],
+        returning: [],
+    };
+    let colIndex = 0;
+    const model = config.models[m];
+    const values = config.middleware.update?.values
+        ? config.middleware.update.values(params.values, {
+              config,
+              model: m,
+          })
+        : params.values;
+
+    if (values.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(values)) {
+        builder.values.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", {
+                    values: { 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", {
+                        values: { 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", {
+                        values: { 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 = {
+    values: 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>,
+> = {
+    values: 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,21 @@
+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.nullable() : 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, values: update, returning } = builder;
+
+    const frag = sql`UPDATE %I.%I AS %I\nSET`.withIdentifiers(
+        table.schema,
+        table.name,
+        table.alias,
+    );
+
+    const fields = update.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,31 @@
+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.NODE_ENV === "test" && !process.env.CI)
+        console.log(statement.text);
+
+    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];
+    });
+};

package/src/queries/util/hasConditions.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "vitest";
+
+import { hasConditions } from "./hasConditions";
+
+describe("hasConditions", () => {
+    test("should return true for non-empty clause", () => {
+        const clause = { field: "name", operator: "equals", value: "John" };
+        expect(hasConditions(clause)).toBe(true);
+    });
+
+    test("should return false for null clause", () => {
+        const clause = null;
+        expect(hasConditions(clause)).toBe(false);
+    });
+
+    test("should return false for undefined clause", () => {
+        const clause = undefined;
+        expect(hasConditions(clause)).toBe(false);
+    });
+
+    test("should return false for empty object clause", () => {
+        const clause = {};
+        expect(hasConditions(clause)).toBe(false);
+    });
+
+    test("should return true for an object clause that contains only symbol keys", () => {
+        const sym = Symbol("test");
+        const clause = { [sym]: 2 };
+        expect(hasConditions(clause)).toBe(true);
+    });
+
+    test("should return false for empty array clause", () => {
+        const clause: string[] = [];
+        expect(hasConditions(clause)).toBe(false);
+    });
+});