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

package/src/queries/createMany.ts

@@ -0,0 +1,38 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../Connection";
+import { logger } from "../logger";
+import { buildCreate } from "./create/buildCreate";
+import { createToSql } from "./create/createToSql";
+import { BaseCreateManyParams } from "./create/types/BaseCreateManyParams";
+import { rowToObject } from "./util/rowToObject";
+
+export const createMany = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    params: BaseCreateManyParams,
+) => {
+    if (params.values.length === 0) {
+        return params.returning ? [] : 0;
+    }
+
+    const builder = buildCreate(config, m, params);
+    const statement = createToSql(builder);
+
+    logger.info({
+        message: "Executing create",
+        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;
+};

package/src/queries/createOne.ts

@@ -0,0 +1,27 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { OrmError } from "..";
+import { Connection } from "../Connection";
+import { BaseCreateOneParams } from "./create/types/BaseCreateOneParams";
+import { createMany } from "./createMany";
+
+export const createOne = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    params: BaseCreateOneParams,
+) => {
+    if (params.onConflict?.do === "nothing" && params.returning) {
+        throw new OrmError(
+            "Cannot use 'returning' with 'onConflict' in createOne",
+            {
+                data: { m, params },
+            },
+        );
+    }
+    const result = await createMany(conn, config, m, {
+        ...params,
+        values: [params.values],
+    });
+    return Array.isArray(result) ? result[0] : result;
+};

package/src/queries/delete/buildDelete.ts

@@ -0,0 +1,56 @@
+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 { BaseDeleteParams } from "./types/BaseDeleteParams";
+
+export type DeleteBuilder = {
+    tableIndex: number;
+    table: { table: string; model: string; alias: string; schema: string };
+    where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
+    returning: { name: string; path: string; alias: string }[];
+};
+
+export const buildDelete = (
+    config: BaseConfiguration,
+    m: string,
+    params: BaseDeleteParams,
+    _tableIndex = 0,
+): DeleteBuilder => {
+    const builder: DeleteBuilder = {
+        tableIndex: _tableIndex,
+        table: {
+            table: config.models[m].table,
+            schema: config.models[m].schema,
+            model: m,
+            alias: tableAlias(_tableIndex++),
+        },
+        where: config.middleware.delete?.where
+            ? config.middleware.delete.where(params.where, {
+                  config,
+                  model: m,
+              })!
+            : params.where,
+        returning: [],
+    };
+    let colIndex = 0;
+    const model = config.models[m];
+
+    if (Object.keys(builder.where).length === 0) {
+        throw new OrmError("No where clause provided for delete operation", {
+            data: { m, model, params },
+        });
+    }
+
+    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/delete/deleteResultSchema.ts

@@ -0,0 +1,23 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+import { ZodSchema, z } from "zod";
+
+import { BaseDeleteParams } from "./types/BaseDeleteParams";
+
+export const deleteResultSchema = (
+    config: BaseConfiguration,
+    m: string,
+    params: BaseDeleteParams,
+) => {
+    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/delete/deleteToSql.ts

@@ -0,0 +1,48 @@
+import pgfmt from "pg-format";
+
+import { OrmError } from "../../errors";
+import { BaseConfiguration } from "../../schema/types/base/BaseConfiguration";
+import { SQLStatement, sql } from "../../sql";
+import { buildWhereClauses } from "../clauses/where/buildWhereClauses";
+import { hasConditions } from "../util/hasConditions";
+import { DeleteBuilder } from "./buildDelete";
+
+export const deleteToSql = (
+    config: BaseConfiguration,
+    m: string,
+    builder: DeleteBuilder,
+): SQLStatement => {
+    const { table, where, returning } = builder;
+
+    const frag = sql`DELETE FROM %I.%I AS %I`.withIdentifiers(
+        table.schema,
+        table.table,
+        table.alias,
+    );
+
+    if (!hasConditions(where)) {
+        throw new OrmError(`No where clause provided for delete`, {
+            data: {
+                table,
+                where,
+                returning,
+            },
+        });
+    }
+    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/delete/tests/deleteOne.test.ts

@@ -0,0 +1,108 @@
+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("deleteOne", () => {
+    test("it deletes a single record in the database", async () => {
+        await db.transact(
+            async (db) => {
+                const { posts } = await seed(db, {
+                    users: [
+                        {
+                            username: "Stewart House",
+                            tenants: [{ name: "Popova Park", posts: 3 }],
+                        },
+                    ],
+                });
+
+                const deleted = await db.deleteOne("post", {
+                    where: { title: "Post a" },
+                    returning: ["id"],
+                });
+
+                expect(deleted.id).toEqual(
+                    posts.find((p) => p.title === "Post a")?.id,
+                );
+
+                const results = await db.findMany("post", {
+                    select: ["id", "title"],
+                    include: {
+                        author: {
+                            select: ["id", "username"],
+                            where: { username: { [$like]: "Stewart %" } },
+                        },
+                    },
+                });
+
+                expect(results.map((p) => p.title)).toEqual([
+                    "Post b",
+                    "Post c",
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("if no records are deleted, it throws an error and rolls back to before the delete", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Stewart House",
+                            tenants: [{ name: "Popova Park", posts: 3 }],
+                        },
+                    ],
+                });
+
+                await expect(
+                    db.deleteOne("post", {
+                        where: { title: "Wrong" },
+                        returning: ["id"],
+                    }),
+                ).rejects.toEqual(new OrmError("No rows deleted"));
+            },
+            { rollback: true },
+        );
+    });
+
+    test("if multiple records are deleted, it throws an error and rolls back to before the delete", 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.deleteOne("post", {
+                        where: { title: { [$like]: "Post%" } },
+                        returning: ["id"],
+                    }),
+                ).rejects.toEqual(
+                    new OrmError(
+                        "More than one deleted row for deleteOne, rolling back",
+                    ),
+                );
+
+                const result = await db.findMany("post", {
+                    select: ["id"],
+                });
+
+                expect(result.length).toEqual(6);
+            },
+            { rollback: true },
+        );
+    });
+});

package/src/queries/delete/types/BaseDeleteParams.ts

@@ -0,0 +1,9 @@
+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 BaseDeleteParams = {
+    where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
+    returning?: NonEmptyArray<string>;
+};

package/src/queries/delete/types/DeleteManyResult.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 { DeleteParams } from "./DeleteParams";
+
+export type DeleteManyResult<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    P extends DeleteParams<Models, M>,
+> =
+    P["returning"] extends ReturningClause<Models[M]>
+        ? Readonly<{
+              [C in P["returning"][number]]: ColumnType<Models, M, C>;
+          }>[]
+        : number;

package/src/queries/delete/types/DeleteOneResult.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 { DeleteParams } from "./DeleteParams";
+
+export type DeleteOneResult<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    P extends DeleteParams<Models, M>,
+> =
+    P["returning"] extends ReturningClause<Models[M]>
+        ? Readonly<{
+              [C in P["returning"][number]]: ColumnType<Models, M, C>;
+          }>
+        : number;

package/src/queries/delete/types/DeleteParams.ts

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

package/src/queries/deleteMany.ts

@@ -0,0 +1,33 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../Connection";
+import { logger } from "../logger";
+import { buildDelete } from "./delete/buildDelete";
+import { deleteToSql } from "./delete/deleteToSql";
+import { BaseDeleteParams } from "./delete/types/BaseDeleteParams";
+import { rowToObject } from "./util/rowToObject";
+
+export const deleteMany = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    params: BaseDeleteParams,
+) => {
+    const builder = buildDelete(config, m, params);
+    const statement = deleteToSql(config, m, builder);
+    logger.info({
+        message: "Executing delete",
+        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/deleteOne.ts

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

package/src/queries/find/buildFind.ts

@@ -0,0 +1,138 @@
+import { max, min, uniq } from "lodash-es";
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { ensureArray } from "../../util/ensureArray";
+import { tableAlias } from "../util/tableAlias";
+import { BaseFindParams } from "./types/BaseFindParams";
+import { FindBuilder } from "./types/FindBuilder";
+
+export const buildFind = (
+    config: BaseConfiguration,
+    m: string,
+    query: BaseFindParams,
+    path: string[] = [],
+    _tableIndex = 0,
+): FindBuilder => {
+    const builder: FindBuilder = {
+        columns: [],
+        table: {
+            table: config.models[m]["table"],
+            model: m,
+            schema: config.models[m]["schema"],
+            alias: tableAlias(_tableIndex++),
+            where: config.middleware.find?.where
+                ? config.middleware.find.where(query.where, {
+                      config,
+                      model: m,
+                  })
+                : query.where,
+            joins: [],
+        },
+        orderBy: [],
+        for: query.for,
+        tableIndex: _tableIndex,
+    };
+
+    const model = config.models[m];
+
+    const alias = builder.table.alias;
+    let colIndex = 0;
+
+    // make sure we always select the model's primary key,
+    // and if necessary the foreign key for a lateral join
+    // - we'll strip them out later
+    const select = uniq([
+        ...query.select,
+        ...model.primaryKey,
+        ...(query.lateralBy ?? []).map(({ column }) => column),
+    ]);
+
+    for (const f of select) {
+        builder.columns.push({
+            table: alias,
+            name: model.columns[f]["name"],
+            alias: `${alias}_${colIndex++}`,
+            path: [...path, f],
+        });
+    }
+
+    for (const [r, subquery] of Object.entries(query.include ?? {})) {
+        const relation = config.relations[m][r];
+        const joinedModel = config.models[relation.model];
+        if (relation.type === "N:1") {
+            const joinBuilder = buildFind(
+                config,
+                relation.model,
+                subquery!,
+                [...path, r],
+                builder.tableIndex++,
+            );
+            const joinedTable = joinBuilder.table;
+            builder.table.joins.push(
+                {
+                    from: {
+                        schema: config.models[m].schema,
+                        table: config.models[m].table,
+                        alias,
+                        model: m,
+                        columns: ensureArray(relation.foreignKey).map(
+                            (c) => model.columns[c].name,
+                        ),
+                    },
+                    to: {
+                        schema: joinedModel.schema,
+                        table: joinedTable.table,
+                        alias: joinedTable.alias,
+                        model: relation.model,
+                        columns: joinedModel.primaryKey.map(
+                            (c) => joinedModel.columns[c].name,
+                        ),
+                    },
+                    type: relation.optional ? "left" : "inner",
+                    where: joinedTable.where,
+                },
+                ...joinedTable.joins,
+            );
+            // this is admittedly a bit weird,
+            // we wouldn't expect N:1 relations to specify
+            // ordering, skipping, and limiting, and typescript
+            // prevents users from doing this, but
+            // we rely on them being present as part of the N:N
+            // implementation
+            builder.columns.push(...joinBuilder.columns);
+            builder.orderBy.push(...joinBuilder.orderBy);
+            builder.limit = min([builder.limit, joinBuilder.limit]);
+            builder.offset = max([builder.offset, joinBuilder.offset]);
+        }
+    }
+
+    if (query.lateralBy) {
+        builder.lateralBy = {
+            groupTable: tableAlias(builder.tableIndex++),
+            itemTable: tableAlias(builder.tableIndex++),
+            columns: query.lateralBy.map(({ column, values }) => ({
+                column: model.columns[column].name,
+                type: model.columns[column].type,
+                values,
+            })),
+        };
+    }
+
+    if (query.orderBy) {
+        builder.orderBy = query.orderBy.map((o) => ({
+            table: alias,
+            column: model.columns[Array.isArray(o) ? o[0] : o].name,
+            direction: Array.isArray(o) ? o[1] : "asc",
+        }));
+    }
+
+    if (query.limit) {
+        builder.limit = query.limit;
+    }
+
+    if (query.offset) {
+        builder.offset = query.offset;
+    }
+
+    return builder;
+};

package/src/queries/find/findResultSchema.ts

@@ -0,0 +1,32 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+import { ZodSchema, z } from "zod";
+
+import { BaseFindParams } from "./types/BaseFindParams";
+
+export const findResultSchema = (
+    config: BaseConfiguration,
+    m: string,
+    query: BaseFindParams,
+) => {
+    const obj: Record<string, ZodSchema<unknown>> = {};
+
+    query.select.forEach((field) => {
+        const col = config.models[m].columns[field];
+        obj[field] = col.nullable
+            ? col.zodSchema.nullish().transform((x) => x ?? null)
+            : col.zodSchema;
+    });
+
+    for (const [field, subquery] of Object.entries(query.include || {})) {
+        const relation = config.relations[m][field];
+        const schema = findResultSchema(config, relation.model, subquery!);
+        obj[field] =
+            relation.type === "N:1"
+                ? relation.optional
+                    ? schema.nullish().transform((x) => x ?? null)
+                    : schema
+                : z.array(schema);
+    }
+
+    return z.object(obj);
+};