forj 0.1.5 → 0.1.7

package/src/query-builder.ts

@@ -1,21 +1,27 @@
+import { Timestamp } from 't0n'
 import ClauseBuilder from './clause-builder'
 import {
+  types,
   isOperator,
   parseColumn, parseSelectColumn,
   formatValue,
   isJoinCompare,
   zSame, zType,
+  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<
@@ -26,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[] = []
@@ -42,6 +52,7 @@ export default class QueryBuilder<
   #joins: string[] = []
 
   #pipe?: Pipe<S, T, C>
+  #opts: TableOpts = {}
 
   constructor(
     table: string,
@@ -54,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.`)
@@ -61,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()
@@ -74,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
   }
@@ -89,7 +134,7 @@ export default class QueryBuilder<
     ...args: JoinArgs<S, J>
   ) {
     this.#hasJoin = true
-    const query = (type ? type + ' ' : '') + `JOIN ${table as string} ON `
+    const query = (type ? type + ' ' : '') + `JOIN ${sqlName(table as string)} ON `
 
     if (typeof args[0] == 'function') {
       const join = new ClauseBuilder<S[J]>(table as string, this.#schema)
@@ -107,7 +152,6 @@ export default class QueryBuilder<
       value = operator
       operator = '='
     } else if (length == 3 && !isOperator(operator)) { // @ts-ignore
-      // console.log(column, operator, value, value2) // @ts-ignore
       value = parseColumn(value as string, operator as string) // TODO: check if value is a valid column
 
       if (this.#schema && !isJoinCompare(value, this.#schema))
@@ -115,16 +159,16 @@ export default class QueryBuilder<
 
       operator = '='
     } else if (length == 4) { // @ts-ignore
-      // console.log(column, operator, value, value2) // @ts-ignore
       value = parseColumn(value2 as string, value as string)
       operator = '='
     }
 
     const col = parseColumn(String(column), String(table))
-    if (this.#schema && !zSame(col, value, this.#schema))
-      throw new Error(`Table column '${col}' of type '${zType(col, this.#schema)}' is not assignable as type of '${typeof value}'.`)
 
-    if (!isJoinCompare(value, this.#schema)) { // @ts-ignore
+    if (!isJoinCompare(value, this.#schema)) {
+      if (this.#schema && !zSame(col.replace(/"/g, ''), value, this.#schema))
+        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