@idb-orm/core 1.0.3 → 1.0.4

package/README.md

@@ -1,5 +1,9 @@
 # IDB-ORM
 
+> THIS PROJECT IS STILL A (ROUGH) WORK IN PROGRESS. I HOPE TO HAVE A GOOD WORKING VERSION SOON.
+>
+> PLEASE CHECK BACK IN A FEW WEEKS/MONTHS
+
 ## Roadmap
 
 -   [x] "Include" query field

package/dist/client/compiled-query.d.ts

@@ -1,17 +1,7 @@
-import type { CollectionObject } from "../builder";
-import type { DbClient } from "./index";
-import type { FindInput, FindOutput } from "./types/find";
-export declare class CompiledQuery<
-    Stores extends string,
-    Models extends CollectionObject<string>,
-    Db extends DbClient<string, Stores, Models>,
-    Input extends FindInput<Stores, Models[Stores], Models> = FindInput<
-        Stores,
-        Models[Stores],
-        Models
-    >,
-    Output = FindOutput<Stores, Models[Stores], Models, Input>
-> {
+import type { CollectionObject } from "../builder.ts";
+import type { DbClient } from "./index.ts";
+import type { FindInput, FindOutput } from "./types/find.ts";
+export declare class CompiledQuery<Stores extends string, Models extends CollectionObject<string>, Db extends DbClient<string, Stores, Models>, Input extends FindInput<Stores, Models[Stores], Models> = FindInput<Stores, Models[Stores], Models>, Output = FindOutput<Stores, Models[Stores], Models, Input>> {
     private readonly client;
     private readonly name;
     private readonly accessedStores;

package/dist/client/delete.d.ts

@@ -0,0 +1,14 @@
+import { CollectionObject } from "../builder.js";
+import { ExtractFields } from "../model/model-types.js";
+import { WhereObject } from "./types/find.js";
+import { MutationState } from "./types";
+import { DbClient } from "./index.js";
+/**
+ * Deletes document(s) from a store
+ * @param name Name of the store
+ * @param client DbClient object
+ * @param stopOnFirst Stop after the first deletion
+ * @param _state Optional state for multi-stage actions
+ * @returns Number of items removed
+ */
+export declare function deleteItems<ModelNames extends string, Name extends ModelNames, Models extends CollectionObject<ModelNames>>(name: Name, client: DbClient<string, ModelNames, Models>, where?: WhereObject<ExtractFields<Models[Name]>>, stopOnFirst?: boolean, _state?: MutationState<ModelNames>): Promise<number>;

package/dist/client/helpers.d.ts

@@ -1,9 +1,8 @@
-import type { Dict } from "../types/common.js";
+import type { Dict, Promisable } from "../types/common.js";
 import type { DbClient } from "./index.ts";
 import type { CollectionObject } from "../builder.ts";
 import type { QueryInput } from "./types/find.ts";
 import type { Transaction } from "../transaction.js";
-import type { Promisable } from "type-fest";
 export declare function generateWhereClause(where?: Dict): (obj: unknown) => boolean;
 export declare function generateSelector<ModelNames extends string, Models extends CollectionObject<ModelNames>, Db extends DbClient<string, ModelNames, Models>, Q extends QueryInput<ModelNames, any, Models> = QueryInput<ModelNames, any, Models>>(name: ModelNames, client: Db, query?: Q, initTx?: Transaction<IDBTransactionMode, ModelNames>): (item: Dict, tx: Transaction<IDBTransactionMode, ModelNames>) => Promisable<Dict | undefined>;
 export declare function getAccessedStores<ModelNames extends string, Models extends CollectionObject<ModelNames>>(name: ModelNames, query: Dict, type: "mutation" | "query", client: DbClient<string, ModelNames, Models>): Set<ModelNames>;

package/dist/client/index.d.ts

@@ -1,12 +1,8 @@
-import type { Arrayable } from "type-fest";
 import type { CollectionObject, CompiledDb } from "../builder";
+import type { Arrayable } from "../types/common";
 import { Transaction, type TransactionOptions } from "../transaction";
-import type { InterfaceMap } from "./types/index";
-export declare class DbClient<
-    Name extends string,
-    ModelNames extends string,
-    Models extends CollectionObject<ModelNames>
-> {
+import { type InterfaceMap } from "./types";
+export declare class DbClient<Name extends string, ModelNames extends string, Models extends CollectionObject<ModelNames>> {
     private readonly db;
     private readonly models;
     readonly name: Name;
@@ -14,14 +10,7 @@ export declare class DbClient<
     readonly stores: InterfaceMap<ModelNames, Models>;
     constructor(db: IDBDatabase, models: CompiledDb<Name, ModelNames, Models>);
     getStore<Name extends ModelNames>(name: Name): (typeof this.stores)[Name];
-    createTransaction<
-        Mode extends IDBTransactionMode,
-        Names extends ModelNames
-    >(
-        mode: Mode,
-        stores: Arrayable<Names>,
-        options?: TransactionOptions
-    ): Transaction<Mode, Names>;
+    createTransaction<Mode extends IDBTransactionMode, Names extends ModelNames>(mode: Mode, stores: Arrayable<Names>, options?: TransactionOptions): Transaction<Mode, Names>;
     deleteDb(): Promise<void>;
     deleteAllStores(): void;
     deleteStore(storeNames: Arrayable<ModelNames>): void;
@@ -30,23 +19,6 @@ export declare class DbClient<
     private createInterface;
     private add;
     private clear;
-    /**
-     * Deletes a single document from a store given its Primary key value
-     * @param name Name of the store
-     * @param key Primary key value
-     * @param _state Optional state for multi-stage actions
-     * @returns Boolean indicating whether or not an item was removed
-     */
-    private deleteSingleton;
-    /**
-     * Deletes documents from the store that match the given filter.
-     * @param name Name of the store
-     * @param where Optional filter
-     * @param stopOnFirst Flag to stop after one successful deletion
-     * @param _state Optional state for multi-stage actions
-     * @returns The number of documents deleted
-     */
-    private delete;
     /**
      * Finds documents from the store that match the filter
      * @param name Name of the store

package/dist/client/types/find.d.ts

@@ -1,107 +1,23 @@
 import type { Dict, If, Keyof, RemoveNeverValues } from "../../types/common.js";
-import type {
-    ExtractFields,
-    ModelStructure,
-    RelationlessModelStructure,
-} from "../../model/model-types.js";
-import type { Model } from "../../model/index";
-import type {
-    BaseRelation,
-    Field,
-    PrimaryKey,
-    RelationOutputStructure,
-    ValidValue,
-} from "../../field/index";
-import type { CollectionObject } from "../../builder";
+import type { ExtractFields, ModelStructure, RelationlessModelStructure } from "../../model/model-types.js";
+import type { Model } from "../../model";
+import type { BaseRelation, Field, PrimaryKey, RelationOutputStructure, ValidValue } from "../../field";
+import type { CollectionObject } from "../../builder.ts";
 export type FilterFn<Input> = (item: Input) => boolean;
-export type WhereObject<Fields extends Dict<ValidValue>> = Partial<
-    RemoveNeverValues<{
-        [K in keyof Fields]: Fields[K] extends Field<infer Output, any>
-            ? Output | FilterFn<Output>
-            : Fields[K] extends PrimaryKey<any, infer Type>
-            ? Type | FilterFn<Type>
-            : never;
-    }>
->;
-export type SelectObject<
-    All extends string,
-    Fields extends Dict<ValidValue>,
-    C extends CollectionObject<All>
-> = {
-    [K in keyof Fields]?: Fields[K] extends Field<any, any>
-        ? true
-        : Fields[K] extends PrimaryKey<any, any>
-        ? true
-        : Fields[K] extends BaseRelation<infer To, any>
-        ?
-              | true
-              | (To extends Keyof<C>
-                    ? C[To] extends Model<any, infer SubFields, any>
-                        ? QueryInput<All, SubFields, C>
-                        : never
-                    : never)
-        : never;
+export type WhereObject<Fields extends Dict<ValidValue>> = Partial<RemoveNeverValues<{
+    [K in keyof Fields]: Fields[K] extends Field<infer Output, any> ? Output | FilterFn<Output> : Fields[K] extends PrimaryKey<any, infer Type> ? Type | FilterFn<Type> : never;
+}>>;
+export type SelectObject<All extends string, Fields extends Dict<ValidValue>, C extends CollectionObject<All>> = {
+    [K in keyof Fields]?: Fields[K] extends Field<any, any> ? true : Fields[K] extends PrimaryKey<any, any> ? true : Fields[K] extends BaseRelation<infer To, any> ? true | (To extends Keyof<C> ? C[To] extends Model<any, infer SubFields, any> ? QueryInput<All, SubFields, C> : never : never) : never;
 };
-export interface QueryInput<
-    All extends string,
-    Fields extends Dict<ValidValue>,
-    C extends CollectionObject<All>
-> {
+export interface QueryInput<All extends string, Fields extends Dict<ValidValue>, C extends CollectionObject<All>> {
     where?: WhereObject<Fields>;
     select?: SelectObject<All, Fields, C>;
     include?: SelectObject<All, Fields, C>;
 }
-export type FindInput<
-    All extends string,
-    Struct extends object,
-    C extends CollectionObject<All>
-> = Struct extends Model<any, infer Fields, any>
-    ? QueryInput<All, Fields, C>
-    : never;
-type _FindOutput<
-    All extends string,
-    Select extends Dict<Dict | true>,
-    Fields extends Dict<ValidValue>,
-    C extends CollectionObject<All>
-> =
-    | {
-          [K in Keyof<Select>]: Fields[K] extends BaseRelation<infer To, any>
-              ? To extends Keyof<C>
-                  ? C[To] extends Model<any, infer Sub, any>
-                      ? If<
-                            Select[K] extends true ? true : false,
-                            RelationOutputStructure<
-                                Fields[K],
-                                RelationlessModelStructure<C[To]>
-                            >,
-                            Select[K] extends Dict<Dict | true>
-                                ? RelationOutputStructure<
-                                      Fields[K],
-                                      _FindOutput<All, Select[K], Sub, C>
-                                  >
-                                : never
-                        >
-                      : never
-                  : never
-              : Fields[K] extends PrimaryKey<any, infer Type>
-              ? Type
-              : Fields[K] extends Field<infer Type, any>
-              ? Type
-              : never;
-      }
-    | undefined;
-export type FindOutput<
-    All extends string,
-    Struct extends Model<any, any, any>,
-    C extends CollectionObject<All>,
-    F extends FindInput<All, Struct, C>
-> = Struct extends Model<any, infer Fields, any>
-    ? F extends object
-        ?
-              | (F["select"] extends Dict<true | Dict>
-                    ? _FindOutput<All, F["select"], Fields, C>
-                    : ModelStructure<ExtractFields<Struct>, C>)
-              | undefined
-        : never
-    : never;
+export type FindInput<All extends string, Struct extends object, C extends CollectionObject<All>> = Struct extends Model<any, infer Fields, any> ? QueryInput<All, Fields, C> : never;
+type _FindOutput<All extends string, Select extends Dict<Dict | true>, Fields extends Dict<ValidValue>, C extends CollectionObject<All>> = {
+    [K in Keyof<Select>]: Fields[K] extends BaseRelation<infer To, any> ? To extends Keyof<C> ? C[To] extends Model<any, infer Sub, any> ? If<Select[K] extends true ? true : false, RelationOutputStructure<Fields[K], RelationlessModelStructure<C[To]>>, Select[K] extends Dict<Dict | true> ? RelationOutputStructure<Fields[K], _FindOutput<All, Select[K], Sub, C>> : never> : never : never : Fields[K] extends PrimaryKey<any, infer Type> ? Type : Fields[K] extends Field<infer Type, any> ? Type : never;
+} | undefined;
+export type FindOutput<All extends string, Struct extends Model<any, any, any>, C extends CollectionObject<All>, F extends FindInput<All, Struct, C>> = Struct extends Model<any, infer Fields, any> ? F extends object ? (F["select"] extends Dict<true | Dict> ? _FindOutput<All, F["select"], Fields, C> : ModelStructure<ExtractFields<Struct>, C>) | undefined : never : never;
 export {};

package/dist/client/types/index.d.ts

@@ -1,58 +1,22 @@
-import type { CollectionObject } from "../../builder";
+import type { CollectionObject } from "../../builder.ts";
 import type { Dict, ValidKey } from "../../types/common.js";
-import type {
-    ExtractFields,
-    Model,
-    ModelStructure,
-    PrimaryKeyType,
-} from "../../model/index";
-import type { AddMutation, UpdateMutation } from "./mutation";
-import type { FindInput, FindOutput, WhereObject } from "./find";
-import type { CompiledQuery } from "../compiled-query";
-import type { DbClient } from "../index";
+import type { ExtractFields, Model, ModelStructure, PrimaryKeyType } from "../../model";
+import type { AddMutation, UpdateMutation } from "./mutation.ts";
+import type { FindInput, FindOutput, WhereObject } from "./find.ts";
+import type { CompiledQuery } from "../compiled-query.ts";
+import type { DbClient } from "../index.ts";
 import { Transaction } from "../../transaction.js";
-import { BaseRelation } from "../../field/index";
-export type InsertMutation<
-    N extends string,
-    C extends Dict
-> = C[N] extends Model<N, infer F, any> ? ModelStructure<F, C> : never;
-export interface StoreInterface<
-    Name extends Names,
-    Names extends string,
-    C extends CollectionObject<Names>,
-    KeyType = PrimaryKeyType<C[Name]>,
-    Add = AddMutation<Name, Names, C[Name], C>,
-    Update = UpdateMutation<Name, Names, C[Name], C>
-> {
-    add(
-        mutation: Add,
-        transaction?: Transaction<"readwrite", Names>
-    ): Promise<KeyType>;
-    addMany(
-        mutations: Add[],
-        transaction?: Transaction<"readwrite", Names>
-    ): Promise<KeyType[]>;
-    find<T extends FindInput<Names, C[Name], C>>(
-        query: T,
-        transaction?: Transaction<IDBTransactionMode, Names>
-    ): Promise<FindOutput<Names, C[Name], C, T>[]>;
-    findFirst<T extends FindInput<Names, C[Name], C>>(
-        query: T,
-        transaction?: Transaction<IDBTransactionMode, Names>
-    ): Promise<FindOutput<Names, C[Name], C, T>>;
+import { BaseRelation } from "../../field";
+export type InsertMutation<N extends string, C extends Dict> = C[N] extends Model<N, infer F, any> ? ModelStructure<F, C> : never;
+export interface StoreInterface<Name extends Names, Names extends string, C extends CollectionObject<Names>, KeyType = PrimaryKeyType<C[Name]>, Add = AddMutation<Name, Names, C[Name], C>, Update = UpdateMutation<Name, Names, C[Name], C>> {
+    add(mutation: Add, transaction?: Transaction<"readwrite", Names>): Promise<KeyType>;
+    addMany(mutations: Add[], transaction?: Transaction<"readwrite", Names>): Promise<KeyType[]>;
+    find<T extends FindInput<Names, C[Name], C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<FindOutput<Names, C[Name], C, T>[]>;
+    findFirst<T extends FindInput<Names, C[Name], C>>(query: T, transaction?: Transaction<IDBTransactionMode, Names>): Promise<FindOutput<Names, C[Name], C, T>>;
     put(): Promise<void>;
-    insert(
-        item: InsertMutation<Name, C>,
-        transaction?: Transaction<"readwrite", Names>
-    ): Promise<KeyType>;
-    updateFirst(
-        item: Update,
-        transaction?: Transaction<"readwrite", Names>
-    ): Promise<KeyType | undefined>;
-    updateMany(
-        item: Update,
-        transaction?: Transaction<"readwrite", Names>
-    ): Promise<KeyType[]>;
+    insert(item: InsertMutation<Name, C>, transaction?: Transaction<"readwrite", Names>): Promise<KeyType>;
+    updateFirst(item: Update, transaction?: Transaction<"readwrite", Names>): Promise<KeyType | undefined>;
+    updateMany(item: Update, transaction?: Transaction<"readwrite", Names>): Promise<KeyType[]>;
     delete(key: KeyType): Promise<boolean>;
     deleteFirst(where?: WhereObject<ExtractFields<C[Name]>>): Promise<boolean>;
     deleteMany(where: WhereObject<ExtractFields<C[Name]>>): Promise<number>;
@@ -60,39 +24,39 @@ export interface StoreInterface<
      * Clears a store (does not update any relations)
      */
     clear(transaction?: Transaction<"readwrite", Names>): Promise<void>;
-    compileQuery<T extends FindInput<Names, C[Name], C>>(
-        query: T
-    ): CompiledQuery<Names, C, DbClient<string, Names, C>, T>;
+    compileQuery<T extends FindInput<Names, C[Name], C>>(query: T): CompiledQuery<Names, C, DbClient<string, Names, C>, T>;
     get(key: KeyType): Promise<any>;
 }
-export type InterfaceMap<
-    Names extends string,
-    C extends CollectionObject<Names>
-> = {
+export type InterfaceMap<Names extends string, C extends CollectionObject<Names>> = {
     [K in Names]: StoreInterface<K, Names, C>;
 };
 export interface QueryState<Names extends string> {
     tx?: Transaction<IDBTransactionMode, Names>;
 }
-export interface MutationState<Names extends string>
-    extends Partial<{
-        tx: Transaction<"readwrite", Names>;
-        relation: {
-            id: ValidKey;
-            key: string;
-        };
-    }> {}
+export declare const enum MutationBreath {
+    Find = 0,
+    Singleton = 1
+}
+export interface MutationState<Names extends string> extends Partial<{
+    tx: Transaction<"readwrite", Names>;
+    relation: {
+        id: ValidKey;
+        key: string;
+    };
+    singleton: {
+        id: ValidKey;
+    };
+    finalStep: boolean;
+}> {
+}
 export type KeyObject<Index = string> = {
     isFun: boolean;
     key: Index;
-} & (
-    | {
-          isRelation: true;
-          relation: BaseRelation<any, any>;
-      }
-    | {
-          isRelation: false;
-          relation?: undefined;
-      }
-);
+} & ({
+    isRelation: true;
+    relation: BaseRelation<any, any>;
+} | {
+    isRelation: false;
+    relation?: undefined;
+});
 export type { AddMutation, UpdateMutation };

package/dist/client/types/mutation.d.ts

@@ -1,225 +1,46 @@
-import type {
-    MakeArrayable,
-    MakeOptional,
-    RemoveNeverValues,
-    PartialOnUndefined,
-} from "../../types/common.js";
-import type {
-    BaseRelation,
-    Field,
-    OptionalRelation,
-    PrimaryKey,
-    RelationArray,
-} from "../../field/index";
-import type { CollectionObject } from "../../builder";
+import type { MakeArrayable, MakeOptional, RemoveNeverValues, PartialOnUndefined } from "../../types/common.js";
+import type { BaseRelation, Field, OptionalRelation, PrimaryKey, RelationArray } from "../../field";
+import type { CollectionObject } from "../../builder.ts";
 import { WhereObject } from "./find.js";
-import { Model, FindRelationKey, RelationValue } from "../../model/index";
-export type MutationActions =
-    | "$connect"
-    | "$connectMany"
-    | "$create"
-    | "$createMany"
-    | "$update"
-    | "$updateMany"
-    | "$delete"
-    | "$deleteMany"
-    | "$deleteAll"
-    | "$disconnect"
-    | "$disconnectMany"
-    | "$disconnectAll";
-export type Mutation<
-    This extends All,
-    All extends string,
-    Struct extends object,
-    C extends CollectionObject<All>,
-    MutType extends string = "add"
-> = PartialOnUndefined<
-    RemoveNeverValues<
-        Struct extends Model<any, infer Fields, any>
-            ? {
-                  [K in keyof Fields]: Fields[K] extends Field<
-                      infer Type,
-                      infer HasDefault
-                  >
-                      ? MutType extends "update"
-                          ? Type | undefined | ((value: Type) => Type)
-                          : HasDefault extends true
-                          ? Type | undefined
-                          : Type
-                      : Fields[K] extends PrimaryKey<infer IsAuto, infer Type>
-                      ? MutType extends "update"
-                          ? never
-                          : IsAuto extends true
-                          ? never
-                          : Type
-                      : Fields[K] extends BaseRelation<infer To, infer Name>
-                      ? To extends All
-                          ? MakeOptional<
-                                Fields[K] extends OptionalRelation<any, any>
-                                    ? true
-                                    : Fields[K] extends RelationArray<any, any>
-                                    ? true
-                                    : MutType extends "update"
-                                    ? true
-                                    : false,
-                                | MakeArrayable<
-                                      Fields[K] extends RelationArray<any, any>
-                                          ? true
-                                          : false,
-                                      | {
-                                            $connect: RelationValue<To, C>;
-                                        }
-                                      | {
-                                            $create: Omit<
-                                                Mutation<
-                                                    To,
-                                                    All,
-                                                    C[To],
-                                                    C,
-                                                    "add"
-                                                >,
-                                                FindRelationKey<
-                                                    This,
-                                                    Name,
-                                                    C[To]
-                                                >
-                                            >;
-                                        }
-                                      | (MutType extends "update"
-                                            ?
-                                                  | {
-                                                        $update: Fields[K] extends RelationArray<
-                                                            any,
-                                                            any
-                                                        >
-                                                            ? {
-                                                                  where?: WhereSelection<
-                                                                      C[To]
-                                                                  >;
-                                                                  data: Mutation<
-                                                                      To,
-                                                                      All,
-                                                                      C[To],
-                                                                      C,
-                                                                      MutType
-                                                                  >;
-                                                              }
-                                                            : Mutation<
-                                                                  To,
-                                                                  All,
-                                                                  C[To],
-                                                                  C,
-                                                                  MutType
-                                                              >;
-                                                    }
-                                                  | {
-                                                        $delete: Fields[K] extends RelationArray<
-                                                            any,
-                                                            any
-                                                        >
-                                                            ? RelationValue<
-                                                                  To,
-                                                                  C
-                                                              >
-                                                            : true;
-                                                    }
-                                                  | {
-                                                        $disconnect: Fields[K] extends RelationArray<
-                                                            any,
-                                                            any
-                                                        >
-                                                            ? RelationValue<
-                                                                  To,
-                                                                  C
-                                                              >
-                                                            : true;
-                                                    }
-                                            : never)
-                                  >
-                                | (Fields[K] extends RelationArray<any, any>
-                                      ?
-                                            | {
-                                                  $connectMany: RelationValue<
-                                                      To,
-                                                      C
-                                                  >[];
-                                              }
-                                            | {
-                                                  $createMany: Omit<
-                                                      Mutation<
-                                                          To,
-                                                          All,
-                                                          C[To],
-                                                          C,
-                                                          "add"
-                                                      >,
-                                                      FindRelationKey<
-                                                          This,
-                                                          Name,
-                                                          C[To]
-                                                      >
-                                                  >[];
-                                              }
-                                            | {
-                                                  $updateMany: {
-                                                      where?: WhereSelection<
-                                                          C[To]
-                                                      >;
-                                                      data: Mutation<
-                                                          To,
-                                                          All,
-                                                          C[To],
-                                                          C,
-                                                          MutType
-                                                      >;
-                                                  }[];
-                                              }
-                                            | {
-                                                  $deleteMany: RelationValue<
-                                                      To,
-                                                      C
-                                                  >[];
-                                              }
-                                            | {
-                                                  $deleteAll: true;
-                                              }
-                                            | {
-                                                  $disconnectMany: RelationValue<
-                                                      To,
-                                                      C
-                                                  >[];
-                                              }
-                                            | {
-                                                  $disconnectAll: true;
-                                              }
-                                      : never)
-                            >
-                          : never
-                      : never;
-              }
-            : never
-    >
->;
-export type AddMutation<
-    This extends All,
-    All extends string,
-    Struct extends object,
-    C extends CollectionObject<All>
-> = Mutation<This, All, Struct, C, "add">;
-export interface UpdateMutation<
-    This extends All,
-    All extends string,
-    Struct extends object,
-    C extends CollectionObject<All>
-> {
+import { Model, FindRelationKey, RelationValue } from "../../model";
+export type MutationActions = "$connect" | "$connectMany" | "$create" | "$createMany" | "$update" | "$updateMany" | "$delete" | "$deleteMany" | "$deleteAll" | "$disconnect" | "$disconnectMany" | "$disconnectAll";
+export type Mutation<This extends All, All extends string, Struct extends object, C extends CollectionObject<All>, MutType extends string = "add"> = PartialOnUndefined<RemoveNeverValues<Struct extends Model<any, infer Fields, any> ? {
+    [K in keyof Fields]: Fields[K] extends Field<infer Type, infer HasDefault> ? MutType extends "update" ? Type | undefined | ((value: Type) => Type) : HasDefault extends true ? Type | undefined : Type : Fields[K] extends PrimaryKey<infer IsAuto, infer Type> ? MutType extends "update" ? never : IsAuto extends true ? never : Type : Fields[K] extends BaseRelation<infer To, infer Name> ? To extends All ? MakeOptional<Fields[K] extends OptionalRelation<any, any> ? true : Fields[K] extends RelationArray<any, any> ? true : MutType extends "update" ? true : false, MakeArrayable<Fields[K] extends RelationArray<any, any> ? true : false, {
+        $connect: RelationValue<To, C>;
+    } | {
+        $create: Omit<Mutation<To, All, C[To], C, "add">, FindRelationKey<This, Name, C[To]>>;
+    } | (MutType extends "update" ? {
+        $update: Fields[K] extends RelationArray<any, any> ? {
+            where?: WhereSelection<C[To]>;
+            data: Mutation<To, All, C[To], C, MutType>;
+        } : Mutation<To, All, C[To], C, MutType>;
+    } | {
+        $delete: Fields[K] extends RelationArray<any, any> ? RelationValue<To, C> : true;
+    } | {
+        $disconnect: Fields[K] extends RelationArray<any, any> ? RelationValue<To, C> : true;
+    } : never)> | (Fields[K] extends RelationArray<any, any> ? {
+        $connectMany: RelationValue<To, C>[];
+    } | {
+        $createMany: Omit<Mutation<To, All, C[To], C, "add">, FindRelationKey<This, Name, C[To]>>[];
+    } | {
+        $updateMany: {
+            where?: WhereSelection<C[To]>;
+            data: Mutation<To, All, C[To], C, MutType>;
+        }[];
+    } | {
+        $deleteMany: RelationValue<To, C>[];
+    } | {
+        $deleteAll: true;
+    } | {
+        $disconnectMany: RelationValue<To, C>[];
+    } | {
+        $disconnectAll: true;
+    } : never)> : never : never;
+} : never>>;
+export type AddMutation<This extends All, All extends string, Struct extends object, C extends CollectionObject<All>> = Mutation<This, All, Struct, C, "add">;
+export interface UpdateMutation<This extends All, All extends string, Struct extends object, C extends CollectionObject<All>> {
     where?: WhereSelection<Struct>;
     data: Mutation<This, All, Struct, C, "update">;
 }
-type WhereSelection<Struct extends object> = Struct extends Model<
-    any,
-    infer Fields,
-    any
->
-    ? WhereObject<Fields>
-    : never;
+type WhereSelection<Struct extends object> = Struct extends Model<any, infer Fields, any> ? WhereObject<Fields> : never;
 export {};