@casekit/orm 0.0.1-alpha.0

package/src/queries/clauses/helpers/OptionalParams.ts

@@ -0,0 +1,14 @@
+import { ColumnType } from "../../../schema/types/helpers/ColumnType";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { OptionalColumn } from "./OptionalColumn";
+
+export type OptionalParams<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> =
+    OptionalColumn<Models, M> extends never
+        ? unknown
+        : {
+              [C in OptionalColumn<Models, M>]?: ColumnType<Models, M, C>;
+          };

package/src/queries/clauses/helpers/RequiredColumn.ts

@@ -0,0 +1,9 @@
+import { ColumnName } from "../../../schema/types/helpers/ColumnName";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { OptionalColumn } from "./OptionalColumn";
+
+export type RequiredColumn<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = Exclude<ColumnName<Models, M>, OptionalColumn<Models, M>>;

package/src/queries/clauses/helpers/RequiredParams.ts

@@ -0,0 +1,14 @@
+import { ColumnType } from "../../../schema/types/helpers/ColumnType";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { RequiredColumn } from "./RequiredColumn";
+
+export type RequiredParams<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> =
+    RequiredColumn<Models, M> extends never
+        ? unknown
+        : {
+              [C in RequiredColumn<Models, M>]: ColumnType<Models, M, C>;
+          };

package/src/queries/clauses/include/IncludedRelationModel.ts

@@ -0,0 +1,13 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { LooseRelationDefinition } from "../../../schema/types/loose/LooseRelationDefinition";
+import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
+
+export type IncludedRelationModel<
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+    M extends ModelName<Models>,
+    R extends keyof Relations[M],
+> = Relations[M][R] extends LooseRelationDefinition
+    ? Extract<Relations[M][R]["model"], ModelName<Models>>
+    : never;

package/src/queries/clauses/include/IncludedRelationName.ts

@@ -0,0 +1,11 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
+import { FindManyParams } from "../../find/types/FindManyParams";
+
+export type IncludedRelationName<
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+    M extends ModelName<Models>,
+    Q extends FindManyParams<Models, Relations, M>,
+> = keyof Relations[M] & keyof Q["include"];

package/src/queries/clauses/include/IncludedRelationQuery.ts

@@ -0,0 +1,20 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
+import { FindManyParams } from "../../find/types/FindManyParams";
+import { IncludedRelationModel } from "./IncludedRelationModel";
+
+export type IncludedRelationQuery<
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+    M extends ModelName<Models>,
+    R extends keyof Q["include"] & keyof Relations[M],
+    Q extends FindManyParams<Models, Relations, M>,
+> =
+    Q["include"][R] extends FindManyParams<
+        Models,
+        Relations,
+        IncludedRelationModel<Models, Relations, M, R>
+    >
+        ? Q["include"][R]
+        : never;

package/src/queries/clauses/where/buildWhereClause.ts

@@ -0,0 +1,121 @@
+import { OrmError } from "../../../errors";
+import { SQLStatement, sql } from "../../../sql";
+import {
+    $eq,
+    $gt,
+    $gte,
+    $ilike,
+    $in,
+    $is,
+    $like,
+    $lt,
+    $lte,
+    $ne,
+    $not,
+} from "./operators";
+
+export const buildWhereClause = (
+    table: string,
+    column: string,
+    v: unknown,
+): SQLStatement => {
+    if (v === null) {
+        return sql`%I.%I IS NULL`.withIdentifiers(table, column);
+    } else if (
+        typeof v === "string" ||
+        typeof v === "number" ||
+        typeof v === "boolean" ||
+        v instanceof Date ||
+        Object.getOwnPropertySymbols(v).length === 0
+    ) {
+        return sql`%I.%I = ${v}`.withIdentifiers(table, column);
+    } else {
+        const clauses = Object.getOwnPropertySymbols(v).map(
+            (op): SQLStatement => {
+                const v2 = (v as Record<symbol, unknown>)[op];
+                switch (op) {
+                    case $eq:
+                        return sql`%I.%I = ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $gt:
+                        return sql`%I.%I > ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $gte:
+                        return sql`%I.%I >= ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $ilike:
+                        return sql`%I.%I ILIKE ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $in:
+                        if (!Array.isArray(v2)) {
+                            throw new OrmError(
+                                "Non-array passed to IN clause",
+                                { data: { table, column, v, v2 } },
+                            );
+                        } else if (v2.length === 0) {
+                            return sql`%I.%I IN (NULL)`.withIdentifiers(
+                                table,
+                                column,
+                            );
+                        } else {
+                            const values = v2.map((v) => sql`${v}`);
+                            return sql`%I.%I IN (${sql.splat(values)})`.withIdentifiers(
+                                table,
+                                column,
+                            );
+                        }
+                    case $is:
+                        return sql`%I.%I IS ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $like:
+                        return sql`%I.%I LIKE ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $lt:
+                        return sql`%I.%I < ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $lte:
+                        return sql`%I.%I <= ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $ne:
+                        return sql`%I.%I != ${v2}`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    case $not:
+                        if (v2 !== null) {
+                            throw new OrmError(
+                                "Unexpected value other than NULL in NOT clause: " +
+                                    v2,
+                            );
+                        }
+                        return sql`%I.%I IS NOT NULL`.withIdentifiers(
+                            table,
+                            column,
+                        );
+                    default:
+                        throw new OrmError("Unexpected symbol in query", {
+                            data: { table, column, op, v },
+                        });
+                }
+            },
+        );
+
+        return sql.splat(clauses, " AND ");
+    }
+};

package/src/queries/clauses/where/buildWhereClauses.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from "vitest";
+
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { db } from "../../../test/db";
+import { WhereClause } from "../types/../WhereClause";
+import { buildWhereClauses } from "./buildWhereClauses";
+import {
+    $and,
+    $eq,
+    $gt,
+    $gte,
+    $ilike,
+    $in,
+    $is,
+    $like,
+    $lt,
+    $lte,
+    $ne,
+    $not,
+    $or,
+} from "./operators";
+
+/**
+ * NB. The dollars in the resulting SQL render as `undefined` in the test output,
+ * but do generate (and test!) the SQL correctly. This is due to a limitation
+ * of vitest.each that I haven't figured a way round yet.
+ */
+describe("buildWhereClauses", () => {
+    test.each([
+        [{ id: 3 }, "(a.id = $1)", [3]],
+        [{ id: { [$eq]: 3 } }, "(a.id = $1)", [3]],
+        [{ a: "foo" }, "(a.a = $1)", ["foo"]],
+        [
+            { timestamp: { [$gt]: new Date(2024, 1, 1) } },
+            `(a.timestamp > $1)`,
+            [new Date(2024, 1, 1)],
+        ],
+        [
+            { timestamp: { [$gte]: new Date(2024, 1, 3) } },
+            "(a.timestamp >= $1)",
+            [new Date(2024, 1, 3)],
+        ],
+        [{ bigint: { [$lt]: 47 } }, "(a.bigint < $1)", [47]],
+        [
+            { timestamp: { [$lte]: new Date(2024, 1, 3) } },
+            "(a.timestamp <= $1)",
+            [new Date(2024, 1, 3)],
+        ],
+
+        [{ id: 3, text: "foo" }, "(a.id = $1 AND a.text = $2)", [3, "foo"]],
+        [
+            { id: 3, text: { [$like]: "foo%" } },
+            "(a.id = $1 AND a.text LIKE $2)",
+            [3, "foo%"],
+        ],
+        [
+            { id: 3, text: { [$ilike]: "foo%" } },
+            "(a.id = $1 AND a.text ILIKE $2)",
+            [3, "foo%"],
+        ],
+        [
+            { id: 3, text: { [$ne]: "Russell" } },
+            "(a.id = $1 AND a.text != $2)",
+            [3, "Russell"],
+        ],
+        [
+            { id: 3, text: { [$not]: null } },
+            "(a.id = $1 AND a.text IS NOT NULL)",
+            [3],
+        ],
+        [
+            { id: 3, text: { [$is]: true } },
+            "(a.id = $1 AND a.text IS $2)",
+            [3, true],
+        ],
+        [
+            { [$and]: [{ id: 3 }, { text: "foo" }] },
+            "(((a.id = $1) AND (a.text = $2)))",
+            [3, "foo"],
+        ],
+        [
+            { [$or]: [{ id: 3 }, { text: "foo" }] },
+            "(((a.id = $1) OR (a.text = $2)))",
+            [3, "foo"],
+        ],
+        [
+            { [$not]: { [$or]: [{ text: "foo" }, { text: "bar" }] } },
+            "(NOT (((a.text = $1) OR (a.text = $2))))",
+            ["foo", "bar"],
+        ],
+        [
+            { text: { [$in]: ["cat", "dog", "fish"] } },
+            "(a.text IN ($1, $2, $3))",
+            ["cat", "dog", "fish"],
+        ],
+        [{ text: { [$in]: [] } }, "(a.text IN (NULL))", []],
+        [
+            {
+                [$not]: {
+                    [$and]: [
+                        { text: "foo" },
+                        {
+                            [$or]: [
+                                {
+                                    [$and]: [
+                                        { text: 1, renamedColumn: 2 },
+                                        { renamedColumn: 3 },
+                                    ],
+                                },
+                                { [$or]: [{ text: 3 }, { renamedColumn: 5 }] },
+                                { renamedColumn: 333 },
+                            ],
+                        },
+                    ],
+                },
+            },
+            "(NOT (((a.text = $1) AND (((((a.text = $2 AND a.original_name = $3) AND (a.original_name = $4))) OR (((a.text = $5) OR (a.original_name = $6))) OR (a.original_name = $7))))))",
+            ["foo", 1, 2, 3, 3, 5, 333],
+        ],
+        [
+            { [$or]: [{ text: 1, renamedColumn: 2 }, { text: 3 }] },
+            "(((a.text = $1 AND a.original_name = $2) OR (a.text = $3)))",
+            [1, 2, 3],
+        ],
+    ])(
+        "Where clause of %s returns SQL %s with variables %s",
+        (
+            where: WhereClause<
+                LooseModelDefinitions,
+                ModelName<LooseModelDefinitions>
+            >,
+            sql: string,
+            values: unknown[],
+        ) => {
+            const clause = buildWhereClauses(
+                db.config,
+                { name: "foo", schema: "casekit", model: "foo", alias: "a" },
+                where,
+            );
+            expect(clause.text).toEqual(sql);
+            expect(clause.values).toEqual(values);
+        },
+    );
+});

package/src/queries/clauses/where/buildWhereClauses.ts

@@ -0,0 +1,45 @@
+import { BaseConfiguration } from "../../../schema/types/base/BaseConfiguration";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { SQLStatement, sql } from "../../../sql";
+import { WhereClause } from "../WhereClause";
+import { buildWhereClause } from "./buildWhereClause";
+import { $and, $not, $or } from "./operators";
+
+export const buildWhereClauses = (
+    config: BaseConfiguration,
+    table: { name: string; schema: string; alias: string; model: string },
+    where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>,
+): SQLStatement => {
+    const clauses: SQLStatement[] = [];
+    Object.entries(where).forEach(([column, value]) => {
+        clauses.push(
+            buildWhereClause(
+                table.alias,
+                config.models[table.model]["columns"][column]["name"],
+                value,
+            ),
+        );
+    });
+
+    if (where[$and]) {
+        const subclauses = where[$and].map((condition) => {
+            return buildWhereClauses(config, table, condition);
+        });
+        clauses.push(sql`(${sql.splat(subclauses, " AND ")})`);
+    }
+
+    if (where[$or]) {
+        const subclauses = where[$or].map((condition) => {
+            return buildWhereClauses(config, table, condition);
+        });
+        clauses.push(sql`(${sql.splat(subclauses, " OR ")})`);
+    }
+
+    if (where[$not]) {
+        const subclauses = buildWhereClauses(config, table, where[$not]);
+        clauses.push(sql`NOT ${subclauses}`);
+    }
+
+    return sql`(${sql.splat(clauses, " AND ")})`;
+};

package/src/queries/clauses/where/operators.ts

@@ -0,0 +1,13 @@
+export const $and = Symbol("and");
+export const $eq = Symbol("eq");
+export const $gt = Symbol("gt");
+export const $gte = Symbol("gte");
+export const $ilike = Symbol("ilike");
+export const $in = Symbol("in");
+export const $is = Symbol("is");
+export const $like = Symbol("like");
+export const $lt = Symbol("lt");
+export const $lte = Symbol("lte");
+export const $ne = Symbol("ne");
+export const $not = Symbol("not");
+export const $or = Symbol("or");

package/src/queries/clauses/where/types/WhereClauseValue.ts

@@ -0,0 +1,39 @@
+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 {
+    $eq,
+    $gt,
+    $gte,
+    $ilike,
+    $in,
+    $is,
+    $like,
+    $lt,
+    $lte,
+    $ne,
+    $not,
+} from "../operators";
+
+export type WhereClauseValue<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    C extends ColumnName<Models, M>,
+    T = ColumnType<Models, M, C>,
+> =
+    | ColumnType<Models, M, C>
+    | null
+    | {
+          [$eq]?: T;
+          [$ne]?: T;
+          [$not]?: null;
+          [$is]?: null | true | false | { [$not]: true | false };
+          [$gt]?: T;
+          [$gte]?: T;
+          [$lt]?: T;
+          [$lte]?: T;
+          [$in]?: T[];
+          [$like]?: string;
+          [$ilike]?: string;
+      };

package/src/queries/count/buildCount.ts

@@ -0,0 +1,71 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { ensureArray } from "../../util/ensureArray";
+import { tableAlias } from "../util/tableAlias";
+import { BaseCountParams } from "./types/BaseCountParams";
+import { CountBuilder } from "./types/CountBuilder";
+
+export const buildCount = (
+    config: BaseConfiguration,
+    m: string,
+    query: BaseCountParams,
+    path: string[] = [],
+    _tableIndex = 0,
+): CountBuilder => {
+    const builder: CountBuilder = {
+        tableIndex: _tableIndex,
+        tables: [],
+    };
+
+    const model = config.models[m];
+
+    const alias = tableAlias(builder.tableIndex++);
+
+    builder.tables.push({
+        name: config.models[m]["table"],
+        model: m,
+        schema: config.models[m]["schema"],
+        alias: alias,
+        where: config.middleware.count?.where
+            ? config.middleware.count.where(query.where, { config, model: m })
+            : query.where,
+    });
+
+    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 = buildCount(
+                config,
+                relation.model,
+                subquery!,
+                [...path, r],
+                builder.tableIndex++,
+            );
+            const [joinedTable, ...otherTables] = joinBuilder.tables;
+            builder.tables.push({
+                ...joinedTable,
+                joins: [
+                    ...(joinedTable.joins ?? []),
+                    {
+                        from: {
+                            table: alias,
+                            columns: ensureArray(relation.foreignKey).map(
+                                (c) => model.columns[c].name,
+                            ),
+                        },
+                        to: {
+                            table: joinedTable.alias,
+                            columns: joinedModel.primaryKey.map(
+                                (c) => joinedModel.columns[c].name,
+                            ),
+                        },
+                    },
+                ],
+            });
+            builder.tables.push(...otherTables);
+        }
+    }
+
+    return builder;
+};

package/src/queries/count/countToSql.ts

@@ -0,0 +1,71 @@
+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 { CountBuilder } from "./types/CountBuilder";
+
+export const countToSql = (
+    config: BaseConfiguration,
+    builder: CountBuilder,
+): SQLStatement => {
+    const [table, ...joinedTables] = builder.tables;
+
+    const frag = sql`SELECT count(1) as "count"`;
+
+    frag.push(pgfmt(`\nFROM %I.%I %I`, table.schema, table.name, table.alias));
+
+    for (const joinedTable of joinedTables) {
+        if (!joinedTable.joins)
+            throw new OrmError("Joined table without join clauses", {
+                data: builder,
+            });
+        frag.push(
+            pgfmt(
+                "\nJOIN %I.%I %I\n    ON ",
+                joinedTable.schema,
+                joinedTable.name,
+                joinedTable.alias,
+            ),
+        );
+        frag.push(
+            joinedTable.joins
+                .flatMap((join) => {
+                    if (join.from.columns.length !== join.to.columns.length) {
+                        throw new OrmError(
+                            "Number of foreign keys doesn't match number of primary keys in join",
+                            { data: builder },
+                        );
+                    }
+
+                    return join.from.columns.map((from, i) =>
+                        pgfmt(
+                            "%I.%I = %I.%I",
+                            table.alias,
+                            from,
+                            joinedTable.alias,
+                            join.to.columns[i],
+                        ),
+                    );
+                })
+                .join(" AND "),
+        );
+        if (hasConditions(joinedTable.where)) {
+            frag.push(
+                sql`\n    AND ${buildWhereClauses(config, joinedTable, joinedTable.where)}`,
+            );
+        }
+    }
+
+    frag.push(sql`\nWHERE 1 = 1`);
+
+    if (hasConditions(table.where)) {
+        frag.push(
+            sql`\n    AND ${buildWhereClauses(config, table, table.where)}`,
+        );
+    }
+
+    return frag;
+};

package/src/queries/count/tests/count.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+
+describe("count", () => {
+    test("it counts the number of rows a query would return", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 3 }],
+                        },
+                        {
+                            username: "Stewart Home",
+                            tenants: [{ name: "Popova Park", posts: 2 }],
+                        },
+                    ],
+                });
+                const result = await db.count("post", {
+                    include: {
+                        author: {
+                            where: { username: "Stewart Home" },
+                        },
+                    },
+                });
+
+                expect(result).toBe(2);
+            },
+            { rollback: true },
+        );
+    });
+});

package/src/queries/count/types/BaseCountParams.ts

@@ -0,0 +1,11 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { WhereClause } from "../../clauses/WhereClause";
+
+export type BaseCountParams = {
+    include?: Partial<Record<string, BaseCountParams>>;
+    where?: WhereClause<
+        LooseModelDefinitions,
+        ModelName<LooseModelDefinitions>
+    >;
+};

package/src/queries/count/types/CountBuilder.ts

@@ -0,0 +1,28 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { WhereClause } from "../../clauses/WhereClause";
+
+export type CountBuilder = {
+    tableIndex: number;
+
+    tables: {
+        name: string;
+        model: string;
+        schema: string;
+        alias: string;
+        joins?: Join[];
+        conditions?: WhereClause<
+            LooseModelDefinitions,
+            ModelName<LooseModelDefinitions>
+        >;
+        where?: WhereClause<
+            LooseModelDefinitions,
+            ModelName<LooseModelDefinitions>
+        >;
+    }[];
+};
+
+export type Join = {
+    from: { table: string; columns: string[] };
+    to: { table: string; columns: string[] };
+};