forj 0.1.6 → 0.1.7

package/src/query-builder.ts

@@ -1,5 +1,7 @@
+import { Timestamp } from 't0n'
 import ClauseBuilder from './clause-builder'
 import {
+  types,
   isOperator,
   parseColumn, parseSelectColumn,
   formatValue,
@@ -8,15 +10,18 @@ import {
   sqlName,
 } from './utils'
 import type {
-  IJoinBuilder, IClauseBuilder,
   OrderDirection,
   JoinType,
   WhereArgs,
-  Values,
+  Value, Values,
   Item,
   JoinArgs,
   DBSchema,
   Pipe,
+  QueryType,
+  TableOpts,
+  WhereFn,
+  Operator,
 } from './types'
 
 export default class QueryBuilder<
@@ -27,9 +32,13 @@ export default class QueryBuilder<
   // T, // = any,,
   // C extends keyof T = keyof T
 // > {
-> implements IJoinBuilder<S>, IClauseBuilder<T> {
+> {
   #table!: string
   #schema?: DBSchema
+  #type: number = 1
+  // #data: Partial<Record<C, Value>> = {}
+  #keys: string[] = []
+  #values: Value[] = []
   #selects: string[] = []
   #clauses!: ClauseBuilder<T>
   #groups: string[] = []
@@ -43,6 +52,7 @@ export default class QueryBuilder<
   #joins: string[] = []
 
   #pipe?: Pipe<S, T, C>
+  #opts: TableOpts = {}
 
   constructor(
     table: string,
@@ -55,6 +65,11 @@ export default class QueryBuilder<
     this.#clauses = new ClauseBuilder<T>(table, schema)
   }
 
+  opts(opts: TableOpts) {
+    this.#opts = opts
+    return this
+  }
+
   async run() {
     if (!this.#pipe?.run)
       throw new Error(`No database connection.`)
@@ -62,6 +77,34 @@ export default class QueryBuilder<
     return await this.#pipe?.run(this)
   }
 
+  #setType(type: QueryType, data?: Partial<Record<C, Value>>) {
+    this.#type = type
+    if (data) {
+      this.#keys = Object.keys(data)
+      this.#values = Object.values(data)
+    }
+
+    return this
+  }
+
+  insert(data: Partial<Record<C, Value>>) {
+    if (this.#opts.timestamps || this.#opts.createdAt) // @ts-ignore
+      data.created_at = Timestamp.now()
+
+    return this.#setType(types.INSERT, data)
+  }
+
+  update(data: Partial<Record<C, Value>>) {
+    if (this.#opts.timestamps || this.#opts.updatedAt) // @ts-ignore
+      data.updated_at = Timestamp.now()
+
+    return this.#setType(types.UPDATE, data)
+  }
+
+  delete() {
+    return this.#setType(types.DELETE)
+  }
+
   async first<K extends keyof T>(...columns: K[] | K[][]): Promise<null | Item<T, C>> {
     columns?.length && this.select(...columns)
     const resp = await this.run()
@@ -75,6 +118,7 @@ export default class QueryBuilder<
   }
 
   select<K extends keyof T>(...columns: K[] | K[][]): QueryBuilder<S, T, K> {
+    this.#type = types.SELECT
     this.#selects.push(...columns.flat(Infinity) as string[])
     return this as any
   }
@@ -123,7 +167,7 @@ export default class QueryBuilder<
 
     if (!isJoinCompare(value, this.#schema)) {
       if (this.#schema && !zSame(col.replace(/"/g, ''), value, this.#schema))
-        throw new Error(`Table column '${col}' of type '${zType(col, this.#schema)}' is not assignable as type of '${typeof value}'.`)
+        throw new Error(`Table column '${col.replace(/"/g, '')}' of type '${zType(col.replace(/"/g, ''), this.#schema)}' is not assignable as type of '${typeof value}'.`)
       // @ts-ignore
       this.#clauses.args = [value] // @ts-ignore // TODO: https://developers.cloudflare.com/d1/worker-api/#type-conversion
       value = '?'
@@ -134,135 +178,272 @@ export default class QueryBuilder<
     return this
   }
 
+  join<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
+  join<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, value: T[K]): this
+  join<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, operator: Operator, value: T[K]): this
+  join<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): this
+  join<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): this
   join<J extends keyof S>(table: J, ...args: JoinArgs<S, J>) {
     return this.#join(undefined, table, ...args)
   }
 
+  innerJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
+  innerJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, value: T[K]): this
+  innerJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, operator: Operator, value: T[K]): this
+  innerJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): this
+  innerJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): this
   innerJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>) {
     return this.#join('INNER', table, ...args)
   }
 
+  leftJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
+  leftJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, value: T[K]): this
+  leftJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, operator: Operator, value: T[K]): this
+  leftJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): this
+  leftJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): this
   leftJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>) {
     return this.#join('LEFT', table, ...args)
   }
 
+  rightJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
+  rightJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, value: T[K]): this
+  rightJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, operator: Operator, value: T[K]): this
+  rightJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): this
+  rightJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): this
   rightJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>) {
     return this.#join('RIGHT', table, ...args)
   }
 
+  crossJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
+  crossJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, value: T[K]): this
+  crossJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T
+  >(table: J, column: K, operator: Operator, value: T[K]): this
+  crossJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, table2: J2, column2: K2): this
+  crossJoin<
+    J extends keyof S,
+    T extends S[J],
+    K extends keyof T,
+    J2 extends keyof S,
+    K2 extends keyof S[J2],
+  >(table: J, column: K, operator: Operator, table2: J2, column2: K2): this
   crossJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>) {
     return this.#join('CROSS', table, ...args)
   }
 
+  where(fn: WhereFn<T>): this
+  where<K extends keyof T>(column: K, value: T[K]): this
+  where<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
   where(...args: WhereArgs<T>) {
     this.#clauses.where(...args)
     return this
   }
-  on(...args: WhereArgs<T>) {
+  on(fn: WhereFn<T>): this
+  on<K extends keyof T>(column: K, value: T[K]): this
+  on<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
+  on(...args: WhereArgs<T>) { // @ts-ignore
     return this.where(...args)
   }
 
+  orWhere(fn: WhereFn<T>): this
+  orWhere<K extends keyof T>(column: K, value: T[K]): this
+  orWhere<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
   orWhere(...args: WhereArgs<T>) {
     this.#clauses.orWhere(...args)
     return this
   }
-  orOn(...args: WhereArgs<T>) {
+  orOn(fn: WhereFn<T>): this
+  orOn<K extends keyof T>(column: K, value: T[K]): this
+  orOn<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
+  orOn(...args: WhereArgs<T>) { // @ts-ignore
     return this.orWhere(...args)
   }
 
-  whereIn(column: C, values: T[C][]) {
+  whereIn<K extends keyof T>(column: K, values: T[K][]) {
     this.#clauses.whereIn(column, values)
     return this
   }
-  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][]) {
+  whereNotIn<K extends keyof T>(column: K, values: T[K][]) {
     this.#clauses.whereNotIn(column, values)
     return this
   }
-  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][]) {
+  orWhereIn<K extends keyof T>(column: K, values: T[K][]) {
     this.#clauses.orWhereIn(column, values)
     return this
   }
-  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][]) {
+  orWhereNotIn<K extends keyof T>(column: K, values: T[K][]) {
     this.#clauses.orWhereNotIn(column, values)
     return this
   }
-  orNotIn(column: C, values: T[C][]) {
+  orNotIn<K extends keyof T>(column: K, values: T[K][]) {
     return this.orWhereNotIn(column, values)
   }
 
-  whereBetween(column: C, one: T[C], two: T[C]) {
+  whereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     this.#clauses.whereBetween(column, one, two)
     return this
   }
-  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]) {
+  orWhereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     this.#clauses.orWhereBetween(column, one, two)
     return this
   }
-  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]) {
+  whereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     this.#clauses.whereNotBetween(column, one, two)
     return this
   }
-  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]) {
+  orWhereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]) {
     this.#clauses.orWhereNotBetween(column, one, two)
     return this
   }
-  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)
   }
 
-  whereNull(column: C) {
+  whereNull<K extends keyof T>(column: K) {
     this.#clauses.whereNull(column)
     return this
   }
-  onNull(column: C) {
+  onNull<K extends keyof T>(column: K) {
     return this.whereNull(column)
   }
 
-  orWhereNull(column: C) {
+  orWhereNull<K extends keyof T>(column: K) {
     this.#clauses.orWhereNull(column)
     return this
   }
-  orOnNull(column: C) {
+  orOnNull<K extends keyof T>(column: K) {
     return this.orWhereNull(column)
   }
 
-  whereNotNull(column: C) {
+  whereNotNull<K extends keyof T>(column: K) {
     this.#clauses.whereNotNull(column)
     return this
   }
-  onNotNull(column: C) {
+  onNotNull<K extends keyof T>(column: K) {
     return this.whereNotNull(column)
   }
 
-  orWhereNotNull(column: C) {
+  orWhereNotNull<K extends keyof T>(column: K) {
     this.#clauses.orWhereNotNull(column)
     return this
   }
-  orNotNull(column: C) {
+  orNotNull<K extends keyof T>(column: K) {
     return this.orWhereNotNull(column)
   }
 
@@ -317,6 +498,9 @@ export default class QueryBuilder<
   }
 
   get args() {
+    if (this.#values.length)
+      return [...this.#values, ...this.#clauses.args]
+
     return this.#clauses.args
   }
   get arguments() {
@@ -329,25 +513,43 @@ export default class QueryBuilder<
   get query() {
     let sql = ''
 
-    const selects = new Set<string>()
-    this.#selects.forEach(column => {
-      column = parseSelectColumn(column, this.#table, this.#hasJoin)
-      !selects.has(column) && selects.add(column)
-    })
+    switch (this.#type) {
+      case types.SELECT:
+        const selects = new Set<string>()
+        this.#selects.forEach(column => {
+          column = parseSelectColumn(column, this.#table, this.#hasJoin)
+          !selects.has(column) && selects.add(column)
+        })
 
-    sql += `SELECT ${this.#distinct ? 'DISTINCT ' : ''}${
-      selects.size ? [...selects].join(', ') : '*'
-    }`
+        sql += `SELECT ${this.#distinct ? 'DISTINCT ' : ''}${
+          selects.size ? [...selects].join(', ') : '*'
+        }`
 
-    sql += ' FROM '+ this.#table
+        sql += ' FROM '+ this.#table
 
-    if (this.#joins.length)
-      sql += ' '+ this.#joins.join(' ')
+        if (this.#joins.length)
+          sql += ' '+ this.#joins.join(' ')
+
+        break
+      case types.INSERT:
+        sql += `INSERT INTO ${this.#table} (${this.#keys.map(key => sqlName(key)).join(', ')})`
+        sql += ` VALUES (${Array.from({ length: this.#keys.length }, () => '?').join(', ')})`
+
+        break
+      case types.UPDATE:
+        sql += `UPDATE ${this.#table} SET ${this.#keys.map(key => key + ` = ?`).join(', ')}`
+
+        break
+      case types.DELETE:
+        sql += `DELETE FROM ` + this.#table
+
+        break
+    }
 
     if (this.#clauses.length)
       sql += ' WHERE '+ this.#clauses.clauses.join(' ')
 
-    if (this.#groups.length)
+    if (this.#type == types.SELECT && this.#groups.length)
       sql += ' GROUP BY '+ this.#groups.join(', ')
 
     if (this.#orders.length)
@@ -363,7 +565,7 @@ export default class QueryBuilder<
   }
 
   get sql() {
-    return this.#bind(this.query, this.#clauses.args)
+    return this.#bind(this.query, this.args)
   }
   get raw() {
     return this.sql

package/src/types.ts

@@ -1,5 +1,6 @@
 import z from 'zod'
 import QueryBuilder from './query-builder'
+import { types } from './utils'
 
 export type text = string
 export type real = number
@@ -15,18 +16,26 @@ export type Values = Value[]
 // export type WriteType = Primitive | ArrayBuffer | ArrayBufferView | undefined
 // export type ReadType = Primitive | any[]
 
+export type QueryType = typeof types[keyof typeof types]
+export type TableOpts = {
+  timestamps?: boolean,
+  createdAt?: boolean,
+  updatedAt?: boolean,
+}
+
 export type Operator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'LIKE' // | 'IN' | 'NOT IN' | 'BETWEEN' | 'IS NULL' | 'IS NOT NULL'
 export type OrderDirection = 'ASC' | 'DESC' | 'asc' | 'desc'
 
 export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'CROSS'
 
-export type DBSchema = z.ZodObject<any>
+export type DBSchema = z.ZodObject<z.ZodRawShape>
+
+export type SchemaObject = z.ZodRawShape
 
-export type SchemaObject = Record<string, z.ZodTypeAny>
-export type SchemaKeys<TSchema extends DBSchema> =
-  TSchema extends z.ZodObject<infer TShape>
+export type SchemaKeys<TSchema extends DBSchema | SchemaObject> =
+  TSchema extends z.ZodObject<infer TShape extends z.ZodRawShape>
     ? keyof TShape
-    : TSchema extends SchemaObject
+    : TSchema extends z.ZodRawShape
       ? keyof TSchema
       : never
 
@@ -53,65 +62,57 @@ export type Item<B, S extends keyof B, T = Pick<B, S>> = { [K in keyof T]: T[K]
 
 export type ClauseOperator = 'AND' | 'OR'
 
-export type WhereFn<T, C extends keyof T = keyof T> = (q: IClauseBuilder<T, C>) => void
-export type WhereArgs<T, C extends keyof T = keyof T> = [WhereFn<T, C>] | [C, T[C]] | [C, Operator, T[C]]
+export type WhereFn<T> = (q: IClauseBuilder<T>) => void
+export type WhereArgs<T, C extends keyof T = keyof T> = [WhereFn<T>] | [C, T[C]] | [C, Operator, T[C]]
 
-export interface IClauseBuilder<T, C extends keyof T = keyof T> {
-  where(fn: WhereFn<T, C>): this
-  where(column: C, value: T[C]): this
-  where(column: C, operator: Operator, value: T[C]): this
-  where(...args: WhereArgs<T>): this
+export interface IClauseBuilder<T> {
+  where<K extends keyof T>(column: K, value: T[K]): this
+  where<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
 
-  on(fn: WhereFn<T, C>): this
-  on(column: C, value: T[C]): this
-  on(column: C, operator: Operator, value: T[C]): this
-  on(...args: WhereArgs<T>): this
+  on<K extends keyof T>(column: K, value: T[K]): this
+  on<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
 
-  orWhere(fn: WhereFn<T, C>): this
-  orWhere(column: C, value: T[C]): this
-  orWhere(column: C, operator: Operator, value: T[C]): this
-  orWhere(...args: WhereArgs<T>): this
+  orWhere<K extends keyof T>(column: K, value: T[K]): this
+  orWhere<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
 
-  orOn(fn: WhereFn<T, C>): this
-  orOn(column: C, value: T[C]): this
-  orOn(column: C, operator: Operator, value: T[C]): this
-  orOn(...args: WhereArgs<T>): this
+  orOn<K extends keyof T>(column: K, value: T[K]): this
+  orOn<K extends keyof T>(column: K, operator: Operator, value: T[K]): this
 
-  whereIn(column: C, values: T[C][]): this
-  in(column: C, values: T[C][]): this
+  whereIn<K extends keyof T>(column: K, values: T[K][]): this
+  in<K extends keyof T>(column: K, values: T[K][]): this
 
-  whereNotIn(column: C, values: T[C][]): this
-  notIn(column: C, values: T[C][]): this
+  whereNotIn<K extends keyof T>(column: K, values: T[K][]): this
+  notIn<K extends keyof T>(column: K, values: T[K][]): this
 
-  orWhereIn(column: C, values: T[C][]): this
-  orIn(column: C, values: T[C][]): this
+  orWhereIn<K extends keyof T>(column: K, values: T[K][]): this
+  orIn<K extends keyof T>(column: K, values: T[K][]): this
 
-  orWhereNotIn(column: C, values: T[C][]): this
-  orNotIn(column: C, values: T[C][]): this
+  orWhereNotIn<K extends keyof T>(column: K, values: T[K][]): this
+  orNotIn<K extends keyof T>(column: K, values: T[K][]): this
 
-  whereBetween(column: C, one: T[C], two: T[C]): this
-  between(column: C, one: T[C], two: T[C]): this
+  whereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
+  between<K extends keyof T>(column: K, one: T[K], two: T[K]): this
 
-  orWhereBetween(column: C, one: T[C], two: T[C]): this
-  orBetween(column: C, one: T[C], two: T[C]): this
+  orWhereBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
+  orBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
 
-  whereNotBetween(column: C, one: T[C], two: T[C]): this
-  notBetween(column: C, one: T[C], two: T[C]): this
+  whereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
+  notBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
 
-  orWhereNotBetween(column: C, one: T[C], two: T[C]): this
-  orNotBetween(column: C, one: T[C], two: T[C]): this
+  orWhereNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
+  orNotBetween<K extends keyof T>(column: K, one: T[K], two: T[K]): this
 
-  whereNull(column: C): this
-  onNull(column: C): this
+  whereNull<K extends keyof T>(column: K): this
+  onNull<K extends keyof T>(column: K): this
 
-  orWhereNull(column: C): this
-  orOnNull(column: C): this
+  orWhereNull<K extends keyof T>(column: K): this
+  orOnNull<K extends keyof T>(column: K): this
 
-  whereNotNull(column: C): this
-  onNotNull(column: C): this
+  whereNotNull<K extends keyof T>(column: K): this
+  onNotNull<K extends keyof T>(column: K): this
 
-  orWhereNotNull(column: C): this
-  orNotNull(column: C): this
+  orWhereNotNull<K extends keyof T>(column: K): this
+  orNotNull<K extends keyof T>(column: K): this
 }
 
 export type JoinArgs<S, J extends keyof S> =
@@ -123,7 +124,6 @@ export type JoinArgs<S, J extends keyof S> =
   | [keyof S[J], Operator, keyof S, keyof S[keyof S]]
 
 export interface IJoinBuilder<S> {
-  join<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
   join<
     J extends keyof S,
     T extends S[J],
@@ -148,9 +148,7 @@ export interface IJoinBuilder<S> {
     J2 extends keyof S,
     C2 extends keyof S[J2],
   >(table: J, column: C, operator: Operator, table2: J2, column2: C2): this
-  join<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this
 
-  innerJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
   innerJoin<
     J extends keyof S,
     T extends S[J],
@@ -175,9 +173,7 @@ export interface IJoinBuilder<S> {
     J2 extends keyof S,
     C2 extends keyof S[J2],
   >(table: J, column: C, operator: Operator, table2: J2, column2: C2): this
-  innerJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this
 
-  leftJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
   leftJoin<
     J extends keyof S,
     T extends S[J],
@@ -202,9 +198,7 @@ export interface IJoinBuilder<S> {
     J2 extends keyof S,
     C2 extends keyof S[J2],
   >(table: J, column: C, operator: Operator, table2: J2, column2: C2): this
-  leftJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this
 
-  rightJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
   rightJoin<
     J extends keyof S,
     T extends S[J],
@@ -229,9 +223,7 @@ export interface IJoinBuilder<S> {
     J2 extends keyof S,
     C2 extends keyof S[J2],
   >(table: J, column: C, operator: Operator, table2: J2, column2: C2): this
-  rightJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this
 
-  crossJoin<J extends keyof S>(table: J, fn: WhereFn<S[J]>): this
   crossJoin<
     J extends keyof S,
     T extends S[J],
@@ -256,5 +248,4 @@ export interface IJoinBuilder<S> {
     J2 extends keyof S,
     C2 extends keyof S[J2],
   >(table: J, column: C, operator: Operator, table2: J2, column2: C2): this
-  crossJoin<J extends keyof S>(table: J, ...args: JoinArgs<S, J>): this
 }