@casekit/orm 0.0.1-alpha.12 → 0.0.1-alpha.13

package/src/queries/findMany.ts

@@ -1,134 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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];
-    });
-};