@apisr/drizzle-model 2.0.2 → 2.0.3

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { CockroachDbDialect, ModelDialect, MssqlDialect, MySqlDialect, PgDialect, ReturningIdDialects, SingleStoreDialect, SqlLiteDialect, UnknownDialect } from "./model/dialect.mjs";
-import { AddToValues, AddUnionToValues, Compose, Fallback, RecursiveBooleanRecord, Replace, UnwrapArray } from "./types.mjs";
+import { AddToValues, AddUnionToValues, ApplyArrayIf, ApplyArrayIfArray, Compose, Fallback, InferArrayItem, MergeExclusive, RecursiveBooleanRecord, Replace, Simplify, UnwrapArray } from "./types.mjs";
 import { IsTable, NormalizeTable, TableColumn, TableColumns, TableInsertModel, TableInsertValues, TableOneRelationsTableName, TableOutput, TableRelationsTableName } from "./model/table.mjs";
 import { MethodInsertValue, MethodWithInsertValue } from "./model/methods/insert.mjs";
 import { MethodUpdateValue } from "./model/methods/update.mjs";
@@ -7,11 +7,11 @@ import { MethodUpsertContext, MethodUpsertContextFunction, MethodUpsertUpdate, M
 import { ApplyRelationCardinality, RelationKind, RelationMeta, RelationTargetRow, ResolveRelationSelection, ResolveSingleRelation, TargetTable } from "./model/relation.mjs";
 import { MethodWithResult, MethodWithValue } from "./model/methods/with.mjs";
 import { ComposeModelOptions, MergeModelOptionsMethods, ModelMethodsFactory, ModelOptionFormat, ModelOptions, ResolveOptionsFormat, ResolveOptionsMethods } from "./model/options.mjs";
-import { ModelFormatValue } from "./model/format.mjs";
+import { ModelFormatResult, ResolveFormatCustomFields } from "./model/format.mjs";
 import { MethodSelectResult, MethodSelectValue, ResolveMethodSelectValue } from "./model/methods/select.mjs";
 import { MethodExcludeResult, MethodExcludeValue, ResolveMethodExcludeValue } from "./model/methods/exclude.mjs";
 import { GetPrimarySerialOrDefaultKeys, MethodReturnResult, PrimaryKeyKeys } from "./model/methods/return.mjs";
-import { ModelMutateResult, ModelQueryResult } from "./model/result.mjs";
+import { ApplySafeResultIf, ModelInMutableResult, ModelMutateResult, ModelQueryResult, SafeResult } from "./model/result.mjs";
 import { Model, ModelBase, ModelIdentifier, ModelMethods, ModelQueryMethods } from "./model/model.mjs";
 import { BoolOps, ColumnOps, ColumnOpsBase, ColumnValue, DateOps, DrizzleColumnDataType, EscapedValue, JsonOps, LogicalOps, NumberOps, StringOps, TypeOps, esc } from "./model/query/operations.mjs";
 import { MethodIncludeIdentifier } from "./model/methods/include.mjs";
@@ -22,4 +22,4 @@ import { ModelForegins } from "./model/foreigns.mjs";
 import { ModelFirstLevelMethods, ModelLevelMethods } from "./model/methods/levels.mjs";
 import { ModelShape } from "./model/shape.mjs";
 import "./model/index.mjs";
-export { AddToValues, AddUnionToValues, ApplyRelationCardinality, BoolOps, CockroachDbDialect, ColumnOps, ColumnOpsBase, ColumnValue, Compose, ComposeModelOptions, DateOps, DrizzleColumnDataType, EscapedValue, Fallback, GetPrimarySerialOrDefaultKeys, IsTable, JsonOps, LogicalOps, MergeModelOptionsMethods, MethodExcludeResult, MethodExcludeValue, MethodIncludeIdentifier, MethodInsertValue, MethodReturnResult, MethodSelectResult, MethodSelectValue, MethodUpdateValue, MethodUpsertContext, MethodUpsertContextFunction, MethodUpsertUpdate, MethodUpsertUpdateValue, MethodUpsertUpdateWhere, MethodUpsertValue, MethodWhereColumns, MethodWhereRelations, MethodWhereValue, MethodWithInsertValue, MethodWithResult, MethodWithValue, Model, ModelBase, ModelConfig, ModelDialect, ModelFirstLevelMethods, ModelForegins, ModelFormatValue, ModelIdentifier, ModelLevelMethods, ModelMethods, ModelMethodsFactory, ModelMutateResult, ModelOptionFormat, ModelOptions, ModelQueryMethods, ModelQueryResult, ModelShape, MssqlDialect, MySqlDialect, NormalizeTable, NumberOps, PgDialect, PrimaryKeyKeys, RecursiveBooleanRecord, RelationKind, RelationMeta, RelationTargetRow, RelationWhere, Replace, ResolveMethodExcludeValue, ResolveMethodSelectValue, ResolveOptionsFormat, ResolveOptionsMethods, ResolveRelationSelection, ResolveSingleRelation, ReturningIdDialects, SingleStoreDialect, SqlLiteDialect, StringOps, TableColumn, TableColumns, TableInsertModel, TableInsertValues, TableOneRelationsTableName, TableOutput, TableRelationsTableName, TargetTable, TypeOps, UnknownDialect, UnwrapArray, esc, modelBuilder };
+export { AddToValues, AddUnionToValues, ApplyArrayIf, ApplyArrayIfArray, ApplyRelationCardinality, ApplySafeResultIf, BoolOps, CockroachDbDialect, ColumnOps, ColumnOpsBase, ColumnValue, Compose, ComposeModelOptions, DateOps, DrizzleColumnDataType, EscapedValue, Fallback, GetPrimarySerialOrDefaultKeys, InferArrayItem, IsTable, JsonOps, LogicalOps, MergeExclusive, MergeModelOptionsMethods, MethodExcludeResult, MethodExcludeValue, MethodIncludeIdentifier, MethodInsertValue, MethodReturnResult, MethodSelectResult, MethodSelectValue, MethodUpdateValue, MethodUpsertContext, MethodUpsertContextFunction, MethodUpsertUpdate, MethodUpsertUpdateValue, MethodUpsertUpdateWhere, MethodUpsertValue, MethodWhereColumns, MethodWhereRelations, MethodWhereValue, MethodWithInsertValue, MethodWithResult, MethodWithValue, Model, ModelBase, ModelConfig, ModelDialect, ModelFirstLevelMethods, ModelForegins, ModelFormatResult, ModelIdentifier, ModelInMutableResult, ModelLevelMethods, ModelMethods, ModelMethodsFactory, ModelMutateResult, ModelOptionFormat, ModelOptions, ModelQueryMethods, ModelQueryResult, ModelShape, MssqlDialect, MySqlDialect, NormalizeTable, NumberOps, PgDialect, PrimaryKeyKeys, RecursiveBooleanRecord, RelationKind, RelationMeta, RelationTargetRow, RelationWhere, Replace, ResolveFormatCustomFields, ResolveMethodExcludeValue, ResolveMethodSelectValue, ResolveOptionsFormat, ResolveOptionsMethods, ResolveRelationSelection, ResolveSingleRelation, ReturningIdDialects, SafeResult, Simplify, SingleStoreDialect, SqlLiteDialect, StringOps, TableColumn, TableColumns, TableInsertModel, TableInsertValues, TableOneRelationsTableName, TableOutput, TableRelationsTableName, TargetTable, TypeOps, UnknownDialect, UnwrapArray, esc, modelBuilder };

package/dist/model/builder.mjs

@@ -1,9 +1,9 @@
-import { makeModelRuntime } from "./core/runtime.mjs";
+import { ModelRuntime } from "../core/runtime.mjs";
 
 //#region src/model/builder.ts
 function modelBuilder({ db, relations, schema, dialect }) {
 	return (table, options) => {
-		return makeModelRuntime({
+		const runtime = new ModelRuntime({
 			db,
 			relations,
 			schema,
@@ -11,6 +11,26 @@ function modelBuilder({ db, relations, schema, dialect }) {
 			dialect,
 			options: options ?? {}
 		});
+		const target = {};
+		for (const key of Object.getOwnPropertyNames(Object.getPrototypeOf(runtime))) {
+			if (key === "constructor") continue;
+			const value = runtime[key];
+			if (typeof value === "function") target[key] = value.bind(runtime);
+		}
+		Object.defineProperty(target, "$model", {
+			get: () => runtime.$model,
+			enumerable: true
+		});
+		Object.defineProperty(target, "$modelName", {
+			get: () => runtime.$modelName,
+			enumerable: true
+		});
+		Object.defineProperty(target, "$format", {
+			get: () => runtime.$format,
+			enumerable: true
+		});
+		runtime.attachMethods(target);
+		return target;
 	};
 }
 

package/dist/model/config.d.mts

@@ -7,17 +7,17 @@ import { MethodWhereValue } from "./methods/query/where.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 
 //#region src/model/config.d.ts
-type ModelConfig<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTable extends TableRelationalConfig = TableRelationalConfig, TDialect extends ModelDialect = ModelDialect, TOptions extends ModelOptions<any> = ModelOptions<any>> = {
-  schema: TSchema;
-  table: TTable;
+interface ModelConfig<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTable extends TableRelationalConfig = TableRelationalConfig, TDialect extends ModelDialect = ModelDialect, TOptions extends ModelOptions<any> = ModelOptions<any>> {
   dialect: TDialect;
   options: TOptions;
-  tableOutput: TableOutput<TTable>;
-  tableColumns: IsTable<TTable["table"]>["_"]["columns"];
   optionsFormat: ResolveOptionsFormat<TOptions["format"]>;
   primaryKeys: keyof GetPrimarySerialOrDefaultKeys<IsTable<TTable["table"]>["_"]["columns"]>;
   primaryKeysWithDataType: { [TKey in keyof GetPrimarySerialOrDefaultKeys<IsTable<TTable["table"]>["_"]["columns"]>]: DrizzleColumnDataType<IsTable<TTable["table"]>["_"]["columns"][TKey]> };
+  schema: TSchema;
+  table: TTable;
+  tableColumns: IsTable<TTable["table"]>["_"]["columns"];
+  tableOutput: TableOutput<TTable>;
   whereValue: MethodWhereValue<TSchema, TTable>;
-};
+}
 //#endregion
 export { ModelConfig };

package/dist/model/format.d.mts

@@ -1,4 +1,8 @@
+import { TableRelationalConfig } from "drizzle-orm/relations";
+import { TableColumns } from "dist/index.mjs";
+
 //#region src/model/format.d.ts
-type ModelFormatValue<TValue extends Record<string, any>, TFormat extends Record<string, any> | undefined> = TFormat extends undefined ? TValue : TValue extends (infer TItem)[] ? TItem extends Record<string, any> ? ModelFormatValue<TItem, TFormat>[] : TValue : Omit<TValue, keyof TFormat> & TFormat;
+type ModelFormatResult<TResult extends Record<string, any>, TFormat extends Record<string, any> | undefined, TTable extends TableRelationalConfig> = TFormat extends undefined ? TResult : Pick<TResult, keyof TFormat & string> & ResolveFormatCustomFields<Exclude<TFormat, undefined>, TTable>;
+type ResolveFormatCustomFields<TFormat extends Record<string, any>, TTable extends TableRelationalConfig> = { [TKey in keyof TFormat as TableColumns<TTable>[TKey & string] extends never ? never : TKey & string]: TFormat[TKey & string] };
 //#endregion
-export { ModelFormatValue };
+export { ModelFormatResult, ResolveFormatCustomFields };

package/dist/model/index.d.mts

@@ -6,11 +6,11 @@ import { MethodUpsertContext, MethodUpsertContextFunction, MethodUpsertUpdate, M
 import { ApplyRelationCardinality, RelationKind, RelationMeta, RelationTargetRow, ResolveRelationSelection, ResolveSingleRelation, TargetTable } from "./relation.mjs";
 import { MethodWithResult, MethodWithValue } from "./methods/with.mjs";
 import { ComposeModelOptions, MergeModelOptionsMethods, ModelMethodsFactory, ModelOptionFormat, ModelOptions, ResolveOptionsFormat, ResolveOptionsMethods } from "./options.mjs";
-import { ModelFormatValue } from "./format.mjs";
+import { ModelFormatResult, ResolveFormatCustomFields } from "./format.mjs";
 import { MethodSelectResult, MethodSelectValue, ResolveMethodSelectValue } from "./methods/select.mjs";
 import { MethodExcludeResult, MethodExcludeValue, ResolveMethodExcludeValue } from "./methods/exclude.mjs";
 import { GetPrimarySerialOrDefaultKeys, MethodReturnResult, PrimaryKeyKeys } from "./methods/return.mjs";
-import { ModelMutateResult, ModelQueryResult } from "./result.mjs";
+import { ApplySafeResultIf, ModelInMutableResult, ModelMutateResult, ModelQueryResult, SafeResult } from "./result.mjs";
 import { Model, ModelBase, ModelIdentifier, ModelMethods, ModelQueryMethods } from "./model.mjs";
 import { BoolOps, ColumnOps, ColumnOpsBase, ColumnValue, DateOps, DrizzleColumnDataType, EscapedValue, JsonOps, LogicalOps, NumberOps, StringOps, TypeOps, esc } from "./query/operations.mjs";
 import { MethodIncludeIdentifier } from "./methods/include.mjs";

package/dist/model/methods/exclude.d.mts

@@ -2,7 +2,7 @@ import { MethodSelectValue } from "./select.mjs";
 
 //#region src/model/methods/exclude.d.ts
 type ResolveMethodExcludeValue<TValue extends Record<string, any>, TResult extends Record<string, any>> = { [Key in keyof TResult as TValue[Key & string] extends true ? never : Key]: TValue[Key & string] extends object ? TResult[Key & string] extends (infer RItem)[] ? RItem extends Record<string, any> ? ResolveMethodExcludeValue<TValue[Key & string], RItem>[] : never : TResult[Key & string] extends Record<string, any> ? ResolveMethodExcludeValue<TValue[Key & string], TResult[Key & string]> : never : TResult[Key & string] };
-type MethodExcludeResult<TValue extends Record<string, any>, TResult extends Record<string, any>> = TResult extends any[] ? TResult extends (infer RItem)[] ? RItem extends Record<string, any> ? ResolveMethodExcludeValue<TValue, RItem>[] : ResolveMethodExcludeValue<TValue, TResult>[] : ResolveMethodExcludeValue<TValue, TResult> : ResolveMethodExcludeValue<TValue, TResult>;
+type MethodExcludeResult<TValue extends Record<string, any>, TResult extends Record<string, any>> = ResolveMethodExcludeValue<TValue, TResult>;
 type MethodExcludeValue<TResult extends Record<string, any>> = MethodSelectValue<TResult>;
 //#endregion
 export { MethodExcludeResult, MethodExcludeValue, ResolveMethodExcludeValue };

package/dist/model/methods/return.d.mts

@@ -1,5 +1,5 @@
 import { ReturningIdDialects } from "../dialect.mjs";
-import { ModelFormatValue } from "../format.mjs";
+import { ModelFormatResult } from "../format.mjs";
 import { ModelConfig } from "../config.mjs";
 import { Column } from "drizzle-orm";
 import { InferModelFromColumns } from "drizzle-orm/table";
@@ -7,6 +7,6 @@ import { InferModelFromColumns } from "drizzle-orm/table";
 //#region src/model/methods/return.d.ts
 type PrimaryKeyKeys<T extends Record<string, Column>> = { [K in keyof T]: T[K]["_"]["isPrimaryKey"] extends true ? K : never }[keyof T];
 type GetPrimarySerialOrDefaultKeys<T extends Record<string, Column>> = { [K in PrimaryKeyKeys<T>]: T[K] };
-type MethodReturnResult<TResultType extends string, TConfig extends ModelConfig> = TConfig["dialect"] extends ReturningIdDialects ? InferModelFromColumns<GetPrimarySerialOrDefaultKeys<TConfig["tableColumns"]>> : TResultType extends "many" ? ModelFormatValue<TConfig["tableOutput"], TConfig["optionsFormat"]>[] : ModelFormatValue<TConfig["tableOutput"], TConfig["optionsFormat"]>;
+type MethodReturnResult<TConfig extends ModelConfig> = TConfig["dialect"] extends ReturningIdDialects ? InferModelFromColumns<GetPrimarySerialOrDefaultKeys<TConfig["tableColumns"]>> : ModelFormatResult<TConfig["tableOutput"], TConfig["optionsFormat"], TConfig["table"]>;
 //#endregion
 export { GetPrimarySerialOrDefaultKeys, MethodReturnResult, PrimaryKeyKeys };

package/dist/model/methods/select.d.mts

@@ -2,7 +2,7 @@ import { UnwrapArray } from "../../types.mjs";
 
 //#region src/model/methods/select.d.ts
 type ResolveMethodSelectValue<TValue extends Record<string, any>, TResult extends Record<string, any>> = { [Key in keyof TValue]: TValue[Key] extends object ? TResult[Key & string] extends (infer RItem)[] ? RItem extends Record<string, any> ? ResolveMethodSelectValue<TValue[Key], RItem>[] : never : TResult[Key & string] extends Record<string, any> ? ResolveMethodSelectValue<TValue[Key], TResult[Key & string]> : never : TResult[Key & string] };
-type MethodSelectResult<TValue extends Record<string, any>, TResult extends Record<string, any> | any[]> = TResult extends any[] ? TResult extends (infer RItem)[] ? RItem extends Record<string, any> ? ResolveMethodSelectValue<TValue, RItem>[] : ResolveMethodSelectValue<TValue, TResult>[] : ResolveMethodSelectValue<TValue, TResult> : ResolveMethodSelectValue<TValue, TResult>;
+type MethodSelectResult<TValue extends Record<string, any>, TResult extends Record<string, any>> = ResolveMethodSelectValue<TValue, TResult>;
 type MethodSelectValue<TResult extends object> = TResult extends readonly (infer U)[] ? U extends object ? MethodSelectValue<U> : never : { [Key in keyof TResult]?: UnwrapArray<TResult[Key]> extends object ? MethodSelectValue<UnwrapArray<TResult[Key]>> | boolean : boolean };
 //#endregion
 export { MethodSelectResult, MethodSelectValue, ResolveMethodSelectValue };

package/dist/model/model.d.mts

@@ -1,11 +1,10 @@
-import { ModelDialect } from "./dialect.mjs";
 import { Replace } from "../types.mjs";
 import { MethodInsertValue } from "./methods/insert.mjs";
 import { MethodUpdateValue } from "./methods/update.mjs";
 import { MethodUpsertValue } from "./methods/upsert.mjs";
 import { MethodWithValue } from "./methods/with.mjs";
-import { ComposeModelOptions, ModelOptions, ResolveOptionsFormat, ResolveOptionsMethods } from "./options.mjs";
-import { ModelMutateResult, ModelQueryResult } from "./result.mjs";
+import { ComposeModelOptions, ModelOptions, ResolveOptionsMethods } from "./options.mjs";
+import { ModelInMutableResult, ModelQueryResult } from "./result.mjs";
 import { MethodWhereValue } from "./methods/query/where.mjs";
 import { ModelConfig } from "./config.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
@@ -17,11 +16,12 @@ import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relat
  * @typeParam TSchema - Full relational schema
  * @typeParam TTable - Relational configuration for the current table
  */
-interface ModelMethods<TConfig extends ModelConfig, TSchema extends TablesRelationalConfig = TConfig["schema"], TTable extends TableRelationalConfig = TConfig["table"], TDialect extends ModelDialect = TConfig["dialect"]> {
+interface ModelMethods<TConfig extends ModelConfig, TSchema extends TablesRelationalConfig = TConfig["schema"], TTable extends TableRelationalConfig = TConfig["table"]> {
+  count(): Promise<number>;
   /**
    * Deletes rows that match the current model query.
    */
-  delete(): ModelMutateResult<void, TConfig, "many">;
+  delete(): ModelInMutableResult<never, TConfig>;
   /**
    * Fetches the first matching row for the current model query.
    */
@@ -41,19 +41,19 @@ interface ModelMethods<TConfig extends ModelConfig, TSchema extends TablesRelati
    *
    * @param value - Insert payload or batch payload
    */
-  insert<TValue extends MethodInsertValue<TTable>>(value: TValue): ModelMutateResult<void, TConfig, TValue extends any[] ? "many" : "one">;
+  insert<TValue extends MethodInsertValue<TTable>>(value: TValue): ModelInMutableResult<never, TConfig>;
   /**
    * Updates rows that match the current model query.
    *
    * @param value - Update payload
    */
-  update<TValue extends MethodUpdateValue<TTable>>(value: TValue): ModelMutateResult<void, TConfig, "many">;
+  update<TValue extends MethodUpdateValue<TTable>>(value: TValue): ModelInMutableResult<never, TConfig>;
   /**
    * Inserts or updates rows based on conflict criteria.
    *
    * @param value - Upsert payload or batch payload
    */
-  upsert<TValue extends MethodUpsertValue<TConfig>>(value: TValue): ModelMutateResult<void, TConfig, TValue["insert"] extends any[] ? "many" : "one">;
+  upsert<TValue extends MethodUpsertValue<TConfig>>(value: TValue): ModelInMutableResult<never, TConfig>;
   /**
    * Adds a where clause to the current model query.
    *
@@ -93,13 +93,11 @@ type ModelBase<TConfig extends ModelConfig> = ModelMethods<TConfig> & ModelQuery
  * @typeParam TConfig - Config that includes all related information about tables, relations and etc...
  */
 type Model<TConfig extends ModelConfig> = ModelIdentifier<TConfig["table"]["name"]> & ModelBase<TConfig> & ResolveOptionsMethods<TConfig["options"]["methods"]> & {
-  $format: TConfig["options"]["format"];
-  $formatValue: ResolveOptionsFormat<TConfig["options"]["format"]>;
   $$config: TConfig;
 };
-type ModelIdentifier<ModelName> = {
+interface ModelIdentifier<ModelName> {
   $model: "model";
   $modelName: ModelName;
-};
+}
 //#endregion
 export { Model, ModelBase, ModelIdentifier, ModelMethods, ModelQueryMethods };

package/dist/model/query/error.d.mts

@@ -0,0 +1,4 @@
+//#region src/model/query/error.d.ts
+interface QueryError extends Error {}
+//#endregion
+export { QueryError };

package/dist/model/query/operations.d.mts

@@ -12,53 +12,53 @@ type EscapedValue<T> = {
   value: T;
 };
 type OpValue<T> = T | SQL | EscapedValue<T>;
-type ColumnOpsBase<T> = {
+interface ColumnOpsBase<T> {
   eq?: OpValue<T>;
   equal?: OpValue<T>;
-  not?: OpValue<T>;
   in?: OpValue<T>[];
-  nin?: OpValue<T>[];
   isNull?: boolean;
-};
-type NumberOps = {
+  nin?: OpValue<T>[];
+  not?: OpValue<T>;
+}
+interface NumberOps {
+  between?: [OpValue<number>, OpValue<number>];
   gt?: OpValue<number>;
   gte?: OpValue<number>;
   lt?: OpValue<number>;
   lte?: OpValue<number>;
-  between?: [OpValue<number>, OpValue<number>];
   notBetween?: [OpValue<number>, OpValue<number>];
-};
-type StringOps = {
-  like?: OpValue<string>;
-  ilike?: OpValue<string>;
-  startsWith?: OpValue<string>;
-  endsWith?: OpValue<string>;
+}
+interface StringOps {
   contains?: OpValue<string>;
-  regex?: OpValue<string>;
-  notRegex?: OpValue<string>;
+  endsWith?: OpValue<string>;
+  ilike?: OpValue<string>;
   length?: NumberOps;
-};
-type BoolOps = {
-  isTrue?: boolean;
+  like?: OpValue<string>;
+  notRegex?: OpValue<string>;
+  regex?: OpValue<string>;
+  startsWith?: OpValue<string>;
+}
+interface BoolOps {
   isFalse?: boolean;
-};
-type DateOps = {
-  before?: OpValue<Date | string>;
+  isTrue?: boolean;
+}
+interface DateOps {
   after?: OpValue<Date | string>;
-  on?: OpValue<Date | string>;
-  notOn?: OpValue<Date | string>;
+  before?: OpValue<Date | string>;
   between?: [OpValue<Date | string>, OpValue<Date | string>];
-};
-type JsonOps<T> = {
+  notOn?: OpValue<Date | string>;
+  on?: OpValue<Date | string>;
+}
+interface JsonOps<T> {
   has?: T;
-  hasAny?: T[];
   hasAll?: T[];
+  hasAny?: T[];
   len?: NumberOps;
-};
-type LogicalOps<TColumn extends Column> = {
-  or?: ColumnValue<TColumn>[];
+}
+interface LogicalOps<TColumn extends Column> {
   and?: ColumnValue<TColumn>[];
-};
+  or?: ColumnValue<TColumn>[];
+}
 type TypeOps<T> = T extends number ? NumberOps : T extends string ? StringOps : T extends boolean ? BoolOps : T extends Date ? DateOps : T extends any[] ? JsonOps<T[number]> : {};
 type ColumnOps<TColumn extends Column, TDataType extends DrizzleColumnDataType<TColumn>> = ColumnOpsBase<TDataType> & TypeOps<TDataType> & LogicalOps<TColumn>;
 type ColumnValue<TColumn extends Column, TDataType extends DrizzleColumnDataType<TColumn> = DrizzleColumnDataType<TColumn>> = ColumnOps<TColumn, TDataType> | EscapedValue<TDataType>;
@@ -71,29 +71,40 @@ type ColumnValue<TColumn extends Column, TDataType extends DrizzleColumnDataType
  * - Drizzle ORM operators should be used directly
  * - complex types (e.g. Date, objects, custom classes) need safe handling
  *
- * There are two supported forms:
+ * There are three supported forms:
  *
  * 1) Implicit equality (default behavior):
  * ```ts
  * where({ name: esc("Alex") })
  * ```
- * Compiles to:
- * ```ts
- * {
- *  eq: "Alex"
- * }
- * // In drizzle: eq(column, "Alex")
- * ```
  *
  * 2) Explicit operator (Drizzle-style):
  * ```ts
  * where({ age: esc(gte, 18) })
  * ```
- * Compiles to:
+ *
+ * 3) Chainable operator methods (recommended):
  * ```ts
- * gte(column, 18)
+ * where({ name: esc.like("%Alex%") })
+ * where({ age: esc.gte(18) })
+ * where({ status: esc.in(["active", "pending"]) })
+ * where({ price: esc.between(10, 100) })
  * ```
  *
+ * Available chainable methods:
+ * - `esc.eq(value)` — equality
+ * - `esc.not(value)` — inequality
+ * - `esc.gt(value)` — greater than
+ * - `esc.gte(value)` — greater than or equal
+ * - `esc.lt(value)` — less than
+ * - `esc.lte(value)` — less than or equal
+ * - `esc.like(pattern)` — SQL LIKE pattern matching
+ * - `esc.ilike(pattern)` — case-insensitive LIKE
+ * - `esc.in(values)` — value in array
+ * - `esc.nin(values)` — value not in array
+ * - `esc.between(min, max)` — value between range
+ * - `esc.notBetween(min, max)` — value not between range
+ *
  * The column is injected later during query compilation.
  * `esc` does NOT execute the operator immediately.
  *
@@ -119,5 +130,44 @@ declare function esc<T>(value: T): EscapedValue<T>;
  * @returns An internal escaped descriptor consumed by the query compiler
  */
 declare function esc<T>(op: (column: any, value: T) => any, value: T): EscapedValue<T>;
+declare namespace esc {
+  export var eq: <T>(value: T) => {
+    eq: T;
+  };
+  export var not: <T>(value: T) => {
+    not: T;
+  };
+  export var gt: <T>(value: T) => {
+    gt: T;
+  };
+  export var gte: <T>(value: T) => {
+    gte: T;
+  };
+  export var lt: <T>(value: T) => {
+    lt: T;
+  };
+  export var lte: <T>(value: T) => {
+    lte: T;
+  };
+  export var like: (pattern: string) => {
+    like: string;
+  };
+  export var ilike: (pattern: string) => {
+    ilike: string;
+  };
+  var _a: <T>(values: T[]) => {
+    in: T[];
+  };
+  export var nin: <T>(values: T[]) => {
+    nin: T[];
+  };
+  export var between: <T>(min: T, max: T) => {
+    between: [T, T];
+  };
+  export var notBetween: <T>(min: T, max: T) => {
+    notBetween: [T, T];
+  };
+  export { _a as in };
+}
 //#endregion
 export { BoolOps, ColumnOps, ColumnOpsBase, ColumnValue, DateOps, DrizzleColumnDataType, EscapedValue, JsonOps, LogicalOps, NumberOps, StringOps, TypeOps, esc };

package/dist/model/query/operations.mjs

@@ -7,6 +7,18 @@ function esc(arg1, arg2) {
 	};
 	return { equal: arg1 };
 }
+esc.eq = (value) => ({ eq: value });
+esc.not = (value) => ({ not: value });
+esc.gt = (value) => ({ gt: value });
+esc.gte = (value) => ({ gte: value });
+esc.lt = (value) => ({ lt: value });
+esc.lte = (value) => ({ lte: value });
+esc.like = (pattern) => ({ like: pattern });
+esc.ilike = (pattern) => ({ ilike: pattern });
+esc.in = (values) => ({ in: values });
+esc.nin = (values) => ({ nin: values });
+esc.between = (min, max) => ({ between: [min, max] });
+esc.notBetween = (min, max) => ({ notBetween: [min, max] });
 
 //#endregion
 export { esc };

package/dist/model/result.d.mts

@@ -1,13 +1,15 @@
 import { ReturningIdDialects } from "./dialect.mjs";
-import { TableOutput } from "./table.mjs";
+import { ApplyArrayIfArray, InferArrayItem, MergeExclusive, Simplify } from "../types.mjs";
 import { MethodWithResult, MethodWithValue } from "./methods/with.mjs";
 import { ResolveOptionsFormat } from "./options.mjs";
-import { ModelFormatValue } from "./format.mjs";
+import { ModelFormatResult } from "./format.mjs";
 import { MethodSelectResult, MethodSelectValue } from "./methods/select.mjs";
 import { MethodExcludeResult, MethodExcludeValue } from "./methods/exclude.mjs";
 import { MethodReturnResult } from "./methods/return.mjs";
+import { QueryError } from "./query/error.mjs";
 import { ModelConfig } from "./config.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
+import { SimplifyDeep } from "type-fest";
 
 //#region src/model/result.d.ts
 /**
@@ -20,15 +22,29 @@ import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relat
  * @typeParam TSchema - Full relational schema
  * @typeParam TTable - Relational configuration for the current table
  */
-interface ModelQueryResult<TResult extends Record<string, any>, TConfig extends ModelConfig, TExcludedKeys extends string = string, TSchema extends TablesRelationalConfig = TConfig["schema"], TTable extends TableRelationalConfig = TConfig["table"], TFormat extends Record<string, any> | undefined = ResolveOptionsFormat<TConfig["options"]["format"]>> extends Promise<ModelFormatValue<TResult, TFormat>> {
+interface ModelQueryResult<TResult extends Record<string, any> | any[], TConfig extends ModelConfig, TExcludedKeys extends string = string, TSchema extends TablesRelationalConfig = TConfig["schema"], TTable extends TableRelationalConfig = TConfig["table"], TFormat extends Record<string, any> | undefined = ResolveOptionsFormat<TConfig["options"]["format"]>, TWithSafe extends true | false = false> extends Promise<ApplySafeResultIf<TWithSafe, ApplyArrayIfArray<TResult, SimplifyDeep<ModelFormatResult<InferArrayItem<TResult>, TFormat, TTable>>>>> {
+  $format: TFormat;
   debug(): any;
-  exclude<TValue extends MethodExcludeValue<TResult>, TExcludeKeys extends string = TExcludedKeys | "exclude">(value: TValue): ModelQueryResult<MethodExcludeResult<TValue, TResult>, TConfig, TExcludeKeys>;
-  raw<TExcludeKeys extends string = TExcludedKeys | "raw">(): ModelQueryResult<TResult, TConfig, TExcludeKeys, TSchema, TTable, undefined>;
-  select<TValue extends MethodSelectValue<TResult>, TExcludeKeys extends string = TExcludedKeys | "select">(value: TValue): ModelQueryResult<MethodSelectResult<TValue, TResult>, TConfig, TExcludeKeys>;
-  with<TValue extends MethodWithValue<TSchema, TTable["relations"]>, TExcludeKeys extends string = TExcludedKeys | "with">(value: TValue): ModelQueryResult<MethodWithResult<TValue, TResult, TSchema, TTable>, TConfig, TExcludeKeys>;
+  exclude<TValue extends MethodExcludeValue<TResult>, TExcludeKeys extends string = TExcludedKeys | "exclude">(value: TValue): ModelQueryResult<ApplyArrayIfArray<TResult, MethodExcludeResult<TValue, InferArrayItem<TResult>>>, TConfig, TExcludeKeys, TSchema, TTable, TFormat, TWithSafe>;
+  raw<TExcludeKeys extends string = TExcludedKeys | "raw">(): ModelQueryResult<TResult, TConfig, TExcludeKeys, TSchema, TTable, undefined, TWithSafe>;
+  safe(): ModelQueryResult<TResult, TConfig, TExcludedKeys | "safe", TSchema, TTable, TFormat, true>;
+  select<TValue extends MethodSelectValue<TResult>, TExcludeKeys extends string = TExcludedKeys | "select">(value: TValue): ModelQueryResult<ApplyArrayIfArray<TResult, MethodSelectResult<TValue, InferArrayItem<TResult>>>, TConfig, TExcludeKeys, TSchema, TTable, TFormat, TWithSafe>;
+  with<TValue extends MethodWithValue<TSchema, TTable["relations"]>, TExcludeKeys extends string = TExcludedKeys | "with">(value: TValue): ModelQueryResult<MethodWithResult<TValue, TResult, TSchema, TTable>, TConfig, TExcludeKeys, TSchema, TTable, TFormat, TWithSafe>;
 }
-interface ModelMutateResult<TBaseResult extends Record<string, any> | void, TConfig extends ModelConfig, TResultType extends string = "one"> extends Promise<TBaseResult> {
-  return<TValue extends MethodSelectValue<TableOutput<TConfig["table"]>> | undefined, TReturnResult extends MethodReturnResult<TResultType, TConfig> = MethodReturnResult<TResultType, TConfig>, TResult extends Record<string, any> = (TValue extends undefined ? TReturnResult : MethodSelectResult<Exclude<TValue, undefined>, TReturnResult>)>(value?: TConfig["dialect"] extends ReturningIdDialects ? never : TValue): Omit<ModelMutateResult<TResult, TConfig, TResultType>, "with">;
+interface ModelInMutableResult<TBaseResult extends Record<string, any> | any[] | never, TConfig extends ModelConfig> extends Promise<Simplify<TBaseResult>> {
+  omit<TValue extends MethodExcludeValue<TConfig["tableOutput"]>>(value: TValue): ModelInMutableResult<ApplyArrayIfArray<TConfig["tableOutput"], MethodExcludeResult<TValue, InferArrayItem<TConfig["tableOutput"]>>>, TConfig>;
+  return<TValue extends MethodSelectValue<TConfig["tableOutput"]> | undefined, TReturnResult extends MethodReturnResult<TConfig> = MethodReturnResult<TConfig>, TResult extends Record<string, any> = (undefined extends TValue ? TReturnResult : MethodSelectResult<Exclude<TValue, undefined>, TReturnResult>)>(value?: TConfig["dialect"] extends ReturningIdDialects ? never : TValue): ModelMutateResult<Simplify<TResult>[], TConfig>;
+  returnFirst<TValue extends MethodSelectValue<TConfig["tableOutput"]> | undefined, TReturnResult extends MethodReturnResult<TConfig> = MethodReturnResult<TConfig>, TResult extends Record<string, any> = (undefined extends TValue ? TReturnResult : MethodSelectResult<Exclude<TValue, undefined>, TReturnResult>)>(value?: TConfig["dialect"] extends ReturningIdDialects ? never : TValue): ModelMutateResult<Simplify<TResult>, TConfig>;
 }
+interface ModelMutateResult<TResult extends Record<string, any> | any[] | never, TConfig extends ModelConfig, TExcludedKeys extends string = string, TWithSafe extends true | false = false> extends Promise<ApplySafeResultIf<TWithSafe, TResult>> {
+  omit<TValue extends MethodExcludeValue<TResult>, TExcludeKeys extends string = TExcludedKeys | "omit">(value: TValue): ModelMutateResult<ApplyArrayIfArray<TResult, Simplify<MethodExcludeResult<TValue, InferArrayItem<TResult>>>>, TConfig, TExcludeKeys>;
+  safe(): ModelMutateResult<TResult, TConfig, TExcludedKeys, true>;
+}
+type SafeResult<TResult> = MergeExclusive<{
+  error: QueryError;
+}, {
+  data: TResult;
+}>;
+type ApplySafeResultIf<TCondition extends true | false, TResult> = TCondition extends true ? SafeResult<TResult> : TResult;
 //#endregion
-export { ModelMutateResult, ModelQueryResult };
+export { ApplySafeResultIf, ModelInMutableResult, ModelMutateResult, ModelQueryResult, SafeResult };

package/dist/types.d.mts

@@ -8,5 +8,20 @@ type AddUnionToValues<T extends Record<PropertyKey, any>, A> = { [K in keyof T]:
 interface RecursiveBooleanRecord {
   [key: string]: boolean | RecursiveBooleanRecord;
 }
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type Without<FirstType, SecondType> = { [KeyType in Exclude<keyof FirstType, keyof SecondType>]?: never };
+type MergeExclusive<FirstType, SecondType> = FirstType | SecondType extends object ? (Without<FirstType, SecondType> & SecondType) | (Without<SecondType, FirstType> & FirstType) : FirstType | SecondType;
+/**
+ * Infer item of Array<>. If not Array<> return type.
+ */
+type InferArrayItem<T extends any | any[]> = T extends any[] ? T extends (infer Item)[] ? Item : T : T;
+/**
+ * Applies Array<> to T if condition is true, otherwise return T as non array.
+ */
+type ApplyArrayIf<TCondition extends true | false, T> = TCondition extends true ? T[] : T;
+/**
+ * Applies Array<> to T if TArray is Array<>, if not return T as non array.
+ */
+type ApplyArrayIfArray<TArray extends any | any[], T> = ApplyArrayIf<TArray extends any[] ? true : false, T>;
 //#endregion
-export { AddToValues, AddUnionToValues, Compose, Fallback, RecursiveBooleanRecord, Replace, UnwrapArray };
+export { AddToValues, AddUnionToValues, ApplyArrayIf, ApplyArrayIfArray, Compose, Fallback, InferArrayItem, MergeExclusive, RecursiveBooleanRecord, Replace, Simplify, UnwrapArray };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apisr/drizzle-model",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "private": false,
   "scripts": {
     "lint": "eslint . --max-warnings 0",

package/tests/snippets/x-2.ts

@@ -13,6 +13,7 @@ const model = modelBuilder({
 // create model
 const userModel = model("user", {});
 
+// #1 syntax
 await userModel
 	.where({
 		name: {
@@ -21,6 +22,7 @@ await userModel
 	})
 	.findFirst();
 
+// #2 syntax
 await userModel
 	.where({
 		name: esc.like("A%"),