@apisr/drizzle-model 0.0.1

package/src/model/methods/insert.ts

@@ -0,0 +1,16 @@
+// import type { DrizzleInsertValues, IsDrizzleTable } from "@/types";
+import type { RelationsRecord, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
+import type { IsTable, NormalizeTable, TableInsertValues } from "../table.ts";
+
+export type MethodInsertValue<TTable extends TableRelationalConfig> = TableInsertValues<
+  NormalizeTable<TTable>
+>;
+
+export type MethodWithInsertValue<
+  TSchema extends TablesRelationalConfig,
+  TRelations extends RelationsRecord,
+> = {
+    [Key in keyof TRelations]?: TableInsertValues<IsTable<
+      TSchema[TRelations[Key]["targetTableName"]]["table"]
+    >>
+  };

package/src/model/methods/levels.ts

@@ -0,0 +1,2 @@
+export type ModelFirstLevelMethods = "$insert";
+export type ModelLevelMethods = "$findMany" | "$findFirst" | "$insert" | "$update" | "$delete" | "$with";

package/src/model/methods/query/where.ts

@@ -0,0 +1,48 @@
+import type { SQL } from "drizzle-orm/sql";
+import type { ModelIdentifier } from "../../model.ts";
+import type { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
+import type { TableColumn, TableColumns, TableOneRelationsTableName } from "../../table.ts";
+import type { MethodIncludeIdentifier } from "../include.ts";
+import type { ColumnValue } from "../../query/operations.ts";
+
+export type MethodWhereValue<
+  TSchema extends TablesRelationalConfig,
+  TTable extends TableRelationalConfig,
+  TValue = ModelIdentifier<TableOneRelationsTableName<TTable>> | SQL | MethodWhereColumns<TTable> | MethodWhereRelations<TSchema, TTable> | MethodIncludeIdentifier<any>
+> =
+  // Is result of .include fn?
+  TValue extends MethodIncludeIdentifier<true>
+  ? never
+  : (
+    // Is SQL?
+    TValue extends SQL
+    ? TValue
+    // Is model?
+    : (TValue extends ModelIdentifier<TableOneRelationsTableName<TTable>>
+      ? TValue
+      // Is columns where clauses?
+      : (TValue extends MethodWhereColumns<TTable>
+        ? TValue
+        // Is relations
+        : (TValue extends MethodWhereRelations<TSchema, TTable>
+          ? TValue
+          : never)
+      )
+    )
+  );
+
+export type MethodWhereRelations<TSchema extends TablesRelationalConfig, TTable extends TableRelationalConfig> = {
+  [TableName in keyof TTable["relations"]as TTable["relations"][TableName]["relationType"] extends "many" ? never : TableName]?: RelationWhere<
+    // Table
+    TSchema[
+    // Table name
+    TTable["relations"][TableName & string]["targetTableName"]
+    ]
+  >;
+};
+
+export type RelationWhere<TTable extends TableRelationalConfig> = MethodWhereColumns<TTable>;
+
+export type MethodWhereColumns<TTable extends TableRelationalConfig> = {
+  [ColumnName in keyof TableColumns<TTable>]?: ColumnValue<TableColumn<ColumnName & string, TTable>>
+};

package/src/model/methods/return.ts

@@ -0,0 +1,39 @@
+import type { ReturningIdDialects } from "../dialect.ts";
+import type { InferModelFromColumns } from "drizzle-orm/table";
+import type { Column } from "drizzle-orm";
+import type { ModelConfig } from "../config.ts";
+import type { ModelFormatValue } from "../format.ts";
+
+// export type GetPrimarySerialOrDefaultKeys<TTable extends TableRelationalConfig, T extends IsDrizzleTable<TTable["table"]>["_"]["columns"] = IsDrizzleTable<TTable["table"]>["_"]["columns"]> = {
+//   [K in keyof T]: T[K]['_']['isPrimaryKey'] extends true
+//   ? (T[K]['_']['isAutoincrement'] extends true
+//     ? K
+//     : (T[K]['_']['hasRuntimeDefault'] extends true
+//       ? (T[K]['_']['isPrimaryKey'] extends true
+//         ? K
+//         : never)
+//       : never))
+//   : ((T[K]['_']['hasRuntimeDefault'] extends true
+//     ? (T[K]['_']['isPrimaryKey'] extends true
+//       ? K
+//       : never)
+//     : never));
+// };
+
+export type PrimaryKeyKeys<T extends Record<string, Column>> = {
+  [K in keyof T]: T[K]['_']['isPrimaryKey'] extends true ? K : never;
+}[keyof T];
+
+export type GetPrimarySerialOrDefaultKeys<T extends Record<string, Column>> = {
+  [K in PrimaryKeyKeys<T>]: T[K];
+};
+
+export 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"]>);

package/src/model/methods/select.ts

@@ -0,0 +1,38 @@
+import type { UnwrapArray } from "@/types.ts";
+
+export 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];
+  };
+
+export 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>;
+
+export 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;
+  };

package/src/model/methods/update.ts

@@ -0,0 +1,4 @@
+import type { TableRelationalConfig } from "drizzle-orm/relations";
+import type { IsTable, TableInsertValues } from "../table.ts";
+
+export type MethodUpdateValue<TTable extends TableRelationalConfig> = Partial<TableInsertValues<IsTable<TTable["table"]>>>;

package/src/model/methods/upsert.ts

@@ -0,0 +1,54 @@
+import type { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
+import type { ModelConfig } from "../config.ts";
+import type { MethodInsertValue } from "./insert.ts";
+import type { MethodUpdateValue } from "./update.ts";
+import type { GetPrimarySerialOrDefaultKeys } from "./return.ts";
+import type { MethodWhereValue } from "./query/where.ts";
+import type { SQL } from "drizzle-orm";
+import type { Column } from "drizzle-orm";
+import type { IsTable } from "../table.ts";
+import type { AddUnionToValues } from "@/types.ts";
+
+export 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[];
+  updateWhere?: MethodUpsertUpdateWhere<TSchema, TTable>;
+};
+
+export type MethodUpsertContext<
+  TTable extends TableRelationalConfig,
+  TFields extends string = (keyof IsTable<TTable["table"]>["_"]["columns"] & string)
+> = {
+  excluded: (field: TFields) => SQL;
+  inserted: (field: TFields) => SQL;
+};
+
+export type MethodUpsertContextFunction<TTable extends TableRelationalConfig, R> =
+  (c: MethodUpsertContext<TTable>) => R;
+
+export type MethodUpsertUpdateValue<
+  TTable extends TableRelationalConfig,
+> = AddUnionToValues<
+  MethodUpdateValue<TTable>,
+  SQL
+>;
+
+export type MethodUpsertUpdate<
+  TTable extends TableRelationalConfig,
+> =
+  MethodUpsertUpdateValue<TTable> | MethodUpsertContextFunction<TTable, MethodUpsertUpdateValue<TTable>>;
+
+export type MethodUpsertUpdateWhere<
+  TSchema extends TablesRelationalConfig,
+  TTable extends TableRelationalConfig
+> = MethodUpsertContextFunction<TTable, MethodWhereValue<TSchema, TTable>>;

package/src/model/methods/with.ts

@@ -0,0 +1,40 @@
+import type {
+	FindTargetTableInRelationalConfig,
+	RelationsRecord,
+	TableRelationalConfig,
+	TablesRelationalConfig,
+} from "drizzle-orm/relations";
+import type { ResolveRelationSelection } from "../relation.ts";
+
+/**
+ * Recursive type structure for defining nested relation selections in the .with() method.
+ *
+ * It maps relation keys to either a boolean (for simple inclusion) or a nested selection object.
+ *
+ * @typeParam TSchema - Full relational schema
+ * @typeParam TRelations - Record of relations for the current level
+ */
+export type MethodWithValue<
+	TSchema extends TablesRelationalConfig,
+	TRelations extends RelationsRecord,
+> = {
+	[Key in keyof TRelations]?:
+		| boolean
+		| MethodWithValue<
+				TSchema,
+				FindTargetTableInRelationalConfig<TSchema, TRelations[Key]>["relations"]
+		  >
+		| object;
+};
+
+export type MethodWithResult<
+	TValue extends Record<string, any>,
+	TResult extends Record<string, any>,
+	TSchema extends TablesRelationalConfig,
+	TTable extends TableRelationalConfig,
+	TOutput = ResolveRelationSelection<TValue, TSchema, TTable>,
+> = TResult extends any[]
+	? TResult extends (infer RItem)[]
+		? (TOutput & RItem)[]
+		: TOutput & TResult
+	: TOutput & TResult;

package/src/model/model.ts

@@ -0,0 +1,148 @@
+import type {
+  TableRelationalConfig,
+  TablesRelationalConfig,
+} from "drizzle-orm/relations";
+import type { MethodWithValue } from "./methods/with.ts";
+import type { MethodInsertValue } from "./methods/insert.ts";
+import type { ModelQueryResult, ModelMutateResult } from "./result.ts";
+import type { MethodUpdateValue } from "./methods/update.ts";
+import type { ModelDialect } from "./dialect.ts";
+import type { MethodWhereValue } from "./methods/query/where.ts";
+import type { ComposeModelOptions, ModelOptions, ResolveOptionsFormat, ResolveOptionsMethods } from "./options.ts";
+import type { ModelConfig } from "./config.ts";
+import type { Replace } from "../types.ts";
+import type { MethodUpsertValue } from "./methods/upsert.ts";
+
+/**
+ * Interface defining standard query methods available on a model.
+ *
+ * @typeParam TSchema - Full relational schema
+ * @typeParam TTable - Relational configuration for the current table
+ */
+export 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.
+   */
+  findMany(): ModelQueryResult<
+    TConfig["tableOutput"][],
+    TConfig
+  >;
+  /**
+   * Fetches the first matching row for the current model query.
+   */
+  findFirst(): ModelQueryResult<
+    TConfig["tableOutput"],
+    TConfig
+  >,
+
+  /**
+   * Adds a where clause to the current model query.
+   *
+   * @param value - Where conditions for the model query
+   */
+  where(value: MethodWhereValue<TConfig["schema"], TConfig["table"]>): Model<TConfig>;
+
+  /**
+   * Inserts one or many rows into the model table.
+   *
+   * @param value - Insert payload or batch payload
+   */
+  insert<TValue extends MethodInsertValue<TTable>>(value: TValue): ModelMutateResult<void, TConfig, TValue extends any[] ? "many" : "one">;
+  /**
+   * Updates rows that match the current model query.
+   *
+   * @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.
+   *
+   * @param value - Upsert payload or batch payload
+   */
+  upsert<TValue extends MethodUpsertValue<TConfig>>(value: TValue): ModelMutateResult<void, TConfig, TValue["insert"] extends any[] ? "many" : "one">;
+
+  /**
+   * Includes related entities in the current model query.
+   *
+   * @param value - Include configuration for relations
+   */
+  include<TValue extends MethodWithValue<TSchema, TTable["relations"]>>(
+    value: TValue,
+  ): TValue;
+}
+
+export interface ModelQueryMethods<
+  TConfig extends ModelConfig
+> {
+  /**
+   * Extends the current model with additional options.
+   *
+   * @param config - Options to merge into the model
+   */
+  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...
+ */
+export type ModelBase<
+  TConfig extends ModelConfig
+> = ModelMethods<TConfig>
+  & ModelQueryMethods<TConfig>;
+
+/**
+ * Main model interface for a table.
+ *
+ * Each column of the table is exposed as a strongly-typed field setter,
+ * allowing type-safe assignment of values when building or mutating models.
+ *
+ * This type is intended to be extended with query helpers and other
+ * model-level utilities.
+ *
+ * @typeParam TConfig - Config that includes all related information about tables, relations and etc...
+ */
+export 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;
+  };
+
+export type ModelIdentifier<ModelName> = {
+  $model: "model";
+  $modelName: ModelName;
+};

package/src/model/options.ts

@@ -0,0 +1,64 @@
+import type { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
+import type { ModelDialect } from "./dialect.ts";
+import type { TableOutput } from "./table.ts";
+import type { Fallback } from "../types.ts";
+import type { MethodWhereValue } from "./methods/query/where.ts";
+
+/**
+ * Options to define a model
+ */
+export 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>;
+
+  // TODO: Make zod schemas
+  // insertSchema?: any;
+  // updateSchema?: any;
+
+  // TODO: Maybe planned for future releases
+  // select?: MethodSelectValue<TableOutput<TTable>>;
+  // exclude?: MethodExcludeValue<TableOutput<TTable>>;
+
+  methods?: ModelMethodsFactory;
+}
+
+export type ComposeModelOptions<
+  O1 extends ModelOptions,
+  O2 extends ModelOptions
+> = Omit<O1, "format" | "methods"> & {
+  format: Fallback<O1["format"], O2["format"]>;
+  methods: MergeModelOptionsMethods<O1["methods"], O2["methods"]>;
+};
+
+export type ModelOptionFormat<TTable extends TableRelationalConfig> = {
+  bivarianceHack(output: TableOutput<TTable>): any;
+}["bivarianceHack"];
+// export type ModelMethodsFactory = {
+//   bivarianceHack(): Record<string, any>;
+// }["bivarianceHack"];
+export type ModelMethodsFactory = Record<string, any>;
+
+export type ResolveOptionsMethods<TFactory extends ModelMethodsFactory | undefined> =
+  (TFactory extends ModelMethodsFactory
+    ? TFactory
+    : {});
+
+export type ResolveOptionsFormat<TFormat> =
+  TFormat extends (...args: any[]) => any
+  ? ReturnType<TFormat>
+  : undefined;
+
+export type MergeModelOptionsMethods<
+  M1 extends ModelMethodsFactory | undefined,
+  M2 extends ModelMethodsFactory | undefined
+> =
+  M1 extends ModelMethodsFactory
+  ? M2 extends ModelMethodsFactory
+  ? Omit<M2, keyof M1> & M1
+  : M1
+  : M2;

package/src/model/query/operations.ts

@@ -0,0 +1,170 @@
+import type { Column, SQL } from "drizzle-orm";
+
+export type DrizzleColumnDataType<TColumn extends Column> = TColumn["_"]["data"];
+
+export type EscapedValue<T> =
+  | {
+    equal: T;
+  }
+  | {
+    __kind: "esc-op";
+    op: {
+      bivarianceHack(column: any, value: T): any;
+    }["bivarianceHack"];
+    value: T;
+  };
+
+type OpValue<T> = T | SQL | EscapedValue<T>;
+
+export type ColumnOpsBase<T> = {
+  eq?: OpValue<T>;
+  equal?: OpValue<T>;
+  not?: OpValue<T>;
+  in?: OpValue<T>[];
+  nin?: OpValue<T>[];
+  isNull?: boolean;
+};
+
+export type NumberOps = {
+  gt?: OpValue<number>;
+  gte?: OpValue<number>;
+  lt?: OpValue<number>;
+  lte?: OpValue<number>;
+  between?: [OpValue<number>, OpValue<number>];
+  notBetween?: [OpValue<number>, OpValue<number>];
+};
+
+export type StringOps = {
+  like?: OpValue<string>;
+  ilike?: OpValue<string>;
+  startsWith?: OpValue<string>;
+  endsWith?: OpValue<string>;
+  contains?: OpValue<string>;
+  regex?: OpValue<string>;
+  notRegex?: OpValue<string>;
+  length?: NumberOps;
+};
+
+export type BoolOps = {
+  isTrue?: boolean;
+  isFalse?: boolean;
+};
+
+export type DateOps = {
+  before?: OpValue<Date | string>;
+  after?: OpValue<Date | string>;
+  on?: OpValue<Date | string>;
+  notOn?: OpValue<Date | string>;
+  between?: [OpValue<Date | string>, OpValue<Date | string>];
+};
+
+export type JsonOps<T> = {
+  has?: T;
+  hasAny?: T[];
+  hasAll?: T[];
+  len?: NumberOps;
+};
+
+export type LogicalOps<TColumn extends Column> = {
+  or?: ColumnValue<TColumn>[];
+  and?: ColumnValue<TColumn>[];
+};
+
+export 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]>
+  : {};
+
+export type ColumnOps<
+  TColumn extends Column,
+  TDataType extends DrizzleColumnDataType<TColumn>,
+> = ColumnOpsBase<TDataType> & TypeOps<TDataType> & LogicalOps<TColumn>;
+
+export 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
+ */
+export 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
+ */
+export function esc<T>(
+  op: (column: any, value: T) => any,
+  value: T
+): EscapedValue<T>;
+
+export function esc<T>(arg1: any, arg2?: any): EscapedValue<T> {
+  if (typeof arg1 === "function") {
+    return {
+      __kind: "esc-op",
+      op: arg1 as (column: any, value: T) => any,
+      value: arg2 as T,
+    };
+  }
+
+  return {
+    equal: arg1,
+  };
+}