@casekit/orm 0.0.1-alpha.14 → 0.0.1-alpha.16

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

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

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

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

@@ -0,0 +1,67 @@
+import { uniq } from "lodash-es";
+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 },
+        });
+
+    const keys = uniq(values.flatMap((v) => Object.keys(v)));
+    for (const k of keys) {
+        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

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

@@ -0,0 +1,44 @@
+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/createMany.varied-keys.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+
+describe("createMany", () => {
+    test("it can handle varied combinations of optional keys in its values", async () => {
+        await db.transact(
+            async (db) => {
+                const russell = await db.createOne("user", {
+                    values: { username: `Russell` },
+                    returning: ["id", "username"],
+                });
+                const others = await db.createMany("user", {
+                    values: [
+                        { username: "Fairooz" },
+                        { username: "Dan", invitedById: russell.id },
+                    ],
+                    returning: ["username", "invitedById"],
+                });
+                expect(others).toEqual([
+                    { username: "Fairooz", invitedById: null },
+                    { username: "Dan", invitedById: russell.id },
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { ReturningClause } from "../../clauses/ReturningClause";
+import { CreateValues } from "./CreateOneParams";
+
+export type CreateManyParams<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = {
+    values: CreateValues<Models, M>[];
+    returning?: ReturningClause<Models[M]>;
+    onConflict?: {
+        do: "nothing";
+    };
+};

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

@@ -0,0 +1,17 @@
+import { ColumnType } from "../../../schema/types/helpers/ColumnType";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { ReturningClause } from "../../clauses/ReturningClause";
+import { CreateManyParams } from "./CreateManyParams";
+import { CreateOneParams } from "./CreateOneParams";
+
+export type CreateManyResult<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    P extends CreateOneParams<Models, M> | CreateManyParams<Models, M>,
+> =
+    P["returning"] extends ReturningClause<Models[M]>
+        ? Readonly<{
+              [C in P["returning"][number]]: ColumnType<Models, M, C>;
+          }>[]
+        : number;

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

@@ -0,0 +1,22 @@
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { Simplify } from "../../../types/util/Simplify";
+import { ReturningClause } from "../../clauses/ReturningClause";
+import { OptionalParams } from "../../clauses/helpers/OptionalParams";
+import { RequiredParams } from "../../clauses/helpers/RequiredParams";
+
+export type CreateValues<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = Simplify<RequiredParams<Models, M> & OptionalParams<Models, M>>;
+
+export type CreateOneParams<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+> = {
+    values: CreateValues<Models, M>;
+    returning?: ReturningClause<Models[M]>;
+    onConflict?: {
+        do: "nothing";
+    };
+};

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

@@ -0,0 +1,17 @@
+import { ColumnType } from "../../../schema/types/helpers/ColumnType";
+import { ModelName } from "../../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
+import { SelectClause } from "../../clauses/SelectClause";
+import { CreateManyParams } from "./CreateManyParams";
+import { CreateOneParams } from "./CreateOneParams";
+
+export type CreateOneResult<
+    Models extends LooseModelDefinitions,
+    M extends ModelName<Models>,
+    P extends CreateOneParams<Models, M> | CreateManyParams<Models, M>,
+> =
+    P["returning"] extends SelectClause<Models[M]>
+        ? Readonly<{
+              [C in P["returning"][number]]: ColumnType<Models, M, C>;
+          }>
+        : number;