@casekit/orm 0.0.1-alpha.0

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,31 @@
+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.NODE_ENV === "test" && !process.env.CI)
+        console.log(statement.text);
+
+    const result = await conn
+        .query(statement)
+        .then((result) => result.rows[0].count);
+
+    return result;
+};

package/src/queries/create/buildCreate.ts

@@ -0,0 +1,62 @@
+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: { name: string; schema: string };
+    params: { name: string; path: string; values: unknown[] }[];
+    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: {
+            name: 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++}`,
+        });
+    }
+
+    return builder;
+};

package/src/queries/create/createResultSchema.ts

@@ -0,0 +1,22 @@
+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.nullable() : col.zodSchema;
+    });
+
+    return z.object(obj);
+};

package/src/queries/create/createToSql.ts

@@ -0,0 +1,36 @@
+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.name),
+        );
+    } else {
+        frag.push(pgfmt("INSERT INTO %I.%I (\n", table.schema, table.name));
+        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 (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

@@ -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,127 @@
+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 },
+        );
+    });
+});

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

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

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

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

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

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

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,19 @@
+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>;
+};

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;

package/src/queries/createMany.ts

@@ -0,0 +1,36 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../Connection";
+import { logger } from "../logger";
+import { buildCreate } from "./create/buildCreate";
+import { createToSql } from "./create/createToSql";
+import { BaseCreateManyParams } from "./create/types/BaseCreateManyParams";
+import { rowToObject } from "./util/rowToObject";
+
+export const createMany = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    params: BaseCreateManyParams,
+) => {
+    if (params.values.length === 0) {
+        return params.returning ? [] : 0;
+    }
+
+    const builder = buildCreate(config, m, params);
+    const statement = createToSql(builder);
+
+    logger.info({
+        message: "Executing create",
+        sql: statement.text,
+        values: statement.values,
+    });
+
+    if (process.env.NODE_ENV === "test" && !process.env.CI)
+        console.log(statement.text);
+
+    const result = await conn.query(statement);
+    return params.returning
+        ? result.rows.map(rowToObject(builder.returning))
+        : result.rowCount;
+};

package/src/queries/createOne.ts

@@ -0,0 +1,18 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { Connection } from "../Connection";
+import { BaseCreateOneParams } from "./create/types/BaseCreateOneParams";
+import { createMany } from "./createMany";
+
+export const createOne = async (
+    conn: Connection,
+    config: BaseConfiguration,
+    m: string,
+    params: BaseCreateOneParams,
+) => {
+    const result = await createMany(conn, config, m, {
+        ...params,
+        values: [params.values],
+    });
+    return Array.isArray(result) ? result[0] : result;
+};

package/src/queries/delete/buildDelete.ts

@@ -0,0 +1,56 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+
+import { OrmError } from "../../errors";
+import { ModelName } from "../../schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
+import { WhereClause } from "../clauses/WhereClause";
+import { tableAlias } from "../util/tableAlias";
+import { BaseDeleteParams } from "./types/BaseDeleteParams";
+
+export type DeleteBuilder = {
+    tableIndex: number;
+    table: { name: string; model: string; alias: string; schema: string };
+    where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
+    returning: { name: string; path: string; alias: string }[];
+};
+
+export const buildDelete = (
+    config: BaseConfiguration,
+    m: string,
+    params: BaseDeleteParams,
+    _tableIndex = 0,
+): DeleteBuilder => {
+    const builder: DeleteBuilder = {
+        tableIndex: _tableIndex,
+        table: {
+            name: config.models[m].table,
+            schema: config.models[m].schema,
+            model: m,
+            alias: tableAlias(_tableIndex++),
+        },
+        where: config.middleware.delete?.where
+            ? config.middleware.delete.where(params.where, {
+                  config,
+                  model: m,
+              })!
+            : params.where,
+        returning: [],
+    };
+    let colIndex = 0;
+    const model = config.models[m];
+
+    if (Object.keys(builder.where).length === 0) {
+        throw new OrmError("No where clause provided for delete operation", {
+            data: { m, model, params },
+        });
+    }
+
+    for (const f of params.returning ?? []) {
+        builder.returning.push({
+            name: model.columns[f]["name"],
+            path: f,
+            alias: `${builder.table.alias}_${colIndex++}`,
+        });
+    }
+    return builder;
+};

package/src/queries/delete/deleteResultSchema.ts

@@ -0,0 +1,21 @@
+import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
+import { ZodSchema, z } from "zod";
+
+import { BaseDeleteParams } from "./types/BaseDeleteParams";
+
+export const deleteResultSchema = (
+    config: BaseConfiguration,
+    m: string,
+    params: BaseDeleteParams,
+) => {
+    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.nullable() : col.zodSchema;
+    });
+
+    return z.object(obj);
+};