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

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

package/src/queries/create/buildCreate.ts

@@ -1,65 +0,0 @@
-import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
-
-import { OrmError } from "../../errors";
-import { tableAlias } from "../util/tableAlias";
-import { BaseCreateManyParams } from "./types/BaseCreateManyParams";
-
-export type CreateBuilder = {
-    tableIndex: number;
-    table: { table: string; schema: string };
-    params: { name: string; path: string; values: unknown[] }[];
-    onConflict?: { do: "nothing" };
-    returning: { name: string; path: string; alias: string }[];
-};
-
-export const buildCreate = (
-    config: BaseConfiguration,
-    m: string,
-    params: BaseCreateManyParams,
-    _tableIndex = 0,
-): CreateBuilder => {
-    const builder: CreateBuilder = {
-        tableIndex: _tableIndex,
-        table: {
-            table: config.models[m].table,
-            schema: config.models[m].schema,
-        },
-        params: [],
-        returning: [],
-    };
-
-    const table = tableAlias(builder.tableIndex++);
-    let colIndex = 0;
-
-    const model = config.models[m];
-    const values = params.values.map((v) =>
-        config.middleware.create?.values
-            ? config.middleware.create.values(v, { config, model: m })
-            : v,
-    );
-
-    if (values.length === 0)
-        throw new OrmError("No data provided for create operation", {
-            data: { m, params },
-        });
-
-    for (const k of Object.keys(values[0])) {
-        builder.params.push({
-            name: model.columns[k]["name"],
-            path: k,
-            values: values.map((v) => v[k]),
-        });
-    }
-
-    for (const f of params.returning ?? []) {
-        builder.returning.push({
-            name: model.columns[f]["name"],
-            path: f,
-            alias: `${table}_${colIndex++}`,
-        });
-    }
-
-    builder.onConflict = params.onConflict;
-
-    return builder;
-};

package/src/queries/create/createResultSchema.ts

@@ -1,24 +0,0 @@
-import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
-import { ZodSchema, z } from "zod";
-
-import { BaseCreateManyParams } from "./types/BaseCreateManyParams";
-import { BaseCreateOneParams } from "./types/BaseCreateOneParams";
-
-export const createResultSchema = (
-    config: BaseConfiguration,
-    m: string,
-    params: BaseCreateManyParams | BaseCreateOneParams,
-) => {
-    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/create/createToSql.ts

@@ -1,44 +0,0 @@
-import pgfmt from "pg-format";
-
-import { SQLStatement, sql } from "../../sql";
-import { CreateBuilder } from "./buildCreate";
-
-export const createToSql = (builder: CreateBuilder): SQLStatement => {
-    const frag = new SQLStatement();
-
-    const { table, params, returning } = builder;
-
-    if (params.length === 0) {
-        frag.push(
-            pgfmt(
-                "INSERT INTO %I.%I DEFAULT VALUES",
-                table.schema,
-                table.table,
-            ),
-        );
-    } else {
-        frag.push(pgfmt("INSERT INTO %I.%I (\n", table.schema, table.table));
-        frag.push(params.map((p) => pgfmt("    %I", p.name)).join(",\n"));
-        frag.push(") VALUES ");
-        const values = params[0].values.map((_, index) => {
-            return sql`\n(${sql.splat(params.map((p) => p.values[index]))})`;
-        });
-        frag.push(sql.splat(values));
-    }
-
-    if (builder.onConflict?.do === "nothing") {
-        frag.push("\nON CONFLICT DO NOTHING");
-    }
-
-    if (returning.length > 0) {
-        frag.push("\nRETURNING ");
-        frag.push(
-            returning
-                .map((r) => pgfmt(`    %I as %I`, r.name, r.alias))
-                .join(",\n"),
-        );
-    }
-    frag.push(";\n");
-
-    return frag;
-};

package/src/queries/create/tests/createOne.test-d.ts

@@ -1,116 +0,0 @@
-import pg from "pg";
-import * as uuid from "uuid";
-import { assertType, describe, expectTypeOf, test } from "vitest";
-import { z } from "zod";
-
-import { ModelDefinition, orm } from "../../..";
-import { db } from "../../../test/db";
-
-describe("createOne", () => {
-    test("only models that exist can be created", () => {
-        assertType(
-            db.createOne(
-                // @ts-expect-error model does not exist
-                "wrong",
-                {},
-            ),
-        );
-    });
-
-    test("a data param must be included in the query", () => {
-        assertType(
-            db.createOne(
-                "post",
-                // @ts-expect-error data param is missing
-                {},
-            ),
-        );
-    });
-
-    test("all required fields must be provided", () => {
-        assertType(
-            db.createOne("post", {
-                // @ts-expect-error required fields not provided
-                values: { title: "hello" },
-            }),
-        );
-    });
-
-    test("only existing fields can be included in the returning clause", () => {
-        assertType(
-            db.createOne("post", {
-                values: {
-                    title: "hello",
-                    content: "it me",
-                    authorId: uuid.v4(),
-                },
-                returning: [
-                    "id",
-                    // @ts-expect-error non-existing fields can't be returned
-                    "x",
-                ],
-            }),
-        );
-    });
-
-    test("without a returning clause, the return type is the number of rows created", async () => {
-        expectTypeOf(
-            await db.createOne("post", {
-                values: {
-                    title: "hello",
-                    content: "it me",
-                    authorId: uuid.v4(),
-                },
-            }),
-        ).toMatchTypeOf<number>();
-    });
-
-    test("with a returning clause, the return type is an object containing the specified fields", async () => {
-        expectTypeOf(
-            await db.createOne("post", {
-                values: {
-                    title: "hello",
-                    content: "it me",
-                    authorId: uuid.v4(),
-                },
-                returning: ["id", "title"],
-            }),
-        ).toMatchTypeOf<{ id: string; title: string }>();
-    });
-
-    test("non-selected fields are not included in the result type", async () => {
-        expectTypeOf(
-            await db.createOne("post", {
-                values: {
-                    title: "hello",
-                    content: "it me",
-                    authorId: uuid.v4(),
-                },
-                returning: ["id", "title"],
-            }),
-        ).not.toMatchTypeOf<{ id: string; title: string; content: string }>();
-    });
-
-    test("when there are no required params, typechecking still works", () => {
-        const foo = {
-            columns: { id: { type: "serial", zodSchema: z.coerce.number() } },
-        } as const satisfies ModelDefinition;
-        const db = orm({ models: { foo }, pool: new pg.Pool() });
-        assertType(db.createOne("foo", { values: { id: 3 } }));
-    });
-
-    test("when all required fields are provided, excess property checking still works", async () => {
-        assertType(
-            await db.createOne("post", {
-                values: {
-                    title: "hello",
-                    content: "it me",
-                    authorId: uuid.v4(),
-                    // @ts-expect-error non-existing properties can't be included
-                    wrong: 2,
-                },
-                returning: ["id", "title"],
-            }),
-        );
-    });
-});

package/src/queries/create/tests/createOne.test.ts

@@ -1,197 +0,0 @@
-import pg from "pg";
-import * as uuid from "uuid";
-import { describe, expect, test } from "vitest";
-import { z } from "zod";
-
-import { ModelDefinition, orm } from "../../..";
-import { createTableSql } from "../../../migrate/sql/createTableSql";
-import { sql } from "../../../sql";
-import { db } from "../../../test/db";
-
-describe("createOne", () => {
-    test("it inserts records into the database", async () => {
-        await db.transact(
-            async (db) => {
-                const userId = uuid.v4();
-                const tenantId = uuid.v4();
-                const postId = uuid.v4();
-                await db.createOne("tenant", {
-                    values: {
-                        id: tenantId,
-                        name: "popovapark",
-                    },
-                });
-                await db.createOne("user", {
-                    values: {
-                        id: userId,
-                        username: "russell",
-                    },
-                });
-                const result = await db.createOne("post", {
-                    values: {
-                        id: postId,
-                        authorId: userId,
-                        tenantId: tenantId,
-                        title: "hello it me",
-                        content: "i'm writing a post",
-                    },
-                });
-
-                expect(result).toEqual(1);
-
-                const rows = await db.findMany("post", {
-                    select: ["id", "title"],
-                });
-
-                expect(rows).toHaveLength(1);
-                expect(rows[0]).toEqual(
-                    expect.objectContaining({
-                        id: postId,
-                        title: "hello it me",
-                    }),
-                );
-            },
-            { rollback: true },
-        );
-    });
-
-    test("columns of type serial do not need to be specified", async () => {
-        const baz = {
-            columns: {
-                id: { type: "serial", zodSchema: z.coerce.number() },
-                big: { type: "bigserial", zodSchema: z.coerce.number() },
-                small: { type: "smallserial", zodSchema: z.coerce.number() },
-            },
-        } as const satisfies ModelDefinition;
-        await orm({
-            schema: "casekit",
-            models: { baz },
-            relations: { baz: {} },
-            pool: new pg.Pool(),
-        }).transact(
-            async (db) => {
-                await db.connection.query(createTableSql(db.models.baz));
-
-                await db.createOne("baz", {
-                    values: {},
-                });
-
-                const rows = await db.findMany("baz", {
-                    select: ["id", "big", "small"],
-                });
-
-                expect(rows).toHaveLength(1);
-                expect(rows[0].id).toBeTypeOf("number");
-                expect(rows[0].big).toBeTypeOf("number");
-                expect(rows[0].small).toBeTypeOf("number");
-            },
-            { rollback: true },
-        );
-    });
-
-    test("columns with default values do not need to be specified", async () => {
-        const baz = {
-            columns: {
-                id: {
-                    type: "uuid",
-                    zodSchema: z.string().uuid(),
-                    default: sql`uuid_generate_v4()`,
-                },
-                name: { type: "text", zodSchema: z.string() },
-            },
-        } as const satisfies ModelDefinition;
-        await orm({
-            schema: "casekit",
-            models: { baz },
-            relations: { baz: {} },
-            pool: new pg.Pool(),
-        }).transact(
-            async (db) => {
-                await db.connection.query(createTableSql(db.models.baz));
-
-                await db.createOne("baz", {
-                    values: { name: "hello" },
-                });
-
-                const rows = await db.findMany("baz", {
-                    select: ["id", "name"],
-                });
-
-                expect(rows).toHaveLength(1);
-                expect(rows[0].id).toBeTypeOf("string");
-                expect(rows[0].name).toEqual("hello");
-            },
-            { rollback: true },
-        );
-    });
-    test("columns that are provided by middleware do not need to be specified", async () => {
-        const baz = {
-            columns: {
-                id: {
-                    type: "uuid",
-                    zodSchema: z.string().uuid(),
-                    provided: true,
-                },
-                name: { type: "text", zodSchema: z.string() },
-            },
-        } as const satisfies ModelDefinition;
-
-        await orm({
-            schema: "casekit",
-            models: { baz },
-            relations: { baz: {} },
-            pool: new pg.Pool(),
-            middleware: [
-                {
-                    create: {
-                        values: (values) => ({ id: uuid.v4(), ...values }),
-                    },
-                },
-            ],
-        }).transact(
-            async (db) => {
-                await db.connection.query(createTableSql(db.models.baz));
-
-                await db.createOne("baz", {
-                    values: { name: "hello" },
-                });
-
-                const rows = await db.findMany("baz", {
-                    select: ["id", "name"],
-                });
-
-                expect(rows).toHaveLength(1);
-                expect(rows[0].id).toBeTypeOf("string");
-                expect(rows[0].name).toEqual("hello");
-            },
-            { rollback: true },
-        );
-    });
-
-    test("conflicts can be ignored", async () => {
-        await db.transact(
-            async (db) => {
-                await db.createOne("user", { values: { username: "russell" } });
-
-                // creating a duplicate user should throw an error
-                await expect(
-                    db.transact(async (db) => {
-                        return db.createOne("user", {
-                            values: { username: "russell" },
-                        });
-                    }),
-                ).rejects.toThrow(
-                    'duplicate key value violates unique constraint "user_username_idx"',
-                );
-
-                // but if we ignore the conflict, it should work
-                const result = await db.createOne("user", {
-                    values: { username: "russell" },
-                    onConflict: { do: "nothing" },
-                });
-                expect(result).toEqual(0);
-            },
-            { rollback: true },
-        );
-    });
-});

package/src/queries/create/types/BaseCreateManyParams.ts

@@ -1,7 +0,0 @@
-import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
-
-export type BaseCreateManyParams = {
-    values: Record<string, unknown | null>[];
-    onConflict?: { do: "nothing" };
-    returning?: NonEmptyArray<string>;
-};

package/src/queries/create/types/BaseCreateOneParams.ts

@@ -1,7 +0,0 @@
-import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
-
-export type BaseCreateOneParams = {
-    values: Record<string, unknown | null>;
-    onConflict?: { do: "nothing" };
-    returning?: NonEmptyArray<string>;
-};