@rvoh/dream 2.18.0 → 2.19.0

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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
      *

package/dist/cjs/src/dream/QueryDriver/Base.js

@@ -273,6 +273,23 @@ export default class QueryDriverBase {
     async max(columnName) {
         throw new Error('implement max in child class');
     }
+    /**
+     * Retrieves the max value of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().maxBy('name', 'score')
+     * // Map(2) { 'primary' => 9, 'secondary' => 4 }
+     * ```
+     *
+     * @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
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+    async maxBy(groupColumn, aggregatedColumn) {
+        throw new Error('implement maxBy in child class');
+    }
     /**
      * Retrieves the min value of the specified column
      * for this Query
@@ -289,6 +306,23 @@ export default class QueryDriverBase {
     async min(columnName) {
         throw new Error('implement min in child class');
     }
+    /**
+     * Retrieves the min value of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().minBy('name', 'score')
+     * // Map(2) { 'primary' => 1, 'secondary' => 4 }
+     * ```
+     *
+     * @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
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+    async minBy(groupColumn, aggregatedColumn) {
+        throw new Error('implement minBy in child class');
+    }
     /**
      * Retrieves the sum value of the specified column
      * for this Query
@@ -305,6 +339,23 @@ export default class QueryDriverBase {
     async sum(columnName) {
         throw new Error('implement sum in child class');
     }
+    /**
+     * Retrieves the sum of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().sumBy('name', 'score')
+     * // Map(2) { 'primary' => 10, 'secondary' => 4 }
+     * ```
+     *
+     * @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
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+    async sumBy(groupColumn, aggregatedColumn) {
+        throw new Error('implement sumBy in child class');
+    }
     /**
      * Retrieves the average value of the specified column
      * for this Query
@@ -321,6 +372,23 @@ export default class QueryDriverBase {
     async avg(columnName) {
         throw new Error('implement avg in child class');
     }
+    /**
+     * Retrieves the average of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().avgBy('name', 'score')
+     * // Map(2) { 'primary' => 5, 'secondary' => 4 }
+     * ```
+     *
+     * @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
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+    async avgBy(groupColumn, aggregatedColumn) {
+        throw new Error('implement avgBy in child class');
+    }
     /**
      * Retrieves the number of records in the database
      *
@@ -334,6 +402,22 @@ export default class QueryDriverBase {
     async count() {
         throw new Error('implement count in child class');
     }
+    /**
+     * Retrieves the number of records in each group, keyed by the
+     * value of the provided group column.
+     *
+     * ```ts
+     * await User.query().countBy('name')
+     * // Map(2) { 'fred' => 2, 'zed' => 1 }
+     * ```
+     *
+     * @param groupColumn - the column to group by
+     * @returns A Map from each present group value to the number of records in that group
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+    async countBy(groupColumn) {
+        throw new Error('implement countBy in child class');
+    }
     /**
      * @internal
      *