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

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

package/src/queries/delete/buildDelete.ts

@@ -1,56 +0,0 @@
-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: { table: 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: {
-            table: 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

@@ -1,23 +0,0 @@
-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.nullish().transform((x) => x ?? null)
-            : col.zodSchema;
-    });
-
-    return z.object(obj);
-};

package/src/queries/delete/deleteToSql.ts

@@ -1,48 +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 { DeleteBuilder } from "./buildDelete";
-
-export const deleteToSql = (
-    config: BaseConfiguration,
-    m: string,
-    builder: DeleteBuilder,
-): SQLStatement => {
-    const { table, where, returning } = builder;
-
-    const frag = sql`DELETE FROM %I.%I AS %I`.withIdentifiers(
-        table.schema,
-        table.table,
-        table.alias,
-    );
-
-    if (!hasConditions(where)) {
-        throw new OrmError(`No where clause provided for delete`, {
-            data: {
-                table,
-                where,
-                returning,
-            },
-        });
-    }
-    frag.push("\nWHERE\n    ");
-    frag.push(buildWhereClauses(config, table, where));
-
-    if (returning.length > 0) {
-        frag.push("\nRETURNING\n");
-        frag.push(
-            returning
-                .map((r) =>
-                    pgfmt(`    %I.%I as %I`, table.alias, r.name, r.alias),
-                )
-                .join(",\n"),
-        );
-    }
-    frag.push(";\n");
-
-    return frag;
-};

package/src/queries/delete/tests/deleteOne.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { OrmError } from "../../../errors";
-import { db } from "../../../test/db";
-import { seed } from "../../../test/seed";
-import { $like } from "../../clauses/where/operators";
-
-describe("deleteOne", () => {
-    test("it deletes a single record in the database", async () => {
-        await db.transact(
-            async (db) => {
-                const { posts } = await seed(db, {
-                    users: [
-                        {
-                            username: "Stewart House",
-                            tenants: [{ name: "Popova Park", posts: 3 }],
-                        },
-                    ],
-                });
-
-                const deleted = await db.deleteOne("post", {
-                    where: { title: "Post a" },
-                    returning: ["id"],
-                });
-
-                expect(deleted.id).toEqual(
-                    posts.find((p) => p.title === "Post a")?.id,
-                );
-
-                const results = await db.findMany("post", {
-                    select: ["id", "title"],
-                    include: {
-                        author: {
-                            select: ["id", "username"],
-                            where: { username: { [$like]: "Stewart %" } },
-                        },
-                    },
-                });
-
-                expect(results.map((p) => p.title)).toEqual([
-                    "Post b",
-                    "Post c",
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("if no records are deleted, it throws an error and rolls back to before the delete", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Stewart House",
-                            tenants: [{ name: "Popova Park", posts: 3 }],
-                        },
-                    ],
-                });
-
-                await expect(
-                    db.deleteOne("post", {
-                        where: { title: "Wrong" },
-                        returning: ["id"],
-                    }),
-                ).rejects.toEqual(new OrmError("No rows deleted"));
-            },
-            { rollback: true },
-        );
-    });
-
-    test("if multiple records are deleted, it throws an error and rolls back to before the delete", async () => {
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Stewart House",
-                            tenants: [{ name: "Popova Park", posts: 3 }],
-                        },
-                        {
-                            username: "Stewart Home",
-                            tenants: [{ name: "Popova Park", posts: 3 }],
-                        },
-                    ],
-                });
-
-                await expect(
-                    db.deleteOne("post", {
-                        where: { title: { [$like]: "Post%" } },
-                        returning: ["id"],
-                    }),
-                ).rejects.toEqual(
-                    new OrmError(
-                        "More than one deleted row for deleteOne, rolling back",
-                    ),
-                );
-
-                const result = await db.findMany("post", {
-                    select: ["id"],
-                });
-
-                expect(result.length).toEqual(6);
-            },
-            { rollback: true },
-        );
-    });
-});

package/src/queries/delete/types/BaseDeleteParams.ts

@@ -1,9 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
-import { WhereClause } from "../../clauses/WhereClause";
-
-export type BaseDeleteParams = {
-    where: WhereClause<LooseModelDefinitions, ModelName<LooseModelDefinitions>>;
-    returning?: NonEmptyArray<string>;
-};

package/src/queries/delete/types/DeleteManyResult.ts

@@ -1,16 +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 { DeleteParams } from "./DeleteParams";
-
-export type DeleteManyResult<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-    P extends DeleteParams<Models, M>,
-> =
-    P["returning"] extends ReturningClause<Models[M]>
-        ? Readonly<{
-              [C in P["returning"][number]]: ColumnType<Models, M, C>;
-          }>[]
-        : number;

package/src/queries/delete/types/DeleteOneResult.ts

@@ -1,16 +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 { DeleteParams } from "./DeleteParams";
-
-export type DeleteOneResult<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-    P extends DeleteParams<Models, M>,
-> =
-    P["returning"] extends ReturningClause<Models[M]>
-        ? Readonly<{
-              [C in P["returning"][number]]: ColumnType<Models, M, C>;
-          }>
-        : number;

package/src/queries/delete/types/DeleteParams.ts

@@ -1,12 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { ReturningClause } from "../../clauses/ReturningClause";
-import { WhereClause } from "../../clauses/WhereClause";
-
-export type DeleteParams<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = {
-    where: WhereClause<Models, M>;
-    returning?: ReturningClause<Models[M]>;
-};

package/src/queries/deleteMany.ts

@@ -1,33 +0,0 @@
-import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
-
-import { Connection } from "../Connection";
-import { logger } from "../logger";
-import { buildDelete } from "./delete/buildDelete";
-import { deleteToSql } from "./delete/deleteToSql";
-import { BaseDeleteParams } from "./delete/types/BaseDeleteParams";
-import { rowToObject } from "./util/rowToObject";
-
-export const deleteMany = async (
-    conn: Connection,
-    config: BaseConfiguration,
-    m: string,
-    params: BaseDeleteParams,
-) => {
-    const builder = buildDelete(config, m, params);
-    const statement = deleteToSql(config, m, builder);
-    logger.info({
-        message: "Executing delete",
-        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 ?? 0;
-};

package/src/queries/deleteOne.ts

@@ -1,32 +0,0 @@
-import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
-
-import { Connection } from "../Connection";
-import { OrmError } from "../errors";
-import { BaseDeleteParams } from "./delete/types/BaseDeleteParams";
-import { deleteMany } from "./deleteMany";
-
-export const deleteOne = async (
-    conn: Connection,
-    config: BaseConfiguration,
-    m: string,
-    params: BaseDeleteParams,
-) => {
-    return await conn.transact(async (conn) => {
-        const results = await deleteMany(conn, config, m, params);
-        const deletedCount =
-            typeof results === "number" ? results : results?.length ?? 0;
-
-        if (deletedCount === 0) {
-            throw new OrmError("No rows deleted", { data: { m, params } });
-        }
-
-        if (deletedCount > 1) {
-            throw new OrmError(
-                "More than one deleted row for deleteOne, rolling back",
-                { data: { m, params, deletedCount } },
-            );
-        }
-
-        return typeof results === "number" ? results : results[0];
-    });
-};

package/src/queries/find/buildFind.ts

@@ -1,137 +0,0 @@
-import { max, min, uniq } from "lodash-es";
-import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
-
-import { ensureArray } from "../../util/ensureArray";
-import { tableAlias } from "../util/tableAlias";
-import { BaseFindParams } from "./types/BaseFindParams";
-import { FindBuilder } from "./types/FindBuilder";
-
-export const buildFind = (
-    config: BaseConfiguration,
-    m: string,
-    query: BaseFindParams,
-    path: string[] = [],
-    _tableIndex = 0,
-): FindBuilder => {
-    const builder: FindBuilder = {
-        columns: [],
-        table: {
-            table: config.models[m]["table"],
-            model: m,
-            schema: config.models[m]["schema"],
-            alias: tableAlias(_tableIndex++),
-            where: config.middleware.find?.where
-                ? config.middleware.find.where(query.where, {
-                      config,
-                      model: m,
-                  })
-                : query.where,
-            joins: [],
-        },
-        orderBy: [],
-        tableIndex: _tableIndex,
-    };
-
-    const model = config.models[m];
-
-    const alias = builder.table.alias;
-    let colIndex = 0;
-
-    // make sure we always select the model's primary key,
-    // and if necessary the foreign key for a lateral join
-    // - we'll strip them out later
-    const select = uniq([
-        ...query.select,
-        ...model.primaryKey,
-        ...(query.lateralBy ?? []).map(({ column }) => column),
-    ]);
-
-    for (const f of select) {
-        builder.columns.push({
-            table: alias,
-            name: model.columns[f]["name"],
-            alias: `${alias}_${colIndex++}`,
-            path: [...path, f],
-        });
-    }
-
-    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 = buildFind(
-                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,
-                        ),
-                    },
-                    type: relation.optional ? "left" : "inner",
-                    where: joinedTable.where,
-                },
-                ...joinedTable.joins,
-            );
-            // this is admittedly a bit weird,
-            // we wouldn't expect N:1 relations to specify
-            // ordering, skipping, and limiting, and typescript
-            // prevents users from doing this, but
-            // we rely on them being present as part of the N:N
-            // implementation
-            builder.columns.push(...joinBuilder.columns);
-            builder.orderBy.push(...joinBuilder.orderBy);
-            builder.limit = min([builder.limit, joinBuilder.limit]);
-            builder.offset = max([builder.offset, joinBuilder.offset]);
-        }
-    }
-
-    if (query.lateralBy) {
-        builder.lateralBy = {
-            groupTable: tableAlias(builder.tableIndex++),
-            itemTable: tableAlias(builder.tableIndex++),
-            columns: query.lateralBy.map(({ column, values }) => ({
-                column: model.columns[column].name,
-                type: model.columns[column].type,
-                values,
-            })),
-        };
-    }
-
-    if (query.orderBy) {
-        builder.orderBy = query.orderBy.map((o) => ({
-            table: alias,
-            column: Array.isArray(o) ? o[0] : o,
-            direction: Array.isArray(o) ? o[1] : "asc",
-        }));
-    }
-
-    if (query.limit) {
-        builder.limit = query.limit;
-    }
-
-    if (query.offset) {
-        builder.offset = query.offset;
-    }
-
-    return builder;
-};

package/src/queries/find/findResultSchema.ts

@@ -1,32 +0,0 @@
-import { BaseConfiguration } from "src/schema/types/base/BaseConfiguration";
-import { ZodSchema, z } from "zod";
-
-import { BaseFindParams } from "./types/BaseFindParams";
-
-export const findResultSchema = (
-    config: BaseConfiguration,
-    m: string,
-    query: BaseFindParams,
-) => {
-    const obj: Record<string, ZodSchema<unknown>> = {};
-
-    query.select.forEach((field) => {
-        const col = config.models[m].columns[field];
-        obj[field] = col.nullable
-            ? col.zodSchema.nullish().transform((x) => x ?? null)
-            : col.zodSchema;
-    });
-
-    for (const [field, subquery] of Object.entries(query.include || {})) {
-        const relation = config.relations[m][field];
-        const schema = findResultSchema(config, relation.model, subquery!);
-        obj[field] =
-            relation.type === "N:1"
-                ? relation.optional
-                    ? schema.nullish().transform((x) => x ?? null)
-                    : schema
-                : z.array(schema);
-    }
-
-    return z.object(obj);
-};