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

package/build/types/FindParams.d.ts

@@ -0,0 +1,22 @@
+import { ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm-schema";
+import { IncludeClause } from "./IncludeClause.js";
+import { OrderByClause } from "./OrderByClause.js";
+import { SelectClause } from "./SelectClause.js";
+import { WhereClause } from "./WhereClause.js";
+/**
+ * We have a single FindParams type rather than a FindOneParams and FindManyParams type
+ * even though it's a bit annoying as it allows you to (incorrectly) specify
+ * a limit, offset, and order by in a findOne query. We do this because choosing between
+ * the two different types (which we did originally) in a nested include clause makes our
+ * types around TEN TIMES as slow for a deeply nested query - and dramatically limits the
+ * depth of nesting possible in a query too. It's just not worth it.
+ */
+export interface FindParams<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>> {
+    select: SelectClause<Models[M]>;
+    include?: IncludeClause<Models, Operators, M>;
+    where?: WhereClause<Models, Operators, M>;
+    for?: "update" | "no key update" | "share" | "key share";
+    limit?: number;
+    offset?: number;
+    orderBy?: OrderByClause<Models, M>;
+}

package/build/types/FindParams.js

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

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

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

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

@@ -0,0 +1,107 @@
+import { describe, test } from "vitest";
+import { $eq } from "#operators.js";
+describe("FindParams", () => {
+    test("minimal valid params with just select", () => {
+        const _ = {
+            select: ["id"],
+        };
+    });
+    test("with include clause", () => {
+        const _ = {
+            select: ["id", "title"],
+            include: { author: { select: ["id", "name"] } },
+        };
+    });
+    test("with where clause", () => {
+        const _ = {
+            select: ["id"],
+            where: { id: { [$eq]: 1 } },
+        };
+    });
+    test("with limit and offset", () => {
+        const _ = {
+            select: ["id"],
+            limit: 10,
+            offset: 5,
+        };
+    });
+    test("with order by", () => {
+        const _ = {
+            select: ["id"],
+            orderBy: [["id", "asc"]],
+        };
+    });
+    test("with all optional parameters", () => {
+        const _ = {
+            select: ["id", "title"],
+            include: { author: { select: ["id"] } },
+            where: { id: { [$eq]: 1 } },
+            limit: 10,
+            offset: 5,
+            orderBy: [["id", "desc"], "author.name"],
+        };
+    });
+    test("invalid field in select", () => {
+        const _ = {
+            // @ts-expect-error invalid field
+            select: ["id", "invalid"],
+        };
+    });
+    test("invalid relation in include", () => {
+        const _ = {
+            select: ["id"],
+            include: {
+                // @ts-expect-error invalid relation
+                invalid: { select: ["id"] },
+            },
+        };
+    });
+    test("invalid field in where clause", () => {
+        const _ = {
+            select: ["id"],
+            where: {
+                // @ts-expect-error invalid field
+                invalid: { [$eq]: 1 },
+            },
+        };
+    });
+    test("invalid field in order by", () => {
+        const _ = {
+            select: ["id"],
+            orderBy: [
+                "id",
+                // @ts-expect-error invalid field
+                "invalid",
+            ],
+        };
+    });
+    test("invalid direction in order by", () => {
+        const _ = {
+            select: ["id"],
+            orderBy: [
+                // @ts-expect-error invalid direction
+                ["id", "invalid"],
+            ],
+        };
+    });
+    test("include when model has no relations", () => {
+        const _ = {
+            select: ["hex"],
+            // @ts-expect-error color has no relations
+            include: { posts: { select: ["id"] } },
+        };
+    });
+    test("allows selecting for update clause", () => {
+        const _ = {
+            select: ["id"],
+            for: "update",
+        };
+    });
+    test("invalid `for` clause", () => {
+        const _ = {
+            select: ["id"],
+            // @ts-expect-error invalid for clause
+            for: "invalid",
+        };
+    });
+});

package/build/types/FindResult.d.ts

@@ -0,0 +1,13 @@
+import { FieldType, ManyToOneRelationDefinition, ModelDefinitions, ModelName, OperatorDefinitions, RelationDefinition } from "@casekit/orm-schema";
+import { Simplify } from "@casekit/toolbox";
+import { FindParams } from "./FindParams.js";
+export type RelationModelName<Models extends ModelDefinitions, M extends ModelName<Models>, R extends keyof Models[M]["relations"]> = Models[M]["relations"][R] extends RelationDefinition ? Extract<Models[M]["relations"][R]["model"], ModelName<Models>> : never;
+export type IncludedRelationName<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>, Q extends FindParams<Models, Operators, M>> = Extract<keyof Q["include"], keyof Models[M]["relations"]>;
+export type IncludedRelationQuery<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>, R extends keyof Q["include"] & keyof Models[M]["relations"], Q extends FindParams<Models, Operators, M>> = Extract<Q["include"][R], FindParams<Models, Operators, RelationModelName<Models, M, R>>>;
+export type FindResult<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>, Q extends FindParams<Models, Operators, M>> = Simplify<{
+    [C in Q["select"][number]]: FieldType<Models[M], C>;
+} & (undefined extends Q["include"] ? unknown : {
+    [R in IncludedRelationName<Models, Operators, M, Q>]: Models[M]["relations"][R] extends {
+        optional: true;
+    } ? FindResult<Models, Operators, RelationModelName<Models, M, R>, IncludedRelationQuery<Models, Operators, M, R, Q>> | null : Models[M]["relations"][R] extends ManyToOneRelationDefinition ? FindResult<Models, Operators, RelationModelName<Models, M, R>, IncludedRelationQuery<Models, Operators, M, R, Q>> : FindResult<Models, Operators, RelationModelName<Models, M, R>, IncludedRelationQuery<Models, Operators, M, R, Q>>[];
+})>;

package/build/types/FindResult.js

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

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

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

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

@@ -0,0 +1,30 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("FindResult", () => {
+    test("simple select fields", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("many-to-one relation returns single object", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("one-to-many relation returns array", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("many-to-many relation returns array", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("optional many-to-one relation can be null", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("nested relations", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("array fields", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("nullable fields", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("without include clause", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/types/IncludeClause.d.ts

@@ -0,0 +1,5 @@
+import { ModelDefinition, ModelDefinitions, ModelName, OperatorDefinitions, RelationDefinitions, RelationName } from "@casekit/orm-schema";
+import { FindParams } from "./FindParams.js";
+export type IncludeClause<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"]>> = Models[M]["relations"] extends NonNullable<Models[M]["relations"]> ? {
+    [R in RelationName<Model>]?: FindParams<Models, Operators, Extract<Relations[R]["model"], string>>;
+} : never;

package/build/types/IncludeClause.js

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

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

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

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

@@ -0,0 +1,69 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("IncludeClause", () => {
+    test("allows including relations with nested find params", () => {
+        const _ = {
+            posts: { select: ["id", "title"] },
+            friends: { select: ["id", "name"] },
+        };
+    });
+    test("allows deeply nested includes", () => {
+        const _ = {
+            posts: {
+                select: ["id"],
+                include: {
+                    author: {
+                        select: ["id", "name"],
+                    },
+                },
+            },
+        };
+    });
+    test("disallows invalid relations", () => {
+        const _ = {
+            // @ts-expect-error invalid relation
+            invalid: { select: ["id"] },
+        };
+    });
+    test("handles models with no relations", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("correctly types many-to-one relations", () => {
+        const _ = {
+            author: { select: ["id"] },
+        };
+    });
+    test("correctly types one-to-many relations", () => {
+        const _ = {
+            posts: { select: ["id"] },
+        };
+    });
+    test("correctly types many-to-many relations", () => {
+        const _ = {
+            friends: { select: ["id"] },
+        };
+    });
+    test("requires valid select clause in nested find params", () => {
+        const _ = {
+            author: {
+                // @ts-expect-error invalid field in select
+                select: ["invalid"],
+            },
+        };
+    });
+    test("allows where clause in nested find params", () => {
+        const _ = {
+            posts: {
+                select: ["id"],
+                where: { id: 1 },
+            },
+        };
+    });
+    test("allows orderBy in nested find params", () => {
+        const _ = {
+            posts: {
+                select: ["id"],
+                orderBy: ["id"],
+            },
+        };
+    });
+});

package/build/types/Middleware.d.ts

@@ -0,0 +1,39 @@
+import { NormalizedConfig } from "@casekit/orm-config";
+import { ModelDefinition, ModelDefinitions, OperatorDefinitions } from "@casekit/orm-schema";
+import { Orm } from "../orm.js";
+import { CountParams } from "./CountParams.js";
+import { CreateManyParams } from "./CreateManyParams.js";
+import { CreateOneParams } from "./CreateOneParams.js";
+import { CreateValues } from "./CreateValues.js";
+import { DeleteParams } from "./DeleteParams.js";
+import { FindParams } from "./FindParams.js";
+import { UpdateParams } from "./UpdateParams.js";
+import { UpdateValues } from "./UpdateValues.js";
+import { WhereClause } from "./WhereClause.js";
+export type WhereMiddleware = (config: NormalizedConfig, modelName: string, where: WhereClause<ModelDefinitions, OperatorDefinitions, string>) => WhereClause<ModelDefinitions, OperatorDefinitions, string>;
+export type ValuesMiddleware = (config: NormalizedConfig, modelName: string, values: CreateValues<ModelDefinition>) => CreateValues<ModelDefinition>;
+export type SetMiddleware = (config: NormalizedConfig, modelName: string, values: UpdateValues<ModelDefinition>) => UpdateValues<ModelDefinition>;
+export type DeleteOneMiddleware = (db: Orm, modelName: string, params: DeleteParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown> | number>;
+export type DeleteManyMiddleware = (db: Orm, modelName: string, params: DeleteParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number>;
+export type FindOneMiddleware = (db: Orm, modelName: string, query: FindParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>>;
+export type FindManyMiddleware = (db: Orm, modelName: string, query: FindParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Readonly<Record<string, unknown>[]>>;
+export type CountMiddleware = (db: Orm, modelName: string, query: CountParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<number>;
+export type CreateOneMiddleware = (db: Orm, modelName: string, query: CreateOneParams<ModelDefinitions, string>) => Promise<Record<string, unknown> | number>;
+export type CreateManyMiddleware = (db: Orm, modelName: string, query: CreateManyParams<ModelDefinitions, string>) => Promise<Record<string, unknown>[] | number>;
+export type UpdateOneMiddleware = (db: Orm, modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown> | number | null>;
+export type UpdateManyMiddleware = (db: Orm, modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number | null>;
+export type Middleware = {
+    name?: string;
+    where?: WhereMiddleware;
+    set?: SetMiddleware;
+    values?: ValuesMiddleware;
+    findOne?: FindOneMiddleware;
+    findMany?: FindManyMiddleware;
+    count?: CountMiddleware;
+    createOne?: CreateOneMiddleware;
+    createMany?: CreateManyMiddleware;
+    updateOne?: UpdateOneMiddleware;
+    updateMany?: UpdateManyMiddleware;
+    deleteOne?: DeleteOneMiddleware;
+    deleteMany?: DeleteManyMiddleware;
+};

package/build/types/Middleware.js

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

package/build/types/OptionalValues.d.ts

@@ -0,0 +1,4 @@
+import { FieldType, ModelDefinition, OptionalField } from "@casekit/orm-schema";
+export type OptionalValues<Model extends ModelDefinition> = OptionalField<Model> extends never ? never : {
+    [K in OptionalField<Model>]?: FieldType<Model, K> | null;
+};

package/build/types/OptionalValues.js

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

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

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

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

@@ -0,0 +1,12 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("OptionalValues", () => {
+    test("extracts optional fields from model", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("returns never for models with no optional fields", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("works for models with no required fields", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/build/types/OrderByClause.d.ts

@@ -0,0 +1,9 @@
+import { FieldName, ModelDefinitions, ModelName } from "@casekit/orm-schema";
+type OrderByField<Models extends ModelDefinitions, M extends ModelName<Models>> = FieldName<Models[M]> | {
+    [R in Extract<keyof Models[M]["relations"], string>]: Models[M]["relations"][R] extends {
+        type: "N:1";
+        model: infer M2 extends ModelName<Models>;
+    } ? `${R}.${Extract<keyof Models[M2]["fields"], string>}` : never;
+}[Extract<keyof Models[M]["relations"], string>];
+export type OrderByClause<Models extends ModelDefinitions, M extends ModelName<Models>> = Array<OrderByField<Models, M> | [OrderByField<Models, M>, "asc" | "desc"]>;
+export {};

package/build/types/OrderByClause.js

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

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

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

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

@@ -0,0 +1,44 @@
+import { describe, test } from "vitest";
+describe("OrderByClause", () => {
+    test("allows ordering by fields of the model", () => {
+        const _ = ["title", "id"];
+    });
+    test("allows ordering by fields on N:1 relations", () => {
+        const _ = ["author.name"];
+    });
+    test("allows specifying a direction", () => {
+        const _ = [
+            "title",
+            "id",
+            ["id", "desc"],
+        ];
+    });
+    test("prevents ordering by non-existing fields", () => {
+        const _ = [
+            "title",
+            // @ts-expect-error non-existent field
+            "wrong",
+        ];
+    });
+    test("prevents ordering by non-existing relations", () => {
+        const _ = [
+            "title",
+            // @ts-expect-error non-existent relation
+            "wrong.name",
+        ];
+    });
+    test("prevents ordering by N:N relations", () => {
+        const _ = [
+            "name",
+            // @ts-expect-error N:N relation
+            "posts.title",
+        ];
+    });
+    test("prevents ordering by 1:N relations", () => {
+        const _ = [
+            "name",
+            // @ts-expect-error N:1 relation
+            "posts.title",
+        ];
+    });
+});

package/build/types/RequiredValues.d.ts

@@ -0,0 +1,4 @@
+import { FieldType, ModelDefinition, RequiredField } from "@casekit/orm-schema";
+export type RequiredValues<Model extends ModelDefinition> = RequiredField<Model> extends never ? never : {
+    [K in RequiredField<Model>]: FieldType<Model, K>;
+};

package/build/types/RequiredValues.js

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

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

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

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

@@ -0,0 +1,22 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("RequiredValues", () => {
+    test("model with required fields", () => {
+        const _ = {
+            title: "Title",
+            content: "Content",
+            authorId: 1,
+        };
+    });
+    test("is never for model with only optional fields", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("model with serial primary key", () => {
+        expectTypeOf().not.toExtend();
+    });
+    test("model with provided fields", () => {
+        expectTypeOf().not.toExtend();
+    });
+    test("model with nullable fields", () => {
+        expectTypeOf().not.toExtend();
+    });
+});

package/build/types/RestrictModels.d.ts

@@ -0,0 +1,23 @@
+import { Config, ModelDefinitions, ModelName, RelationDefinitions } from "@casekit/orm-schema";
+export type RestrictRelation<Relations extends RelationDefinitions, R extends keyof Relations, Allowed extends string> = Relations[R] extends {
+    type: "N:N";
+} ? Relations[R] extends {
+    model: Allowed;
+    through: {
+        model: Allowed;
+    };
+} ? R : never : Relations[R] extends {
+    model: Allowed;
+} ? R : never;
+export type RestrictModel<Models extends ModelDefinitions, Allowed extends ModelName<Models>, M extends ModelName<Models>> = Omit<Models[M], "relations"> & {
+    relations: Models[M]["relations"] extends infer Relations extends RelationDefinitions ? keyof {
+        [R in keyof Relations as RestrictRelation<Relations, R, Allowed>]: Relations[R];
+    } extends never ? undefined : {
+        [R in keyof Relations as RestrictRelation<Relations, R, Allowed>]: Relations[R];
+    } : undefined;
+};
+export type RestrictModels<C extends Config, Allowed extends ModelName<C["models"]>, Models extends ModelDefinitions = C["models"]> = Omit<C, "models"> & {
+    models: {
+        [M in Allowed]: RestrictModel<Models, Allowed, M>;
+    };
+};

package/build/types/RestrictModels.js

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

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

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

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

@@ -0,0 +1,44 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("RestrictModels", () => {
+    test("restricts relations to only allowed models", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("excludes relations to non-allowed models", () => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("N:N relations are excluded unless the through model is also allowed", () => {
+        // @ts-expect-error - friendship model is not allowed
+        const _ = {
+            friends: {
+                type: "N:N",
+                model: "user",
+                through: {
+                    model: "friendship",
+                    fromRelation: "user",
+                    toRelation: "friend",
+                },
+            },
+        };
+    });
+    test("N:N relations are allowed if the through model is also allowed", () => {
+        const _ = {
+            friends: {
+                type: "N:N",
+                model: "user",
+                through: {
+                    model: "friendship",
+                    fromRelation: "user",
+                    toRelation: "friend",
+                },
+            },
+            friendships: {
+                type: "1:N",
+                model: "friendship",
+                fromField: "id",
+                toField: "userId",
+            },
+        };
+    });
+});

package/build/types/ReturningClause.d.ts

@@ -0,0 +1,3 @@
+import { NonEmptyArray } from "ts-essentials";
+import { FieldName, ModelDefinition } from "@casekit/orm-schema";
+export type ReturningClause<Model extends ModelDefinition> = NonEmptyArray<FieldName<Model>>;

package/build/types/ReturningClause.js

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

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

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

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

@@ -0,0 +1,15 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("ReturningClause", () => {
+    test("accepts array of valid field names", () => {
+        expectTypeOf().toExtend();
+    });
+    test("requires at least one field", () => {
+        expectTypeOf().not.toExtend();
+    });
+    test("rejects invalid field names", () => {
+        expectTypeOf().not.toExtend();
+    });
+    test("accepts single field array", () => {
+        expectTypeOf().toExtend();
+    });
+});

package/build/types/SelectClause.d.ts

@@ -0,0 +1,3 @@
+import { NonEmptyArray } from "ts-essentials";
+import { FieldName, ModelDefinition } from "@casekit/orm-schema";
+export type SelectClause<Model extends ModelDefinition> = NonEmptyArray<FieldName<Model>>;

package/build/types/SelectClause.js

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

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

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

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

@@ -0,0 +1,15 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("SelectClause", () => {
+    test("accepts array of valid field names", () => {
+        expectTypeOf().toExtend();
+    });
+    test("requires at least one field", () => {
+        expectTypeOf().not.toExtend();
+    });
+    test("rejects invalid field names", () => {
+        expectTypeOf().not.toExtend();
+    });
+    test("accepts single field array", () => {
+        expectTypeOf().toExtend();
+    });
+});

package/build/types/UpdateManyResult.d.ts

@@ -0,0 +1,5 @@
+import { FieldType, ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm-schema";
+import { UpdateParams } from "./UpdateParams.js";
+export type UpdateManyResult<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/UpdateManyResult.js

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

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

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

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

@@ -0,0 +1,15 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("UpdateManyResult", () => {
+    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/UpdateOneResult.d.ts

@@ -0,0 +1,5 @@
+import { FieldType, ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm-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/orm-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]>;
+};