@casekit/orm2 0.0.0-20250322230249

package/build/tests/util/db.js

@@ -0,0 +1,10 @@
+import { config } from "@casekit/orm2-fixtures";
+import { makeFactory } from "@casekit/orm2-testing";
+import { orm } from "#orm.js";
+import { mockLogger } from "./logger.js";
+export const createTestDB = (overrides) => {
+    const logger = mockLogger();
+    const db = orm({ ...config, logger, ...overrides });
+    const factory = makeFactory(db.config);
+    return { db, logger, factory };
+};

package/build/tests/util/logger.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from "@casekit/orm2-schema";
+interface LogEntry {
+    message: unknown;
+    args: unknown[];
+}
+interface LogEntries {
+    debug: LogEntry[];
+    info: LogEntry[];
+    warn: LogEntry[];
+    error: LogEntry[];
+}
+export interface MockLogger extends Logger {
+    get logs(): LogEntries;
+    clear(): void;
+}
+export declare function mockLogger({ silence }?: {
+    silence: boolean;
+}): MockLogger;
+export {};

package/build/tests/util/logger.js

@@ -0,0 +1,40 @@
+/* v8 ignore start */
+export function mockLogger({ silence } = { silence: true }) {
+    const entries = { debug: [], info: [], warn: [], error: [] };
+    return {
+        get logs() {
+            return entries;
+        },
+        clear() {
+            entries.debug.length = 0;
+            entries.info.length = 0;
+            entries.warn.length = 0;
+            entries.error.length = 0;
+        },
+        debug(message, ...args) {
+            if (!silence) {
+                console.debug(message, ...args);
+            }
+            entries.debug.push({ message, args });
+        },
+        info(message, ...args) {
+            if (!silence) {
+                console.info(message, ...args);
+            }
+            entries.info.push({ message, args });
+        },
+        warn(message, ...args) {
+            if (!silence) {
+                console.warn(message, ...args);
+            }
+            entries.warn.push({ message, args });
+        },
+        error(message, ...args) {
+            if (!silence) {
+                console.error(message, ...args);
+            }
+            entries.error.push({ message, args });
+        },
+    };
+}
+/* v8 ignore stop */

package/build/types/BaseFindParams.d.ts

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

package/build/types/BaseFindParams.js

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

package/build/types/CountParams.d.ts

@@ -0,0 +1,16 @@
+import { ModelDefinition, ModelDefinitions, ModelName, OperatorDefinitions, RelationDefinitions } from "@casekit/orm2-schema";
+import { WhereClause } from "./WhereClause.js";
+export type IncludeCountClause<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>, Model extends ModelDefinition = Models[M], Relations extends RelationDefinitions = Model["relations"] extends undefined ? Record<string, never> : NonNullable<Model["relations"]>> = keyof {
+    [R in keyof Relations as Relations[R] extends {
+        type: "N:1";
+    } ? R : never]: true;
+} extends never ? never : {
+    [R in keyof Relations as Relations[R] extends {
+        type: "N:1";
+    } ? R : never]?: CountParams<Models, Operators, Extract<Relations[R]["model"], string>>;
+};
+export interface CountParams<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>> {
+    include?: IncludeCountClause<Models, Operators, M>;
+    where?: WhereClause<Models, Operators, M>;
+    for?: "update" | "no key update" | "share" | "key share";
+}

package/build/types/CountParams.js

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

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

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

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

@@ -0,0 +1,89 @@
+import { describe, test } from "vitest";
+import { $eq } from "#operators.js";
+describe("CountParams", () => {
+    test("empty params", () => {
+        const _ = {};
+    });
+    test("with where clause", () => {
+        const _ = {
+            where: { id: { [$eq]: 1 } },
+        };
+    });
+    test("with include clause", () => {
+        const _ = {
+            include: { author: {} },
+        };
+    });
+    test("with nested include and where", () => {
+        const _ = {
+            include: {
+                author: {
+                    where: { id: { [$eq]: 1 } },
+                },
+            },
+            where: { title: { [$eq]: "test" } },
+        };
+    });
+    test("invalid relation in include", () => {
+        const _ = {
+            include: {
+                // @ts-expect-error invalid relation
+                invalidRelation: {
+                    where: { id: { [$eq]: 1 } },
+                },
+            },
+        };
+    });
+    test("invalid field in where clause", () => {
+        const _ = {
+            where: {
+                // @ts-expect-error invalid field
+                invalidField: { [$eq]: 1 },
+            },
+        };
+    });
+    test("include when model has no relations", () => {
+        const _ = {
+            where: { hex: { [$eq]: "#fff" } },
+            // @ts-expect-error color has no relations
+            include: {
+                foo: {},
+            },
+        };
+    });
+    test("include when model has relations, but no N:1 relations", () => {
+        const _ = {
+            // @ts-expect-error models with no N:1 relations
+            include: {
+                friends: {
+                    where: { id: { [$eq]: 1 } },
+                },
+            },
+        };
+    });
+    test("non-N:1 relations are not allowed in include", () => {
+        const _ = {
+            include: {
+                // @ts-expect-error N:1 relations are not allowed
+                likes: {
+                    where: { id: { [$eq]: 1 } },
+                },
+            },
+        };
+    });
+    test("models with no N:1 relations don't allow include clauses", () => {
+        const _ = {
+            // @ts-expect-error N:N relations are not allowed
+            include: {
+                friends: {
+                    where: { id: { [$eq]: 1 } },
+                },
+            },
+        };
+    });
+    test("allows counting with a for update clause", () => {
+        const _ = {
+            for: "update",
+        };
+    });
+});

package/build/types/CreateManyParams.d.ts

@@ -0,0 +1,11 @@
+import { DeepReadonly } from "ts-essentials";
+import { ModelDefinitions, ModelName } from "@casekit/orm2-schema";
+import { CreateValues } from "./CreateValues.js";
+import { ReturningClause } from "./ReturningClause.js";
+export type CreateManyParams<Models extends ModelDefinitions, M extends ModelName<ModelDefinitions>> = {
+    values: DeepReadonly<CreateValues<Models[M]>[]>;
+    returning?: ReturningClause<Models[M]>;
+    onConflict?: {
+        do: "nothing";
+    };
+};

package/build/types/CreateManyParams.js

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

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

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

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

@@ -0,0 +1,83 @@
+import { describe, test } from "vitest";
+describe("CreateManyParams", () => {
+    test("creating a single value", () => {
+        const _ = {
+            values: [
+                {
+                    title: "Hello world!",
+                    content: "My first post",
+                    authorId: 1,
+                },
+            ],
+            returning: ["id"],
+        };
+    });
+    test("creating multiple values", () => {
+        const _ = {
+            values: [
+                {
+                    title: "Hello world!",
+                    content: "My first post",
+                    authorId: 1,
+                },
+                {
+                    title: "Hello world!",
+                    content: "My first post",
+                    authorId: 1,
+                },
+            ],
+            returning: ["id"],
+        };
+    });
+    test("without a returning clause", () => {
+        const _ = {
+            values: [
+                {
+                    title: "Hello world!",
+                    content: "My first post",
+                    authorId: 1,
+                },
+            ],
+        };
+    });
+    test("with on conflict behaviour specified", () => {
+        const _ = {
+            values: [
+                {
+                    title: "Hello world!",
+                    content: "My first post",
+                    authorId: 1,
+                },
+            ],
+            onConflict: { do: "nothing" },
+        };
+    });
+    test("invalid field in values", () => {
+        const _ = {
+            values: [
+                {
+                    title: "Hello world!",
+                    content: "My first post",
+                    // @ts-expect-error invalid field
+                    invalid: "wrong",
+                },
+            ],
+        };
+    });
+    test("invalid field in returning clause", () => {
+        const _ = {
+            values: [
+                {
+                    title: "Hello world!",
+                    content: "My first post",
+                    authorId: 1,
+                },
+            ],
+            returning: [
+                "id",
+                // @ts-expect-error invalid field
+                "wrong",
+            ],
+        };
+    });
+});

package/build/types/CreateManyResult.d.ts

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

package/build/types/CreateManyResult.js

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

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

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

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

@@ -0,0 +1,22 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("CreateManyResult", () => {
+    test("returns array of objects when returning clause is specified", () => {
+        // Should return an array of objects with id (number), title (string), and createdAt (Date)
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns number when no returning clause is specified", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles nullable fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles complex field types from model definition", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returned object only includes fields specified in returning clause", () => {
+        // Should only include id, not title or content
+        expectTypeOf().toEqualTypeOf();
+        // @ts-expect-error - title is not included in returning clause
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/types/CreateOneParams.d.ts

@@ -0,0 +1,11 @@
+import { DeepReadonly } from "ts-essentials";
+import { ModelDefinitions, ModelName } from "@casekit/orm2-schema";
+import { CreateValues } from "./CreateValues.js";
+import { ReturningClause } from "./ReturningClause.js";
+export type CreateOneParams<Models extends ModelDefinitions, M extends ModelName<ModelDefinitions>> = {
+    values: DeepReadonly<CreateValues<Models[M]>>;
+    returning?: ReturningClause<Models[M]>;
+    onConflict?: {
+        do: "nothing";
+    };
+};

package/build/types/CreateOneParams.js

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

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

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

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

@@ -0,0 +1,56 @@
+import { describe, test } from "vitest";
+describe("CreateOneParams", () => {
+    test("creating a record", () => {
+        const _ = {
+            values: {
+                title: "Hello world!",
+                content: "My first post",
+                authorId: 1,
+            },
+            returning: ["id"],
+        };
+    });
+    test("without a returning clause", () => {
+        const _ = {
+            values: {
+                title: "Hello world!",
+                content: "My first post",
+                authorId: 1,
+            },
+        };
+    });
+    test("with on conflict behaviour specified", () => {
+        const _ = {
+            values: {
+                title: "Hello world!",
+                content: "My first post",
+                authorId: 1,
+            },
+            onConflict: { do: "nothing" },
+        };
+    });
+    test("invalid field in values", () => {
+        const _ = {
+            values: {
+                title: "Hello world!",
+                content: "My first post",
+                // @ts-expect-error invalid field
+                invalid: "wrong",
+            },
+        };
+    });
+    test("invalid field in returning clause", () => {
+        const _ = {
+            values: {
+                title: "Hello world!",
+                content: "My first post",
+                authorId: 1,
+            },
+            returning: [
+                "id",
+                // @ts-expect-error invalid field
+                "wrong",
+            ],
+        };
+    });
+});

package/build/types/CreateOneResult.d.ts

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

package/build/types/CreateOneResult.js

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

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

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

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

@@ -0,0 +1,23 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("CreateOneResult", () => {
+    test("returns object with fields when returning clause specified", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns number when no returning clause specified", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles nullable fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles array fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles json fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returned object only includes fields specified in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+        // @ts-expect-error - title is not included in returning clause
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/types/CreateValues.d.ts

@@ -0,0 +1,6 @@
+import { DeepReadonly } from "ts-essentials";
+import { ModelDefinition } from "@casekit/orm2-schema";
+import { Simplify } from "@casekit/toolbox";
+import { OptionalValues } from "./OptionalValues.js";
+import { RequiredValues } from "./RequiredValues.js";
+export type CreateValues<Model extends ModelDefinition> = DeepReadonly<Simplify<RequiredValues<Model> extends never ? OptionalValues<Model> : OptionalValues<Model> extends never ? RequiredValues<Model> : RequiredValues<Model> & OptionalValues<Model>>>;

package/build/types/CreateValues.js

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

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

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

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

@@ -0,0 +1,60 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("CreateValues", () => {
+    test("combines required and optional fields for post model", () => {
+        const _ = {
+            title: "Hello world",
+            content: "My first post",
+            tags: ["a", "b", "c"],
+            metadata: {
+                foo: "a",
+                bar: [
+                    { baz: "good", quux: true },
+                    { baz: "bad", quux: false },
+                ],
+            },
+            authorId: 1,
+        };
+    });
+    test("enforces required fields", () => {
+        // @ts-expect-error authorId is required
+        const _ = {
+            title: "Hello",
+            content: "World",
+            metadata: { foo: "a", bar: [{ baz: "good", quux: true }] },
+        };
+    });
+    test("allows omitting optional fields", () => {
+        const values = {
+            title: "Hello",
+            content: "World",
+            authorId: 1,
+        };
+        expectTypeOf(values).toEqualTypeOf();
+    });
+    test("handles model with only required fields", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles model with only optional fields", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("nullable fields are optional but typed correctly", () => {
+        const values = {
+            title: "Hello",
+            content: "World",
+            authorId: 1,
+            deletedAt: null,
+        };
+        expectTypeOf(values.deletedAt).toEqualTypeOf();
+    });
+    test("type error for invalid field value types", () => {
+        const _ = {
+            title: "Hello",
+            content: "World",
+            authorId: 1,
+            // @ts-expect-error tags must be string[]
+            tags: "not-an-array",
+            // @ts-expect-error publishedAt must be Date | null
+            deletedAt: "not-a-date",
+        };
+    });
+});

package/build/types/DeleteManyResult.d.ts

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

package/build/types/DeleteManyResult.js

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

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

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

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

@@ -0,0 +1,23 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("DeleteManyResult", () => {
+    test("returns array of objects when returning clause is specified", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns number when no returning clause specified", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles nullable fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles array fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles JSON fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returned objects only include fields specified in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+        // @ts-expect-error - title is not included in returning clause
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/types/DeleteOneResult.d.ts

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

package/build/types/DeleteOneResult.js

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

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

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

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

@@ -0,0 +1,23 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("DeleteOneResult types", () => {
+    test("returns single object when returning clause is specified", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns number when no returning clause specified", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles nullable fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles array fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("handles JSON fields in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returned object only includes fields specified in returning clause", () => {
+        expectTypeOf().toEqualTypeOf();
+        // @ts-expect-error - title is not included in returning clause
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/types/DeleteParams.d.ts

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

package/build/types/DeleteParams.js

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

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

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

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

@@ -0,0 +1,46 @@
+import { describe, test } from "vitest";
+import { $gt } from "#operators.js";
+describe("DeleteParams", () => {
+    test("minimal valid params with just where clause", () => {
+        const _ = {
+            where: { id: 1 },
+        };
+    });
+    test("with returning clause", () => {
+        const _ = {
+            where: { id: 1 },
+            returning: ["id", "title"],
+        };
+    });
+    test("with complex where clause", () => {
+        const _ = {
+            where: { id: 1, title: "hello", publishedAt: null },
+            returning: ["id"],
+        };
+    });
+    test("invalid field in where clause", () => {
+        const _ = {
+            // @ts-expect-error invalid field
+            where: { invalidField: "wrong" },
+        };
+    });
+    test("invalid field in returning clause", () => {
+        const _ = {
+            where: { id: 1 },
+            // @ts-expect-error invalid field
+            returning: ["invalidField"],
+        };
+    });
+    test("where clause is required", () => {
+        // @ts-expect-error where clause is required
+        const _ = {
+            returning: ["id"],
+        };
+    });
+    test("handles operators in where clause", () => {
+        const _ = {
+            where: { title: { [$gt]: "hello" } },
+            returning: ["id"],
+        };
+    });
+});