@rvoh/dream 2.1.2 → 2.1.4-alpha.1

package/README.md

@@ -158,7 +158,7 @@ this test app is used to run all of our assertions, and is meant to be replaced
 to get into the console, type:
 
 ```bash
-yarn console
+pnpm console
 ```
 
 Once inside the repl, you are able to access all the models within the test app. All the classes are automagically imported.
@@ -174,7 +174,7 @@ await user.save()
 Running specs is very easy, not much to explain here.
 
 ```
-yarn spec
+pnpm spec
 ```
 
 We are using jest under the hood, and have a plugin enabled called `jest-plugin-context`, which allows us to branch specs out using the `context` function in place of `describe`, like so:
@@ -210,7 +210,7 @@ describe('Dream#pluck', () => {
 Dream provides a similarity searching library out of the box which allows you to implement fuzzy-searching in your app. To use it, first write a migration.
 
 ```bash
-yarn psy g:migration add_fuzzy_search_to_users
+pnpm psy g:migration add_fuzzy_search_to_users
 ```
 
 Open the generated migration, create the pg_trgm extension and create a gin index for a field on your model
@@ -236,7 +236,7 @@ export async function down(db: Kysely<any>): Promise<void> {
 Once done, run migrations
 
 ```bash
-NODE_ENV=development yarn psy db:migrate
+NODE_ENV=development pnpm psy db:migrate
 ```
 
 Now you can take full advantage of pg_trgm using the dream adapters!

package/dist/cjs/src/Dream.js

@@ -556,7 +556,9 @@ export default class Dream {
         const serializer = inferSerializersFromDreamClassOrViewModelClass(this, key)[0] ?? null;
         if (!serializer)
             throw new Error(`unable to find serializer with key: ${key}`);
+        // eslint-disable-next-line no-console
         console.log(yoctocolors.cyan(this.sanitizedName));
+        // eslint-disable-next-line no-console
         console.log(yoctocolors.gray(serializer.globalName));
         return this.recursiveSerializationMap(serializer, {
             forDisplay: true,
@@ -1014,6 +1016,38 @@ export default class Dream {
     static async min(columnName) {
         return await this.query().min(columnName);
     }
+    /**
+     * 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 async sum(columnName) {
+        return await this.query().sum(columnName);
+    }
+    /**
+     * 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 async avg(columnName) {
+        return await this.query().avg(columnName);
+    }
     /**
      * Persists a new record, setting the provided attributes.
      * Automatically sets createdAt and updatedAt timestamps.
@@ -3356,6 +3390,7 @@ export default class Dream {
      */
     loaded(associationName) {
         try {
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
             ;
             this[associationName];
             return true;

package/dist/cjs/src/bin/index.js

@@ -65,7 +65,7 @@ export default class DreamBin {
     // to use it to generate docs for their apps.
     static async buildDocs() {
         DreamCLI.logger.logStartProgress('generating docs...');
-        await sspawn('yarn typedoc src/package-exports/*.ts --tsconfig ./tsconfig.esm.build.json --out docs');
+        await sspawn('pnpm typedoc src/package-exports/*.ts --tsconfig ./tsconfig.esm.build.json --out docs');
         DreamCLI.logger.logEndProgress();
     }
 }

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

@@ -14,6 +14,10 @@ ${INDENT}all properties default to not nullable; null can be allowed by appendin
 ${INDENT}    subtitle:string:optional
 ${INDENT}
 ${INDENT}supported types:
+${INDENT}    - uuid:
+${INDENT}    - uuid[]:
+${INDENT}        a column optimized for storing UUIDs
+${INDENT}
 ${INDENT}    - citext:
 ${INDENT}    - citext[]:
 ${INDENT}        case insensitive text (indexes and queries are automatically case insensitive)
@@ -213,7 +217,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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/src/dream/QueryDriver/Kysely.js

@@ -67,6 +67,7 @@ import sqlResultToDreamInstance from '../internal/sqlResultToDreamInstance.js';
 import Query from '../Query.js';
 import QueryDriverBase from './Base.js';
 import checkForNeedToBeRunMigrations from './helpers/kysely/checkForNeedToBeRunMigrations.js';
+import foreignKeyTypeFromPrimaryKey from './helpers/kysely/foreignKeyTypeFromPrimaryKey.js';
 import runMigration from './helpers/kysely/runMigration.js';
 export default class KyselyQueryDriver extends QueryDriverBase {
     // ATTENTION FRED
@@ -194,6 +195,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();
@@ -210,12 +212,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      * gives the driver the opportunity to switch i.e. bigserial to bigint.
      */
     static foreignKeyTypeFromPrimaryKey(primaryKey) {
-        switch (primaryKey) {
-            case 'bigserial':
-                return 'bigint';
-            default:
-                return primaryKey;
-        }
+        return foreignKeyTypeFromPrimaryKey(primaryKey);
     }
     /**
      * @internal
@@ -228,6 +225,8 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         switch (dreamconf.primaryKeyType) {
             case 'bigint':
             case 'bigserial':
+            case 'uuid7':
+            case 'uuid4':
             case 'uuid':
             case 'integer':
                 return dreamconf.primaryKeyType;
@@ -452,6 +451,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 +938,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/cjs/src/dream/QueryDriver/helpers/kysely/foreignKeyTypeFromPrimaryKey.js

@@ -1,5 +1,8 @@
 export default function foreignKeyTypeFromPrimaryKey(primaryKey) {
     switch (primaryKey) {
+        case 'uuid7':
+        case 'uuid4':
+            return 'uuid';
         case 'bigserial':
             return 'bigint';
         default:

package/dist/cjs/src/dream/constants.js

@@ -1,4 +1,4 @@
-export const primaryKeyTypes = ['bigserial', 'bigint', 'uuid', 'integer'];
+export const primaryKeyTypes = ['uuid7', 'uuid4', 'bigserial', 'bigint', 'integer'];
 export const TRIGRAM_OPERATORS = ['%', '<%', '<<%'];
 class RequiredAttribute {
     constructor() { }

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/src/helpers/cli/generateFactoryContent.js

@@ -9,16 +9,17 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
     const dreamTypeImports = ['UpdateableProperties'];
     const dreamImports = [];
     const additionalImports = [];
+    const nodeImports = [];
     const belongsToNames = [];
     const belongsToTypedNames = [];
     const associationCreationStatements = [];
     const attributeDefaults = [];
     let counterVariableIncremented = false;
     for (const attribute of columnsWithTypes) {
-        const [attributeName, attributeType, ...descriptors] = attribute.split(':');
+        const [attributeName, _attributeType, ...descriptors] = attribute.split(':');
         if (attributeName === undefined)
             continue;
-        if (attributeType === undefined)
+        if (_attributeType === undefined)
             continue;
         const optional = optionalFromDescriptors(descriptors);
         if (optional)
@@ -28,6 +29,7 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
             continue;
         if (/(_type|_id)$/.test(attributeName))
             continue;
+        const attributeType = /uuid$/.test(attributeName) ? 'uuid' : _attributeType;
         if (!attributeType)
             throw new Error(`Must pass a column type for ${attributeName} (i.e. ${attributeName}:string)`);
         const safeAttributeType = camelize(attributeType)?.toLowerCase();
@@ -95,6 +97,14 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
                 dreamImports.push('DateTime');
                 attributeDefaults.push(`${attributeVariable}: [DateTime.now()],`);
                 break;
+            case 'uuid':
+                nodeImports.push('randomUUID');
+                attributeDefaults.push(`${attributeVariable}: randomUUID(),`);
+                break;
+            case 'uuid[]':
+                nodeImports.push('randomUUID');
+                attributeDefaults.push(`${attributeVariable}: [randomUUID()],`);
+                break;
             default:
                 if (/\[\]$/.test(attributeType)) {
                     attributeDefaults.push(`${attributeVariable}: [],`);
@@ -105,7 +115,7 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
     const relativePath = absoluteDreamPath('models', fullyQualifiedModelName);
     const modelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
     return `\
-${dreamImports.length ? `import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'\n` : ''}import { ${uniq(dreamTypeImports).join(', ')} } from '@rvoh/dream/types'
+${nodeImports.length ? `import { ${uniq(nodeImports).join(', ')} } from 'node:crypto'\n` : ''}${dreamImports.length ? `import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'\n` : ''}import { ${uniq(dreamTypeImports).join(', ')} } from '@rvoh/dream/types'
 import ${modelClassName} from '${relativePath}'${additionalImports.length ? '\n' + uniq(additionalImports).join('\n') : ''}
 ${counterVariableIncremented ? '\nlet counter = 0\n' : ''}
 export default async function create${modelClassName}(attrs: UpdateableProperties<${modelClassName}> = {}) {

package/dist/cjs/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/cjs/src/helpers/cli/generateMigrationContent.js

@@ -1,9 +1,9 @@
 import pluralize from 'pluralize-esm';
 import Query from '../../dream/Query.js';
 import InvalidDecimalFieldPassedToGenerator from '../../errors/InvalidDecimalFieldPassedToGenerator.js';
+import camelize from '../camelize.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, } = {}) {
@@ -13,11 +13,17 @@ export default function generateMigrationContent({ connectionName = 'default', t
     const { columnDefs, columnDrops, indexDefs, indexDrops } = columnsWithTypes.reduce((acc, attributeDeclaration) => {
         const { columnDefs, columnDrops, indexDefs, indexDrops } = acc;
         const [nonStandardAttributeName, _attributeType, ...descriptors] = attributeDeclaration.split(':');
+        if (!nonStandardAttributeName)
+            return acc;
         /**
          * Automatically set email columns to citext since different casings of
          * email address are the same email address
          */
-        const attributeType = nonStandardAttributeName === 'email' ? 'citext' : _attributeType;
+        const 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;
@@ -232,7 +238,7 @@ function generateColumnStr(attributeName, attributeType, descriptors, { omitInli
     const providedDefaultArg = descriptors.find(d => /^default\(/.test(d));
     const providedDefault = providedDefaultArg?.replace(/^default\(/, '')?.replace(/\)$/, '');
     const notNull = !optional;
-    const isUnique = attributeName === 'email' || /token$/.test(attributeName);
+    const isUnique = /(email|token|uuid)$/.test(attributeName);
     const hasExtraValues = providedDefault || notNull || isUnique;
     const isArray = /\[\]$/.test(attributeType);
     if (hasExtraValues)
@@ -249,7 +255,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;
 }
@@ -281,6 +287,14 @@ function generateBelongsToStr(connectionName, associationName, { primaryKeyType,
 }
 function generateIdStr({ primaryKeyType }) {
     switch (primaryKeyType) {
+        case 'uuid7':
+            return `\
+.addColumn('id', 'uuid', col =>
+      col
+        .primaryKey()
+        .defaultTo(sql\`uuid_generate_v7()\`),
+    )`;
+        case 'uuid4':
         case 'uuid':
             return `\
 .addColumn('id', 'uuid', col =>

package/dist/cjs/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/cjs/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/cjs/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');
         }));