@casekit/orm 0.0.1-alpha.9 → 0.0.1-release-candidate

package/src/pull/util/format.ts

@@ -1,17 +0,0 @@
-import prettier from "prettier";
-
-export const format = async (source: string) => {
-    try {
-        return await prettier.format(source, {
-            parser: "typescript",
-            printWidth: 80,
-            tabWidth: 4,
-            trailingComma: "all",
-            singleQuote: false,
-            semi: true,
-        });
-    } catch (e) {
-        console.error(e);
-        return source;
-    }
-};

package/src/pull/util/quote.ts

@@ -1,7 +0,0 @@
-import { unquote } from "./unquote";
-
-export const quote = (s: string) => {
-    // we unquote the string first to avoid
-    // double quoting
-    return JSON.stringify(unquote(s));
-};

package/src/pull/util/unquote.ts

@@ -1,9 +0,0 @@
-export const unquote = (s: string) => {
-    // if we're given an quoted string,
-    // strip the quotes
-    if (s.startsWith('"') && s.endsWith('"')) {
-        return s.substring(1, s.length - 1);
-    } else {
-        return s;
-    }
-};

package/src/queries/clauses/IncludeClause.ts

@@ -1,23 +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 { FindOneParams } from "../find/types/FindOneParams";
-
-export type IncludeClause<
-    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" }
-            ? FindOneParams<Models, Relations, Relations[M][R]["model"]>
-            : Relations[M][R] extends { type: "1:N" }
-              ? FindManyParams<Models, Relations, Relations[M][R]["model"]>
-              : Relations[M][R] extends { type: "N:N" }
-                ? FindManyParams<Models, Relations, Relations[M][R]["model"]>
-                : never
-        : never;
-};

package/src/queries/clauses/LateralByClause.ts

@@ -1,4 +0,0 @@
-export type LateralByClause = {
-    column: string;
-    values: unknown[];
-}[];

package/src/queries/clauses/ReturningClause.ts

@@ -1,7 +0,0 @@
-import { ColumnName } from "../../schema/types/helpers/ColumnName";
-import { LooseModelDefinition } from "../../schema/types/loose/LooseModelDefinition";
-import { NonEmptyArray } from "../../types/util/NonEmptyArray";
-
-export type ReturningClause<Model extends LooseModelDefinition> = NonEmptyArray<
-    ColumnName<Model>
->;

package/src/queries/clauses/SelectClause.ts

@@ -1,7 +0,0 @@
-import { ColumnName } from "../../schema/types/helpers/ColumnName";
-import { LooseModelDefinition } from "../../schema/types/loose/LooseModelDefinition";
-import { NonEmptyArray } from "../../types/util/NonEmptyArray";
-
-export type SelectClause<Model extends LooseModelDefinition> = NonEmptyArray<
-    ColumnName<Model>
->;

package/src/queries/clauses/WhereClause.ts

@@ -1,16 +0,0 @@
-import { ColumnName } from "../../schema/types/helpers/ColumnName";
-import { ModelName } from "../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
-import { $and, $not, $or } from "../clauses/where/operators";
-import { WhereClauseValue } from "./where/types/WhereClauseValue";
-
-export type WhereClause<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = {
-    [C in ColumnName<Models[M]>]?: WhereClauseValue<Models, M, C>;
-} & {
-    [$and]?: WhereClause<Models, M>[];
-    [$or]?: WhereClause<Models, M>[];
-    [$not]?: WhereClause<Models, M>;
-};

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

@@ -1,18 +0,0 @@
-import { ColumnName } from "../../../schema/types/helpers/ColumnName";
-import { HasDefault } from "../../../schema/types/helpers/HasDefault";
-import { IsNullable } from "../../../schema/types/helpers/IsNullable";
-import { IsProvided } from "../../../schema/types/helpers/IsProvided";
-import { IsSerial } from "../../../schema/types/helpers/IsSerial";
-import { LooseModelDefinition } from "../../../schema/types/loose/LooseModelDefinition";
-
-export type OptionalColumn<Model extends LooseModelDefinition> = {
-    [C in ColumnName<Model>]: IsNullable<Model, C> extends true
-        ? C
-        : IsSerial<Model, C> extends true
-          ? C
-          : HasDefault<Model, C> extends true
-            ? C
-            : IsProvided<Model, C> extends true
-              ? C
-              : never;
-}[ColumnName<Model>];

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

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

@@ -1,8 +0,0 @@
-import { ColumnName } from "../../../schema/types/helpers/ColumnName";
-import { LooseModelDefinition } from "../../../schema/types/loose/LooseModelDefinition";
-import { OptionalColumn } from "./OptionalColumn";
-
-export type RequiredColumn<Model extends LooseModelDefinition> = Exclude<
-    ColumnName<Model>,
-    OptionalColumn<Model>
->;

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

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

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

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

@@ -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;
-};