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

package/src/queries/create/buildCreate.ts

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

@@ -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/createMany.varied-keys.test.ts

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

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

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

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

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

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

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

@@ -1,38 +0,0 @@
-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.ORM_VERBOSE_LOGGING) {
-        console.log(statement.text);
-        console.log(statement.values);
-    }
-
-    const result = await conn.query(statement);
-    return params.returning
-        ? result.rows.map(rowToObject(builder.returning))
-        : result.rowCount;
-};

package/src/queries/createOne.ts

@@ -1,27 +0,0 @@
-import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
-
-import { OrmError } from "..";
-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,
-) => {
-    if (params.onConflict?.do === "nothing" && params.returning) {
-        throw new OrmError(
-            "Cannot use 'returning' with 'onConflict' in createOne",
-            {
-                data: { m, params },
-            },
-        );
-    }
-    const result = await createMany(conn, config, m, {
-        ...params,
-        values: [params.values],
-    });
-    return Array.isArray(result) ? result[0] : result;
-};