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

package/src/queries/delete/buildDelete.ts

@@ -1,56 +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 { 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

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

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

@@ -1,108 +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("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

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

package/src/queries/delete/types/DeleteManyResult.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 { 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

@@ -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 { 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

@@ -1,12 +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";
-
-export type DeleteParams<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = {
-    where: WhereClause<Models, M>;
-    returning?: ReturningClause<Models[M]>;
-};

package/src/queries/deleteMany.ts

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

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

@@ -1,138 +0,0 @@
-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: Array.isArray(o) ? o[0] : o,
-            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

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

package/src/queries/find/findToSql.test.ts

@@ -1,123 +0,0 @@
-import { unindent } from "@casekit/unindent";
-
-import * as uuid from "uuid";
-import { describe, expect, test } from "vitest";
-
-import { FindMany, db } from "../../test/db";
-import { $and, $ilike, $lte } from "../clauses/where/operators";
-import { buildFind } from "./buildFind";
-import { findToSql } from "./findToSql";
-
-describe("findToSql", () => {
-    test("it builds a valid query for simple selects", async () => {
-        const builder = buildFind(db.config, "post", {
-            select: ["id", "title"],
-        });
-        const statement = findToSql(db.config, builder);
-        expect(statement.text).toEqual(unindent`
-            SELECT
-                a.id AS a_0,
-                a.title AS a_1
-            FROM casekit.post a
-            WHERE 1 = 1
-        `);
-    });
-
-    test("it builds a valid query for included N:1 relations", async () => {
-        const builder = buildFind(db.config, "post", {
-            select: ["id", "title"],
-            include: {
-                author: { select: ["username"] },
-            },
-        } as FindMany<"post">);
-
-        const statement = findToSql(db.config, builder);
-        expect(statement.text).toEqual(unindent`
-            SELECT
-                a.id AS a_0,
-                a.title AS a_1,
-                b.username AS b_0,
-                b.id AS b_1
-            FROM casekit.post a
-            JOIN casekit."user" b
-                ON a.created_by_id = b.id
-            WHERE 1 = 1
-        `);
-    });
-
-    test("it builds a valid lateral query for 1:N relations", async () => {
-        const builder = buildFind(db.config, "post", {
-            select: ["id", "title"],
-            include: {
-                author: { select: ["username"] },
-            },
-            lateralBy: [{ column: "id", values: [uuid.v4()] }],
-        } as FindMany<"post">);
-
-        const statement = findToSql(db.config, builder);
-        expect(statement.text).toEqual(unindent`
-            SELECT d.* FROM (
-            SELECT UNNEST(ARRAY[$1]::uuid[]) AS id) c
-            JOIN LATERAL (
-            SELECT
-                a.id AS a_0,
-                a.title AS a_1,
-                b.username AS b_0,
-                b.id AS b_1
-            FROM casekit.post a
-            JOIN casekit."user" b
-                ON a.created_by_id = b.id
-            WHERE 1 = 1
-                AND a.id = c.id
-            ) d ON TRUE
-        `);
-    });
-
-    test("it allows specifying where clauses on both the top level table and N:1 relations", async () => {
-        const id1 = uuid.v4();
-        const id2 = uuid.v4();
-        const builder = buildFind(db.config, "post", {
-            select: ["id", "title"],
-            where: { title: { [$ilike]: "%cats%" } },
-            include: {
-                author: {
-                    select: ["username"],
-                    where: {
-                        [$and]: [
-                            { username: "Russell" },
-                            { joinedAt: { [$lte]: new Date(2024, 6, 4) } },
-                        ],
-                    },
-                },
-            },
-            lateralBy: [{ column: "id", values: [id1, id2] }],
-        } as FindMany<"post">);
-
-        const statement = findToSql(db.config, builder);
-        expect(statement.text).toEqual(unindent`
-            SELECT d.* FROM (
-            SELECT UNNEST(ARRAY[$1, $2]::uuid[]) AS id) c
-            JOIN LATERAL (
-            SELECT
-                a.id AS a_0,
-                a.title AS a_1,
-                b.username AS b_0,
-                b.id AS b_1
-            FROM casekit.post a
-            JOIN casekit."user" b
-                ON a.created_by_id = b.id
-                AND (((b.username = $3) AND (b.created_at <= $4)))
-            WHERE 1 = 1
-                AND (a.title ILIKE $5)
-                AND a.id = c.id
-            ) d ON TRUE
-        `);
-        expect(statement.values).toEqual([
-            id1,
-            id2,
-            "Russell",
-            new Date(2024, 6, 4),
-            "%cats%",
-        ]);
-    });
-});