generic code cleanup

Author: koskimas

src/dialect/mysql/mysql-driver.ts

@@ -14,7 +14,12 @@ import {
 
 import { Driver, TransactionSettings } from '../../driver/driver.js'
 import { CompiledQuery } from '../../query-compiler/compiled-query.js'
-import { isFunction, isObject } from '../../util/object-utils.js'
+import {
+  isFunction,
+  isNumber,
+  isObject,
+  isString,
+} from '../../util/object-utils.js'
 import { MysqlDialectConfig } from './mysql-dialect.js'
 
 const PRIVATE_RELEASE_METHOD = Symbol()
@@ -145,12 +150,12 @@ class MysqlConnection implements DatabaseConnection {
     const result = await this.#executeQuery(compiledQuery)
 
     if (isObject(result) && 'insertId' in result && 'affectedRows' in result) {
-      if (result.insertId) {
+      if (isNumber(result.insertId) && result.insertId > 0) {
         return {
           insertedPrimaryKey: result.insertId,
           rows: [],
         }
-      } else {
+      } else if (isNumber(result.affectedRows)) {
         return {
           numUpdatedOrDeletedRows: result.affectedRows,
           rows: [],

src/parser/group-by-parser.ts

@@ -0,0 +1,15 @@
+import { GroupByItemNode } from '../operation-node/group-by-item-node.js'
+import { ParseContext } from './parse-context.js'
+import {
+  parseReferenceExpressionOrList,
+  ReferenceExpressionOrList,
+} from './reference-parser.js'
+
+export function parseGroupBy(
+  ctx: ParseContext,
+  orderBy: ReferenceExpressionOrList<any, any>
+): GroupByItemNode[] {
+  return parseReferenceExpressionOrList(ctx, orderBy).map(
+    GroupByItemNode.create
+  )
+}

src/parser/order-by-parser.ts

@@ -1,4 +1,5 @@
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js'
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js'
 import { RawNode } from '../operation-node/raw-node.js'
 import { AnyRawBuilder } from '../util/type-utils.js'
 import { ParseContext } from './parse-context.js'
@@ -15,14 +16,25 @@ export type OrderByExpression<DB, TB extends keyof DB, O> =
 
 export type OrderByDirectionExpression = OrderByDirection | AnyRawBuilder
 
-export function parseOrderByExpression(
+export function parseOrderBy(
+  ctx: ParseContext,
+  orderBy: OrderByExpression<any, any, any>,
+  direction?: OrderByDirectionExpression
+): OrderByItemNode {
+  return OrderByItemNode.create(
+    parseOrderByExpression(ctx, orderBy),
+    parseOrderByDirectionExpression(direction)
+  )
+}
+
+function parseOrderByExpression(
   ctx: ParseContext,
   expr: OrderByExpression<any, any, any>
 ): ReferenceExpressionNode {
   return parseReferenceExpression(ctx, expr)
 }
 
-export function parseOrderByDirectionExpression(
+function parseOrderByDirectionExpression(
   expr?: OrderByDirectionExpression
 ): RawNode | undefined {
   if (!expr) {

src/parser/reference-parser.ts

@@ -4,7 +4,12 @@ import { isOperationNodeSource } from '../operation-node/operation-node-source.j
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js'
 import { ReferenceNode } from '../operation-node/reference-node.js'
 import { TableNode } from '../operation-node/table-node.js'
-import { isFunction, isString, PrimitiveValue } from '../util/object-utils.js'
+import {
+  isFunction,
+  isReadonlyArray,
+  isString,
+  PrimitiveValue,
+} from '../util/object-utils.js'
 import {
   AnyColumn,
   AnyColumnWithTable,
@@ -31,7 +36,7 @@ export type ReferenceExpression<DB, TB extends keyof DB> =
 
 export type ReferenceExpressionOrList<DB, TB extends keyof DB> =
   | ReferenceExpression<DB, TB>
-  | ReferenceExpression<DB, TB>[]
+  | ReadonlyArray<ReferenceExpression<DB, TB>>
 
 export type StringReference<DB, TB extends keyof DB> =
   | AnyColumn<DB, TB>
@@ -78,7 +83,7 @@ export function parseReferenceExpressionOrList(
   ctx: ParseContext,
   arg: ReferenceExpressionOrList<any, any>
 ): ReferenceExpressionNode[] {
-  if (Array.isArray(arg)) {
+  if (isReadonlyArray(arg)) {
     return arg.map((it) => parseReferenceExpression(ctx, it))
   } else {
     return [parseReferenceExpression(ctx, arg)]

src/query-builder/query-builder.ts

@@ -37,11 +37,10 @@ import {
 } from '../parser/insert-values-parser.js'
 import { QueryBuilderWithReturning } from '../parser/returning-parser.js'
 import {
-  parseReferenceExpressionOrList,
   ReferenceExpression,
+  ReferenceExpressionOrList,
 } from '../parser/reference-parser.js'
 import { ValueExpressionOrList } from '../parser/value-parser.js'
-import { OrderByItemNode } from '../operation-node/order-by-item-node.js'
 import { SelectQueryNode } from '../operation-node/select-query-node.js'
 import { InsertQueryNode } from '../operation-node/insert-query-node.js'
 import {
@@ -58,10 +57,8 @@ import {
 import {
   OrderByDirectionExpression,
   OrderByExpression,
-  parseOrderByDirectionExpression,
-  parseOrderByExpression,
+  parseOrderBy,
 } from '../parser/order-by-parser.js'
-import { GroupByItemNode } from '../operation-node/group-by-item-node.js'
 import { UpdateQueryNode } from '../operation-node/update-query-node.js'
 import {
   MutationObject,
@@ -83,6 +80,7 @@ import { freeze } from '../util/object-utils.js'
 import { ParseContext } from '../parser/parse-context.js'
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js'
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js'
+import { parseGroupBy } from '../parser/group-by-parser.js'
 
 /**
  * The main query builder class.
@@ -2062,10 +2060,7 @@ export class QueryBuilder<DB, TB extends keyof DB, O = {}>
       ...this.#props,
       queryNode: SelectQueryNode.cloneWithOrderByItem(
         this.#props.queryNode,
-        OrderByItemNode.create(
-          parseOrderByExpression(this.#props.parseContext, orderBy),
-          parseOrderByDirectionExpression(direction)
-        )
+        parseOrderBy(this.#props.parseContext, orderBy, direction)
       ),
     })
   }
@@ -2174,16 +2169,14 @@ export class QueryBuilder<DB, TB extends keyof DB, O = {}>
 
   groupBy(orderBy: ReferenceExpression<DB, TB>): QueryBuilder<DB, TB, O>
 
-  groupBy(orderBy: any): QueryBuilder<DB, TB, O> {
+  groupBy(orderBy: ReferenceExpressionOrList<DB, TB>): any {
     assertCanHaveGroupByClause(this.#props.queryNode)
 
     return new QueryBuilder({
       ...this.#props,
       queryNode: SelectQueryNode.cloneWithGroupByItems(
         this.#props.queryNode,
-        parseReferenceExpressionOrList(this.#props.parseContext, orderBy).map(
-          GroupByItemNode.create
-        )
+        parseGroupBy(this.#props.parseContext, orderBy)
       ),
     })
   }
@@ -2516,7 +2509,7 @@ function assertCanHaveReturningClause(
 ): asserts node is MutatingQueryNode {
   if (!QueryNode.isMutating(node)) {
     throw new Error(
-      'only an insert, delete and update queries can have a returning clause'
+      'only insert, delete and update queries can have a returning clause'
     )
   }
 }

src/query-compiler/compiled-query.ts

@@ -1,4 +1,4 @@
 export interface CompiledQuery {
   readonly sql: string
-  readonly parameters: ReadonlyArray<any>
+  readonly parameters: ReadonlyArray<unknown>
 }

src/query-compiler/default-query-compiler.ts

@@ -80,7 +80,7 @@ export class DefaultQueryCompiler
   implements QueryCompiler
 {
   #sql = ''
-  #parameters: any[] = []
+  #parameters: unknown[] = []
 
   protected get numParameters(): number {
     return this.#parameters.length
@@ -887,8 +887,8 @@ export class DefaultQueryCompiler
     this.#sql += str
   }
 
-  protected appendValue(value: PrimitiveValue): void {
-    this.addParameter(value)
+  protected appendValue(parameter: unknown): void {
+    this.addParameter(parameter)
     this.append(this.getCurrentParameterPlaceholder())
   }
 
@@ -904,7 +904,7 @@ export class DefaultQueryCompiler
     return '$' + this.numParameters
   }
 
-  protected addParameter(parameter: any): void {
+  protected addParameter(parameter: unknown): void {
     this.#parameters.push(parameter)
   }
 

src/util/object-utils.ts

@@ -8,7 +8,7 @@ export type PrimitiveValue =
   | BigInt
 
 export function isEmpty(
-  obj: ArrayLike<any> | string | object | Buffer
+  obj: ArrayLike<unknown> | string | object | Buffer
 ): boolean {
   if (Array.isArray(obj) || isString(obj) || Buffer.isBuffer(obj)) {
     return obj.length === 0
@@ -19,35 +19,35 @@ export function isEmpty(
   return false
 }
 
-export function isString(obj: any): obj is string {
+export function isString(obj: unknown): obj is string {
   return typeof obj === 'string'
 }
 
-export function isNumber(obj: any): obj is number {
+export function isNumber(obj: unknown): obj is number {
   return typeof obj === 'number'
 }
 
-export function isBoolean(obj: any): obj is boolean {
+export function isBoolean(obj: unknown): obj is boolean {
   return typeof obj === 'boolean'
 }
 
-export function isNull(obj: any): obj is null {
+export function isNull(obj: unknown): obj is null {
   return obj === null
 }
 
-export function isDate(obj: any): obj is Date {
+export function isDate(obj: unknown): obj is Date {
   return obj instanceof Date
 }
 
-export function isBuffer(obj: any): obj is Buffer {
+export function isBuffer(obj: unknown): obj is Buffer {
   return Buffer.isBuffer(obj)
 }
 
-export function isBigInt(obj: any): obj is BigInt {
+export function isBigInt(obj: unknown): obj is BigInt {
   return typeof obj === 'bigint'
 }
 
-export function isPrimitive(obj: any): obj is PrimitiveValue {
+export function isPrimitive(obj: unknown): obj is PrimitiveValue {
   return (
     isString(obj) ||
     isNumber(obj) ||
@@ -59,12 +59,12 @@ export function isPrimitive(obj: any): obj is PrimitiveValue {
   )
 }
 
-export function isFunction(obj: any): obj is Function {
+export function isFunction(obj: unknown): obj is Function {
   return typeof obj === 'function'
 }
 
-export function isObject(obj: any): obj is Record<string, any> {
-  return obj && typeof obj === 'object'
+export function isObject(obj: unknown): obj is Record<string, unknown> {
+  return typeof obj === 'object' && obj !== null
 }
 
 export function getLast<T>(arr: ArrayLike<T>): T | undefined {