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

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

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

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

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

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

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

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

@@ -0,0 +1,50 @@
+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>
+                        >[];
+              })
+    >
+>;