@rvoh/dream 2.18.0 → 2.19.0

package/dist/cjs/src/errors/CannotNamespaceAssociationFilterToAnotherTable.js

@@ -0,0 +1,27 @@
+export default class CannotNamespaceAssociationFilterToAnotherTable extends Error {
+    dreamClass;
+    key;
+    expectedAlias;
+    constructor(dreamClass, key, expectedAlias) {
+        super();
+        this.dreamClass = dreamClass;
+        this.key = key;
+        this.expectedAlias = expectedAlias;
+    }
+    get message() {
+        return `
+Cannot filter on an association via a where-clause key namespaced to another table.
+
+dream class: ${this.dreamClass.sanitizedName}
+where-clause key: ${this.key}
+table alias this where clause applies to: ${this.expectedAlias}
+
+A Dream instance (or array of Dream instances) as a where-clause value resolves
+an association on the model the where clause applies to, so the key may not be
+namespaced to a different table. To filter a joined table by one of its
+associations, pass the filter in the join's on-clause instead, e.g.:
+
+  .innerJoin('association', { and: { myBelongsToAssociation: instances } })
+`;
+    }
+}

package/dist/cjs/src/helpers/cli/generateMigrationContent.js

@@ -8,8 +8,13 @@ import globalClassNameFromFullyQualifiedModelName from '../globalClassNameFromFu
 import snakeify from '../snakeify.js';
 import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
 const STI_TYPE_COLUMN_NAME = 'type';
-const DELETED_AT_COLUMN_NAME = 'deleted_at';
-const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME, DELETED_AT_COLUMN_NAME];
+// deleted_at is deliberately NOT in this list: the SoftDelete default scope's
+// `WHERE deleted_at IS NULL` is unselective on healthy tables, Dream internals
+// never issue a query a deleted_at index could serve, and the useful partial
+// index alternatives are dialect-specific SQL the generator must not emit by
+// default. See spec/unit/cli/generateMigrationContent.spec.ts
+// ("deleted_at is deliberately NOT indexed") and the CHANGELOG.
+const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME];
 export default function generateMigrationContent({ connectionName = 'default', table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', stiChildClassName, softDelete = false, } = {}) {
     const altering = createOrAlter === 'alter';
     let requireCitextExtension = false;
@@ -43,13 +48,18 @@ export default function generateMigrationContent({ connectionName = 'default', t
             return acc;
         /**
          * Automatically set email columns to citext since different casings of
-         * email address are the same email address
+         * email address are the same email address. Skip this when the user
+         * explicitly asked for an encrypted column, since encrypted columns
+         * are always stored as encrypted text and must not be overridden by
+         * the name-based heuristic.
          */
-        const attributeType = /email$/.test(nonStandardAttributeName)
-            ? 'citext'
-            : /uuid$/.test(nonStandardAttributeName)
-                ? 'uuid'
-                : _attributeType;
+        const attributeType = _attributeType === 'encrypted' || _attributeType === 'encrypted[]'
+            ? _attributeType
+            : /email$/.test(nonStandardAttributeName)
+                ? 'citext'
+                : /uuid$/.test(nonStandardAttributeName)
+                    ? 'uuid'
+                    : _attributeType;
         const processedAttrType = camelize(attributeType)?.toLowerCase();
         const userWantsThisOptional = optionalFromDescriptors(descriptors);
         // when creating a migration for an STI child, we don't want to include notNull;
@@ -115,6 +125,7 @@ export default function generateMigrationContent({ connectionName = 'default', t
                 attributeName = `encrypted_${attributeName}`;
                 columnDefs.push(generateColumnStr(attributeName, 'text', descriptors, {
                     omitInlineNonNull,
+                    skipUniqueHeuristic: true,
                 }));
                 break;
             // TODO: determine if we need to support encrypted[] in the future
@@ -145,9 +156,6 @@ export default function generateMigrationContent({ connectionName = 'default', t
         }
         return acc;
     }, { columnDefs: [], columnDrops: [], indexDefs: [] });
-    if (emitDeletedAtColumn) {
-        indexDefs.push(columnIndexStatement(table, DELETED_AT_COLUMN_NAME));
-    }
     if (!table) {
         return `\
 import { Kysely, sql } from 'kysely'
@@ -274,12 +282,12 @@ function generateDecimalStr(attributeName, { descriptors, omitInlineNonNull: opt
         : `'decimal(${scale}, ${precision})'`;
     return `.addColumn('${attributeName}', ${decimalStatement}${optional ? '' : `, col => ${columnModifiers}`})`;
 }
-function generateColumnStr(attributeName, attributeType, descriptors, { omitInlineNonNull: optional }) {
+function generateColumnStr(attributeName, attributeType, descriptors, { omitInlineNonNull: optional, skipUniqueHeuristic = false, }) {
     let returnStr = `.addColumn('${attributeName}', ${attributeTypeString(attributeType)}`;
     const providedDefaultArg = descriptors.find(d => /^default\(/.test(d));
     const providedDefault = providedDefaultArg?.replace(/^default\(/, '')?.replace(/\)$/, '');
     const notNull = !optional;
-    const isUnique = /(email|token|uuid)$/.test(attributeName);
+    const isUnique = !skipUniqueHeuristic && /(email|token|uuid)$/.test(attributeName);
     const hasExtraValues = providedDefault || notNull || isUnique;
     const isArray = /\[\]$/.test(attributeType);
     const needsJsonDefault = notNull && !isArray && (attributeType === 'jsonb' || attributeType === 'json');

package/dist/esm/src/Dream.js

@@ -976,6 +976,25 @@ export default class Dream {
     static async count() {
         return await this.query().count();
     }
+    /**
+     * Retrieves the number of records in each group, keyed by the
+     * value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await User.countBy('name')
+     * // Map(2) { 'fred' => 2, 'zed' => 1 }
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map; seed absent
+     * groups yourself with `map.get(key) ?? 0`. When the group column is nullable,
+     * records with a `null` value are grouped under a real `null` key.
+     *
+     * @param groupColumn - the column to group by
+     * @returns A Map from each present group value to the number of records in that group
+     */
+    static async countBy(groupColumn) {
+        return await this.query().countBy(groupColumn);
+    }
     /**
      * Retrieves the max value of the specified column
      * for this model's records.
@@ -991,6 +1010,27 @@ export default class Dream {
     static async max(columnName) {
         return await this.query().max(columnName);
     }
+    /**
+     * Retrieves the max value of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await CompositionAsset.maxBy('name', 'score')
+     * // Map(2) { 'primary' => 9, 'secondary' => 4 }
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map. When the group
+     * column is nullable, records with a `null` value are grouped under a real
+     * `null` key; a group whose aggregated values are all `null` yields a `null`
+     * value.
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to take the max of within each group
+     * @returns A Map from each present group value to the max of the aggregated column in that group
+     */
+    static async maxBy(groupColumn, aggregatedColumn) {
+        return await this.query().maxBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the min value of the specified column
      * for this model's records.
@@ -1007,6 +1047,27 @@ export default class Dream {
     static async min(columnName) {
         return await this.query().min(columnName);
     }
+    /**
+     * Retrieves the min value of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await CompositionAsset.minBy('name', 'score')
+     * // Map(2) { 'primary' => 1, 'secondary' => 4 }
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map. When the group
+     * column is nullable, records with a `null` value are grouped under a real
+     * `null` key; a group whose aggregated values are all `null` yields a `null`
+     * value.
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to take the min of within each group
+     * @returns A Map from each present group value to the min of the aggregated column in that group
+     */
+    static async minBy(groupColumn, aggregatedColumn) {
+        return await this.query().minBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the sum for all values of the specified column
      * for this model's records.
@@ -1023,6 +1084,27 @@ export default class Dream {
     static async sum(columnName) {
         return await this.query().sum(columnName);
     }
+    /**
+     * Retrieves the sum of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await CompositionAsset.sumBy('name', 'score')
+     * // Map(2) { 'primary' => 10, 'secondary' => 4 }
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map. When the group
+     * column is nullable, records with a `null` value are grouped under a real
+     * `null` key; a group whose aggregated values are all `null` yields a `null`
+     * value.
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to sum within each group
+     * @returns A Map from each present group value to the sum of the aggregated column in that group
+     */
+    static async sumBy(groupColumn, aggregatedColumn) {
+        return await this.query().sumBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the average for all values of the specified column
      * for this model's records.
@@ -1039,6 +1121,27 @@ export default class Dream {
     static async avg(columnName) {
         return await this.query().avg(columnName);
     }
+    /**
+     * Retrieves the average of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await CompositionAsset.avgBy('name', 'score')
+     * // Map(2) { 'primary' => 5, 'secondary' => 4 }
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map. When the group
+     * column is nullable, records with a `null` value are grouped under a real
+     * `null` key; a group whose aggregated values are all `null` yields a `null`
+     * value.
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to average within each group
+     * @returns A Map from each present group value to the average of the aggregated column in that group
+     */
+    static async avgBy(groupColumn, aggregatedColumn) {
+        return await this.query().avgBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Persists a new record, setting the provided attributes.
      * Automatically sets createdAt and updatedAt timestamps.

package/dist/esm/src/db/DreamDbConnection.js

@@ -103,6 +103,12 @@ async function destroyConnectionWithinTimeout(conn, label) {
             reportLeakedDbConnections(label);
         }
     }
+    catch (error) {
+        // teardown is best-effort (the registry entry has already been removed,
+        // so a subsequent getConnection() builds a fresh pool), but a rejected
+        // destroy() must not vanish silently
+        DreamApp.logWithLevel('error', `[dream] failed to close db connection "${label}"`, error);
+    }
     finally {
         if (timer)
             clearTimeout(timer);

package/dist/esm/src/decorators/class/SoftDelete.js

@@ -35,6 +35,18 @@ export const SOFT_DELETE_SCOPE_NAME = 'dream:SoftDelete';
  *     return 'customDatetimeField' as const
  *   }
  * }
+ *
+ * Note on indexing: Dream deliberately does not index `deleted_at`.
+ * The default scope's `WHERE deleted_at IS NULL` matches nearly every
+ * row on a healthy table, so a plain b-tree on the column is rarely
+ * chosen by the planner while still costing index size and write
+ * amplification, and Dream itself never issues a query such an index
+ * could serve. If your app needs one, add it yourself based on your
+ * own access patterns — on Postgres, the two useful shapes are a
+ * composite partial index on your hot lookup columns with
+ * `WHERE deleted_at IS NULL` (fast scoped reads), or a partial index
+ * `WHERE deleted_at IS NOT NULL` (purge/GC sweeps over soft-deleted
+ * rows). Both are Postgres-specific syntax.
  */
 export default function SoftDelete() {
     return function (target) {

package/dist/esm/src/dream/DreamClassTransactionBuilder.js

@@ -58,6 +58,27 @@ export default class DreamClassTransactionBuilder {
     async count() {
         return this.queryInstance().count();
     }
+    /**
+     * Retrieves the number of records in each group, keyed by the
+     * value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   await User.txn(txn).countBy('name')
+     *   // Map(2) { 'fred' => 2, 'zed' => 1 }
+     * })
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map; seed absent
+     * groups yourself with `map.get(key) ?? 0`. When the group column is nullable,
+     * records with a `null` value are grouped under a real `null` key.
+     *
+     * @param groupColumn - the column to group by
+     * @returns A Map from each present group value to the number of records in that group
+     */
+    async countBy(groupColumn) {
+        return this.queryInstance().countBy(groupColumn);
+    }
     /**
      * Returns a new Query instance, specifying a limit
      *
@@ -107,6 +128,29 @@ export default class DreamClassTransactionBuilder {
     async max(columnName) {
         return this.queryInstance().max(columnName);
     }
+    /**
+     * Retrieves the max value of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   await CompositionAsset.txn(txn).maxBy('name', 'score')
+     *   // Map(2) { 'primary' => 9, 'secondary' => 4 }
+     * })
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map. When the group
+     * column is nullable, records with a `null` value are grouped under a real
+     * `null` key; a group whose aggregated values are all `null` yields a `null`
+     * value.
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to take the max of within each group
+     * @returns A Map from each present group value to the max of the aggregated column in that group
+     */
+    async maxBy(groupColumn, aggregatedColumn) {
+        return this.queryInstance().maxBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the min value of the specified column
      * for this model's records.
@@ -124,6 +168,29 @@ export default class DreamClassTransactionBuilder {
     async min(columnName) {
         return this.queryInstance().min(columnName);
     }
+    /**
+     * Retrieves the min value of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   await CompositionAsset.txn(txn).minBy('name', 'score')
+     *   // Map(2) { 'primary' => 1, 'secondary' => 4 }
+     * })
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map. When the group
+     * column is nullable, records with a `null` value are grouped under a real
+     * `null` key; a group whose aggregated values are all `null` yields a `null`
+     * value.
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to take the min of within each group
+     * @returns A Map from each present group value to the min of the aggregated column in that group
+     */
+    async minBy(groupColumn, aggregatedColumn) {
+        return this.queryInstance().minBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the sum value of the specified column
      * for this Query
@@ -139,6 +206,29 @@ export default class DreamClassTransactionBuilder {
     async sum(columnName) {
         return this.queryInstance().sum(columnName);
     }
+    /**
+     * Retrieves the sum of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   await CompositionAsset.txn(txn).sumBy('name', 'score')
+     *   // Map(2) { 'primary' => 10, 'secondary' => 4 }
+     * })
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map. When the group
+     * column is nullable, records with a `null` value are grouped under a real
+     * `null` key; a group whose aggregated values are all `null` yields a `null`
+     * value.
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to sum within each group
+     * @returns A Map from each present group value to the sum of the aggregated column in that group
+     */
+    async sumBy(groupColumn, aggregatedColumn) {
+        return this.queryInstance().sumBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the average value of the specified column
      * for this Query
@@ -154,6 +244,29 @@ export default class DreamClassTransactionBuilder {
     async avg(columnName) {
         return this.queryInstance().avg(columnName);
     }
+    /**
+     * Retrieves the average of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   await CompositionAsset.txn(txn).avgBy('name', 'score')
+     *   // Map(2) { 'primary' => 5, 'secondary' => 4 }
+     * })
+     * ```
+     *
+     * Only groups with at least one matching row appear in the Map. When the group
+     * column is nullable, records with a `null` value are grouped under a real
+     * `null` key; a group whose aggregated values are all `null` yields a `null`
+     * value.
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to average within each group
+     * @returns A Map from each present group value to the average of the aggregated column in that group
+     */
+    async avgBy(groupColumn, aggregatedColumn) {
+        return this.queryInstance().avgBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Persists a new record, setting the provided attributes.
      * Automatically sets createdAt and updatedAt timestamps.

package/dist/esm/src/dream/Query.js

@@ -980,6 +980,39 @@ export default class Query {
     async count() {
         return await this.dbDriverInstance().count();
     }
+    /**
+     * Retrieves the number of records in each group, keyed by the
+     * value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await User.query().countBy('name')
+     * // Map(2) { 'fred' => 2, 'zed' => 1 }
+     *
+     * await User.where({ email: ops.ilike('%gmail.com') }).countBy('name')
+     * // Map(1) { 'fred' => 3 }
+     * ```
+     *
+     * Any `where` clauses, base scopes (soft-delete / STI), and joined-association
+     * `and` clauses on the Query carry through automatically. A joined-association
+     * column may be grouped on by passing its namespaced name (e.g.
+     * `'compositionAssets.name'`).
+     *
+     * Only groups with at least one matching row appear in the Map (inherent to
+     * `GROUP BY`); seed absent groups yourself with `map.get(key) ?? 0`. When the
+     * group column is nullable, records with a `null` value are grouped under a real
+     * `null` key.
+     *
+     * ```ts
+     * await Composition.query().innerJoin('compositionAssets').countBy('compositionAssets.name')
+     * // Map(2) { 'primary' => 3, null => 1 }
+     * ```
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @returns A Map from each present group value to the number of records in that group
+     */
+    async countBy(groupColumn) {
+        return await this.dbDriverInstance().countBy(groupColumn);
+    }
     /**
      * Returns new Query with distinct clause applied.
      * If no column is specified, applies distinct to the primary key.
@@ -1038,6 +1071,32 @@ export default class Query {
     async max(columnName) {
         return await this.dbDriverInstance().max(columnName);
     }
+    /**
+     * Retrieves the max value of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await CompositionAsset.query().maxBy('name', 'score')
+     * // Map(2) { 'primary' => 9, 'secondary' => 4 }
+     * ```
+     *
+     * Any `where` clauses, base scopes (soft-delete / STI), and joined-association
+     * `and` clauses on the Query carry through automatically. A joined-association
+     * column may be grouped on or aggregated by passing its namespaced name (e.g.
+     * `'compositionAssets.name'`).
+     *
+     * Only groups with at least one matching row appear in the Map (inherent to
+     * `GROUP BY`). When the group column is nullable, records with a `null` value
+     * are grouped under a real `null` key; a group whose aggregated values are all
+     * `null` yields a `null` value.
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @param aggregatedColumn - the column to take the max of within each group
+     * @returns A Map from each present group value to the max of the aggregated column in that group
+     */
+    async maxBy(groupColumn, aggregatedColumn) {
+        return await this.dbDriverInstance().maxBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the min value of the specified column
      * for this Query
@@ -1053,6 +1112,32 @@ export default class Query {
     async min(columnName) {
         return await this.dbDriverInstance().min(columnName);
     }
+    /**
+     * Retrieves the min value of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await CompositionAsset.query().minBy('name', 'score')
+     * // Map(2) { 'primary' => 1, 'secondary' => 4 }
+     * ```
+     *
+     * Any `where` clauses, base scopes (soft-delete / STI), and joined-association
+     * `and` clauses on the Query carry through automatically. A joined-association
+     * column may be grouped on or aggregated by passing its namespaced name (e.g.
+     * `'compositionAssets.name'`).
+     *
+     * Only groups with at least one matching row appear in the Map (inherent to
+     * `GROUP BY`). When the group column is nullable, records with a `null` value
+     * are grouped under a real `null` key; a group whose aggregated values are all
+     * `null` yields a `null` value.
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @param aggregatedColumn - the column to take the min of within each group
+     * @returns A Map from each present group value to the min of the aggregated column in that group
+     */
+    async minBy(groupColumn, aggregatedColumn) {
+        return await this.dbDriverInstance().minBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the sum value of the specified column
      * for this Query
@@ -1068,6 +1153,32 @@ export default class Query {
     async sum(columnName) {
         return await this.dbDriverInstance().sum(columnName);
     }
+    /**
+     * Retrieves the sum of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await CompositionAsset.query().sumBy('name', 'score')
+     * // Map(2) { 'primary' => 10, 'secondary' => 4 }
+     * ```
+     *
+     * Any `where` clauses, base scopes (soft-delete / STI), and joined-association
+     * `and` clauses on the Query carry through automatically. A joined-association
+     * column may be grouped on or aggregated by passing its namespaced name (e.g.
+     * `'compositionAssets.name'`).
+     *
+     * Only groups with at least one matching row appear in the Map (inherent to
+     * `GROUP BY`). When the group column is nullable, records with a `null` value
+     * are grouped under a real `null` key; a group whose aggregated values are all
+     * `null` yields a `null` value.
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @param aggregatedColumn - the column to sum within each group
+     * @returns A Map from each present group value to the sum of the aggregated column in that group
+     */
+    async sumBy(groupColumn, aggregatedColumn) {
+        return await this.dbDriverInstance().sumBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Retrieves the average value of the specified column
      * for this Query
@@ -1083,6 +1194,32 @@ export default class Query {
     async avg(columnName) {
         return await this.dbDriverInstance().avg(columnName);
     }
+    /**
+     * Retrieves the average of the specified column within each group, keyed by
+     * the value of the provided group column (a SQL `GROUP BY`).
+     *
+     * ```ts
+     * await CompositionAsset.query().avgBy('name', 'score')
+     * // Map(2) { 'primary' => 5, 'secondary' => 4 }
+     * ```
+     *
+     * Any `where` clauses, base scopes (soft-delete / STI), and joined-association
+     * `and` clauses on the Query carry through automatically. A joined-association
+     * column may be grouped on or aggregated by passing its namespaced name (e.g.
+     * `'compositionAssets.name'`).
+     *
+     * Only groups with at least one matching row appear in the Map (inherent to
+     * `GROUP BY`). When the group column is nullable, records with a `null` value
+     * are grouped under a real `null` key; a group whose aggregated values are all
+     * `null` yields a `null` value.
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @param aggregatedColumn - the column to average within each group
+     * @returns A Map from each present group value to the average of the aggregated column in that group
+     */
+    async avgBy(groupColumn, aggregatedColumn) {
+        return await this.dbDriverInstance().avgBy(groupColumn, aggregatedColumn);
+    }
     /**
      * Plucks the provided fields from the given dream class table
      *