@ez4/database 0.18.0 → 0.20.0

package/dist/services/client.d.ts

@@ -1,5 +1,5 @@
-import type { Transaction } from './transaction.js';
-import type { Parameters } from './parameters.js';
+import type { ParametersUtils } from './parameters.js';
+import type { TransactionUtils } from './transaction.js';
 import type { TableClients } from './table.js';
 import type { Database } from './database.js';
 /**
@@ -13,12 +13,12 @@ export type Client<T extends Database.Service> = TableClients<T> & {
      * @param parameters Parameters in use by the given query.
      * @returns Returns the results for the given query.
      */
-    rawQuery(query: string, parameters?: Parameters.Type<T>): Promise<Record<string, unknown>[]>;
+    rawQuery(query: string, parameters?: ParametersUtils.Type<T>): Promise<Record<string, unknown>[]>;
     /**
      * Prepare and execute the given transaction.
      *
      * @param operation Transaction operation.
      * @returns Returns the transaction result if the given transaction is interactive.
      */
-    transaction<O extends Transaction.Type<T, R>, R>(operation: O): Promise<Transaction.Result<O>>;
+    transaction<O extends TransactionUtils.Type<T, R>, R>(operation: O): Promise<TransactionUtils.Result<O>>;
 };

package/dist/services/database.d.ts

@@ -71,7 +71,7 @@ export declare namespace Database {
         /**
          * Log retention (in days) for the handler.
          */
-        retention?: number;
+        logRetention?: number;
         /**
          * Max execution time (in seconds) for the handler.
          */

package/dist/services/engine.d.ts

@@ -1,22 +1,52 @@
-/**
- * Transaction type.
- */
-export declare const enum TransactionType {
-    Interactive = "interactive",
-    Static = "static"
-}
-/**
- * Parameters type.
- */
-export declare const enum ParametersType {
-    NameAndIndex = "both",
-    OnlyIndex = "index"
-}
+import type { ParametersMode } from './parameters.js';
+import type { TransactionMode } from './transaction.js';
+import type { InsensitiveMode } from './insensitive.js';
+import type { PaginationMode } from './pagination.js';
+import type { OrderMode } from './order.js';
+import type { Database } from './database.js';
 /**
  * Database engine.
  */
 export type DatabaseEngine = {
-    transaction: TransactionType;
-    parameters: ParametersType;
+    parametersMode: ParametersMode;
+    transactionMode: TransactionMode;
+    insensitiveMode: InsensitiveMode;
+    paginationMode: PaginationMode;
+    orderMode: OrderMode;
     name: string;
 };
+/**
+ * Engine utils.
+ */
+export declare namespace EngineUtils {
+    /**
+     * Get the parameters mode from the given database service.
+     */
+    type GetParametersMode<T extends Database.Service> = T['engine'] extends {
+        parametersMode: infer M;
+    } ? M : never;
+    /**
+     * Get the transaction mode from the given database service.
+     */
+    type GetTransactionMode<T extends Database.Service> = T['engine'] extends {
+        transactionMode: infer M;
+    } ? M : never;
+    /**
+     * Get the insensitive mode from the given database engine.
+     */
+    type GetInsensitiveMode<E extends DatabaseEngine> = E extends {
+        insensitiveMode: infer M;
+    } ? M : never;
+    /**
+     * Get the pagination mode from the given database engine.
+     */
+    type GetPaginationMode<E extends DatabaseEngine> = E extends {
+        paginationMode: infer M;
+    } ? M : never;
+    /**
+     * Get the order mode from the given database service.
+     */
+    type GetOrderMode<T extends Database.Service> = T['engine'] extends {
+        orderMode: infer M;
+    } ? M : never;
+}

package/dist/services/insensitive.d.ts

@@ -0,0 +1,19 @@
+import type { DatabaseEngine, EngineUtils } from './engine.js';
+/**
+ * Insensitive mode.
+ */
+export declare const enum InsensitiveMode {
+    Unsupported = "unsupported",
+    Enabled = "enabled"
+}
+/**
+ * Insensitive utils.
+ */
+export declare namespace InsensitiveUtils {
+    /**
+     * Get the insensitive input based on the given database engine.
+     */
+    type Input<E extends DatabaseEngine> = EngineUtils.GetInsensitiveMode<E> extends InsensitiveMode.Enabled ? {
+        insensitive?: boolean;
+    } : {};
+}

package/dist/services/order.d.ts

@@ -1,3 +1,6 @@
+import type { DecomposeIndexName } from './indexes.js';
+import type { TableMetadata } from './table.js';
+import type { Database } from './database.js';
 /**
  * Query order types.
  */
@@ -5,3 +8,31 @@ export declare const enum Order {
     Asc = "asc",
     Desc = "desc"
 }
+/**
+ * Order mode.
+ */
+export declare const enum OrderMode {
+    IndexColumns = "index",
+    AnyColumns = "any"
+}
+/**
+ * Order utils.
+ */
+export declare namespace OrderUtils {
+    /**
+     * Order input for index columns.
+     */
+    type IndexInput<I extends Database.Indexes> = {
+        [P in DecomposeIndexName<keyof I>]?: Order;
+    };
+    /**
+     * Order input for any columns.
+     */
+    type AnyInput<T extends Database.Schema> = {
+        [P in keyof T]?: Order;
+    };
+    /**
+     * Order input type based on the table metadata.
+     */
+    type Input<T extends TableMetadata> = T['engine']['orderMode'] extends OrderMode.IndexColumns ? IndexInput<T['indexes']> : AnyInput<T['schema']>;
+}

package/dist/services/pagination.d.ts

@@ -0,0 +1,45 @@
+import type { DatabaseEngine, EngineUtils } from './engine.js';
+/**
+ * Pagination mode.
+ */
+export declare const enum PaginationMode {
+    Cursor = "cursor",
+    Offset = "offset"
+}
+/**
+ * Pagination utils.
+ */
+export declare namespace PaginationUtils {
+    /**
+     * Get the pagination range based on the given database engine.
+     */
+    type Range<E extends DatabaseEngine> = EngineUtils.GetPaginationMode<E> extends PaginationMode.Cursor ? {
+        cursor?: string;
+        limit?: number;
+    } : {
+        skip?: number;
+        take?: number;
+    };
+    /**
+     * Get the pagination begin based on the given table metadata.
+     */
+    type Begin<E extends DatabaseEngine> = EngineUtils.GetPaginationMode<E> extends PaginationMode.Cursor ? {
+        cursor?: string;
+    } : {
+        skip?: number;
+    };
+    /**
+     * Get the pagination end based on the given table metadata.
+     */
+    type End<E extends DatabaseEngine> = EngineUtils.GetPaginationMode<E> extends PaginationMode.Cursor ? {
+        limit?: number;
+    } : {
+        take?: number;
+    };
+    /**
+     * Get the pagination result based on the given table metadata.
+     */
+    type Result<E extends DatabaseEngine> = EngineUtils.GetPaginationMode<E> extends PaginationMode.Cursor ? {
+        cursor?: string;
+    } : {};
+}

package/dist/services/parameters.d.ts

@@ -1,18 +1,18 @@
-import type { ParametersType } from './engine.js';
+import type { EngineUtils } from './engine.js';
 import type { Database } from './database.js';
 /**
- * Parameters builder types.
+ * Parameters mode.
  */
-export declare namespace Parameters {
-    /**
-     * Determines the parameters type based on the given database service.
-     */
-    export type Type<T extends Database.Service> = EngineParametersType<T> extends ParametersType.NameAndIndex ? unknown[] | Record<string, unknown> : unknown[];
+export declare const enum ParametersMode {
+    NameAndIndex = "both",
+    OnlyIndex = "index"
+}
+/**
+ * Parameters utils.
+ */
+export declare namespace ParametersUtils {
     /**
-     * Extract the parameters from the given database service.
+     * Get the parameters type based on the given database service.
      */
-    type EngineParametersType<T extends Database.Service> = T['engine'] extends {
-        parameters: infer R;
-    } ? R : never;
-    export {};
+    type Type<T extends Database.Service> = EngineUtils.GetParametersMode<T> extends ParametersMode.NameAndIndex ? unknown[] | Record<string, unknown> : unknown[];
 }

package/dist/services/query.d.ts

@@ -1,150 +1,149 @@
 import type { DecomposeIndexName, PrimaryIndexes, UniqueIndexes } from './indexes.js';
+import type { DatabaseEngine } from './engine.js';
 import type { RelationMetadata } from './relations.js';
+import type { InsensitiveUtils } from './insensitive.js';
+import type { PaginationUtils } from './pagination.js';
+import type { TableMetadata } from './table.js';
+import type { OrderUtils } from './order.js';
 import type { Database } from './database.js';
-import type { Order } from './order.js';
 import type { AnyObject, PartialProperties, PartialObject, FlatObject, OptionalObject, StrictObject, IsNullable, IsObjectEmpty, IsObject, IsArray } from '@ez4/utils';
 /**
  * Query builder types.
  */
 export declare namespace Query {
-    export type InsertOneInput<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = {
-        select?: StrictSelectInput<T, S, R>;
-        data: InsertDataInput<T, R>;
-    };
-    export type UpdateOneInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes, R extends RelationMetadata> = {
-        select?: StrictSelectInput<T, S, R>;
-        include?: StrictIncludeInput<S, R>;
-        data: OptionalObject<UpdateDataInput<T, R>>;
-        where: WhereInput<T, I, R>;
-    };
-    export type FindOneInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes, R extends RelationMetadata> = {
-        select: StrictSelectInput<T, S, R>;
-        include?: StrictIncludeInput<S, R>;
-        where: WhereInput<T, I, R>;
-    };
-    export type UpsertOneInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes, R extends RelationMetadata> = {
-        select?: StrictSelectInput<T, S, R>;
-        include?: StrictIncludeInput<S, R>;
-        update: OptionalObject<UpdateDataInput<T, R>>;
-        insert: InsertDataInput<T, R>;
-        where: WhereInput<T, I, R>;
-    };
-    export type DeleteOneInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes, R extends RelationMetadata> = {
-        select?: StrictSelectInput<T, S, R>;
-        include?: StrictIncludeInput<S, R>;
-        where: WhereInput<T, I, R>;
-    };
-    export type InsertManyInput<T extends Database.Schema = {}> = {
-        data: T[];
-    };
-    export type UpdateManyInput<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = {
-        select?: StrictSelectInput<T, S, R>;
-        include?: StrictIncludeInput<S, R>;
-        data: OptionalObject<UpdateDataInput<T, R>>;
-        where?: WhereInput<T, {}, R>;
-        limit?: number;
-    };
-    export type FindManyInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes, R extends RelationMetadata, C extends boolean> = {
+    export type InsertOneInput<S extends AnyObject, T extends TableMetadata> = {
+        select?: StrictSelectInput<S, T>;
+        data: InsertDataInput<T>;
+    };
+    export type UpdateOneInput<S extends AnyObject, T extends TableMetadata> = {
+        select?: StrictSelectInput<S, T>;
+        include?: StrictIncludeInput<S, T>;
+        data: OptionalObject<UpdateDataInput<T>>;
+        where: WhereInput<T, true>;
+    };
+    export type FindOneInput<S extends AnyObject, T extends TableMetadata> = {
+        select: StrictSelectInput<S, T>;
+        include?: StrictIncludeInput<S, T>;
+        where: WhereInput<T, true>;
+    };
+    export type UpsertOneInput<S extends AnyObject, T extends TableMetadata> = {
+        select?: StrictSelectInput<S, T>;
+        include?: StrictIncludeInput<S, T>;
+        update: OptionalObject<UpdateDataInput<T>>;
+        insert: InsertDataInput<T>;
+        where: WhereInput<T, true>;
+    };
+    export type DeleteOneInput<S extends AnyObject, T extends TableMetadata> = {
+        select?: StrictSelectInput<S, T>;
+        include?: StrictIncludeInput<S, T>;
+        where: WhereInput<T, true>;
+    };
+    export type InsertManyInput<T extends TableMetadata> = {
+        data: T['schema'][];
+    };
+    export type UpdateManyInput<S extends AnyObject, T extends TableMetadata> = PaginationUtils.End<T['engine']> & {
+        select?: StrictSelectInput<S, T>;
+        include?: StrictIncludeInput<S, T>;
+        data: OptionalObject<UpdateDataInput<T>>;
+        where?: WhereInput<T>;
+    };
+    export type FindManyInput<S extends AnyObject, T extends TableMetadata, C extends boolean> = PaginationUtils.Range<T['engine']> & {
         count?: C;
-        select: StrictSelectInput<T, S, R>;
-        include?: StrictIncludeInput<S, R>;
-        where?: WhereInput<T, {}, R>;
-        order?: OrderInput<I>;
-        cursor?: number | string;
-        limit?: number;
-    };
-    export type DeleteManyInput<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = {
-        select?: StrictSelectInput<T, S, R>;
-        include?: StrictIncludeInput<S, R>;
-        where?: WhereInput<T, {}, R>;
-        limit?: number;
-    };
-    export type CountInput<T extends Database.Schema, R extends RelationMetadata> = {
-        where?: WhereInput<T, {}, R>;
-    };
-    export type InsertOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = S extends never ? void : Record<T, S, R>;
-    export type UpdateOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = S extends never ? void : Record<T, S, R> | undefined;
-    export type FindOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = S extends never ? void : Record<T, S, R> | undefined;
-    export type UpsertOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = S extends never ? void : Record<T, S, R> | undefined;
-    export type DeleteOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = S extends never ? void : Record<T, S, R> | undefined;
-    export type UpdateManyResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = S extends never ? void : Record<T, S, R>[];
+        select: StrictSelectInput<S, T>;
+        include?: StrictIncludeInput<S, T>;
+        where?: WhereInput<T>;
+        order?: OrderInput<T>;
+    };
+    export type DeleteManyInput<S extends AnyObject, T extends TableMetadata> = PaginationUtils.End<T['engine']> & {
+        select?: StrictSelectInput<S, T>;
+        include?: StrictIncludeInput<S, T>;
+        where?: WhereInput<T>;
+    };
+    export type CountInput<T extends TableMetadata> = {
+        where?: WhereInput<T>;
+    };
+    export type InsertOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T>;
+    export type UpdateOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T> | undefined;
+    export type FindOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T> | undefined;
+    export type UpsertOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T>;
+    export type DeleteOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T> | undefined;
+    export type UpdateManyResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T>[];
     export type InsertManyResult = void;
-    export type FindManyResult<T extends Database.Schema, S extends Database.Schema, R extends RelationMetadata, C extends boolean> = C extends true ? {
-        records: Record<T, S, R>[];
-        cursor?: number | string;
+    export type FindManyResult<S extends AnyObject, T extends TableMetadata, C extends boolean> = PaginationUtils.Result<T['engine']> & (C extends true ? {
+        records: Record<S, T>[];
         total: number;
     } : {
-        records: Record<T, S, R>[];
-        cursor?: number | string;
-    };
-    export type DeleteManyResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = Record<T, S, R>[];
-    export type Record<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = S extends never ? undefined : PartialObject<SelectFields<T, R>, S, false>;
-    export type SelectInput<T extends Database.Schema, R extends RelationMetadata> = PartialProperties<SelectFields<T, R>>;
-    export type StrictSelectInput<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = StrictObject<S, FlatObject<SelectFields<T, R>>>;
-    export type InsertDataInput<T extends Database.Schema, R extends RelationMetadata> = Omit<IsObjectEmpty<R['changes']> extends true ? T : T & R['changes'], IndexFields<R>>;
-    export type UpdateDataInput<T extends Database.Schema, R extends RelationMetadata> = AtomicDataInput<Omit<IsObjectEmpty<R['changes']> extends true ? T : T & FlatObject<R['changes']>, IndexFields<R>>>;
-    export type StrictIncludeInput<S extends AnyObject, R extends RelationMetadata> = IsObjectEmpty<R['filters']> extends true ? never : IncludeFilters<R['filters'], S>;
-    export type OrderInput<I extends Database.Indexes> = {
-        [P in DecomposeIndexName<keyof I>]?: Order;
-    };
-    export type WhereInput<T extends Database.Schema, I extends Database.Indexes, R extends RelationMetadata> = WhereInputFilters<T, I, R> & {
-        NOT?: WhereInput<T, {}, R>;
-        AND?: WhereInput<T, {}, R>[];
-        OR?: WhereInput<T, {}, R>[];
-    };
-    type IndexFields<R extends RelationMetadata> = string extends R['indexes'] ? never : R['indexes'];
-    type SelectFields<T extends Database.Schema, R extends RelationMetadata> = IsObjectEmpty<R['selects']> extends true ? T : T & R['selects'];
-    type IncludeFilters<T extends AnyObject, S extends AnyObject> = {
-        [P in keyof T]?: P extends keyof S ? (IsObject<T[P]> extends true ? null | WhereRelationField<NonNullable<T[P]>> : never) : never;
+        records: Record<S, T>[];
+    });
+    export type DeleteManyResult<S extends AnyObject, T extends TableMetadata> = Record<S, T>[];
+    export type Record<S extends AnyObject, T extends TableMetadata> = S extends never ? undefined : PartialObject<SelectFields<T['schema'], T['relations']>, S, false>;
+    export type SelectInput<T extends TableMetadata> = PartialProperties<SelectFields<T['schema'], T['relations']>>;
+    export type StrictSelectInput<S extends AnyObject, T extends TableMetadata> = StrictObject<S, FlatObject<SelectFields<T['schema'], T['relations']>>>;
+    export type InsertDataInput<T extends TableMetadata> = Omit<IsObjectEmpty<T['relations']['changes']> extends true ? T['schema'] : T['schema'] & T['relations']['changes'], T['relations']['indexes']>;
+    export type UpdateDataInput<T extends TableMetadata> = AtomicDataInput<Omit<IsObjectEmpty<T['relations']['changes']> extends true ? T['schema'] : T['schema'] & FlatObject<T['relations']['changes']>, T['relations']['indexes']>>;
+    export type OrderInput<T extends TableMetadata> = OrderUtils.Input<T>;
+    export type StrictIncludeInput<S extends AnyObject, T extends TableMetadata> = IsObjectEmpty<T['relations']['filters']> extends true ? never : {
+        [P in keyof T['relations']['filters']]?: P extends keyof S ? StrictIncludeRelation<T['relations']['filters'][P], T['engine']> : never;
+    };
+    export type StrictIncludeOrder<V extends AnyObject> = OrderUtils.AnyInput<V>;
+    export type StrictIncludeRelation<V extends AnyObject, E extends DatabaseEngine> = PaginationUtils.Range<E> & {
+        where?: WhereRelationField<V, E>;
+        order?: StrictIncludeOrder<V>;
+    };
+    export type WhereInput<T extends TableMetadata, I extends boolean = false> = WhereInputFilters<T, I extends true ? T['indexes'] : {}> & {
+        NOT?: WhereInput<T>;
+        AND?: WhereInput<T>[];
+        OR?: WhereInput<T>[];
     };
-    type WhereOperations<T> = WhereNegate<T> | WhereEqual<T> | WhereGreaterThan<T> | WhereGreaterThanOrEqual<T> | WhereLessThan<T> | WhereLessThanOrEqual<T> | WhereIn<T> | WhereBetween<T> | WhereIsMissing | WhereIsNull | WhereStartsWith | WhereContains<T>;
-    type WhereField<T> = IsObject<T> extends false ? T | WhereOperations<T> : IsNullable<T> extends true ? null | WhereObjectField<NonNullable<T>> : WhereObjectField<NonNullable<T>>;
-    type WhereObjectField<T extends AnyObject> = {
-        [P in keyof T]?: WhereField<T[P]>;
+    type SelectFields<T extends Database.Schema, R extends RelationMetadata> = IsObjectEmpty<R['selects']> extends true ? T : T & R['selects'];
+    type WhereOperations<V, E extends DatabaseEngine> = WhereNegate<V> | WhereEqual<V> | WhereGreaterThan<V> | WhereGreaterThanOrEqual<V> | WhereLessThan<V> | WhereLessThanOrEqual<V> | WhereIn<V> | WhereBetween<V> | WhereIsMissing | WhereIsNull | WhereStartsWith<E> | WhereContains<V, E>;
+    type WhereField<V, E extends DatabaseEngine> = IsObject<V> extends false ? V | WhereOperations<V, E> : IsNullable<V> extends true ? null | WhereObjectField<NonNullable<V>, E> : WhereObjectField<NonNullable<V>, E>;
+    type WhereObjectField<V extends AnyObject, E extends DatabaseEngine> = {
+        [P in keyof V]?: WhereField<V[P], E>;
     };
-    type WhereRelationField<T extends AnyObject> = WhereObjectField<T> & {
-        NOT?: WhereRelationField<T>;
-        AND?: WhereRelationField<T>[];
-        OR?: WhereRelationField<T>[];
+    type WhereRelationField<V extends AnyObject, E extends DatabaseEngine> = WhereObjectField<V, E> & {
+        NOT?: WhereRelationField<V, E>;
+        AND?: WhereRelationField<V, E>[];
+        OR?: WhereRelationField<V, E>[];
     };
-    type WhereRelationFilters<T extends AnyObject> = {
-        [P in keyof T]?: IsObject<T[P]> extends true ? IsObjectEmpty<T[P]> extends false ? null | WhereRelationField<T[P]> : null | {} : never;
+    type WhereRelationFilters<V extends AnyObject, E extends DatabaseEngine> = {
+        [P in keyof V]?: IsObject<V[P]> extends true ? IsObjectEmpty<V[P]> extends false ? null | WhereRelationField<V[P], E> : null | {} : never;
     };
     type WhereIndexFields<I extends Database.Indexes> = PrimaryIndexes<I> & UniqueIndexes<I>;
-    type WhereRequiredFilters<T extends AnyObject, I extends Database.Indexes> = {
+    type WhereRequiredFilters<V extends AnyObject, I extends Database.Indexes> = {
         [P in keyof WhereIndexFields<I>]: {
-            [N in DecomposeIndexName<P>]: T[N];
+            [N in DecomposeIndexName<P>]: V[N];
         };
     }[keyof WhereIndexFields<I>];
-    type WhereOptionalFilters<T extends AnyObject, I extends Database.Indexes> = {
-        [P in Exclude<keyof T, keyof WhereIndexFields<I>>]?: WhereField<T[P]>;
+    type WhereOptionalFilters<V extends AnyObject, T extends TableMetadata, I extends Database.Indexes> = {
+        [P in Exclude<keyof V, keyof WhereIndexFields<I>>]?: WhereField<V[P], T['engine']>;
     };
-    type WhereCommonFilters<T extends AnyObject, I extends Database.Indexes> = IsObjectEmpty<I> extends true ? WhereObjectField<T> : WhereRequiredFilters<T, I> & WhereOptionalFilters<T, I>;
-    type WhereInputFilters<T extends Database.Schema, I extends Database.Indexes, R extends RelationMetadata> = WhereCommonFilters<T, I> & WhereRelationFilters<R['filters']>;
-    export type WhereOperators = keyof (WhereNegate<any> & WhereEqual<any> & WhereGreaterThan<any> & WhereGreaterThanOrEqual<any> & WhereLessThan<any> & WhereLessThanOrEqual<any> & WhereIn<any> & WhereBetween<any> & WhereIsMissing & WhereIsNull & WhereStartsWith & WhereContains<any>);
-    type WhereNegate<T> = {
-        not: T | WhereOperations<T>;
+    type WhereCommonFilters<V extends AnyObject, T extends TableMetadata, I extends Database.Indexes> = IsObjectEmpty<I> extends true ? WhereObjectField<V, T['engine']> : WhereRequiredFilters<V, I> & WhereOptionalFilters<V, T, I>;
+    type WhereInputFilters<T extends TableMetadata, I extends Database.Indexes> = WhereCommonFilters<T['schema'], T, I> & WhereRelationFilters<T['relations']['filters'], T['engine']>;
+    export type WhereOperators = keyof (WhereNegate<any> & WhereEqual<any> & WhereGreaterThan<any> & WhereGreaterThanOrEqual<any> & WhereLessThan<any> & WhereLessThanOrEqual<any> & WhereIn<any> & WhereBetween<any> & WhereIsMissing & WhereIsNull & WhereStartsWith<never> & WhereContains<any, never>);
+    type WhereNegate<V> = {
+        not: V;
     };
-    type WhereEqual<T> = {
-        equal: T;
+    type WhereEqual<V> = {
+        equal: V;
     };
-    type WhereGreaterThan<T> = {
-        gt: T;
+    type WhereGreaterThan<V> = {
+        gt: V;
     };
-    type WhereGreaterThanOrEqual<T> = {
-        gte: T;
+    type WhereGreaterThanOrEqual<V> = {
+        gte: V;
     };
-    type WhereLessThan<T> = {
-        lt: T;
+    type WhereLessThan<V> = {
+        lt: V;
     };
-    type WhereLessThanOrEqual<T> = {
-        lte: T;
+    type WhereLessThanOrEqual<V> = {
+        lte: V;
     };
-    type WhereIn<T> = {
-        isIn: IsArray<T> extends true ? T : IsObject<T> extends true ? T : T[];
+    type WhereIn<V> = {
+        isIn: IsArray<V> extends true ? V : IsObject<V> extends true ? V : V[];
     };
-    type WhereBetween<T> = {
-        isBetween: [T, T];
+    type WhereBetween<V> = {
+        isBetween: [V, V];
     };
     type WhereIsMissing = {
         isMissing: boolean;
@@ -152,11 +151,11 @@ export declare namespace Query {
     type WhereIsNull = {
         isNull: boolean;
     };
-    type WhereStartsWith = {
+    type WhereStartsWith<E extends DatabaseEngine> = InsensitiveUtils.Input<E> & {
         startsWith: string;
     };
-    type WhereContains<T> = {
-        contains: IsObject<T> extends true ? Partial<T> : T;
+    type WhereContains<V, E extends DatabaseEngine> = (V extends string ? InsensitiveUtils.Input<E> : {}) & {
+        contains: IsObject<V> extends true ? Partial<V> : V;
     };
     export type AtomicOperators = keyof (AtomicIncrement & AtomicDecrement & AtomicMultiply & AtomicDivide);
     type AtomicDataInput<T extends AnyObject> = AtomicRequiredFields<T> & AtomicOptionalFields<T>;

package/dist/services/relations.d.ts

@@ -6,10 +6,10 @@ import type { TableSchemas } from './schemas.js';
  * Internal relation type.
  */
 export type RelationMetadata = {
+    filters: Record<string, {}>;
+    selects: Record<string, {}>;
+    changes: Record<string, {}>;
     indexes: string;
-    filters: Record<string, unknown>;
-    selects: Record<string, unknown>;
-    changes: Record<string, unknown>;
 };
 /**
  * Given a relation source name `T`, it produces the source table name.
@@ -44,23 +44,23 @@ type TableRelation<T, S extends Record<string, Database.Schema>, I extends Recor
     relations: infer R;
 } ? N extends string ? R extends AnyObject ? {
     [P in N]: {
-        indexes: RequiredRelationIndexes<PropertyType<N, S>, I, R>;
-        filters: FilterableRelationSchemas<S, I, R>;
+        indexes: RelationIndexes<PropertyType<N, I>, R>;
+        filters: FilterableRelationSchemas<S, R>;
         changes: RequiredRelationSchemas<PropertyType<N, S>, S, I, R, true> & OptionalRelationSchemas<PropertyType<N, S>, S, I, R, true>;
         selects: RequiredRelationSchemas<PropertyType<N, S>, S, I, R, false> & OptionalRelationSchemas<PropertyType<N, S>, S, I, R, false>;
     };
 } : {} : {} : {};
 /**
- * Produce an object containing all required relation indexes.
+ * Produce an object containing all relation indexes.
  */
-type RequiredRelationIndexes<T extends Database.Schema, I extends Record<string, Database.Indexes>, R extends AnyObject> = keyof {
-    [C in keyof R as IsOptionalRelation<R[C], C, T, I, true> extends true ? never : RelationTargetColumn<C>]: never;
+type RelationIndexes<I extends Database.Indexes, R extends AnyObject> = keyof {
+    [C in keyof R as RelationTargetColumn<C> extends keyof PrimaryIndexes<I> ? never : RelationTargetColumn<C>]: never;
 };
 /**
  * Produce an object containing all filterable relation schemas.
  */
-type FilterableRelationSchemas<S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
-    [C in keyof R as RelationTargetAlias<C>]: IsPrimaryIndex<R[C], I> extends false ? Omit<PropertyType<RelationSourceTable<R[C]>, S>, RelationSourceColumn<R[C]>> : PropertyType<RelationSourceTable<R[C]>, S>;
+type FilterableRelationSchemas<S extends Record<string, Database.Schema>, R extends AnyObject> = {
+    [C in keyof R as RelationTargetAlias<C>]: Omit<PropertyType<RelationSourceTable<R[C]>, S>, RelationSourceColumn<R[C]>>;
 };
 /**
  * Produce an object containing only required relation schemas.