@apisr/drizzle-model 0.0.2 → 0.0.3

package/dist/index.d.mts

@@ -1,3 +1,25 @@
+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 { 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";
+import { MethodUpsertContext, MethodUpsertContextFunction, MethodUpsertUpdate, MethodUpsertUpdateValue, MethodUpsertUpdateWhere, MethodUpsertValue } from "./model/methods/upsert.mjs";
+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 { 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 { 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";
+import { MethodWhereColumns, MethodWhereRelations, MethodWhereValue, RelationWhere } from "./model/methods/query/where.mjs";
+import { ModelConfig } from "./model/config.mjs";
 import { modelBuilder } from "./model/builder.mjs";
+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 { modelBuilder };
+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 };

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import { modelBuilder } from "./model/builder.mjs";
+import { esc } from "./model/query/operations.mjs";
 import "./model/index.mjs";
 
-export { modelBuilder };
+export { esc, modelBuilder };

package/dist/model/builder.d.mts

@@ -1,7 +1,7 @@
 import { ModelDialect } from "./dialect.mjs";
 import { ModelOptions } from "./options.mjs";
-import { ModelConfig } from "./config.mjs";
 import { Model } from "./model.mjs";
+import { ModelConfig } from "./config.mjs";
 import { AnyRelations, EmptyRelations } from "drizzle-orm";
 
 //#region src/model/builder.d.ts

package/dist/model/config.d.mts

@@ -1,9 +1,9 @@
-import { IsTable, TableOutput } from "./table.mjs";
 import { ModelDialect } from "./dialect.mjs";
-import { DrizzleColumnDataType } from "./query/operations.mjs";
-import { MethodWhereValue } from "./methods/query/where.mjs";
+import { IsTable, TableOutput } from "./table.mjs";
 import { ModelOptions, ResolveOptionsFormat } from "./options.mjs";
 import { GetPrimarySerialOrDefaultKeys } from "./methods/return.mjs";
+import { DrizzleColumnDataType } from "./query/operations.mjs";
+import { MethodWhereValue } from "./methods/query/where.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 
 //#region src/model/config.d.ts

package/dist/model/core/runtime.mjs

@@ -1,6 +1,6 @@
+import { buildSelectProjection } from "./projection.mjs";
 import { MutateResult, QueryResult } from "./thenable.mjs";
 import { applyExclude, applyFormat, applySelect } from "./transform.mjs";
-import { buildSelectProjection } from "./projection.mjs";
 import { compileWhere } from "./where.mjs";
 import { runWithJoins } from "./with.mjs";
 import { and } from "drizzle-orm";

package/dist/model/core/where.mjs

@@ -96,7 +96,7 @@ function compileColumnValue(column, value) {
 			const sub = v.and.map((item) => compileColumnValue(column, item)).filter(Boolean);
 			if (sub.length) pushIf(and(...sub));
 		}
-		if (!parts.length) return void 0;
+		if (!parts.length) return;
 		return parts.length === 1 ? parts[0] : and(...parts);
 	}
 	return eq(column, value);
@@ -113,11 +113,11 @@ function compileWhereObject(fields, where) {
 		}
 		if (value && typeof value === "object") throw new Error(`Relation where is not implemented yet for key '${key}'.`);
 	}
-	if (!parts.length) return void 0;
+	if (!parts.length) return;
 	return parts.length === 1 ? parts[0] : and(...parts);
 }
 function compileWhere(fields, where) {
-	if (!where) return void 0;
+	if (!where) return;
 	if (typeof where === "object" && where && !isPromiseLike(where)) {
 		if (where.$model === "model") throw new Error("Model-as-where is not implemented yet.");
 		if (where.getSQL) return where;

package/dist/model/dialect.d.mts

@@ -9,4 +9,4 @@ type MssqlDialect = "MSSQL";
 type CockroachDbDialect = "CockroachDB";
 type ReturningIdDialects = MySqlDialect | SingleStoreDialect | CockroachDbDialect;
 //#endregion
-export { ModelDialect, ReturningIdDialects };
+export { CockroachDbDialect, ModelDialect, MssqlDialect, MySqlDialect, PgDialect, ReturningIdDialects, SingleStoreDialect, SqlLiteDialect, UnknownDialect };

package/dist/model/foreigns.d.mts

@@ -0,0 +1,7 @@
+import { ModelDialect } from "./dialect.mjs";
+import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
+
+//#region src/model/foreigns.d.ts
+type ModelForegins<TSchema extends TablesRelationalConfig, TTable extends TableRelationalConfig, TDialect extends ModelDialect> = {};
+//#endregion
+export { ModelForegins };

package/dist/model/format.d.mts

@@ -1,4 +1,4 @@
 //#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 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;
 //#endregion
 export { ModelFormatValue };

package/dist/model/index.d.mts

@@ -1 +1,23 @@
-import { modelBuilder } from "./builder.mjs";
+import { CockroachDbDialect, ModelDialect, MssqlDialect, MySqlDialect, PgDialect, ReturningIdDialects, SingleStoreDialect, SqlLiteDialect, UnknownDialect } from "./dialect.mjs";
+import { IsTable, NormalizeTable, TableColumn, TableColumns, TableInsertModel, TableInsertValues, TableOneRelationsTableName, TableOutput, TableRelationsTableName } from "./table.mjs";
+import { MethodInsertValue, MethodWithInsertValue } from "./methods/insert.mjs";
+import { MethodUpdateValue } from "./methods/update.mjs";
+import { MethodUpsertContext, MethodUpsertContextFunction, MethodUpsertUpdate, MethodUpsertUpdateValue, MethodUpsertUpdateWhere, MethodUpsertValue } from "./methods/upsert.mjs";
+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 { 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 { 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";
+import { MethodWhereColumns, MethodWhereRelations, MethodWhereValue, RelationWhere } from "./methods/query/where.mjs";
+import { ModelConfig } from "./config.mjs";
+import { modelBuilder } from "./builder.mjs";
+import { ModelForegins } from "./foreigns.mjs";
+import { ModelFirstLevelMethods, ModelLevelMethods } from "./methods/levels.mjs";
+import "./methods/index.mjs";
+import { ModelShape } from "./shape.mjs";

package/dist/model/index.mjs

@@ -1,3 +1,4 @@
 import { modelBuilder } from "./builder.mjs";
+import { esc } from "./query/operations.mjs";
 
 export {  };

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

@@ -5,4 +5,4 @@ type ResolveMethodExcludeValue<TValue extends Record<string, any>, TResult exten
 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 MethodExcludeValue<TResult extends Record<string, any>> = MethodSelectValue<TResult>;
 //#endregion
-export { MethodExcludeResult, MethodExcludeValue };
+export { MethodExcludeResult, MethodExcludeValue, ResolveMethodExcludeValue };

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

@@ -0,0 +1,10 @@
+import { MethodInsertValue, MethodWithInsertValue } from "./insert.mjs";
+import { MethodUpdateValue } from "./update.mjs";
+import { MethodUpsertContext, MethodUpsertContextFunction, MethodUpsertUpdate, MethodUpsertUpdateValue, MethodUpsertUpdateWhere, MethodUpsertValue } from "./upsert.mjs";
+import { MethodWithResult, MethodWithValue } from "./with.mjs";
+import { MethodSelectResult, MethodSelectValue, ResolveMethodSelectValue } from "./select.mjs";
+import { MethodExcludeResult, MethodExcludeValue, ResolveMethodExcludeValue } from "./exclude.mjs";
+import { GetPrimarySerialOrDefaultKeys, MethodReturnResult, PrimaryKeyKeys } from "./return.mjs";
+import { MethodIncludeIdentifier } from "./include.mjs";
+import { MethodWhereColumns, MethodWhereRelations, MethodWhereValue, RelationWhere } from "./query/where.mjs";
+import { ModelFirstLevelMethods, ModelLevelMethods } from "./levels.mjs";

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

@@ -1,7 +1,8 @@
-import { NormalizeTable, TableInsertValues } from "../table.mjs";
+import { IsTable, NormalizeTable, TableInsertValues } from "../table.mjs";
 import { RelationsRecord, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 
 //#region src/model/methods/insert.d.ts
 type MethodInsertValue<TTable extends TableRelationalConfig> = TableInsertValues<NormalizeTable<TTable>>;
+type MethodWithInsertValue<TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord> = { [Key in keyof TRelations]?: TableInsertValues<IsTable<TSchema[TRelations[Key]["targetTableName"]]["table"]>> };
 //#endregion
-export { MethodInsertValue };
+export { MethodInsertValue, MethodWithInsertValue };

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

@@ -0,0 +1,5 @@
+//#region src/model/methods/levels.d.ts
+type ModelFirstLevelMethods = "$insert";
+type ModelLevelMethods = "$findMany" | "$findFirst" | "$insert" | "$update" | "$delete" | "$with";
+//#endregion
+export { ModelFirstLevelMethods, ModelLevelMethods };

package/dist/model/methods/query/where.d.mts

@@ -1,14 +1,14 @@
 import { TableColumn, TableColumns, TableOneRelationsTableName } from "../../table.mjs";
-import { MethodIncludeIdentifier } from "../include.mjs";
-import { ColumnValue } from "../../query/operations.mjs";
 import { ModelIdentifier } from "../../model.mjs";
+import { ColumnValue } from "../../query/operations.mjs";
+import { MethodIncludeIdentifier } from "../include.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 import { SQL } from "drizzle-orm/sql";
 
 //#region src/model/methods/query/where.d.ts
-type MethodWhereValue<TSchema extends TablesRelationalConfig, TTable extends TableRelationalConfig, TValue = ModelIdentifier<TableOneRelationsTableName<TTable>> | SQL | MethodWhereColumns<TTable> | MethodWhereRelations<TSchema, TTable> | MethodIncludeIdentifier<any>> = TValue extends MethodIncludeIdentifier<true> ? never : (TValue extends SQL ? TValue : (TValue extends ModelIdentifier<TableOneRelationsTableName<TTable>> ? TValue : (TValue extends MethodWhereColumns<TTable> ? TValue : (TValue extends MethodWhereRelations<TSchema, TTable> ? TValue : never))));
+type MethodWhereValue<TSchema extends TablesRelationalConfig, TTable extends TableRelationalConfig, TValue = ModelIdentifier<TableOneRelationsTableName<TTable>> | SQL | MethodWhereColumns<TTable> | MethodWhereRelations<TSchema, TTable> | MethodIncludeIdentifier<any>> = TValue extends MethodIncludeIdentifier<true> ? never : TValue extends SQL ? TValue : TValue extends ModelIdentifier<TableOneRelationsTableName<TTable>> ? TValue : TValue extends MethodWhereColumns<TTable> ? TValue : TValue extends MethodWhereRelations<TSchema, TTable> ? TValue : never;
 type MethodWhereRelations<TSchema extends TablesRelationalConfig, TTable extends TableRelationalConfig> = { [TableName in keyof TTable["relations"] as TTable["relations"][TableName]["relationType"] extends "many" ? never : TableName]?: RelationWhere<TSchema[TTable["relations"][TableName & string]["targetTableName"]]> };
 type RelationWhere<TTable extends TableRelationalConfig> = MethodWhereColumns<TTable>;
 type MethodWhereColumns<TTable extends TableRelationalConfig> = { [ColumnName in keyof TableColumns<TTable>]?: ColumnValue<TableColumn<ColumnName & string, TTable>> };
 //#endregion
-export { MethodWhereValue };
+export { MethodWhereColumns, MethodWhereRelations, MethodWhereValue, RelationWhere };

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

@@ -1,12 +1,12 @@
 import { ReturningIdDialects } from "../dialect.mjs";
-import { ModelConfig } from "../config.mjs";
 import { ModelFormatValue } from "../format.mjs";
+import { ModelConfig } from "../config.mjs";
 import { Column } from "drizzle-orm";
 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 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<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"]>;
 //#endregion
-export { GetPrimarySerialOrDefaultKeys, MethodReturnResult };
+export { GetPrimarySerialOrDefaultKeys, MethodReturnResult, PrimaryKeyKeys };

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

@@ -5,4 +5,4 @@ type ResolveMethodSelectValue<TValue extends Record<string, any>, TResult extend
 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 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 };
+export { MethodSelectResult, MethodSelectValue, ResolveMethodSelectValue };

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

@@ -1,9 +1,9 @@
-import { IsTable } from "../table.mjs";
 import { AddUnionToValues } from "../../types.mjs";
+import { IsTable } from "../table.mjs";
 import { MethodInsertValue } from "./insert.mjs";
+import { MethodUpdateValue } from "./update.mjs";
 import { MethodWhereValue } from "./query/where.mjs";
 import { ModelConfig } from "../config.mjs";
-import { MethodUpdateValue } from "./update.mjs";
 import { Column, SQL } from "drizzle-orm";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 
@@ -11,10 +11,10 @@ import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relat
 type MethodUpsertValue<TConfig extends ModelConfig, TSchema extends TablesRelationalConfig = TConfig["schema"], TTable extends TableRelationalConfig = TConfig["table"]> = {
   insert: MethodInsertValue<TTable>;
   update: MethodUpsertUpdate<TTable>;
-  target?: (TConfig["primaryKeys"]) | (TConfig["primaryKeys"])[] | Column | Column[];
+  target?: TConfig["primaryKeys"] | TConfig["primaryKeys"][] | Column | Column[];
   updateWhere?: MethodUpsertUpdateWhere<TSchema, TTable>;
 };
-type MethodUpsertContext<TTable extends TableRelationalConfig, TFields extends string = (keyof IsTable<TTable["table"]>["_"]["columns"] & string)> = {
+type MethodUpsertContext<TTable extends TableRelationalConfig, TFields extends string = keyof IsTable<TTable["table"]>["_"]["columns"] & string> = {
   excluded: (field: TFields) => SQL;
   inserted: (field: TFields) => SQL;
 };
@@ -23,4 +23,4 @@ type MethodUpsertUpdateValue<TTable extends TableRelationalConfig> = AddUnionToV
 type MethodUpsertUpdate<TTable extends TableRelationalConfig> = MethodUpsertUpdateValue<TTable> | MethodUpsertContextFunction<TTable, MethodUpsertUpdateValue<TTable>>;
 type MethodUpsertUpdateWhere<TSchema extends TablesRelationalConfig, TTable extends TableRelationalConfig> = MethodUpsertContextFunction<TTable, MethodWhereValue<TSchema, TTable>>;
 //#endregion
-export { MethodUpsertValue };
+export { MethodUpsertContext, MethodUpsertContextFunction, MethodUpsertUpdate, MethodUpsertUpdateValue, MethodUpsertUpdateWhere, MethodUpsertValue };

package/dist/model/model.d.mts

@@ -1,13 +1,13 @@
+import { ModelDialect } from "./dialect.mjs";
 import { Replace } from "../types.mjs";
-import { MethodWithValue } from "./methods/with.mjs";
 import { MethodInsertValue } from "./methods/insert.mjs";
-import { ModelDialect } from "./dialect.mjs";
-import { MethodWhereValue } from "./methods/query/where.mjs";
-import { ComposeModelOptions, ModelOptions, ResolveOptionsFormat, ResolveOptionsMethods } from "./options.mjs";
-import { ModelConfig } from "./config.mjs";
-import { ModelMutateResult, ModelQueryResult } from "./result.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 { MethodWhereValue } from "./methods/query/where.mjs";
+import { ModelConfig } from "./config.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 
 //#region src/model/model.d.ts
@@ -19,19 +19,23 @@ import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relat
  */
 interface ModelMethods<TConfig extends ModelConfig, TSchema extends TablesRelationalConfig = TConfig["schema"], TTable extends TableRelationalConfig = TConfig["table"], TDialect extends ModelDialect = TConfig["dialect"]> {
   /**
-   * Fetches all rows for the current model query.
+   * Deletes rows that match the current model query.
    */
-  findMany(): ModelQueryResult<TConfig["tableOutput"][], TConfig>;
+  delete(): ModelMutateResult<void, TConfig, "many">;
   /**
    * Fetches the first matching row for the current model query.
    */
   findFirst(): ModelQueryResult<TConfig["tableOutput"], TConfig>;
   /**
-   * Adds a where clause to the current model query.
+   * Fetches all rows for the current model query.
+   */
+  findMany(): ModelQueryResult<TConfig["tableOutput"][], TConfig>;
+  /**
+   * Includes related entities in the current model query.
    *
-   * @param value - Where conditions for the model query
+   * @param value - Include configuration for relations
    */
-  where(value: MethodWhereValue<TConfig["schema"], TConfig["table"]>): Model<TConfig>;
+  include<TValue extends MethodWithValue<TSchema, TTable["relations"]>>(value: TValue): TValue;
   /**
    * Inserts one or many rows into the model table.
    *
@@ -44,10 +48,6 @@ interface ModelMethods<TConfig extends ModelConfig, TSchema extends TablesRelati
    * @param value - Update payload
    */
   update<TValue extends MethodUpdateValue<TTable>>(value: TValue): ModelMutateResult<void, TConfig, "many">;
-  /**
-   * Deletes rows that match the current model query.
-   */
-  delete(): ModelMutateResult<void, TConfig, "many">;
   /**
    * Inserts or updates rows based on conflict criteria.
    *
@@ -55,13 +55,19 @@ interface ModelMethods<TConfig extends ModelConfig, TSchema extends TablesRelati
    */
   upsert<TValue extends MethodUpsertValue<TConfig>>(value: TValue): ModelMutateResult<void, TConfig, TValue["insert"] extends any[] ? "many" : "one">;
   /**
-   * Includes related entities in the current model query.
+   * Adds a where clause to the current model query.
    *
-   * @param value - Include configuration for relations
+   * @param value - Where conditions for the model query
    */
-  include<TValue extends MethodWithValue<TSchema, TTable["relations"]>>(value: TValue): TValue;
+  where(value: MethodWhereValue<TConfig["schema"], TConfig["table"]>): Model<TConfig>;
 }
 interface ModelQueryMethods<TConfig extends ModelConfig> {
+  /**
+   * Binds a database client to the model.
+   *
+   * @param db - Database client instance
+   */
+  db(db: any): Model<TConfig>;
   /**
    * Extends the current model with additional options.
    *
@@ -70,12 +76,6 @@ interface ModelQueryMethods<TConfig extends ModelConfig> {
   extend<TOptions extends ModelOptions<TConfig["schema"], TConfig["table"], TConfig["dialect"]>>(config: TOptions): Model<Replace<TConfig, {
     options: ComposeModelOptions<TOptions, TConfig["options"]>;
   }>>;
-  /**
-   * Binds a database client to the model.
-   *
-   * @param db - Database client instance
-   */
-  db(db: any): Model<TConfig>;
 }
 /**
  * Just base represenation of model. This type JUST made for more clearer types, not more...
@@ -102,4 +102,4 @@ type ModelIdentifier<ModelName> = {
   $modelName: ModelName;
 };
 //#endregion
-export { Model, ModelIdentifier };
+export { Model, ModelBase, ModelIdentifier, ModelMethods, ModelQueryMethods };

package/dist/model/options.d.mts

@@ -1,6 +1,6 @@
-import { TableOutput } from "./table.mjs";
-import { Fallback } from "../types.mjs";
 import { ModelDialect } from "./dialect.mjs";
+import { Fallback } from "../types.mjs";
+import { TableOutput } from "./table.mjs";
 import { MethodWhereValue } from "./methods/query/where.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 
@@ -10,8 +10,8 @@ import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relat
  */
 interface ModelOptions<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTable extends TableRelationalConfig = TableRelationalConfig, TDialect extends ModelDialect = ModelDialect, TSelf extends ModelOptions<any, any, any, TSelf> = ModelOptions<TSchema, TTable, TDialect, any>> {
   format?: ModelOptionFormat<TTable>;
-  where?: MethodWhereValue<TSchema, TTable>;
   methods?: ModelMethodsFactory;
+  where?: MethodWhereValue<TSchema, TTable>;
 }
 type ComposeModelOptions<O1 extends ModelOptions, O2 extends ModelOptions> = Omit<O1, "format" | "methods"> & {
   format: Fallback<O1["format"], O2["format"]>;
@@ -21,8 +21,8 @@ type ModelOptionFormat<TTable extends TableRelationalConfig> = {
   bivarianceHack(output: TableOutput<TTable>): any;
 }["bivarianceHack"];
 type ModelMethodsFactory = Record<string, any>;
-type ResolveOptionsMethods<TFactory extends ModelMethodsFactory | undefined> = (TFactory extends ModelMethodsFactory ? TFactory : {});
+type ResolveOptionsMethods<TFactory extends ModelMethodsFactory | undefined> = TFactory extends ModelMethodsFactory ? TFactory : {};
 type ResolveOptionsFormat<TFormat> = TFormat extends ((...args: any[]) => any) ? ReturnType<TFormat> : undefined;
 type MergeModelOptionsMethods<M1 extends ModelMethodsFactory | undefined, M2 extends ModelMethodsFactory | undefined> = M1 extends ModelMethodsFactory ? M2 extends ModelMethodsFactory ? Omit<M2, keyof M1> & M1 : M1 : M2;
 //#endregion
-export { ComposeModelOptions, ModelOptions, ResolveOptionsFormat, ResolveOptionsMethods };
+export { ComposeModelOptions, MergeModelOptionsMethods, ModelMethodsFactory, ModelOptionFormat, ModelOptions, ResolveOptionsFormat, ResolveOptionsMethods };

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

@@ -62,5 +62,62 @@ type LogicalOps<TColumn extends Column> = {
 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>;
+/**
+ * Escapes a value from the query DSL and forces it to be compiled using
+ * a specific comparison operator.
+ *
+ * This function exists as an explicit escape hatch for cases where:
+ * - the default DSL operators are insufficient
+ * - Drizzle ORM operators should be used directly
+ * - complex types (e.g. Date, objects, custom classes) need safe handling
+ *
+ * There are two 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:
+ * ```ts
+ * gte(column, 18)
+ * ```
+ *
+ * The column is injected later during query compilation.
+ * `esc` does NOT execute the operator immediately.
+ *
+ * @typeParam T - The value type being compared against the column
+ *
+ * @param value - Value to compare using implicit equality
+ *
+ * @returns An internal escaped descriptor consumed by the query compiler
+ */
+declare function esc<T>(value: T): EscapedValue<T>;
+/**
+ * Escapes a value from the query DSL and forces it to be compiled using
+ * the provided binary operator.
+ *
+ * This overload allows reuse of Drizzle ORM operators that normally
+ * require the column as the first argument.
+ *
+ * @typeParam T - The value type expected by the operator
+ *
+ * @param op - A binary comparison operator (e.g. eq, gte, ilike)
+ * @param value - Value to pass as the operator's right-hand side
+ *
+ * @returns An internal escaped descriptor consumed by the query compiler
+ */
+declare function esc<T>(op: (column: any, value: T) => any, value: T): EscapedValue<T>;
 //#endregion
-export { ColumnValue, DrizzleColumnDataType };
+export { BoolOps, ColumnOps, ColumnOpsBase, ColumnValue, DateOps, DrizzleColumnDataType, EscapedValue, JsonOps, LogicalOps, NumberOps, StringOps, TypeOps, esc };

package/dist/model/query/operations.mjs

@@ -0,0 +1,12 @@
+//#region src/model/query/operations.ts
+function esc(arg1, arg2) {
+	if (typeof arg1 === "function") return {
+		__kind: "esc-op",
+		op: arg1,
+		value: arg2
+	};
+	return { equal: arg1 };
+}
+
+//#endregion
+export { esc };

package/dist/model/relation.d.mts

@@ -1,5 +1,5 @@
-import { IsTable, TableOutput } from "./table.mjs";
 import { RecursiveBooleanRecord } from "../types.mjs";
+import { IsTable, TableOutput } from "./table.mjs";
 import { ModelIdentifier } from "./model.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 
@@ -65,4 +65,4 @@ type ResolveSingleRelation<Key extends string, Value, TSchema extends TablesRela
  */
 type ResolveRelationSelection<TSelection extends Record<string, any>, TSchema extends TablesRelationalConfig, TTable extends TableRelationalConfig> = { [Key in keyof TSelection as TSelection[Key] extends true | RecursiveBooleanRecord | ModelIdentifier<any> ? Key & string : never]: ResolveSingleRelation<Key & string, TSelection[Key], TSchema, TTable> };
 //#endregion
-export { ResolveRelationSelection };
+export { ApplyRelationCardinality, RelationKind, RelationMeta, RelationTargetRow, ResolveRelationSelection, ResolveSingleRelation, TargetTable };

package/dist/model/result.d.mts

@@ -1,12 +1,12 @@
+import { ReturningIdDialects } from "./dialect.mjs";
 import { TableOutput } from "./table.mjs";
 import { MethodWithResult, MethodWithValue } from "./methods/with.mjs";
-import { MethodSelectResult, MethodSelectValue } from "./methods/select.mjs";
-import { MethodExcludeResult, MethodExcludeValue } from "./methods/exclude.mjs";
-import { ReturningIdDialects } from "./dialect.mjs";
 import { ResolveOptionsFormat } from "./options.mjs";
-import { ModelConfig } from "./config.mjs";
 import { ModelFormatValue } from "./format.mjs";
+import { MethodSelectResult, MethodSelectValue } from "./methods/select.mjs";
+import { MethodExcludeResult, MethodExcludeValue } from "./methods/exclude.mjs";
 import { MethodReturnResult } from "./methods/return.mjs";
+import { ModelConfig } from "./config.mjs";
 import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
 
 //#region src/model/result.d.ts
@@ -21,11 +21,11 @@ import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relat
  * @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>> {
-  with<TValue extends MethodWithValue<TSchema, TTable["relations"]>, TExcludeKeys extends string = TExcludedKeys | "with">(value: TValue): ModelQueryResult<MethodWithResult<TValue, TResult, TSchema, TTable>, TConfig, TExcludeKeys>;
-  select<TValue extends MethodSelectValue<TResult>, TExcludeKeys extends string = TExcludedKeys | "select">(value: TValue): ModelQueryResult<MethodSelectResult<TValue, TResult>, TConfig, TExcludeKeys>;
+  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>;
-  debug(): any;
+  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>;
 }
 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">;

package/dist/model/shape.d.mts

@@ -0,0 +1,8 @@
+import { ResolveOptionsMethods } from "./options.mjs";
+import { ModelBase, ModelIdentifier } from "./model.mjs";
+import { ModelConfig } from "./config.mjs";
+
+//#region src/model/shape.d.ts
+type ModelShape<TConfig extends ModelConfig> = ModelIdentifier<TConfig["table"]["name"]> & ModelBase<TConfig> & ResolveOptionsMethods<TConfig["options"]["methods"]>;
+//#endregion
+export { ModelShape };

package/dist/model/table.d.mts

@@ -40,7 +40,13 @@ type TableOutput<TTable extends TableRelationalConfig | SchemaEntry | Table> = N
  *
  * @typeParam TTable - Relation config, schema entry, or table
  */
-type NormalizeTable<TTable extends TableRelationalConfig | SchemaEntry | Table> = (TTable extends TableRelationalConfig ? IsTable<TTable["table"]> : (TTable extends SchemaEntry ? IsTable<TTable> : (TTable extends Table ? TTable : never)));
+type NormalizeTable<TTable extends TableRelationalConfig | SchemaEntry | Table> = TTable extends TableRelationalConfig ? IsTable<TTable["table"]> : TTable extends SchemaEntry ? IsTable<TTable> : TTable extends Table ? TTable : never;
+/**
+ * Collects target table names from all relations.
+ *
+ * @typeParam TTable - Relational configuration for the table
+ */
+type TableRelationsTableName<TTable extends TableRelationalConfig> = { [K in keyof TTable["relations"]]: TTable["relations"][K]["targetTableName"] }[keyof TTable["relations"]];
 /**
  * Maps non-"many" relations to their target table names.
  *
@@ -59,6 +65,12 @@ type TableOneRelationsTableName<TTable extends TableRelationalConfig> = TableOne
  * @typeParam T - Candidate table type
  */
 type IsTable<T> = T extends Table ? T : never;
+/**
+ * Infers insert model for a Drizzle table.
+ *
+ * @typeParam TTable - Drizzle table type
+ */
+type TableInsertModel<TTable extends Table> = InferInsertModel<TTable>;
 /**
  * Accepts a single insert payload or a batch of insert payloads.
  *
@@ -66,4 +78,4 @@ type IsTable<T> = T extends Table ? T : never;
  */
 type TableInsertValues<TTable extends Table> = InferInsertModel<TTable> | InferInsertModel<TTable>[];
 //#endregion
-export { IsTable, NormalizeTable, TableColumn, TableColumns, TableInsertValues, TableOneRelationsTableName, TableOutput };
+export { IsTable, NormalizeTable, TableColumn, TableColumns, TableInsertModel, TableInsertValues, TableOneRelationsTableName, TableOutput, TableRelationsTableName };

package/dist/types.d.mts

@@ -1,10 +1,12 @@
 //#region src/types.d.ts
+type Compose<T, U> = T & U;
 type Fallback<A, B> = A extends undefined ? B : A;
 type Replace<T, R> = Omit<T, keyof R> & R;
 type UnwrapArray<T> = T extends (infer R)[] ? R : T;
+type AddToValues<T extends Record<PropertyKey, any>, A> = { [K in keyof T]: T[K] & A };
 type AddUnionToValues<T extends Record<PropertyKey, any>, A> = { [K in keyof T]: T[K] | A };
 interface RecursiveBooleanRecord {
   [key: string]: boolean | RecursiveBooleanRecord;
 }
 //#endregion
-export { AddUnionToValues, Fallback, RecursiveBooleanRecord, Replace, UnwrapArray };
+export { AddToValues, AddUnionToValues, Compose, Fallback, RecursiveBooleanRecord, Replace, UnwrapArray };

package/package.json

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

package/src/index.ts

@@ -1 +1,2 @@
 export * from "./model/index.ts";
+export * from "./types";

package/src/model/index.ts

@@ -1 +1,15 @@
 export * from "./builder.ts";
+export * from "./config";
+export * from "./dialect.ts";
+export * from "./foreigns.ts";
+export * from "./format.ts";
+// Methods
+export * from "./methods";
+export * from "./model.ts";
+export * from "./options.ts";
+// Query
+export * from "./query/operations.ts";
+export * from "./relation.ts";
+export * from "./result.ts";
+export * from "./shape.ts";
+export * from "./table.ts";

package/src/model/methods/index.ts

@@ -0,0 +1,10 @@
+export * from "./exclude";
+export * from "./include";
+export * from "./insert";
+export * from "./levels";
+export * from "./query/where";
+export * from "./return";
+export * from "./select";
+export * from "./update";
+export * from "./upsert";
+export * from "./with";