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

package/src/queries/find/tests/middleware.find.where.test.ts

@@ -1,467 +0,0 @@
-import { snakeCase } from "lodash-es";
-import pg from "pg";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-
-import { orm } from "../../../orm";
-import { models, relations } from "../../../test/db";
-import { seed } from "../../../test/seed";
-import { $not } from "../../clauses/where/operators";
-import { Middleware } from "../../middleware/Middleware";
-
-export const timestamps: Middleware = {
-    create: {
-        values: (values, { model, config }) => {
-            if ("createdAt" in config.models[model].columns) {
-                return {
-                    createdAt: new Date(),
-                    ...values,
-                };
-            }
-            return values;
-        },
-    },
-    update: {
-        set: (set, { model, config }) => {
-            if ("updatedAt" in config.models[model].columns) {
-                return {
-                    updatedAt: new Date(),
-                    ...set,
-                };
-            } else {
-                return set;
-            }
-        },
-    },
-};
-
-export const softdelete: Middleware = {
-    where: (where, { model, config }) => {
-        if ("deletedAt" in config.models[model].columns) {
-            return {
-                deletedAt: null,
-                ...where,
-            };
-        } else {
-            return where;
-        }
-    },
-    delete: {
-        deleteOne: (params, { model, config, deleteOne, updateOne }) => {
-            if ("deletedAt" in config.models[model].columns) {
-                return updateOne({
-                    ...params,
-                    set: {
-                        deletedAt: new Date(),
-                    },
-                });
-            } else return deleteOne(params);
-        },
-        deleteMany: (params, { model, config, deleteMany, updateMany }) => {
-            if ("deletedAt" in config.models[model].columns) {
-                return updateMany({
-                    ...params,
-                    set: {
-                        deletedAt: new Date(),
-                    },
-                });
-            } else return deleteMany(params);
-        },
-    },
-};
-
-describe("middleware.find.where", () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-
-    test("it allows modifying the query object before a find operation", async () => {
-        const db = orm({
-            models,
-            relations,
-            extensions: ["uuid-ossp"],
-            naming: { column: snakeCase },
-            schema: "casekit",
-            middleware: [softdelete],
-            pool: new pg.Pool(),
-        });
-        await db.transact(
-            async (db) => {
-                const { users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Lynne Tillman",
-                            tenants: [{ name: "Popova Park", posts: 2 }],
-                        },
-                    ],
-                });
-
-                const lynne = users["Lynne Tillman"];
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title"],
-                        where: { authorId: lynne.id },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([{ title: "Post a" }, { title: "Post b" }]);
-
-                await db.updateMany("post", {
-                    set: { deletedAt: new Date() },
-                    where: { authorId: lynne.id },
-                });
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title"],
-                        where: { authorId: lynne.id },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("it applies to N:1 relations", async () => {
-        const db = orm({
-            models,
-            relations,
-            extensions: ["uuid-ossp"],
-            naming: { column: snakeCase },
-            schema: "casekit",
-            middleware: [softdelete],
-            pool: new pg.Pool(),
-        });
-        await db.transact(
-            async (db) => {
-                const { users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Lynne Tillman",
-                            tenants: [{ name: "Popova Park", posts: 2 }],
-                        },
-                    ],
-                });
-
-                const lynne = users["Lynne Tillman"];
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title"],
-                        where: { authorId: lynne.id },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([{ title: "Post a" }, { title: "Post b" }]);
-
-                await db.updateOne("user", {
-                    set: { deletedAt: new Date() },
-                    where: { id: lynne.id },
-                });
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title"],
-                        include: { author: { select: ["username"] } },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("it applies to 1:N relations", async () => {
-        const db = orm({
-            models,
-            relations,
-            extensions: ["uuid-ossp"],
-            naming: { column: snakeCase },
-            schema: "casekit",
-            middleware: [softdelete],
-            pool: new pg.Pool(),
-        });
-        await db.transact(
-            async (db) => {
-                const { users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Lynne Tillman",
-                            tenants: [{ name: "Popova Park", posts: 2 }],
-                        },
-                    ],
-                });
-
-                const lynne = users["Lynne Tillman"];
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title"],
-                        where: { authorId: lynne.id },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([{ title: "Post a" }, { title: "Post b" }]);
-
-                await db.updateOne("post", {
-                    set: { deletedAt: new Date() },
-                    where: { title: "Post a" },
-                });
-
-                expect(
-                    await db.findOne("user", {
-                        select: ["username"],
-                        include: { posts: { select: ["title"] } },
-                        where: { id: lynne.id },
-                    }),
-                ).toEqual({
-                    username: "Lynne Tillman",
-                    posts: [{ title: "Post b" }],
-                });
-            },
-            { rollback: true },
-        );
-    });
-
-    test("it applies to N:N relations", async () => {
-        const db = orm({
-            models,
-            relations,
-            extensions: ["uuid-ossp"],
-            naming: { column: snakeCase },
-            schema: "casekit",
-            middleware: [softdelete],
-            pool: new pg.Pool(),
-        });
-        await db.transact(
-            async (db) => {
-                await seed(db, {
-                    users: [
-                        {
-                            username: "Lynne Tillman",
-                            tenants: [{ name: "Popova Park", posts: 2 }],
-                        },
-                    ],
-                });
-
-                expect(
-                    await db.findMany("tenant", {
-                        select: ["name"],
-                        include: { users: { select: ["username"] } },
-                        orderBy: ["name"],
-                    }),
-                ).toEqual([
-                    {
-                        name: "Popova Park",
-                        users: [{ username: "Lynne Tillman" }],
-                    },
-                ]);
-
-                await db.updateOne("user", {
-                    set: { deletedAt: new Date() },
-                    where: { username: "Lynne Tillman" },
-                });
-
-                expect(
-                    await db.findOne("tenant", {
-                        select: ["name"],
-                        include: { users: { select: ["username"] } },
-                        where: { name: "Popova Park" },
-                    }),
-                ).toEqual({
-                    name: "Popova Park",
-                    users: [],
-                });
-            },
-            { rollback: true },
-        );
-    });
-
-    test("it works even if there is no where clause in the original query", async () => {
-        const db = orm({
-            models,
-            relations,
-            extensions: ["uuid-ossp"],
-            naming: { column: snakeCase },
-            schema: "casekit",
-            middleware: [softdelete],
-            pool: new pg.Pool(),
-        });
-        await db.transact(
-            async (db) => {
-                const { users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Lynne Tillman",
-                            tenants: [{ name: "Popova Park", posts: 2 }],
-                        },
-                    ],
-                });
-
-                const lynne = users["Lynne Tillman"];
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title"],
-                        where: { authorId: lynne.id },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([{ title: "Post a" }, { title: "Post b" }]);
-
-                await db.updateMany("post", {
-                    set: { deletedAt: new Date() },
-                    where: { authorId: lynne.id },
-                });
-
-                expect(
-                    await db.findMany("post", { select: ["title"] }),
-                ).toEqual([]);
-            },
-            { rollback: true },
-        );
-    });
-
-    test("multilpe middlewares can be applied", async () => {
-        const db = orm({
-            models,
-            relations,
-            extensions: ["uuid-ossp"],
-            naming: { column: snakeCase },
-            schema: "casekit",
-            middleware: [softdelete, timestamps],
-            pool: new pg.Pool(),
-        });
-
-        await db.transact(
-            async (db) => {
-                const { users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Lynne Tillman",
-                            tenants: [{ name: "Popova Park", posts: 2 }],
-                        },
-                    ],
-                });
-
-                vi.setSystemTime(new Date("2022-05-23"));
-                const lynne = users["Lynne Tillman"];
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title", "updatedAt"],
-                        where: { authorId: lynne.id },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([
-                    { title: "Post a", updatedAt: null },
-                    { title: "Post b", updatedAt: null },
-                ]);
-
-                await db.updateMany("post", {
-                    set: { title: "Post AAAAAA" },
-                    where: { authorId: lynne.id, title: "Post a" },
-                });
-                await db.updateMany("post", {
-                    set: { deletedAt: new Date() },
-                    where: { authorId: lynne.id, title: "Post b" },
-                });
-
-                // updatedAt field has been set by the timestamps middleware
-                // and Post b is not returned by the query because of the softdelete middleware
-                expect(
-                    await db.findMany("post", {
-                        select: ["title", "updatedAt"],
-                    }),
-                ).toEqual([
-                    {
-                        title: "Post AAAAAA",
-                        updatedAt: new Date("2022-05-23"),
-                    },
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-    test("it allows overriding deleteOne and deleteMany functions", async () => {
-        const db = orm({
-            models,
-            relations,
-            extensions: ["uuid-ossp"],
-            naming: { column: snakeCase },
-            schema: "casekit",
-            middleware: [softdelete, timestamps],
-            pool: new pg.Pool(),
-        });
-        await db.transact(
-            async (db) => {
-                const { users } = await seed(db, {
-                    users: [
-                        {
-                            username: "Lynne Tillman",
-                            tenants: [{ name: "Popova Park", posts: 2 }],
-                        },
-                    ],
-                });
-
-                const lynne = users["Lynne Tillman"];
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title", "updatedAt"],
-                        where: { authorId: lynne.id },
-                        orderBy: ["title"],
-                    }),
-                ).toEqual([
-                    { title: "Post a", updatedAt: null },
-                    { title: "Post b", updatedAt: null },
-                ]);
-
-                vi.setSystemTime(new Date("2022-05-23"));
-
-                await db.deleteMany("post", {
-                    where: { authorId: lynne.id, title: "Post a" },
-                });
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title", "updatedAt", "deletedAt"],
-                        where: { deletedAt: { [$not]: null } },
-                    }),
-                ).toEqual([
-                    {
-                        title: "Post a",
-                        updatedAt: new Date("2022-05-23"),
-                        deletedAt: new Date("2022-05-23"),
-                    },
-                ]);
-
-                vi.setSystemTime(new Date("2022-05-24"));
-
-                await db.deleteOne("post", {
-                    where: { authorId: lynne.id, title: "Post b" },
-                });
-
-                expect(
-                    await db.findMany("post", {
-                        select: ["title", "updatedAt", "deletedAt"],
-                        where: { deletedAt: { [$not]: null } },
-                    }),
-                ).toEqual([
-                    {
-                        title: "Post a",
-                        updatedAt: new Date("2022-05-23"),
-                        deletedAt: new Date("2022-05-23"),
-                    },
-                    {
-                        title: "Post b",
-                        updatedAt: new Date("2022-05-24"),
-                        deletedAt: new Date("2022-05-24"),
-                    },
-                ]);
-            },
-            { rollback: true },
-        );
-    });
-});

package/src/queries/find/types/BaseFindParams.ts

@@ -1,18 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { LateralByClause } from "../../clauses/LateralByClause";
-import { WhereClause } from "../../clauses/WhereClause";
-
-export type BaseFindParams = {
-    select: string[];
-    include?: Partial<Record<string, Omit<BaseFindParams, "for">>>;
-    where?: WhereClause<
-        LooseModelDefinitions,
-        ModelName<LooseModelDefinitions>
-    >;
-    limit?: number;
-    offset?: number;
-    lateralBy?: LateralByClause;
-    for?: "update" | "no key update" | "share" | "key share";
-    orderBy?: (string | [string, "asc" | "desc"])[];
-};

package/src/queries/find/types/FindBuilder.ts

@@ -1,73 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { WhereClause } from "../../clauses/WhereClause";
-
-export type FindBuilder = {
-    tableIndex: number;
-
-    columns: {
-        table: string;
-        name: string;
-        alias: string;
-        path: string[];
-    }[];
-
-    table: {
-        table: string;
-        model: string;
-        schema: string;
-        alias: string;
-        joins: Join[];
-        conditions?: WhereClause<
-            LooseModelDefinitions,
-            ModelName<LooseModelDefinitions>
-        >;
-        where?: WhereClause<
-            LooseModelDefinitions,
-            ModelName<LooseModelDefinitions>
-        >;
-    };
-
-    lateralBy?: {
-        groupTable: string;
-        itemTable: string;
-        columns: {
-            column: string;
-            type: string;
-            values: unknown[];
-        }[];
-    };
-
-    for?: "update" | "no key update" | "share" | "key share";
-
-    orderBy: {
-        table: string;
-        column: string;
-        direction: "asc" | "desc";
-    }[];
-
-    limit?: number;
-
-    offset?: number;
-};
-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/find/types/FindManyParams.ts

@@ -1,24 +0,0 @@
-import { ColumnName } from "../../../schema/types/helpers/ColumnName";
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
-import { NonEmptyArray } from "../../../types/util/NonEmptyArray";
-import { IncludeClause } from "../../clauses/IncludeClause";
-import { SelectClause } from "../../clauses/SelectClause";
-import { WhereClause } from "../../clauses/WhereClause";
-
-export type FindManyParams<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-> = {
-    select: SelectClause<Models[M]>;
-    include?: IncludeClause<Models, Relations, M>;
-    where?: WhereClause<Models, M>;
-    limit?: number;
-    offset?: number;
-    orderBy?: NonEmptyArray<
-        ColumnName<Models[M]> | [ColumnName<Models[M]>, "asc" | "desc"]
-    >;
-    for?: "update" | "no key update" | "share" | "key share";
-};

package/src/queries/find/types/FindManyResult.ts

@@ -1,13 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
-import { Simplify } from "../../../types/util/Simplify";
-import { FindManyParams } from "./FindManyParams";
-import { FindOneResult } from "./FindOneResult";
-
-export type FindManyResult<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-    Q extends FindManyParams<Models, Relations, M>,
-> = Simplify<FindOneResult<Models, Relations, M, Q>[]>;

package/src/queries/find/types/FindOneParams.ts

@@ -1,17 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
-import { IncludeClause } from "../../clauses/IncludeClause";
-import { SelectClause } from "../../clauses/SelectClause";
-import { WhereClause } from "../../clauses/WhereClause";
-
-export type FindOneParams<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-> = {
-    select: SelectClause<Models[M]>;
-    where?: WhereClause<Models, M>;
-    include?: IncludeClause<Models, Relations, M>;
-    for?: "update" | "no key update" | "share" | "key share";
-};

package/src/queries/find/types/FindOneResult.ts

@@ -1,50 +0,0 @@
-import { ColumnType } from "../../../schema/types/helpers/ColumnType";
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
-import { Simplify } from "../../../types/util/Simplify";
-import { IncludedRelationModel } from "../../clauses/include/IncludedRelationModel";
-import { IncludedRelationName } from "../../clauses/include/IncludedRelationName";
-import { IncludedRelationQuery } from "../../clauses/include/IncludedRelationQuery";
-import { FindManyParams } from "./FindManyParams";
-import { FindOneParams } from "./FindOneParams";
-
-export type FindOneResult<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-    Q extends
-        | FindManyParams<Models, Relations, M>
-        | FindOneParams<Models, Relations, M>,
-> = Readonly<
-    Simplify<
-        {
-            [C in Extract<Q["select"][number], string>]: ColumnType<
-                Models,
-                M,
-                C
-            >;
-        } & (undefined extends Q["include"]
-            ? unknown
-            : {
-                  [R in IncludedRelationName<
-                      Models,
-                      Relations,
-                      M,
-                      Q
-                  >]: Relations[M][R] extends { type: "N:1" }
-                      ? FindOneResult<
-                            Models,
-                            Relations,
-                            IncludedRelationModel<Models, Relations, M, R>,
-                            IncludedRelationQuery<Models, Relations, M, R, Q>
-                        >
-                      : FindOneResult<
-                            Models,
-                            Relations,
-                            IncludedRelationModel<Models, Relations, M, R>,
-                            IncludedRelationQuery<Models, Relations, M, R, Q>
-                        >[];
-              })
-    >
->;