forj 0.1.5 → 0.1.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "forj",
   "description": "SQLite ORM and Query Builder whitout dependencies",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "main": "src/index.ts",
   "files": ["src"],
@@ -33,17 +33,17 @@
     "@aws-sdk/lib-dynamodb": "3.817.0",
     "pluralize": "^8.0",
     "t0n": "^0.1",
-    "zod": "^3.19.1"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/pluralize": "^0.0.33",
     "@cloudflare/workers-types": "^4.20260113.0",
-    "bun-types": "^1.2.13",
+    "bun-types": "^1.3.8",
     "terser": "^5.46.0",
     "tiny-glob": "^0.2",
     "tsup": "^8.5.1",
     "tsx": "^4.19.4",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -89,4 +89,4 @@
     "bun",
     "nodejs"
   ]
-}
+}

package/src/clause-builder.ts

@@ -39,7 +39,7 @@ export default class ClauseBuilder<
     this.#schema = schema
   }
 
-  #nested(fn: WhereFn<T, C>, operator: ClauseOperator = 'AND') {
+  #nested(fn: WhereFn<T>, operator: ClauseOperator = 'AND') {
     const nested = new ClauseBuilder<T, C>(this.#table, this.#schema)
     fn(nested)
 
@@ -79,9 +79,8 @@ export default class ClauseBuilder<
     // @ts-ignore
     column = parseColumn(String(column), this.#table)
 
-    if (this.#schema && !zSame(column, value, this.#schema)) {
-      throw new Error(`Table column '${String(column)}' of type '${zType(column, this.#schema)}' is not assignable as type of '${typeof value}'.`)
-    }
+    if (this.#schema && !zSame(column.replace(/"/g, ''), value, this.#schema))
+      throw new Error(`Table column '${String(column.replace(/"/g, ''))}' of type '${zType(column.replace(/"/g, ''), this.#schema)}' is not assignable as type of '${typeof value}'.`)
 
     return isJoinCompare(value, this.#schema) // @ts-ignore
       ? this.#clause(`${column} ${operator} ${value}`, [], logical) // @ts-ignore
@@ -112,31 +111,31 @@ export default class ClauseBuilder<
     return this.#clause(parseColumn(column, this.#table) + ` ${operator} (${values.map(() => '?').join(', ')})`, values, logical)
   }
 
-  whereIn(column: C, values: T[C][]) { // @ts-ignore
+  whereIn<K extends keyof T>(column: K, values: T[K][]) { // @ts-ignore
     return this.#in(column, values, 'IN')
   }
-  in(column: C, values: T[C][]) {
+  in<K extends keyof T>(column: K, values: T[K][]) {
     return this.whereIn(column, values)
   }
 
-  whereNotIn(column: C, values: T[C][]) { // @ts-ignore
+  whereNotIn<K extends keyof T>(column: K, values: T[K][]) { // @ts-ignore
     return this.#in(column, values, 'NOT IN')
   }
-  notIn(column: C, values: T[C][]) {
+  notIn<K extends keyof T>(column: K, values: T[K][]) {
     return this.whereNotIn(column, values)
   }
 
-  orWhereIn(column: C, values: T[C][]) { // @ts-ignore
+  orWhereIn<K extends keyof T>(column: K, values: T[K][]) { // @ts-ignore
     return this.#in(column, values, 'IN', 'OR')
   }
-  orIn(column: C, values: T[C][]) {
+  orIn<K extends keyof T>(column: K, values: T[K][]) {
     return this.orWhereIn(column, values)
   }
 
-  orWhereNotIn(column: C, values: T[C][]) { // @ts-ignore
+  orWhereNotIn<K extends keyof T>(column: K, values: T[K][]) { // @ts-ignore
     return this.#in(column, values, 'NOT IN', 'OR')
   }
-  orNotIn(column: C, values: T[C][]) {
+  orNotIn<K extends keyof T>(column: K, values: T[K][]) {
     return this.orWhereNotIn(column, values)
   }
 
@@ -150,31 +149,31 @@ export default class ClauseBuilder<
     return this.#clause(parseColumn(column, this.#table) + ` ${operator} ? AND ?`, [one, two], logical)
   }
 
-  whereBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+  whereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) { // @ts-ignore
     return this.#between(column, one, two, 'BETWEEN')
   }
-  between(column: C, one: T[C], two: T[C]) {
+  between<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     return this.whereBetween(column, one, two)
   }
 
-  orWhereBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+  orWhereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) { // @ts-ignore
     return this.#between(column, one, two, 'BETWEEN', 'OR')
   }
-  orBetween(column: C, one: T[C], two: T[C]) {
+  orBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     return this.orWhereBetween(column, one, two)
   }
 
-  whereNotBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+  whereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) { // @ts-ignore
     return this.#between(column, one, two, 'NOT BETWEEN')
   }
-  notBetween(column: C, one: T[C], two: T[C]) {
+  notBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     return this.whereNotBetween(column, one, two)
   }
 
-  orWhereNotBetween(column: C, one: T[C], two: T[C]) { // @ts-ignore
+  orWhereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) { // @ts-ignore
     return this.#between(column, one, two, 'NOT BETWEEN', 'OR')
   }
-  orNotBetween(column: C, one: T[C], two: T[C]) {
+  orNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     return this.orWhereNotBetween(column, one, two)
   }
 
@@ -186,31 +185,31 @@ export default class ClauseBuilder<
     return this.#clause(parseColumn(column, this.#table) +` ${operator} NULL`, [], logical)
   }
 
-  whereNull(column: C) {
+  whereNull<K extends keyof T>(column: K) {
     return this.#null(column as string)
   }
-  onNull(column: C) {
+  onNull<K extends keyof T>(column: K) {
     return this.whereNull(column)
   }
 
-  orWhereNull(column: C) {
+  orWhereNull<K extends keyof T>(column: K) {
     return this.#null(column as string, 'IS', 'OR')
   }
-  orOnNull(column: C) {
+  orOnNull<K extends keyof T>(column: K) {
     return this.orWhereNull(column)
   }
 
-  whereNotNull(column: C) {
+  whereNotNull<K extends keyof T>(column: K) {
     return this.#null(column as string, 'IS NOT')
   }
-  onNotNull(column: C) {
+  onNotNull<K extends keyof T>(column: K) {
     return this.whereNotNull(column)
   }
 
-  orWhereNotNull(column: C) {
+  orWhereNotNull<K extends keyof T>(column: K) {
     return this.#null(column as string, 'IS NOT', 'OR')
   }
-  orNotNull(column: C) {
+  orNotNull<K extends keyof T>(column: K) {
     return this.orWhereNotNull(column)
   }
 }

package/src/d1/model.ts

@@ -10,16 +10,16 @@ import { Envir } from 't0n'
 import QueryBuilder from '../query-builder'
 import BModel from '../model'
 import type {
-  DBSchema, SchemaKeys,
+  DBSchema,
   Item,
   Pipe, Result, RunFn,
 } from '../types'
 
 export function Model<
   TSchema extends DBSchema,
-  TBase extends SchemaKeys<TSchema>
+  TBase extends keyof z.infer<TSchema>
 >(schema: TSchema, base: TBase) {
-  type S = z.infer<typeof schema>
+  type S = z.infer<TSchema>
   return class extends BaseModel<TBase, S> {
     static $table = String(base)
     static $schema = schema
@@ -55,8 +55,9 @@ export abstract class BaseModel<TB extends keyof DB, DB> extends BModel<TB, DB>
     ): Promise<Result<T, C>> => {
       let stmt = db.prepare(qb.query)
 
-      if (qb.args?.length)
-        stmt = stmt.bind(...qb.args)
+      const args = qb.args
+      if (args?.length)
+        stmt = stmt.bind(...args)
 
       const resp = await stmt.run<Item<T, C>>()
 

package/src/dynamodb/schema.ts

@@ -12,17 +12,26 @@ export function arraySchema(v: any): any {
   return v
 }
 
+function getArrayItem(schema: z.ZodArray<any>): ZodTypeAny {
+  const def: any = schema._def
+  return (def.element ?? def.type ?? def.innerType) as ZodTypeAny
+}
+
 export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
   if (schema instanceof z.ZodObject) {
-    return Object.entries(schema.shape).map(([key, value]) => {
+    const shape = schema.shape
+
+    return Object.entries(shape).map(([key, value]) => {
       const inner = unwrap(value as ZodTypeAny)
 
       if (inner instanceof z.ZodObject)
         return notEmpty(key, extractZodKeys(inner))
 
       if (inner instanceof z.ZodArray) {
-        const item = unwrap(inner._def.type as ZodTypeAny)
-        return item instanceof z.ZodObject ? notEmpty(key, extractZodKeys(item)) : key
+        const item = unwrap(getArrayItem(inner))
+        return item instanceof z.ZodObject
+          ? notEmpty(key, extractZodKeys(item))
+          : key
       }
 
       return key
@@ -30,7 +39,8 @@ export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
   }
 
   if (schema instanceof z.ZodArray) {
-    const item = unwrap(schema._def.type as ZodTypeAny)
+    const item = unwrap(getArrayItem(schema))
+
     if (item instanceof z.ZodObject)
       return arraySchema(extractZodKeys(item))
 
@@ -41,23 +51,41 @@ export function extractZodKeys(schema: ZodTypeAny): SchemaStructure {
 }
 
 export function unwrap(schema: ZodTypeAny): ZodTypeAny {
-  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable)
-    return unwrap(schema._def.innerType)
+  while (true) {
+    if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable) {
+      schema = (schema._def as any).innerType
+      continue
+    }
 
-  if (schema instanceof z.ZodDefault)
-    return unwrap(schema._def.innerType)
+    if (schema instanceof z.ZodDefault) {
+      schema = (schema._def as any).innerType
+      continue
+    }
 
-  // if (schema instanceof z.ZodUnion)
-  //   return unwrap(schema._def.options[0] as ZodTypeAny)
+    if (schema instanceof z.ZodUnion) {
+      const options = (schema._def as any).options as ZodTypeAny[]
+      const nonEmpty = options.find(
+        opt => !(opt instanceof z.ZodUndefined) && !(opt instanceof z.ZodNull)
+      )
+      schema = nonEmpty ?? options[0]
+      continue
+    }
 
-  if (schema instanceof z.ZodUnion) {
-    const options = schema._def.options as ZodTypeAny[]
-    const nonEmptyOption = options.find(opt => !(opt instanceof z.ZodUndefined) && !(opt instanceof z.ZodNull))
-    return nonEmptyOption ? unwrap(nonEmptyOption) : options[0]
-  }
+    const def: any = schema._def
+
+    // unwrap transforms / pipes do v4
+    if (def?.schema) {
+      schema = def.schema
+      continue
+    }
 
-  if (schema instanceof z.ZodEffects)
-    return unwrap(schema._def.schema)
+    if (def?.innerType) {
+      schema = def.innerType
+      continue
+    }
+
+    break
+  }
 
   return schema
 }

package/src/model.ts

@@ -4,6 +4,8 @@ import type {
   Operator, OrderDirection,
   WhereFn, WhereArgs,
   DBSchema, Pipe,
+  Value,
+  JoinArgs,
 } from './types'
 
 export default abstract class Model<TB extends keyof DB, DB> {
@@ -14,6 +16,10 @@ export default abstract class Model<TB extends keyof DB, DB> {
   static $table: string = ''
   static $schema?: DBSchema
 
+  static $timestamps?: boolean = false
+  static $createdAt?: boolean = false
+  static $updatedAt?: boolean = false
+
   static pipe<S, T>(): Pipe<S, T> {
     throw new Error(`Database connection not provided.`) // TODO: improv this message
   }
@@ -21,7 +27,35 @@ export default abstract class Model<TB extends keyof DB, DB> {
   static builder<S, T>() {
     const table = this.$table || pluralize(this.name.toLowerCase())
 
-    return new QueryBuilder<S, T>(table, this.$schema, this.pipe<S, T>())
+    return new QueryBuilder<S, T>(table, this.$schema, this.pipe<S, T>()).opts({
+      timestamps: this.$timestamps,
+      createdAt: this.$createdAt,
+      updatedAt: this.$updatedAt,
+    })
+  }
+
+  static insert< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+  >(this: M, data: Record<keyof T, Value>) {
+    return this.builder<I['$DBShape'], T>().insert(data)
+  }
+
+  static update< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+  >(this: M, data: Record<keyof T, Value>) {
+    return this.builder<I['$DBShape'], T>().update(data)
+  }
+
+  static delete< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape'],
+  >(this: M) {
+    return this.builder<I['$DBShape'], T>().delete()
   }
 
   static select< // @ts-ignore
@@ -41,56 +75,278 @@ export default abstract class Model<TB extends keyof DB, DB> {
     return this.builder<I['$DBShape'], T>().distinct()
   }
 
-  static where< // @ts-ignore
+  static join< // @ts-ignore
     M extends typeof Model<TB, DB>,
     I extends InstanceType<M>,
+    S extends I['$DBShape'],
     T extends I['$TShape'],
-    C extends keyof T
-  >(this: M, fn: WhereFn<T>): QueryBuilder<I['$DBShape'], T, C>
+    J extends keyof S,
+  >(this: M, table: J, fn: WhereFn<T>): QueryBuilder<S, T>
+  static join< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1
+  >(table: J, column: K, value: T[K]): QueryBuilder<S, T>
+  static join< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1
+  >(table: J, column: K, operator: Operator, value: T[K]): QueryBuilder<S, T>
+  static join< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): QueryBuilder<S, T>
+  static join< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): QueryBuilder<S, T>
+  static join< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    J extends keyof S
+  >(this: M, table: J, ...args: JoinArgs<S, J>) { // @ts-ignore
+    return this.builder<S, I['$TShape']>().join(table, ...args)
+  }
+
+  static innerJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+  >(this: M, table: J, fn: WhereFn<T>): QueryBuilder<S, T>
+  static innerJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1
+  >(table: J, column: K, value: T[K]): QueryBuilder<S, T>
+  static innerJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1
+  >(table: J, column: K, operator: Operator, value: T[K]): QueryBuilder<S, T>
+  static innerJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): QueryBuilder<S, T>
+  static innerJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): QueryBuilder<S, T>
+  static innerJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    J extends keyof S
+  >(this: M, table: J, ...args: JoinArgs<S, J>) { // @ts-ignore
+    return this.builder<S, I['$TShape']>().innerJoin(table, ...args)
+  }
+
+  static rightJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+  >(this: M, table: J, fn: WhereFn<T>): QueryBuilder<S, T>
+  static rightJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1
+  >(table: J, column: K, value: T[K]): QueryBuilder<S, T>
+  static rightJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1
+  >(table: J, column: K, operator: Operator, value: T[K]): QueryBuilder<S, T>
+  static rightJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): QueryBuilder<S, T>
+  static rightJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): QueryBuilder<S, T>
+  static rightJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    J extends keyof S
+  >(this: M, table: J, ...args: JoinArgs<S, J>) { // @ts-ignore
+    return this.builder<S, I['$TShape']>().rightJoin(table, ...args)
+  }
+
+  static crossJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+  >(this: M, table: J, fn: WhereFn<T>): QueryBuilder<S, T>
+  static crossJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1
+  >(table: J, column: K, value: T[K]): QueryBuilder<S, T>
+  static crossJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1
+  >(table: J, column: K, operator: Operator, value: T[K]): QueryBuilder<S, T>
+  static crossJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): QueryBuilder<S, T>
+  static crossJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    T extends I['$TShape'],
+    J extends keyof S,
+    T1 extends S[J],
+    K extends keyof T1,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): QueryBuilder<S, T>
+  static crossJoin< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    S extends I['$DBShape'],
+    J extends keyof S
+  >(this: M, table: J, ...args: JoinArgs<S, J>) { // @ts-ignore
+    return this.builder<S, I['$TShape']>().crossJoin(table, ...args)
+  }
+
+  static where< // @ts-ignore
+    M extends typeof Model<TB, DB>,
+    I extends InstanceType<M>,
+    T extends I['$TShape']
+  >(this: M, fn: WhereFn<T>): QueryBuilder<I['$DBShape'], T>
   static where< // @ts-ignore
     M extends typeof Model<TB, DB>,
     I extends InstanceType<M>,
     T extends I['$TShape'],
     C extends keyof T
-  >(this: M, column: C, value: T[C]): QueryBuilder<I['$DBShape'], T, C>
+  >(this: M, column: C, value: T[C]): QueryBuilder<I['$DBShape'], T>
   static where< // @ts-ignore
     M extends typeof Model<TB, DB>,
     I extends InstanceType<M>,
     T extends I['$TShape'],
     C extends keyof T
-  >(this: M, column: C, operator: Operator, value: T[C]): QueryBuilder<I['$DBShape'], T, C>
+  >(this: M, column: C, operator: Operator, value: T[C]): QueryBuilder<I['$DBShape'], T>
   static where< // @ts-ignore
     M extends typeof Model<TB, DB>,
     I extends InstanceType<M>,
     T extends I['$TShape']
-  >(this: M, ...args: WhereArgs<T>) {
+  >(this: M, ...args: WhereArgs<T>) { // @ts-ignore
     return this.builder<I['$DBShape'], T>().where(...args)
   }
 
   static on< // @ts-ignore
     M extends typeof Model<TB, DB>,
     I extends InstanceType<M>,
-    T extends I['$TShape'],
-    C extends keyof T
-  >(this: M, fn: WhereFn<T>): QueryBuilder<I['$DBShape'], T, C>
+    T extends I['$TShape']
+  >(this: M, fn: WhereFn<T>): QueryBuilder<I['$DBShape'], T>
   static on< // @ts-ignore
     M extends typeof Model<TB, DB>,
     I extends InstanceType<M>,
     T extends I['$TShape'],
     C extends keyof T
-  >(this: M, column: C, value: T[C]): QueryBuilder<I['$DBShape'], T, C>
+  >(this: M, column: C, value: T[C]): QueryBuilder<I['$DBShape'], T>
   static on< // @ts-ignore
     M extends typeof Model<TB, DB>,
     I extends InstanceType<M>,
     T extends I['$TShape'],
     C extends keyof T
-  >(this: M, column: C, operator: Operator, value: T[C]): QueryBuilder<I['$DBShape'], T, C>
+  >(this: M, column: C, operator: Operator, value: T[C]): QueryBuilder<I['$DBShape'], T>
   static on< // @ts-ignore
     M extends typeof Model<TB, DB>,
     I extends InstanceType<M>,
     T extends I['$TShape']
-  >(this: M, ...args: WhereArgs<T>) {
-    return this.builder<I['$DBShape'], T>().where(...args)
+  >(this: M, ...args: WhereArgs<T>) { // @ts-ignore
+    return this.where(...args)
   }
 
   static whereIn< // @ts-ignore