feat: add aggregate helpers

Author: thetutlage

index.ts

@@ -11,4 +11,3 @@ export * from './src/define_config.js'
 export { Connection } from './src/connection/connection.js'
 export { QueryClient } from './src/database_clients/query_client.js'
 export { DatabaseClient } from './src/database_clients/abstract_client.js'
-export { SelectQueryBuilder } from './src/query_builders/select_query_builder.js'

package.json

@@ -12,7 +12,9 @@
     "!build/tests"
   ],
   "exports": {
-    ".": "./build/index.js"
+    ".": "./build/index.js",
+    "./types": "./build/src/types/main.js",
+    "./query_builder": "./build/src/query_builders/main.js"
   },
   "scripts": {
     "pretest": "npm run lint && rm -rf coverage/tmp && mkdir -p coverage/tmp",
@@ -48,6 +50,7 @@
     "@japa/file-system": "^2.3.2",
     "@japa/runner": "^4.2.0",
     "@japa/snapshot": "^2.0.8",
+    "@libsql/sqlite3": "^0.3.1",
     "@release-it/conventional-changelog": "^10.0.0",
     "@swc/core": "1.10.7",
     "@types/better-sqlite3": "^7.6.12",
@@ -78,7 +81,37 @@
     "tarn": "3.0.2"
   },
   "peerDependencies": {
-    "@adonisjs/core": "^6.17.2"
+    "@adonisjs/core": "^6.17.2",
+    "tedious": "^18.6.1",
+    "better-sqlite3": "^11.9.1",
+    "mysql2": "^3.14.0",
+    "pg": "^8.14.1",
+    "@types/pg": "^8.11.11",
+    "@types/better-sqlite3": "^7.6.12",
+    "@libsql/sqlite3": "^0.3.1"
+  },
+  "peerDependenciesMeta": {
+    "tedious": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "@types/pg": {
+      "optional": true
+    },
+    "@types/better-sqlite3": {
+      "optional": true
+    },
+    "@libsql/sqlite3": {
+      "optional": true
+    }
   },
   "homepage": "https://github.com/adonisjs/lucid#readme",
   "repository": {

src/connection/connection.ts

@@ -14,17 +14,18 @@ import { RuntimeException } from '@poppinss/exception'
 
 import { debug } from '../debug.js'
 import * as errors from '../errors.js'
+import { NOOP_EMITTER } from '../helpers.js'
 import { createKnexLogger } from './logger.js'
 import { dialects } from '../dialects/main.js'
 import { QueryClient } from '../database_clients/query_client.js'
+
 import type { DialectContract } from '../types/dialect.js'
 import type {
   ConnectionConfig,
   ConnectionLogger,
   DatabaseEmitter,
   SupportedDialectNames,
 } from '../types/connection.js'
-import { NOOP_EMITTER } from '../helpers.js'
 
 /**
  * A connection represents a database connection created by instantiating
@@ -134,6 +135,34 @@ export class Connection {
     this.dialect = new dialects[config.dialectName](this)
   }
 
+  /**
+   * Patches the knex client's "acquireRawConnection" method to add
+   * support for BigInts when using the better-sqlite3 client and
+   * "defaultSafeIntegers" is enabled.
+   */
+  #patchSqliteConnectionToSupportBigInts(client: Knex) {
+    /**
+     * Return early when defaultSafeIntegers are disabled
+     */
+    if (
+      this.config.clientName !== 'better-sqlite3' ||
+      'defaultSafeIntegers' in this.config === false ||
+      !this.config.defaultSafeIntegers
+    ) {
+      return
+    }
+
+    const originalAcquireRawConnection = client.client.acquireRawConnection.bind(client.client)
+    client.client.acquireRawConnection = function () {
+      return originalAcquireRawConnection(...arguments).then((db: any) => {
+        if ('defaultSafeIntegers' in db) {
+          db.defaultSafeIntegers(true)
+        }
+        return db
+      })
+    }
+  }
+
   /**
    * Creates the fresh state for the connection
    */
@@ -211,6 +240,7 @@ export class Connection {
 
     debug('%s: creating write connection %O', this.identifier, writeConfig)
     this.client = knex.knex({ log: this.#knexLogger, ...writeConfig })
+    this.#patchSqliteConnectionToSupportBigInts(this.client)
     patchKnex(this.client, (originalConfig) => originalConfig.connection as Knex.ConnectionConfig)
   }
 
@@ -250,6 +280,7 @@ export class Connection {
 
     debug('%s: creating read connection %O', this.identifier, initialConfig)
     this.readClient = knex({ log: this.#knexLogger, ...initialConfig })
+    this.#patchSqliteConnectionToSupportBigInts(this.readClient)
 
     /**
      * Creating the final config array of read replicas.
@@ -387,7 +418,9 @@ export class Connection {
    * @default: 'dual'
    */
   getQueryClient(mode: 'dual' | 'write' | 'read' = 'dual') {
-    return new QueryClient(this, mode, this.#emitter)
+    const client = new QueryClient(this, mode, this.#emitter)
+    client.debug = this.config.debug ?? false
+    return client
   }
 
   /**

src/database_clients/abstract_client.ts

@@ -15,7 +15,7 @@ import { NOOP_EMITTER } from '../helpers.js'
 import { DatabaseEmitter } from '../types/connection.js'
 import type { DialectContract } from '../types/dialect.js'
 import type { Connection } from '../connection/connection.js'
-import { beginTransactionTracer, queryTracer } from '../tracing_channels.js'
+import { beginTransaction, dbQuery } from '../tracing_channels.js'
 import { SelectQueryBuilder } from '../query_builders/select_query_builder.js'
 import { InsertQueryBuilder } from '../query_builders/insert_query_builder.js'
 import { DeleteQueryBuilder } from '../query_builders/delete_query_builder.js'
@@ -33,6 +33,7 @@ import type {
   FromExpressionArguments,
 } from '../types/query.js'
 import { TransactionClient } from './transaction_client.js'
+import { FunctionExpressionBuilder } from '../expression_builders/function_expression_builder.js'
 
 /**
  * DatabaseClient can be used to create different query builders and execute
@@ -77,6 +78,11 @@ export abstract class DatabaseClient implements DatabaseClientContract {
    */
   isTransaction: boolean = false
 
+  /**
+   * Helpers functions to express parts of a SQL query
+   */
+  fn = new FunctionExpressionBuilder()
+
   /**
    * The name of the connection from which the client
    * was originated.
@@ -140,7 +146,7 @@ export abstract class DatabaseClient implements DatabaseClientContract {
     const tracingData = { ...this.getContext(), isSavePoint: this.isTransaction }
     const event = this.createEvent('db:transaction:begin', this.debug)
 
-    return beginTransactionTracer.tracePromise(async () => {
+    return beginTransaction.tracePromise(async () => {
       const trx = await this.getWriteClient().transaction(options)
       debug('begin transaction')
       event.emit(tracingData)
@@ -528,7 +534,7 @@ export abstract class DatabaseClient implements DatabaseClientContract {
       const tracingData = { ...query.getContext() } as DbQueryEventData
       const event = this.createEvent('db:query', query.debugging)
 
-      const result = (await queryTracer.tracePromise(async () => {
+      const result = (await dbQuery.tracePromise(async () => {
         /**
          * This logic will mess up if one query instance is used to execute
          * multiple times, which in itself is incorrect usage of the

src/database_clients/transaction_client.ts

@@ -13,7 +13,7 @@ import { DatabaseClient } from './abstract_client.js'
 import type { IsolationLevels } from '../types/query.js'
 import type { Connection } from '../connection/connection.js'
 import type { DatabaseEmitter } from '../types/connection.js'
-import { commitTransactionTracer, rollbackTransactionTracer } from '../tracing_channels.js'
+import { commitTransaction, rollbackTransaction } from '../tracing_channels.js'
 import { debug } from '../debug.js'
 
 export class TransactionClient extends DatabaseClient {
@@ -81,7 +81,7 @@ export class TransactionClient extends DatabaseClient {
     const tracingData = { ...this.getContext() }
     const event = this.createEvent('db:transaction:commit', this.debug)
 
-    return commitTransactionTracer.tracePromise(async () => {
+    return commitTransaction.tracePromise(async () => {
       debug('committing transaction')
       await this.knexTransaction.commit()
       tracingData.duration = process.hrtime(this.#startedAt)
@@ -104,7 +104,7 @@ export class TransactionClient extends DatabaseClient {
     const tracingData = { ...this.getContext() }
     const event = this.createEvent('db:transaction:rollback', this.debug)
 
-    return rollbackTransactionTracer.tracePromise(async () => {
+    return rollbackTransaction.tracePromise(async () => {
       debug('rolling back transaction')
       await this.knexTransaction.rollback()
       tracingData.duration = process.hrtime(this.#startedAt)

src/expression_builders/function_expression_builder.ts

@@ -0,0 +1,74 @@
+/*
+ * @adonisjs/lucid
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { AGGREGATE_ARGUMENTS } from '../symbols.js'
+import type {
+  AggregateMethods,
+  AggregateExpression,
+  AggregateExpressionArguments,
+} from '../types/query.js'
+
+export class FunctionExpressionBuilder {
+  /**
+   * Creates an aggregate to be parsed by the select expression
+   * builder
+   */
+  #createAggregate(method: AggregateMethods, expression: AggregateExpressionArguments) {
+    const aggregate = {
+      [AGGREGATE_ARGUMENTS]: {
+        method: method,
+        expression,
+        alias: undefined as string | undefined,
+      },
+      as(alias: string) {
+        this[AGGREGATE_ARGUMENTS].alias = alias
+        return this
+      },
+    }
+    return aggregate satisfies AggregateExpression
+  }
+
+  /**
+   * Sum values of one or more columns
+   */
+  sum(...expression: AggregateExpressionArguments) {
+    return this.#createAggregate('sum', expression)
+  }
+
+  /**
+   * Sum values of one or more columns
+   */
+  sumDistinct(...expression: AggregateExpressionArguments) {
+    return this.#createAggregate('sumDistinct', expression)
+  }
+
+  avg(...expression: AggregateExpressionArguments) {
+    return this.#createAggregate('avg', expression)
+  }
+
+  avgDistinct(...expression: AggregateExpressionArguments) {
+    return this.#createAggregate('avgDistinct', expression)
+  }
+
+  min(...expression: AggregateExpressionArguments) {
+    return this.#createAggregate('min', expression)
+  }
+
+  max(...expression: AggregateExpressionArguments) {
+    return this.#createAggregate('max', expression)
+  }
+
+  count(...expression: AggregateExpressionArguments) {
+    return this.#createAggregate('count', expression)
+  }
+
+  countDistinct(...expression: AggregateExpressionArguments) {
+    return this.#createAggregate('countDistinct', expression)
+  }
+}