@casekit/orm2 0.0.0-20250322230249

package/build/types/UpdateOneResult.d.ts

@@ -0,0 +1,5 @@
+import { FieldType, ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
+import { UpdateParams } from "./UpdateParams.js";
+export type UpdateOneResult<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>, Q extends UpdateParams<Models, Operators, M>> = Q["returning"] extends NonNullable<Q["returning"]> ? {
+    [C in Q["returning"][number]]: FieldType<Models[M], C>;
+} : number;

package/build/types/UpdateOneResult.js

@@ -0,0 +1 @@
+export {};

package/build/types/UpdateOneResult.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/UpdateOneResult.test-d.js

@@ -0,0 +1,15 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("UpdateOneResult", () => {
+    test("returns count when no returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns array of selected fields when returning clause present", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles complex field types", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("does not allow invalid field names in returning clause", () => {
+        let _;
+    });
+});

package/build/types/UpdateParams.d.ts

@@ -0,0 +1,9 @@
+import { ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
+import { ReturningClause } from "./ReturningClause.js";
+import { UpdateValues } from "./UpdateValues.js";
+import { WhereClause } from "./WhereClause.js";
+export type UpdateParams<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>> = {
+    set: UpdateValues<Models[M]>;
+    where: WhereClause<Models, Operators, M>;
+    returning?: ReturningClause<Models[M]>;
+};

package/build/types/UpdateParams.js

@@ -0,0 +1 @@
+export {};

package/build/types/UpdateParams.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/UpdateParams.test-d.js

@@ -0,0 +1,29 @@
+import { describe, test } from "vitest";
+describe("UpdateParams", () => {
+    test("basic structure", () => {
+        const _ = {
+            set: { title: "hello world" },
+            where: { authorId: 1 },
+            returning: ["id", "title"],
+        };
+    });
+    test("returning clause is optional", () => {
+        const _ = {
+            set: { content: "hello" },
+            where: { id: 1 },
+        };
+    });
+    test("handles complex field types", () => {
+        const _ = {
+            set: { tags: ["hello", "world"], deletedAt: null },
+            where: { title: "hello" },
+            returning: ["id", "tags", "deletedAt"],
+        };
+    });
+    test("rejects invalid field names", () => {
+        const _ = {
+            // @ts-expect-error invalid field
+            invalid: "wrong",
+        };
+    });
+});

package/build/types/UpdateValues.d.ts

@@ -0,0 +1,6 @@
+import { DeepReadonly } from "ts-essentials";
+import { FieldName, FieldType, ModelDefinition } from "@casekit/orm2-schema";
+import { Simplify } from "@casekit/toolbox";
+export type UpdateValues<Model extends ModelDefinition> = DeepReadonly<Simplify<{
+    [K in FieldName<Model>]?: FieldType<Model, K>;
+}>>;

package/build/types/UpdateValues.js

@@ -0,0 +1 @@
+export {};

package/build/types/UpdateValues.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/UpdateValues.test-d.js

@@ -0,0 +1,33 @@
+import { describe, test } from "vitest";
+describe("UpdateValues", () => {
+    test("all fields are optional", () => {
+        const _ = {};
+    });
+    test("handles nullable fields", () => {
+        const _ = {
+            backgroundColorValue: null,
+        };
+    });
+    test("handles arrays", () => {
+        const _ = {
+            tags: ["a", "b", "c"],
+        };
+    });
+    test("handles jsonb fields", () => {
+        const _ = {
+            metadata: {
+                foo: "a",
+                bar: [
+                    { baz: "good", quux: true },
+                    { baz: "bad", quux: false },
+                ],
+            },
+        };
+    });
+    test("rejects invalid field names", () => {
+        const _ = {
+            // @ts-expect-error invalid field
+            invalid: "wrong",
+        };
+    });
+});

package/build/types/WhereClause.d.ts

@@ -0,0 +1,29 @@
+import { DeepReadonly } from "ts-essentials";
+import { FieldName, FieldType, ModelDefinition, ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
+import { $and, $eq, $gt, $gte, $ilike, $in, $is, $like, $lt, $lte, $ne, $not, $or } from "#operators.js";
+export interface DefaultOperators<T> {
+    [$eq]?: T;
+    [$ne]?: T;
+    [$not]?: null | true | false;
+    [$is]?: null | true | false;
+    [$gt]?: T;
+    [$gte]?: T;
+    [$lt]?: T;
+    [$lte]?: T;
+    [$in]?: T[];
+    [$like]?: string;
+    [$ilike]?: string;
+}
+export type ReadonlyArrays<T> = T extends (infer E)[] ? readonly E[] : T extends Date ? Date : T extends object ? {
+    readonly [K in keyof T]: ReadonlyArrays<T[K]>;
+} : T;
+export type WhereClauseValue<Model extends ModelDefinition, Operators extends OperatorDefinitions, C extends FieldName<Model>, T = DeepReadonly<FieldType<Model, C>>> = T | null | DefaultOperators<T> | (Operators["where"] extends never ? never : {
+    [K in Extract<keyof Operators["where"], symbol>]?: Parameters<NonNullable<Operators["where"]>[K]>[1];
+});
+export type WhereClause<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>, _Model extends ModelDefinition = Models[M]> = {
+    [C in FieldName<_Model>]?: WhereClauseValue<_Model, Operators, C>;
+} & {
+    [$and]?: Array<WhereClause<Models, Operators, M>>;
+    [$or]?: Array<WhereClause<Models, Operators, M>>;
+    [$not]?: WhereClause<Models, Operators, M>;
+};

package/build/types/WhereClause.js

@@ -0,0 +1 @@
+import { $and, $eq, $gt, $gte, $ilike, $in, $is, $like, $lt, $lte, $ne, $not, $or, } from "#operators.js";

package/build/types/WhereClause.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/WhereClause.test-d.js

@@ -0,0 +1,137 @@
+import { describe, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { $and, $gt, $gte, $ilike, $in, $is, $like, $lt, $not, $or, } from "#operators.js";
+describe("WhereClause", () => {
+    test("basic value comparisons", () => {
+        const _ = {
+            name: "John",
+            createdAt: { [$gt]: new Date("2000-01-01") },
+        };
+    });
+    test("logical operators", () => {
+        const _ = {
+            [$or]: [
+                { name: { [$like]: "John%" } },
+                {
+                    [$and]: [
+                        { createdAt: { [$gte]: new Date("2000-01-01") } },
+                        { createdAt: { [$lt]: new Date("2024-01-01") } },
+                    ],
+                },
+            ],
+        };
+    });
+    test("null checks with $is", () => {
+        const _ = {
+            name: { [$is]: null },
+            createdAt: { [$is]: null },
+        };
+    });
+    test("null checks with $not", () => {
+        const _ = {
+            name: { [$is]: null },
+            createdAt: { [$not]: null },
+        };
+    });
+    test("boolean checks with $is", () => {
+        const _ = {
+            name: { [$is]: null },
+            createdAt: { [$is]: false },
+        };
+    });
+    test("boolean checks with $not", () => {
+        const _ = {
+            name: { [$is]: null },
+            createdAt: { [$not]: true },
+        };
+    });
+    test("string operations", () => {
+        const _ = {
+            name: {
+                [$like]: "%doe%",
+                [$ilike]: "JOHN%",
+            },
+            email: { [$in]: ["john@example.com", "jane@example.com"] },
+        };
+    });
+    test("compound conditions", () => {
+        const _ = {
+            [$and]: [
+                {
+                    createdAt: {
+                        [$gte]: new Date("2000-01-01"),
+                        [$lt]: new Date("2024-01-01"),
+                    },
+                },
+                {
+                    [$or]: [
+                        { email: { [$like]: "%@company.com" } },
+                        { role: { [$in]: ["admin", "user"] } },
+                    ],
+                },
+            ],
+        };
+    });
+    test("custom operators", () => {
+        const $startswith = Symbol("startswith");
+        const operators = {
+            where: {
+                [$startswith]: ({ table, column }, value) => sql `${table}.${column} LIKE ${value}%`,
+            },
+        };
+        const _ = {
+            name: { [$startswith]: "John" },
+        };
+    });
+    describe("invalid queries", () => {
+        test("wrong type", () => {
+            const _ = {
+                // @ts-expect-error name should be string
+                name: 621,
+            };
+        });
+        test("non existent column", () => {
+            const _ = {
+                // @ts-expect-error non existent column
+                wrong: "x",
+            };
+        });
+        test("invalid $in value", () => {
+            const _ = {
+                role: {
+                    // @ts-expect-error invalid $in value
+                    [$in]: ["admin", "user", "wrong"],
+                },
+            };
+        });
+        test("invalid $is value", () => {
+            const _ = {
+                name: {
+                    // @ts-expect-error $is only works with null or boolean
+                    [$is]: "test",
+                },
+            };
+        });
+        test("invalid $like value", () => {
+            const _ = {
+                counter: {
+                    // @ts-expect-error $like only works with string
+                    [$like]: 123,
+                },
+            };
+        });
+        test("invalid $and value", () => {
+            const _ = {
+                [$and]: 
+                // @ts-expect-error should be an array
+                { createdAt: { [$gt]: Date } },
+            };
+        });
+        test("invalid $not value", () => {
+            const _ = {
+                // @ts-expect-error $not should take an object, not an array
+                [$not]: [{ age: 21 }],
+            };
+        });
+    });
+});

package/build/util/getIncludedToManySubqueries.d.ts

@@ -0,0 +1,12 @@
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinition, OperatorDefinitions } from "@casekit/orm2-schema";
+import { FindParams } from "../types/FindParams.js";
+export type ToManyRelationSubquery = {
+    query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>;
+    modelName: string;
+    from: string[];
+    to: string[];
+    path: string[];
+    extract: (rows: Record<string, unknown>[]) => unknown[];
+};
+export declare const getIncludedToManySubqueries: (config: NormalizedConfig, modelName: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>, path?: string[]) => ToManyRelationSubquery[];

package/build/util/getIncludedToManySubqueries.js

@@ -0,0 +1,63 @@
+import { identity } from "es-toolkit";
+import { getModel, getRelation } from "@casekit/orm2-config";
+export const getIncludedToManySubqueries = (config, modelName, query, path = []) => {
+    const relationQueries = [];
+    for (const [relationName, subquery] of Object.entries(query.include ?? {})) {
+        const model = getModel(config.models, modelName);
+        const relation = getRelation(model, relationName);
+        if (relation.type === "1:N") {
+            relationQueries.push({
+                modelName: relation.model,
+                query: subquery,
+                from: relation.from.fields,
+                to: relation.to.fields,
+                extract: identity,
+                path: [...path, relation.name],
+            });
+        }
+        else if (relation.type === "N:N") {
+            // for N:N relations, we create a lateral join from the parent model
+            // to the join model via its 'fromRelation', rather than directly tothe relation
+            // model itself.
+            const throughModel = getModel(config.models, relation.through.model);
+            const fromRelation = getRelation(throughModel, relation.through.fromRelation);
+            if (fromRelation.type !== "N:1") {
+                throw new Error(`Expected relation ${relation.through.fromRelation} to be a N:1 relation, but got ${fromRelation.type}`);
+            }
+            const toRelation = getRelation(throughModel, relation.through.toRelation);
+            if (toRelation.type !== "N:1") {
+                throw new Error(`Expected relation ${relation.through.toRelation} to be a N:1 relation, but got ${toRelation.type}`);
+            }
+            const from = fromRelation.to.fields;
+            const to = fromRelation.from.fields;
+            // instead of querying directly for the relation model,
+            // we wrap the query in a query of the join model and
+            // include the query of the relation model as a 1:N
+            // subquery
+            const query = {
+                select: throughModel.primaryKey.map((k) => k.field),
+                include: {
+                    [toRelation.name]: subquery,
+                },
+            };
+            // because we're going to be running a query on the join model
+            // rather than directly on the relation model, the results
+            // will be for the join model, so we need to map over them
+            // and extract the embedded relation model results.
+            const extract = (rows) => rows.map((r) => r[toRelation.name]);
+            relationQueries.push({
+                modelName: relation.through.model,
+                query,
+                path: [...path, relation.name],
+                from,
+                to,
+                extract,
+            });
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        }
+        else if (relation.type === "N:1") {
+            relationQueries.push(...getIncludedToManySubqueries(config, relation.model, subquery, [...path, relation.name]));
+        }
+    }
+    return relationQueries;
+};

package/build/util/getIncludedToManySubqueries.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/getIncludedToManySubqueries.test.js

@@ -0,0 +1,121 @@
+import { identity } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { createTestDB } from "../tests/util/db.js";
+import { getIncludedToManySubqueries } from "./getIncludedToManySubqueries.js";
+describe("getIncludedToManySubqueries", () => {
+    const { db } = createTestDB();
+    test("returns empty array when no includes specified", () => {
+        const result = getIncludedToManySubqueries(db.config, "user", {
+            select: ["id", "name"],
+        });
+        expect(result).toEqual([]);
+    });
+    test("processes 1:N relations correctly", () => {
+        const result = getIncludedToManySubqueries(db.config, "user", {
+            select: ["id", "name"],
+            include: {
+                posts: {
+                    select: ["id", "title"],
+                    where: { deletedAt: null },
+                },
+            },
+        });
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            modelName: "post",
+            from: ["id"],
+            to: ["authorId"],
+            path: ["posts"],
+            query: {
+                select: ["id", "title"],
+                where: { deletedAt: null },
+            },
+        });
+        expect(result[0].extract).toBe(identity);
+    });
+    test("processes N:N relations correctly", () => {
+        const result = getIncludedToManySubqueries(db.config, "user", {
+            select: ["id", "name"],
+            include: {
+                friends: {
+                    select: ["id", "name"],
+                },
+            },
+        });
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            modelName: "friendship",
+            from: ["id"],
+            to: ["userId"],
+            path: ["friends"],
+            query: {
+                select: ["userId", "friendId"],
+                include: {
+                    friend: {
+                        select: ["id", "name"],
+                    },
+                },
+            },
+        });
+        const mockRows = [
+            { friend: { id: 1, name: "Friend 1" } },
+            { friend: { id: 2, name: "Friend 2" } },
+        ];
+        expect(result[0].extract(mockRows)).toEqual([
+            { id: 1, name: "Friend 1" },
+            { id: 2, name: "Friend 2" },
+        ]);
+    });
+    test("processes nested N:1 relations with to-many relations correctly", () => {
+        const result = getIncludedToManySubqueries(db.config, "like", {
+            select: ["id", "userId"],
+            include: {
+                post: {
+                    select: ["id"],
+                    include: {
+                        likes: {
+                            select: ["id", "userId"],
+                        },
+                    },
+                },
+            },
+        });
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            modelName: "like",
+            path: ["post", "likes"],
+            query: {
+                select: ["id", "userId"],
+            },
+        });
+    });
+    test("handles multiple to-many relations at the same level", () => {
+        const result = getIncludedToManySubqueries(db.config, "post", {
+            select: ["id", "title"],
+            include: {
+                likes: {
+                    select: ["id", "userId"],
+                },
+                author: {
+                    select: ["id"],
+                    include: {
+                        posts: {
+                            select: ["id", "title"],
+                        },
+                    },
+                },
+            },
+        });
+        expect(result).toHaveLength(2);
+        expect(result).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                modelName: "like",
+                path: ["likes"],
+            }),
+            expect.objectContaining({
+                modelName: "post",
+                path: ["author", "posts"],
+            }),
+        ]));
+    });
+});

package/build/util/getLateralJoinValues.d.ts

@@ -0,0 +1,4 @@
+export declare const getLateralJoinValues: (results: Record<string, unknown>[], path: string[], from: string[], to: string[]) => {
+    field: string;
+    values: unknown[];
+}[];

package/build/util/getLateralJoinValues.js

@@ -0,0 +1,30 @@
+import { isEqual, isNil, uniqWith } from "es-toolkit";
+import { get } from "es-toolkit/compat";
+export const getLateralJoinValues = (results, path, from, to) => {
+    const all = results.flatMap((result) => {
+        const parent = path.length === 0
+            ? result
+            : get(result, path);
+        if (isNil(parent)) {
+            // if the relation is a join from an optional N:1 relation of
+            // the query's top level model, then the value being joined from
+            // make not exist on the result. in that case we can't do a lateral
+            // join so we ignore it.
+            return [];
+        }
+        return [
+            Object.fromEntries(to.map((f, index) => [f, parent[from[index]]])),
+        ];
+    });
+    const unique = uniqWith(all, isEqual);
+    const values = Object.fromEntries(to.map((f) => [f, []]));
+    for (const v of unique) {
+        for (const f of to) {
+            values[f].push(v[f]);
+        }
+    }
+    return to.map((f) => ({
+        field: f,
+        values: values[f] ?? [],
+    }));
+};

package/build/util/getLateralJoinValues.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/getLateralJoinValues.test.js

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "vitest";
+import { getLateralJoinValues } from "./getLateralJoinValues.js";
+describe("getLateralJoinValues", () => {
+    test("should handle flat objects with direct mapping", () => {
+        const results = [
+            { id: 1, name: "John" },
+            { id: 2, name: "Jane" },
+            { id: 2, name: "Jane" }, // Duplicate to test uniqueness
+        ];
+        const result = getLateralJoinValues(results, [], // empty path for top-level properties
+        ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+            {
+                field: "userName",
+                values: ["John", "Jane"],
+            },
+        ]);
+    });
+    test("should handle nested objects with path", () => {
+        const results = [
+            { user: { id: 1, name: "John" } },
+            { user: { id: 2, name: "Jane" } },
+        ];
+        const result = getLateralJoinValues(results, ["user"], ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+            {
+                field: "userName",
+                values: ["John", "Jane"],
+            },
+        ]);
+    });
+    test("should handle missing nested objects", () => {
+        const results = [
+            { user: { id: 1, name: "John" } },
+            { user: null },
+            { user: { id: 2, name: "Jane" } },
+        ];
+        const result = getLateralJoinValues(results, ["user"], ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+            {
+                field: "userName",
+                values: ["John", "Jane"],
+            },
+        ]);
+    });
+    test(" handle deeply nested paths", () => {
+        const results = [
+            { data: { user: { profile: { id: 1, name: "John" } } } },
+            { data: { user: { profile: { id: 2, name: "Jane" } } } },
+        ];
+        const result = getLateralJoinValues(results, ["data", "user", "profile"], ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+            {
+                field: "userName",
+                values: ["John", "Jane"],
+            },
+        ]);
+    });
+    test("should handle empty results array", () => {
+        const results = [];
+        const result = getLateralJoinValues(results, ["user"], ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [],
+            },
+            {
+                field: "userName",
+                values: [],
+            },
+        ]);
+    });
+    test("should handle single field mapping", () => {
+        const results = [{ id: 1 }, { id: 2 }];
+        const result = getLateralJoinValues(results, [], ["id"], ["userId"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+        ]);
+    });
+});

package/build/util/hasClauses.d.ts

@@ -0,0 +1 @@
+export declare const hasClauses: <T>(clause: T) => clause is NonNullable<T>;

package/build/util/hasClauses.js

@@ -0,0 +1,9 @@
+export const hasClauses = (clause) => {
+    if (clause === null || clause === undefined || typeof clause !== "object")
+        return false;
+    const keys = [
+        ...Object.keys(clause),
+        ...Object.getOwnPropertySymbols(clause),
+    ];
+    return keys.length > 0;
+};

package/build/util/hasClauses.test.d.ts

@@ -0,0 +1 @@
+export {};