@rvoh/dream 0.29.3 → 0.29.5

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

@@ -365,7 +365,7 @@ export default class Query extends ConnectedToDB {
     async findOrFail(primaryKey) {
         const record = await this.find(primaryKey);
         if (!record)
-            throw new RecordNotFound(this.dreamInstance.constructor.name);
+            throw new RecordNotFound(this.dreamInstance['sanitizedConstructorName']);
         return record;
     }
     /**
@@ -400,7 +400,7 @@ export default class Query extends ConnectedToDB {
     async findOrFailBy(whereStatement) {
         const record = await this.findBy(whereStatement);
         if (!record)
-            throw new RecordNotFound(this.dreamInstance.constructor.name);
+            throw new RecordNotFound(this.dreamInstance['sanitizedConstructorName']);
         return record;
     }
     /**
@@ -1099,6 +1099,9 @@ export default class Query extends ConnectedToDB {
             // base model, it will be underscored (to match the table name), but when the selected column
             // comes back from Kysely camelCased
             aliases.push(field.includes('_') ? camelize(field) : field);
+            //  namespace the selection so that when plucking the same column name from
+            // multpile tables, they don't get saved as the same name (e.g. select results with two `id` columns,
+            // which the pg package then returns in an object with a single `id` key)
             kyselyQuery = kyselyQuery.select(`${this.namespaceColumn(field)} as ${field}`);
         });
         return (await executeDatabaseQuery(kyselyQuery, 'execute')).map(singleResult => aliases.map(alias => singleResult[alias]));
@@ -1420,7 +1423,7 @@ export default class Query extends ConnectedToDB {
     async firstOrFail() {
         const record = await this.first();
         if (!record)
-            throw new RecordNotFound(this.dreamInstance.constructor.name);
+            throw new RecordNotFound(this.dreamInstance['sanitizedConstructorName']);
         return record;
     }
     /**
@@ -1459,7 +1462,7 @@ export default class Query extends ConnectedToDB {
     async lastOrFail() {
         const record = await this.last();
         if (!record)
-            throw new RecordNotFound(this.dreamInstance.constructor.name);
+            throw new RecordNotFound(this.dreamInstance['sanitizedConstructorName']);
         return record;
     }
     /**
@@ -1754,7 +1757,7 @@ export default class Query extends ConnectedToDB {
     }
     async preloadPolymorphicAssociationModel(dreams, association, associatedDreamClass, associatedDreams) {
         const relevantAssociatedModels = dreams.filter((dream) => {
-            return dream[association.foreignKeyTypeField()] === associatedDreamClass['stiBaseClassOrOwnClass'].name;
+            return dream[association.foreignKeyTypeField()] === associatedDreamClass['stiBaseClassOrOwnClassName'];
         });
         if (relevantAssociatedModels.length) {
             dreams.forEach((dream) => {
@@ -1777,7 +1780,7 @@ export default class Query extends ConnectedToDB {
             for (const loadedAssociation of loadedAssociations) {
                 dreams
                     .filter((dream) => {
-                    return (dream[association.foreignKeyTypeField()] === loadedAssociation['stiBaseClassOrOwnClass'].name &&
+                    return (dream[association.foreignKeyTypeField()] === loadedAssociation['stiBaseClassOrOwnClassName'] &&
                         dream[association.foreignKey()] === association.primaryKeyValue(loadedAssociation));
                 })
                     .forEach((dream) => {
@@ -1800,14 +1803,15 @@ export default class Query extends ConnectedToDB {
         const dream = dreams.find(dream => dream['getAssociationMetadata'](associationName));
         if (!dream)
             return;
-        const association = dream['getAssociationMetadata'](associationName);
+        const { name, alias } = extractAssociationMetadataFromAssociationName(associationName);
+        const association = dream['getAssociationMetadata'](name);
         const dreamClass = dream.constructor;
         const dreamClassToHydrate = association.modelCB();
         if ((association.polymorphic && association.type === 'BelongsTo') || Array.isArray(dreamClassToHydrate))
             return this.preloadPolymorphicBelongsTo(association, dreams);
         const dreamClassToHydrateColumns = [...dreamClassToHydrate.columns()];
         const throughColumnsToHydrate = [];
-        const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), associationName));
+        const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), alias));
         const asHasAssociation = association;
         if (asHasAssociation.through && asHasAssociation.preloadThroughColumns) {
             if (isObject(asHasAssociation.preloadThroughColumns)) {
@@ -1919,9 +1923,17 @@ export default class Query extends ConnectedToDB {
         }
         return query;
     }
-    // Through associations don't get written into the SQL; they
-    // locate the next association we need to build into the SQL
-    // AND the source to reference on the other side
+    /**
+     * Each association in the chain is pushed onto `throughAssociations`
+     * and `applyOneJoin` is recursively called. The trick is that the
+     * through associations don't get written into the SQL; they
+     * locate the next association we need to build into the SQL,
+     * which is only run by the association that started the `through`
+     * chain. The final association at the end of the `through` chain _is_
+     * written into the SQL as a full association, but the modifications from
+     * the `through` association are only added when the recursion returns
+     * back to the association that kicked off the through associations.
+     */
     joinsBridgeThroughAssociations({ query, dreamClass, association, previousAssociationTableOrAlias, throughAssociations, joinType, }) {
         if (association.type === 'BelongsTo' || !association.through) {
             return {
@@ -2002,25 +2014,33 @@ export default class Query extends ConnectedToDB {
         previousAssociationTableOrAlias = results.previousAssociationTableOrAlias;
         const throughClass = results.throughClass;
         if (timeToApplyThroughAssociations) {
-            ///////////////////////////////////////////////////////////////////////////////////////
-            // when an association is through another association, `joinsBridgeThroughAssociations`
-            // is called, which eventually calls back to this method, passing in the original
-            // through association as `originalAssociation`
-            ///////////////////////////////////////////////////////////////////////////////////////
+            /**
+             * Each association in the chain is pushed onto `throughAssociations`
+             * and `applyOneJoin` is recursively called. The trick is that the
+             * through associations don't get written into the SQL; they
+             * locate the next association we need to build into the SQL,
+             * which is only run by the association that started the `through`
+             * chain (thus the
+             * `throughAssociations.length && throughAssociations[0].source === association.as`
+             * above). The final association at the end of the `through` chain _is_
+             * written into the SQL as a full association, but the modifications from
+             * the `through` association are only added when the recursion returns
+             * back to the association that kicked off the through associations.
+             */
             throughAssociations.forEach((throughAssociation) => {
                 if (throughAssociation.type === 'HasMany') {
                     if (query?.distinctOn && throughAssociation.distinct) {
                         query = query.distinctOn(this.distinctColumnNameForAssociation({
                             association: throughAssociation,
-                            tableNameOrAlias: throughAssociation.as,
+                            tableNameOrAlias: currentAssociationTableOrAlias,
                             foreignKey: throughAssociation.primaryKey(),
                         }));
                     }
                     if (throughAssociation.order) {
                         query = this.applyOrderStatementForAssociation({
                             query,
-                            tableNameOrAlias: throughAssociation.as,
                             association: throughAssociation,
+                            tableNameOrAlias: currentAssociationTableOrAlias,
                         });
                     }
                 }
@@ -2070,8 +2090,8 @@ export default class Query extends ConnectedToDB {
                 if (association.polymorphic) {
                     join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement({
                         [association.foreignKeyTypeField()]: throughClass
-                            ? throughClass['stiBaseClassOrOwnClass'].name
-                            : dreamClass['stiBaseClassOrOwnClass'].name,
+                            ? throughClass['stiBaseClassOrOwnClassName']
+                            : dreamClass['stiBaseClassOrOwnClassName'],
                     }, currentAssociationTableOrAlias)));
                 }
                 if (timeToApplyThroughAssociations) {

package/dist/esm/src/dream/internal/associations/createAssociation.js

@@ -25,7 +25,7 @@ export default async function createAssociation(dream, txn = null, associationNa
                 ...opts,
             };
             if (hasAssociation.polymorphic) {
-                modifiedOpts[hasAssociation.foreignKeyTypeField()] = dream['stiBaseClassOrOwnClass'].name;
+                modifiedOpts[hasAssociation.foreignKeyTypeField()] = dream['stiBaseClassOrOwnClassName'];
             }
             if (txn) {
                 hasresult = await associationClass.txn(txn).create(modifiedOpts);

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

@@ -51,7 +51,7 @@ export async function runHook(statement, dream, txn) {
 Attempting to run ${statement.method} as part of the ${statement.type}
 Dream model hook sequence, but we encountered a method that does not exist.
 
-Please make sure "${statement.method}" is defined on ${dream.constructor.name}
+Please make sure "${statement.method}" is defined on ${dream['sanitizedConstructorName']}
 `);
     }
     await dream[statement.method](txn);

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

@@ -20,7 +20,7 @@ export default async function saveDream(dream, txn = null, { skipHooks = false }
     // need to check validations after running before hooks, or else
     // model hooks that might make a model valid cannot run
     if (dream.isInvalid)
-        throw new ValidationError(dream.constructor.name, dream.errors);
+        throw new ValidationError(dream['sanitizedConstructorName'], dream.errors);
     if (alreadyPersisted && !dream.isDirty)
         return dream;
     let query;

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

@@ -25,7 +25,7 @@ export default function sqlResultToDreamInstance(dreamClass, sqlResult) {
 export function findExtendingDreamClass(dreamClass, type) {
     if (!dreamClass['extendedBy'])
         return undefined;
-    const extendingDreamClass = dreamClass['extendedBy'].find(extendingDreamClass => extendingDreamClass.name === type);
+    const extendingDreamClass = dreamClass['extendedBy'].find(extendingDreamClass => extendingDreamClass.sanitizedName === type);
     if (extendingDreamClass)
         return extendingDreamClass;
     return dreamClass['extendedBy']

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

@@ -1,3 +1,9 @@
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';

package/dist/esm/src/errors/CannotCallUndestroyOnANonSoftDeleteModel.js

@@ -10,7 +10,7 @@ Cannot call "undestroy" on a non-SoftDelete model. Ensure that your
 model has @SoftDelete applied before calling "undestroy":
 
 @SoftDelete()
-class ${this.dreamClass.name} extends ApplicationModel {
+class ${this.dreamClass.sanitizedName} extends ApplicationModel {
   ...
 }
     `;

package/dist/esm/src/errors/CannotDefineAssociationWithBothDependentAndPassthrough.js

@@ -10,7 +10,7 @@ export default class CannotDefineAssociationWithBothDependentAndPassthrough exte
         return `
 Cannot define association with both "dependent" and "DreamConst.passthrough".
 Error found when trying to parse "${this.associationName}" on the 
-${this.dreamClass.name} dream class.
+${this.dreamClass.sanitizedName} dream class.
     `;
     }
 }

package/dist/esm/src/errors/CannotDefineAssociationWithBothDependentAndRequiredOnClause.js

@@ -10,7 +10,7 @@ export default class CannotDefineAssociationWithBothDependentAndRequiredOnClause
         return `
 Cannot define association with both "dependent" and "DreamConst.required".
 Error found when trying to parse "${this.associationName}" on the 
-${this.dreamClass.name} dream class.
+${this.dreamClass.sanitizedName} dream class.
     `;
     }
 }

package/dist/esm/src/errors/CannotPassUndefinedAsAValueToAWhereClause.js

@@ -10,7 +10,7 @@ export default class CannotPassUndefinedAsAValueToAWhereClause extends Error {
         return `
 Cannot pass undefined as a value to a where clause.
 
-dream class: ${this.dreamClass.name}
+dream class: ${this.dreamClass.sanitizedName}
 key receiving an undefined value: ${this.key}
 `;
     }

package/dist/esm/src/errors/CannotReloadUnsavedDream.js

@@ -7,7 +7,7 @@ export default class CannotReloadUnsavedDream extends Error {
     get message() {
         return `
 Cannot reload a Dream that has not yet been persisted
-  dream: ${this.dream.constructor.name}
+  dream: ${this.dream['sanitizedConstructorName']}
     `;
     }
 }

package/dist/esm/src/errors/CreateOrFindByFailedToCreateAndFind.js

@@ -6,7 +6,7 @@ export default class CreateOrFindByFailedToCreateAndFind extends Error {
     }
     get message() {
         return `
-Failed to create instance of ${this.dreamClass.name} and no matching model exists.
+Failed to create instance of ${this.dreamClass.sanitizedName} and no matching model exists.
 
 The likely cause is that one of the \`createWith\` fields violates
 a uniqueness constraint.

package/dist/esm/src/errors/DoNotSetEncryptedFieldsDirectly.js

@@ -13,7 +13,7 @@ export default class DoNotSetEncryptedFieldsDirectly extends Error {
 Do not set @Encrypted columns directly. Instead, set their accessors, so that
 those fields can be encrypted by Dream internally.
 
-Dream class: ${this.dreamClass.name}
+Dream class: ${this.dreamClass.sanitizedName}
 Problematic setter: ${this.encryptedColumnName}
 Setter to be used instead: ${this.encryptedProperty}`;
     }

package/dist/esm/src/errors/MissingDeletedAtFieldForSoftDelete.js

@@ -12,7 +12,7 @@ Whenever the using SoftDelete decorator, you must have either a deletedAt column
 or else another column defined, along with an ovrriding getter on your model, like so:
 
   @SoftDelete()
-  class ${this.dreamClass.name} extends ApplicationModel {
+  class ${this.dreamClass.sanitizedName} extends ApplicationModel {
     public get deletedAtField() {
       return 'customDeletedAtField' as const
     }

package/dist/esm/src/errors/MissingSerializersDefinition.js

@@ -7,14 +7,14 @@ export default class MissingSerializersDefinition extends Error {
     get message() {
         return `
 Missing serializers definition on the following class
-Dream class: ${this.dreamClass.name}
+Dream class: ${this.dreamClass.sanitizedName}
 
-Try something like this in your ${this.dreamClass.name}'s serializer getter:
+Try something like this in your ${this.dreamClass.sanitizedName}'s serializer getter:
 
-class ${this.dreamClass.name} {
-  public get serializers(): DreamSerializers<${this.dreamClass.name}> {
+class ${this.dreamClass.sanitizedName} {
+  public get serializers(): DreamSerializers<${this.dreamClass.sanitizedName}> {
     return {
-      default: '${this.dreamClass.name}Serializer'
+      default: '${this.dreamClass.sanitizedName}Serializer'
     }
   }
   ...

package/dist/esm/src/errors/MissingTable.js

@@ -9,14 +9,14 @@ export default class MissingTable extends Error {
     get message() {
         return `
 Missing table definition on the following dream class:
-Dream class: ${this.dreamClass.name}
+Dream class: ${this.dreamClass.sanitizedName}
 
-Try something like this in your ${this.dreamClass.name}'s table getter:
+Try something like this in your ${this.dreamClass.sanitizedName}'s table getter:
 
-class ${this.dreamClass.name} {
+class ${this.dreamClass.sanitizedName} {
   ...
   public get table() {
-    return '${pluralize(snakeify(this.dreamClass.name))}'
+    return '${pluralize(snakeify(this.dreamClass.sanitizedName))}'
   }
 }
     `;

package/dist/esm/src/errors/NonBelongsToAssociationProvidedAsSortableDecoratorScope.js

@@ -10,10 +10,10 @@ export default class NonBelongsToAssociationProvidedAsSortableDecoratorScope ext
         return `
 Only BelongsTo associations are supported as scopes for the @Sortable decorator.
 received:
-  dream model class: ${this.dreamClass.name}
+  dream model class: ${this.dreamClass.sanitizedName}
   scope: ${this.scope}
 
-BelongsTo scopes on ${this.dreamClass.name} are:
+BelongsTo scopes on ${this.dreamClass.sanitizedName} are:
   ${this.dreamClass['associationMetadataByType'].belongsTo.map(assoc => assoc.as).join('\n        ')}
     `;
     }

package/dist/esm/src/errors/NonExistentScopeProvidedToResort.js

@@ -10,10 +10,10 @@ export default class NonExistentScopeProvidedToResort extends Error {
         return `
 Only BelongsTo scopes are supported by the #resort method
 received:
-  dream model class: ${this.dreamClass.name}
+  dream model class: ${this.dreamClass.sanitizedName}
   scope: ${this.scopes.join(', ')}
 
-BelongsTo scopes on ${this.dreamClass.name} are:
+BelongsTo scopes on ${this.dreamClass.sanitizedName} are:
   ${this.dreamClass['sortableFields'].map(conf => conf.positionField).join('\n        ')}
     `;
     }

package/dist/esm/src/errors/SortableDecoratorRequiresColumnOrBelongsToAssociation.js

@@ -10,13 +10,13 @@ export default class SortableDecoratorRequiresColumnOrBelongsToAssociation exten
         return `
 Only Column or BelongsTo scopes are supported by the @Sortable decorator.
 received:
-  dream model class: ${this.dreamClass.name}
+  dream model class: ${this.dreamClass.sanitizedName}
   scope: ${this.attributeOrScope}
 
-Columns on ${this.dreamClass.name} are:
+Columns on ${this.dreamClass.sanitizedName} are:
   ${[...this.dreamClass.columns()].join('\n        ')}
 
-BelongsTo scopes on ${this.dreamClass.name} are:
+BelongsTo scopes on ${this.dreamClass.sanitizedName} are:
   ${this.dreamClass['associationMetadataByType'].belongsTo.map(assoc => assoc.as).join('\n        ')}
     `;
     }

package/dist/esm/src/errors/associations/CanOnlyPassBelongsToModelParam.js

@@ -9,7 +9,7 @@ export default class CanOnlyPassBelongsToModelParam extends Error {
     get message() {
         return `
 Can only pass BelongsTo associated models as params
-Dream class: ${this.dreamClass.name}
+Dream class: ${this.dreamClass.sanitizedName}
 Association: ${this.association.as}
 Association type: ${this.association.type}
     `;

package/dist/esm/src/errors/associations/CannotAssociateThroughPolymorphic.js

@@ -9,7 +9,7 @@ export default class CannotAssociateThroughPolymorphic extends Error {
     get message() {
         return `
 Cannot join through a polymorphic association
-Dream class: ${this.dreamClass.name}
+Dream class: ${this.dreamClass.sanitizedName}
 Association: ${this.association.as}
     `;
     }

package/dist/esm/src/errors/associations/CannotCreateAssociationWithThroughContext.js

@@ -9,7 +9,7 @@ export default class CannotCreateAssociationWithThroughContext extends Error {
     get message() {
         return `
 'createAssociation' is not supported for through associations.
-Dream class: ${this.dreamClass.name}
+Dream class: ${this.dreamClass.sanitizedName}
 Association: ${this.association.as}
     `;
     }

package/dist/esm/src/errors/associations/CannotJoinPolymorphicBelongsToError.js

@@ -13,7 +13,7 @@ export default class CannotJoinPolymorphicBelongsToError extends Error {
     get message() {
         return `
 Cannot join on a polymorphic BelongsTo
-Dream class: ${this.dreamClass.name}
+Dream class: ${this.dreamClass.sanitizedName}
 Association: ${this.association.as}
 Inner Join statements:
 ${JSON.stringify(this.innerJoinStatements, null, 2)}

package/dist/esm/src/errors/associations/CannotPassNullOrUndefinedToRequiredBelongsTo.js

@@ -9,7 +9,7 @@ export default class CannotPassNullOrUndefinedToRequiredBelongsTo extends Error
     get message() {
         return `
 Cannot pass null or undefined as a value to a required association.
-Dream class: ${this.dreamClass.name}
+Dream class: ${this.dreamClass.sanitizedName}
 Association: ${this.association.as}
     `;
     }

package/dist/esm/src/errors/associations/InvalidComputedForeignKey.js

@@ -14,7 +14,7 @@ export class InvalidComputedForeignKey extends Error {
     get message() {
         return `
 Add an explicit foreignKey declaration to this association declaration:
-  Dream class: ${this.dreamClass.name}
+  Dream class: ${this.dreamClass.sanitizedName}
   Association: ${this.partialAssociation.as}
 Dream tried ${this.computedForeignKey} automatically, but it isn't a column in table ${this.table}.
     `;
@@ -36,7 +36,7 @@ export class ExplicitForeignKeyRequired extends Error {
         return `
 ${this.explicitForeignKey} is not a valid column on table ${this.table}.
 Fix the foreignKey declaration on:
-  Dream class: ${this.dreamClass.name}
+  Dream class: ${this.dreamClass.sanitizedName}
   Association: ${this.partialAssociation.as}
     `;
     }

package/dist/esm/src/errors/associations/JoinAttemptedOnMissingAssociation.js

@@ -8,15 +8,15 @@ export default class JoinAttemptedOnMissingAssociation extends Error {
     }
     get message() {
         return `
-A joins call has been attempted on \`${this.dreamClass.name}\` association \`${this.associationName}\`,
-but \`${this.dreamClass.name}\` does not define association \`${this.associationName}\`.
+A joins call has been attempted on \`${this.dreamClass.sanitizedName}\` association \`${this.associationName}\`,
+but \`${this.dreamClass.sanitizedName}\` does not define association \`${this.associationName}\`.
 
 
 Either \`${this.associationName}\` is a typo in the joins statement, or association \`${this.associationName}\` needs to be defined on \`${this.dreamClass.name}\`, for example:
 
-class ${this.dreamClass.name} {
+class ${this.dreamClass.sanitizedName} {
   ...
-  @${this.dreamClass.name}.HasMany('SomeModelClass')
+  @${this.dreamClass.sanitizedName}.HasMany('SomeModelClass')
   public ${this.associationName}: SomeModelClass[]
 }
     `;

package/dist/esm/src/errors/associations/MissingThroughAssociation.js

@@ -8,15 +8,15 @@ export default class MissingThroughAssociation extends Error {
     }
     get message() {
         return `
-\`${this.dreamClass.name}\` defines through association \`${this.association.through}\`, but \`${this.dreamClass.name}\` does not define association \`${this.association.through}\`.
+\`${this.dreamClass.sanitizedName}\` defines through association \`${this.association.through}\`, but \`${this.dreamClass.name}\` does not define association \`${this.association.through}\`.
 
 
-To fix, define association \`${this.association.through}\` on \`${this.dreamClass.name}\`.
+To fix, define association \`${this.association.through}\` on \`${this.dreamClass.sanitizedName}\`.
 For example:
 
-class ${this.dreamClass.name} {
+class ${this.dreamClass.sanitizedName} {
   ...
-  @${this.dreamClass.name}.HasMany('TheJoinModelClass')
+  @${this.dreamClass.sanitizedName}.HasMany('TheJoinModelClass')
   public ${this.association.through}: TheJoinModelClass[]
 }
     `;

package/dist/esm/src/errors/associations/MissingThroughAssociationSource.js

@@ -10,29 +10,29 @@ export default class MissingThroughAssociationSource extends Error {
     }
     get message() {
         return `
-\`${this.dreamClass.name}\` defines association \`${this.association.as}\` through \`${this.dreamClass.name}\` association \`${this.association.through}\`.
+\`${this.dreamClass.sanitizedName}\` defines association \`${this.association.as}\` through \`${this.dreamClass.sanitizedName}\` association \`${this.association.through}\`.
 
-\`${this.dreamClass.name}\` association \`${this.association.through}\` points to \`${this.throughClass.name}\`.
+\`${this.dreamClass.sanitizedName}\` association \`${this.association.through}\` points to \`${this.throughClass.sanitizedName}\`.
 
-Dream expects association \`${this.association.source}\` to be defiend on \`${this.throughClass.name}\`, but \`${this.throughClass.name}\` does not define association \`${this.association.source}\`.
+Dream expects association \`${this.association.source}\` to be defiend on \`${this.throughClass.sanitizedName}\`, but \`${this.throughClass.sanitizedName}\` does not define association \`${this.association.source}\`.
 
 There are two possible fixes:
 
 1. Provide an explicit \`source\` in addition to \`through\`.
 
-class ${this.dreamClass.name} {
+class ${this.dreamClass.sanitizedName} {
   ...
-  @${this.dreamClass.name}.HasMany(() => ${this.throughClass.name}, { through: '${this.association.through}', source: '<a valid association on ${this.throughClass.name}>'})
-  public ${this.association.as}: ${this.throughClass.name}[]
+  @${this.dreamClass.name}.HasMany(() => ${this.throughClass.sanitizedName}, { through: '${this.association.through}', source: '<a valid association on ${this.throughClass.sanitizedName}>'})
+  public ${this.association.as}: ${this.throughClass.sanitizedName}[]
 }
 
-2. Define association \`${this.association.source}\` on \`${this.throughClass.name}\`.
+2. Define association \`${this.association.source}\` on \`${this.throughClass.sanitizedName}\`.
 For example:
 
-class ${this.throughClass.name} {
+class ${this.throughClass.sanitizedName} {
   ...
-  @${this.throughClass.name}.HasMany(() => ${this.association.modelCB().name})
-  public ${this.association.source}: ${this.association.modelCB().name}[]
+  @${this.throughClass.sanitizedName}.HasMany(() => ${this.association.modelCB().name})
+  public ${this.association.source}: ${this.association.modelCB().sanitizedName}[]
 }
     `;
     }

package/dist/esm/src/errors/associations/NonLoadedAssociation.js

@@ -8,7 +8,7 @@ export default class NonLoadedAssociation extends Error {
     }
     get message() {
         return `
-Attempting to access \`${this.associationName}\` on an instance of \`${this.dreamClass.name}\`,
+Attempting to access \`${this.associationName}\` on an instance of \`${this.dreamClass.sanitizedName}\`,
 but \`${this.associationName}\` has not been preloaded or loaded.
 `;
     }

package/dist/esm/src/errors/ops/AnyRequiresArrayColumn.js

@@ -9,7 +9,7 @@ export default class AnyRequiresArrayColumn extends Error {
     get message() {
         return `
 Attempting to call where({ ${this.column}: ops.any(<some value>)} ),
-but ${this.dreamClass.name}#${this.column} is not an array in the database.
+but ${this.dreamClass.sanitizedName}#${this.column} is not an array in the database.
 `;
     }
 }

package/dist/esm/src/errors/schema-builder/FailedToIdentifyAssociation.js

@@ -22,7 +22,7 @@ An unexpected error occurred while looking up an association that you have defin
 
 While building the schema for your app, we failed to find a match for
 the ${this.associationType} association "${this.associationName}" on the
-${this.modelClass.name} model.
+${this.modelClass.sanitizedName} model.
 
 This method requires either a string or string array as the first argument,
 to the ${this.associationType} decorator. However, we received the following:
@@ -34,7 +34,7 @@ to the ${this.associationType} decorator. However, we received the following:
     "${typeof attemptedName}"
 
 Details:
-    dream: ${this.modelClass.name} (${this.modelClass.globalName})
+    dream: ${this.modelClass.sanitizedName} (${this.modelClass.globalName})
     association type: ${this.associationType}
     association name: ${this.associationName}
 ".
@@ -51,7 +51,7 @@ An unexpected error occurred while looking up an association that you have defin
 
 While building the schema for your app, we failed to find a match for
 the ${this.associationType} association "${this.associationName}"
-on ${this.modelClass.name}, using the global model name "${attemptedName}".
+on ${this.modelClass.sanitizedName}, using the global model name "${attemptedName}".
 
 Usually, this is because the global name for
 the model is not what you anticipated, which often happens when you are
@@ -63,7 +63,7 @@ first argument to an association, since it can help to catch these
 familiar gotchas.
 
 Details:
-    dream: ${this.modelClass.name} (${this.modelClass.globalName})
+    dream: ${this.modelClass.sanitizedName} (${this.modelClass.globalName})
     association type: ${this.associationType}
     association name: ${this.associationName}
     attempted model name: ${attemptedName}

package/dist/esm/src/errors/sti/STIChildMissing.js

@@ -11,7 +11,7 @@ export default class STIChildMissing extends Error {
     get message() {
         return `
 Missing STI child class
-Base Dream class: ${this.baseDreamClass.name}
+Base Dream class: ${this.baseDreamClass.sanitizedName}
 Type specified in DB record: ${this.extendingDreamClassName}
 Table: ${this.baseDreamClass.table}
 Primary key value: ${this.primaryKeyValue}

package/dist/esm/src/errors/sti/StiChildIncompatibleWithSoftDeleteDecorator.js

@@ -8,7 +8,7 @@ export default class StiChildIncompatibleWithSoftDeleteDecorator extends Error {
         return `
 @SoftDelete decorator cannot be applied to STI children.
 Apply @SoftDelete to the base STI class instead.
-STI child class: ${this.childStiDreamClass.name}
+STI child class: ${this.childStiDreamClass.sanitizedName}
     `;
     }
 }

package/dist/esm/src/helpers/db/loadPgClient.js

@@ -1,3 +1,9 @@
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';