@rvoh/dream 2.1.0 → 2.1.3

package/dist/esm/src/cli/index.js

@@ -213,7 +213,7 @@ ${INDENT}    to extend the Coach model in src/app/models/Health/Coach: Health/Co
             .description('Seeds the database using the file located in db/seed.ts.')
             .action(async () => {
             if (process.env.NODE_ENV === 'test' && process.env.DREAM_SEED_DB_IN_TEST !== '1') {
-                console.log('skipping db seed for test env. To really seed for test, add DREAM_SEED_DB_IN_TEST=1');
+                DreamApp.log('skipping db seed for test env. To really seed for test, add DREAM_SEED_DB_IN_TEST=1');
                 return;
             }
             await initializeDreamApp();

package/dist/esm/src/cli/logger/loggable/DreamCliLoggableText.js

@@ -13,6 +13,7 @@ export default class DreamCliLoggableText extends DreamCliLoggable {
         this.logPrefixBgColor = logPrefixBgColor;
     }
     render() {
+        // eslint-disable-next-line no-console
         console.log(`${this.colorizedLogPrefix} ${colorize(this.text, { color: this.color, bgColor: this.bgColor })}`);
     }
 }

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

@@ -124,6 +124,36 @@ export default class DreamClassTransactionBuilder {
     async min(columnName) {
         return this.queryInstance().min(columnName);
     }
+    /**
+     * Retrieves the sum value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.txn(txn).sum('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the sum of the values of the specified column for this Query
+     */
+    async sum(columnName) {
+        return this.queryInstance().sum(columnName);
+    }
+    /**
+     * Retrieves the average value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.txn(txn).avg('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the average of the values of the specified column for this Query
+     */
+    async avg(columnName) {
+        return this.queryInstance().avg(columnName);
+    }
     /**
      * Persists a new record, setting the provided attributes.
      * Automatically sets createdAt and updatedAt timestamps.

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

@@ -1043,6 +1043,36 @@ export default class Query {
     async min(columnName) {
         return await this.dbDriverInstance().min(columnName);
     }
+    /**
+     * Retrieves the sum value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().sum('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the sum of the values of the specified column for this Query
+     */
+    async sum(columnName) {
+        return await this.dbDriverInstance().sum(columnName);
+    }
+    /**
+     * Retrieves the average value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().avg('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the average of the values of the specified column for this Query
+     */
+    async avg(columnName) {
+        return await this.dbDriverInstance().avg(columnName);
+    }
     /**
      * Plucks the provided fields from the given dream class table
      *

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

@@ -273,6 +273,38 @@ export default class QueryDriverBase {
     async min(columnName) {
         throw new Error('implement min in child class');
     }
+    /**
+     * Retrieves the sum value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().sum('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the sum of the values of the specified column for this Query
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+    async sum(columnName) {
+        throw new Error('implement sum in child class');
+    }
+    /**
+     * Retrieves the average value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().avg('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the average of the values of the specified column for this Query
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+    async avg(columnName) {
+        throw new Error('implement avg in child class');
+    }
     /**
      * Retrieves the number of records in the database
      *

package/dist/esm/src/dream/QueryDriver/Kysely.js

@@ -194,6 +194,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             }
         }
         catch (error) {
+            // eslint-disable-next-line no-console
             console.error(error);
             await DreamCLI.logger.logProgress('[dream] sync failed, reverting file contents...', async () => {
                 await CliFileWriter.revert();
@@ -452,6 +453,52 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         const data = await executeDatabaseQuery(kyselyQuery, 'executeTakeFirstOrThrow');
         return data.min;
     }
+    /**
+     * Retrieves the sum value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().sum('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the sum of the values of the specified column for this Query
+     */
+    async sum(columnName) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const { sum } = this.dbFor('select').fn;
+        let kyselyQuery = new this.constructor(this.query).buildSelect({
+            bypassSelectAll: true,
+            bypassOrder: true,
+        });
+        kyselyQuery = kyselyQuery.select(sum(columnName));
+        const data = await executeDatabaseQuery(kyselyQuery, 'executeTakeFirstOrThrow');
+        return data.sum === null ? null : parseFloat(data.sum);
+    }
+    /**
+     * Retrieves the average value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().avg('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the average of the values of the specified column for this Query
+     */
+    async avg(columnName) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const { avg } = this.dbFor('select').fn;
+        let kyselyQuery = new this.constructor(this.query).buildSelect({
+            bypassSelectAll: true,
+            bypassOrder: true,
+        });
+        kyselyQuery = kyselyQuery.select(avg(columnName));
+        const data = await executeDatabaseQuery(kyselyQuery, 'executeTakeFirstOrThrow');
+        return data.avg;
+    }
     /**
      * Retrieves the number of records in the database
      *
@@ -893,6 +940,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             const hasMany = association.type === 'HasMany';
             // initialize by trying to access the association, which throws an exception if not yet initialized
             try {
+                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
                 ;
                 dream[association.as];
             }

package/dist/esm/src/dream/internal/printSerializerHierarchyLevel.js

@@ -7,7 +7,9 @@ export default function printSerializerHierarchyLevel({ serializerAssociationTyp
     });
     const prefix = `${hierarchyLine} `;
     const nestedAssociationDisplay = indentation + `${prefix}${serializerAssociationType} ${yoctocolors.cyan(serializerAssociationName)}`;
+    // eslint-disable-next-line no-console
     console.log(nestedAssociationDisplay);
+    // eslint-disable-next-line no-console
     console.log(yoctocolors.gray(indentation +
         indent(prefix.length, { tabWidth: 1 }) +
         associationSerializer.globalName));

package/dist/esm/src/dream-app/helpers/DreamImporter.js

@@ -4,7 +4,9 @@ export default class DreamImporter {
     static async ls(dir) {
         try {
             const dirents = await fs.readdir(dir, { withFileTypes: true });
-            const files = await Promise.all(dirents
+            const files = await Promise.all(
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            dirents
                 .map(dirent => {
                 const res = path.resolve(dir, dirent.name);
                 return dirent.isDirectory()

package/dist/esm/src/dream-app/index.js

@@ -137,6 +137,7 @@ export default class DreamApp {
     }
     static checkKey(encryptionIdentifier, key, algorithm) {
         if (!Encrypt.validateKey(key, algorithm))
+            // eslint-disable-next-line no-console
             console.warn(`
 Your current key value for ${encryptionIdentifier} encryption is invalid.
 Try setting it to something valid, like:
@@ -410,7 +411,7 @@ function argToString(arg) {
         return arg.toISO();
     return util.inspect(arg, { depth: 3 });
 }
-export const DreamAppAllowedPackageManagersEnumValues = ['yarn', 'npm', 'pnpm'];
+export const DreamAppAllowedPackageManagersEnumValues = ['pnpm', 'yarn', 'npm'];
 // GeneratorImportStyles are used by CLI generators to determine how
 // to style import suffixes. When integrating with other apps, this
 // suffix style can change, and may need to be configured.

package/dist/esm/src/helpers/Env.js

@@ -38,12 +38,14 @@ export default class Env {
         return this.optional(env) === '1';
     }
     setString(env, val) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
         val === undefined ? delete process.env[env] : (process.env[env] = val);
     }
     unsetString(env) {
         delete process.env[env];
     }
     setInteger(env, val) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
         val === undefined ? delete process.env[env] : (process.env[env] = Math.floor(val).toString());
     }
     unsetInteger(env) {

package/dist/esm/src/helpers/cli/ASTConnectionBuilder.js

@@ -179,7 +179,7 @@ export default class ASTConnectionBuilder extends ASTBuilder {
                         foreignKey = _foreignKey;
                     }
                 }
-                catch (err) {
+                catch {
                     this.hasForeignKeyError = true;
                 }
                 try {

package/dist/esm/src/helpers/cli/DBClassDeprecation.js

@@ -37,7 +37,9 @@ export default class DBClassDeprecation {
             }
         }
         catch (err) {
+            // eslint-disable-next-line no-console
             console.error(err);
+            // eslint-disable-next-line no-console
             console.log(`
 ATTENTION: 
 

package/dist/esm/src/helpers/cli/generateDream.js

@@ -1,4 +1,5 @@
 import * as fs from 'node:fs/promises';
+import DreamCLI from '../../cli/index.js';
 import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
 import dreamPath from '../path/dreamPath.js';
 import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
@@ -11,7 +12,7 @@ export default async function generateDream({ fullyQualifiedModelName, columnsWi
     fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
     const { relFilePath, absDirPath, absFilePath } = dreamFileAndDirPaths(dreamPath('models'), `${fullyQualifiedModelName}.ts`);
     try {
-        console.log(`generating dream: ${relFilePath}`);
+        DreamCLI.logger.log(`[dream] generating dream: ${relFilePath}`);
         await fs.mkdir(absDirPath, { recursive: true });
         await fs.writeFile(absFilePath, generateDreamContent({
             fullyQualifiedModelName,

package/dist/esm/src/helpers/cli/generateDreamContent.js

@@ -94,11 +94,12 @@ export function processAttribute(attribute, modelClassName) {
     if (!attributeType) {
         throw new Error(`must pass a column type for ${attributeName} (i.e. ${attributeName}:string)`);
     }
-    switch (attributeType) {
-        case 'belongs_to':
+    const processedAttrType = camelize(attributeType).toLowerCase();
+    switch (processedAttrType) {
+        case 'belongsto':
             return createBelongsToAttribute(attributeName, descriptors, modelClassName);
-        case 'has_one':
-        case 'has_many':
+        case 'hasone':
+        case 'hasmany':
             return { content: '', imports: [] };
         case 'encrypted':
             return createEncryptedAttribute(attributeName, attribute, modelClassName);

package/dist/esm/src/helpers/cli/generateFactory.js

@@ -3,11 +3,12 @@ import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
 import dreamPath from '../path/dreamPath.js';
 import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
 import generateFactoryContent from './generateFactoryContent.js';
+import DreamCLI from '../../cli/index.js';
 export default async function generateFactory({ fullyQualifiedModelName, columnsWithTypes, }) {
     fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
     const { relFilePath, absDirPath, absFilePath } = dreamFileAndDirPaths(dreamPath('factories'), `${fullyQualifiedModelName}Factory.ts`);
     try {
-        console.log(`generating factory: ${relFilePath}`);
+        DreamCLI.logger.log(`[dream] generating factory: ${relFilePath}`);
         await fs.mkdir(absDirPath, { recursive: true });
         await fs.writeFile(absFilePath, generateFactoryContent({ fullyQualifiedModelName, columnsWithTypes }));
     }

package/dist/esm/src/helpers/cli/generateFactoryContent.js

@@ -30,8 +30,9 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
             continue;
         if (!attributeType)
             throw new Error(`Must pass a column type for ${attributeName} (i.e. ${attributeName}:string)`);
-        switch (attributeType) {
-            case 'belongs_to': {
+        const safeAttributeType = camelize(attributeType)?.toLowerCase();
+        switch (safeAttributeType) {
+            case 'belongsto': {
                 const attributeVariable = camelize(attributeName.split('/').pop());
                 const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(attributeName);
                 const associationModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);

package/dist/esm/src/helpers/cli/generateMigration.js

@@ -10,6 +10,7 @@ import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
 import dreamPath from '../path/dreamPath.js';
 import snakeify from '../snakeify.js';
 import generateStiMigrationContent from './generateStiMigrationContent.js';
+import DreamCLI from '../../cli/index.js';
 export default async function generateMigration({ migrationName, columnsWithTypes, connectionName, fullyQualifiedModelName, fullyQualifiedParentName, }) {
     const { relFilePath, absFilePath } = connectionName === 'default'
         ? dreamFileAndDirPaths(path.join(dreamPath('db'), 'migrations'), `${migrationVersion()}-${hyphenize(migrationName).replace(/\//g, '-')}.ts`)
@@ -41,7 +42,7 @@ export default async function generateMigration({ migrationName, columnsWithType
         });
     }
     try {
-        console.log(`generating migration: ${relFilePath}`);
+        DreamCLI.logger.log(`[dream] generating migration: ${relFilePath}`);
         await fs.writeFile(absFilePath, finalContent);
     }
     catch (error) {

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

@@ -3,6 +3,7 @@ import Query from '../../dream/Query.js';
 import InvalidDecimalFieldPassedToGenerator from '../../errors/InvalidDecimalFieldPassedToGenerator.js';
 import compact from '../compact.js';
 import snakeify from '../snakeify.js';
+import camelize from '../camelize.js';
 const STI_TYPE_COLUMN_NAME = 'type';
 const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME];
 export default function generateMigrationContent({ connectionName = 'default', table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', stiChildClassName, } = {}) {
@@ -17,11 +18,12 @@ export default function generateMigrationContent({ connectionName = 'default', t
          * email address are the same email address
          */
         const attributeType = nonStandardAttributeName === 'email' ? 'citext' : _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;
         // instead, we'll add a check constraint that uses the STI child class name
         const sqlAttributeType = getAttributeType(attributeType, descriptors);
-        if (attributeType === undefined || ['has_one', 'has_many'].includes(attributeType))
+        if (attributeType === undefined || ['hasone', 'hasmany'].includes(processedAttrType))
             return acc;
         if (attributeType === 'citext')
             requireCitextExtension = true;
@@ -30,8 +32,8 @@ export default function generateMigrationContent({ connectionName = 'default', t
         if (nonStandardAttributeName === undefined)
             return acc;
         let attributeName = snakeify(nonStandardAttributeName);
-        switch (attributeType) {
-            case 'belongs_to':
+        switch (processedAttrType) {
+            case 'belongsto':
                 columnDefs.push(generateBelongsToStr(connectionName, attributeName, {
                     primaryKeyType,
                     omitInlineNonNull,
@@ -82,7 +84,7 @@ export default function generateMigrationContent({ connectionName = 'default', t
                 break;
         }
         columnDrops.push(`.dropColumn('${attributeName}')`);
-        if (attributeType === 'belongs_to' || COLUMNS_TO_INDEX.includes(attributeName)) {
+        if (processedAttrType === 'belongsto' || COLUMNS_TO_INDEX.includes(attributeName)) {
             const indexName = `${table}_${attributeName}`;
             indexDefs.push(`await db.schema
     .createIndex('${indexName}')
@@ -247,7 +249,7 @@ function generateColumnStr(attributeName, attributeType, descriptors, { omitInli
     if (attributeName === STI_TYPE_COLUMN_NAME)
         returnStr = `// CONSIDER: when using type for STI, always use an enum
     // Try using the enum syntax in your generator, e.g.:
-    // yarn psy g:model Balloon type:enum:balloon_type:latex,mylar
+    // pnpm psy g:model Balloon type:enum:balloon_type:latex,mylar
     ${returnStr}`;
     return returnStr;
 }

package/dist/esm/src/helpers/cli/generateSerializer.js

@@ -3,11 +3,12 @@ import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
 import dreamPath from '../path/dreamPath.js';
 import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
 import generateSerializerContent from './generateSerializerContent.js';
+import DreamCLI from '../../cli/index.js';
 export default async function generateSerializer({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, stiBaseSerializer, includeAdminSerializers, }) {
     fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
     const { relFilePath, absDirPath, absFilePath } = dreamFileAndDirPaths(dreamPath('serializers'), `${fullyQualifiedModelName}Serializer.ts`);
     try {
-        console.log(`generating serializer: ${relFilePath}`);
+        DreamCLI.logger.log(`[dream] generating serializer: ${relFilePath}`);
         await fs.mkdir(absDirPath, { recursive: true });
         await fs.writeFile(absFilePath, generateSerializerContent({
             fullyQualifiedModelName,

package/dist/esm/src/helpers/cli/generateSerializerContent.js

@@ -49,7 +49,7 @@ export default function generateSerializerContent({ fullyQualifiedModelName, col
         const [name, type] = attr.split(':');
         if (name === undefined)
             return '';
-        if (['belongs_to', 'has_one', 'has_many'].includes(type))
+        if (['belongsto', 'hasone', 'hasmany'].includes(camelize(type)?.toLowerCase()))
             return '';
         return `\n    ${attribute(modelClassName, name, type, attr, stiBaseSerializer)}`;
     })

package/dist/esm/src/helpers/cli/generateUnitSpec.js

@@ -1,4 +1,5 @@
 import * as fs from 'node:fs/promises';
+import DreamCLI from '../../cli/index.js';
 import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
 import dreamPath from '../path/dreamPath.js';
 import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
@@ -7,7 +8,7 @@ export default async function generateUnitSpec({ fullyQualifiedModelName, }) {
     fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
     const { relFilePath, absDirPath, absFilePath } = dreamFileAndDirPaths(dreamPath('modelSpecs'), `${fullyQualifiedModelName}.spec.ts`);
     try {
-        console.log(`generating spec: ${relFilePath}`);
+        DreamCLI.logger.log(`[dream] generating spec: ${relFilePath}`);
         await fs.mkdir(absDirPath, { recursive: true });
         await fs.writeFile(absFilePath, generateUnitSpecContent({ fullyQualifiedModelName }));
     }

package/dist/esm/src/helpers/getFiles.js

@@ -3,7 +3,9 @@ import * as path from 'node:path';
 export default async function getFiles(dir) {
     try {
         const dirents = await fs.readdir(dir, { withFileTypes: true });
-        const files = await Promise.all(dirents.map(dirent => {
+        const files = await Promise.all(
+        // eslint-disable-next-line @typescript-eslint/await-thenable
+        dirents.map(dirent => {
             const res = path.resolve(dir, dirent.name);
             return dirent.isDirectory() ? getFiles(res) : res.replace(/\.ts$/, '.js');
         }));

package/dist/esm/src/helpers/sspawn.js

@@ -28,6 +28,7 @@ export function ssspawn(command, opts = {}) {
             opts?.onStdout?.(txt);
         }
         else {
+            // eslint-disable-next-line no-console
             console.log(txt);
         }
     });
@@ -38,5 +39,6 @@ export function ssspawn(command, opts = {}) {
     return proc;
 }
 function handleSpawnError(err) {
+    // eslint-disable-next-line no-console
     console.error(err?.toString());
 }

package/dist/types/src/Dream.d.ts

@@ -707,6 +707,34 @@ export default class Dream {
      * @returns the min value of the specified column for this model's records
      */
     static min<T extends typeof Dream, ColumnName extends DreamColumnNames<InstanceType<T>>>(this: T, columnName: ColumnName): Promise<InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]["coercedType" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]]>;
+    /**
+     * Retrieves the sum for all values of the specified column
+     * for this model's records.
+     *
+     *
+     * ```ts
+     * await Game.sum('score')
+     * // 100
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the sum for all values of the specified column for this model's records
+     */
+    static sum<T extends typeof Dream, ColumnName extends DreamColumnNames<InstanceType<T>>>(this: T, columnName: ColumnName): Promise<InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]["coercedType" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]]>;
+    /**
+     * Retrieves the average for all values of the specified column
+     * for this model's records.
+     *
+     *
+     * ```ts
+     * await Game.avg('score')
+     * // 100
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the average for all values of the specified column for this model's records
+     */
+    static avg<T extends typeof Dream, ColumnName extends DreamColumnNames<InstanceType<T>>>(this: T, columnName: ColumnName): Promise<InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]["coercedType" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]]>;
     /**
      * Persists a new record, setting the provided attributes.
      * Automatically sets createdAt and updatedAt timestamps.

package/dist/types/src/dream/DreamClassTransactionBuilder.d.ts

@@ -115,6 +115,32 @@ export default class DreamClassTransactionBuilder<DreamClass extends typeof Drea
      * @returns The min value of the specified column for this model's records
      */
     min<I extends DreamClassTransactionBuilder<DreamClass, DreamInstance>, T extends DreamColumnNames<DreamInstance>>(this: I, columnName: T): Promise<DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]][T & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]]]["coercedType" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]][T & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]]]]>;
+    /**
+     * Retrieves the sum value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.txn(txn).sum('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the sum of the values of the specified column for this Query
+     */
+    sum<I extends DreamClassTransactionBuilder<DreamClass, DreamInstance>, T extends DreamColumnNames<DreamInstance>>(this: I, columnName: T): Promise<DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]][T & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]]]["coercedType" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]][T & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]]]]>;
+    /**
+     * Retrieves the average value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.txn(txn).avg('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the average of the values of the specified column for this Query
+     */
+    avg<I extends DreamClassTransactionBuilder<DreamClass, DreamInstance>, T extends DreamColumnNames<DreamInstance>>(this: I, columnName: T): Promise<DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]][T & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]]]["coercedType" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]][T & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]["columns" & keyof DreamInstance["schema"][DreamInstance["table"] & keyof DreamInstance["schema"]]]]]>;
     /**
      * Persists a new record, setting the provided attributes.
      * Automatically sets createdAt and updatedAt timestamps.

package/dist/types/src/dream/Query.d.ts

@@ -752,6 +752,32 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * @returns the min value of the specified column for this Query
      */
     min<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], ColumnName extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>, ReturnType extends NamespacedOrBaseModelColumnTypes<[ColumnName], Q, DreamInstance>[0]>(columnName: ColumnName): Promise<ReturnType>;
+    /**
+     * Retrieves the sum value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().sum('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the sum of the values of the specified column for this Query
+     */
+    sum<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], ColumnName extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>, ReturnType extends NamespacedOrBaseModelColumnTypes<[ColumnName], Q, DreamInstance>[0]>(columnName: ColumnName): Promise<ReturnType>;
+    /**
+     * Retrieves the average value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().avg('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the average of the values of the specified column for this Query
+     */
+    avg<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], ColumnName extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>, ReturnType extends NamespacedOrBaseModelColumnTypes<[ColumnName], Q, DreamInstance>[0]>(columnName: ColumnName): Promise<ReturnType>;
     /**
      * Plucks the provided fields from the given dream class table
      *

package/dist/types/src/dream/QueryDriver/Base.d.ts

@@ -195,6 +195,32 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @returns the min value of the specified column for this Query
      */
     min(columnName: string): Promise<any>;
+    /**
+     * Retrieves the sum value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().sum('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the sum of the values of the specified column for this Query
+     */
+    sum(columnName: string): Promise<any>;
+    /**
+     * Retrieves the average value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await Game.query().avg('score')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the average of the values of the specified column for this Query
+     */
+    avg(columnName: string): Promise<any>;
     /**
      * Retrieves the number of records in the database
      *