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

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

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

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

@@ -1,145 +0,0 @@
-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,
-                { table: "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

@@ -1,45 +0,0 @@
-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: { table: 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

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

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

@@ -1,77 +0,0 @@
-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 = {
-        table: {
-            table: config.models[m]["table"],
-            model: m,
-            schema: config.models[m]["schema"],
-            alias: tableAlias(_tableIndex++),
-            joins: [],
-            where: config.middleware.count?.where
-                ? config.middleware.count.where(query.where, {
-                      config,
-                      model: m,
-                  })
-                : query.where,
-        },
-        tableIndex: _tableIndex,
-    };
-
-    const model = config.models[m];
-
-    const alias = builder.table.alias;
-
-    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 = 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,
-                        ),
-                    },
-                    where: joinedTable.where,
-                    type: relation.optional ? "left" : "inner",
-                },
-                ...joinedTable.joins,
-            );
-        }
-    }
-
-    return builder;
-};

package/src/queries/count/countToSql.ts

@@ -1,66 +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 { CountBuilder } from "./types/CountBuilder";
-
-export const countToSql = (
-    config: BaseConfiguration,
-    builder: CountBuilder,
-): SQLStatement => {
-    const table = builder.table;
-
-    const frag = sql`SELECT count(1) as "count"`;
-
-    frag.push(pgfmt(`\nFROM %I.%I %I`, table.schema, table.table, table.alias));
-
-    for (const join of table.joins ?? []) {
-        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 },
-            );
-        }
-
-        frag.push(join.type === "left" ? "\nLEFT JOIN" : "\nJOIN");
-        frag.push(
-            pgfmt(
-                "\n %I.%I %I\n    ON ",
-                join.to.schema,
-                join.to.table,
-                join.to.alias,
-            ),
-        );
-        frag.push(
-            join.from.columns
-                .map((from, i) =>
-                    pgfmt(
-                        "%I.%I = %I.%I",
-                        join.from.alias,
-                        from,
-                        join.to.alias,
-                        join.to.columns[i],
-                    ),
-                )
-                .join(" AND "),
-        );
-        if (hasConditions(join.where)) {
-            frag.push(
-                sql`\n    AND ${buildWhereClauses(config, join.to, join.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

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

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

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

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

@@ -1,27 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
-import { WhereClause } from "../../clauses/WhereClause";
-
-export type IncludeHasOneRelationsClause<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-> = {
-    [R in Extract<keyof Relations[M], string>]?: Relations[M][R] extends {
-        model: ModelName<Models>;
-    }
-        ? Relations[M][R] extends { type: "N:1" }
-            ? CountParams<Models, Relations, Relations[M][R]["model"]>
-            : never
-        : never;
-};
-
-export type CountParams<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-> = {
-    where?: WhereClause<Models, M>;
-    include?: IncludeHasOneRelationsClause<Models, Relations, M>;
-};

package/src/queries/count.ts

@@ -1,33 +0,0 @@
-import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
-
-import { Connection } from "../Connection";
-import { logger } from "../logger";
-import { buildCount } from "./count/buildCount";
-import { countToSql } from "./count/countToSql";
-import { BaseCountParams } from "./count/types/BaseCountParams";
-
-export const count = async (
-    conn: Connection,
-    config: BaseConfiguration,
-    m: string,
-    query: BaseCountParams,
-) => {
-    const builder = buildCount(config, m, query);
-    const statement = countToSql(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 result = await conn
-        .query(statement)
-        .then((result) => result.rows[0].count);
-
-    return result;
-};