@rvoh/dream 0.34.0 → 0.35.1

package/dist/esm/src/Dream.js

@@ -24,7 +24,11 @@ import undestroyDream from './dream/internal/undestroyDream.js';
 import LeftJoinLoadBuilder from './dream/LeftJoinLoadBuilder.js';
 import LoadBuilder from './dream/LoadBuilder.js';
 import Query from './dream/Query.js';
+import CannotAssociationQueryOnUnpersistedDream from './errors/associations/CannotAssociationQueryOnUnpersistedDream.js';
+import CannotCreateAssociationOnUnpersistedDream from './errors/associations/CannotCreateAssociationOnUnpersistedDream.js';
+import CannotDestroyAssociationOnUnpersistedDream from './errors/associations/CannotDestroyAssociationOnUnpersistedDream.js';
 import CannotPassNullOrUndefinedToRequiredBelongsTo from './errors/associations/CannotPassNullOrUndefinedToRequiredBelongsTo.js';
+import CannotUpdateAssociationOnUnpersistedDream from './errors/associations/CannotUpdateAssociationOnUnpersistedDream.js';
 import CanOnlyPassBelongsToModelParam from './errors/associations/CanOnlyPassBelongsToModelParam.js';
 import NonLoadedAssociation from './errors/associations/NonLoadedAssociation.js';
 import CannotCallUndestroyOnANonSoftDeleteModel from './errors/CannotCallUndestroyOnANonSoftDeleteModel.js';
@@ -40,6 +44,7 @@ import { DateTime } from './helpers/DateTime.js';
 import cachedTypeForAttribute from './helpers/db/cachedTypeForAttribute.js';
 import isJsonColumn from './helpers/db/types/isJsonColumn.js';
 import inferSerializerFromDreamOrViewModel from './helpers/inferSerializerFromDreamOrViewModel.js';
+import notEqual from './helpers/notEqual.js';
 import { isString } from './helpers/typechecks.js';
 export default class Dream {
     DB;
@@ -2243,13 +2248,8 @@ export default class Dream {
         this.constructor.columns().forEach(column => {
             const was = this.previousValueForAttribute(column);
             const now = this[column];
-            if (was !== now) {
-                ;
-                obj[column] = {
-                    was,
-                    now,
-                };
-            }
+            if (notEqual(was, now))
+                obj[column] = { was, now };
         });
         return obj;
     }
@@ -2283,7 +2283,7 @@ export default class Dream {
      * @returns Returns the previous value for an attribute
      */
     previousValueForAttribute(columnName) {
-        if (this.frozenAttributes[columnName] !== this[columnName])
+        if (notEqual(this.frozenAttributes[columnName], this[columnName]))
             return this.frozenAttributes[columnName];
         return this.attributesFromBeforeLastSave[columnName];
     }
@@ -2299,7 +2299,7 @@ export default class Dream {
         const changes = this.changes();
         const now = changes?.[columnName]?.now;
         const was = changes?.[columnName]?.was;
-        return this.isPersisted && now !== was;
+        return this.isPersisted && notEqual(now, was);
     }
     /**
      * Returns true if the columnName provided has
@@ -2482,7 +2482,12 @@ export default class Dream {
      * @returns A boolean
      */
     equals(other) {
-        return other?.constructor === this.constructor && other.primaryKeyValue === this.primaryKeyValue;
+        if (!other?.isDreamInstance)
+            return false;
+        return this.comparisonKey === other.comparisonKey;
+    }
+    get comparisonKey() {
+        return `${this.constructor.globalName}:${this.primaryKeyValue}`;
     }
     /**
      * @internal
@@ -2545,6 +2550,8 @@ export default class Dream {
      * @returns The created association
      */
     async createAssociation(associationName, attributes = {}) {
+        if (this.isNewRecord)
+            throw new CannotCreateAssociationOnUnpersistedDream(this, associationName);
         return createAssociation(this, null, associationName, attributes);
     }
     /**
@@ -2565,6 +2572,8 @@ export default class Dream {
      * @returns The number of records deleted
      */
     async destroyAssociation(associationName, options) {
+        if (this.isNewRecord)
+            throw new CannotDestroyAssociationOnUnpersistedDream(this, associationName);
         return await destroyAssociation(this, null, associationName, {
             ...destroyOptions(options),
             joinOnStatements: {
@@ -2597,6 +2606,8 @@ export default class Dream {
      * @returns The number of records deleted
      */
     async reallyDestroyAssociation(associationName, options) {
+        if (this.isNewRecord)
+            throw new CannotDestroyAssociationOnUnpersistedDream(this, associationName);
         return await destroyAssociation(this, null, associationName, {
             ...reallyDestroyOptions(options),
             joinOnStatements: {
@@ -2648,6 +2659,8 @@ export default class Dream {
      *
      */
     associationQuery(associationName, joinOnStatements) {
+        if (this.isNewRecord)
+            throw new CannotAssociationQueryOnUnpersistedDream(this, associationName);
         return associationQuery(this, null, associationName, {
             joinOnStatements: joinOnStatements,
             bypassAllDefaultScopes: DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
@@ -2677,6 +2690,8 @@ export default class Dream {
      * @returns The number of updated records
      */
     async updateAssociation(associationName, attributes, updateAssociationOptions) {
+        if (this.isNewRecord)
+            throw new CannotUpdateAssociationOnUnpersistedDream(this, associationName);
         return associationUpdateQuery(this, null, associationName, {
             joinOnStatements: {
                 on: updateAssociationOptions?.on,

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

@@ -1,3 +1,7 @@
+import CannotAssociationQueryOnUnpersistedDream from '../errors/associations/CannotAssociationQueryOnUnpersistedDream.js';
+import CannotCreateAssociationOnUnpersistedDream from '../errors/associations/CannotCreateAssociationOnUnpersistedDream.js';
+import CannotDestroyAssociationOnUnpersistedDream from '../errors/associations/CannotDestroyAssociationOnUnpersistedDream.js';
+import CannotUpdateAssociationOnUnpersistedDream from '../errors/associations/CannotUpdateAssociationOnUnpersistedDream.js';
 import associationQuery from './internal/associations/associationQuery.js';
 import associationUpdateQuery from './internal/associations/associationUpdateQuery.js';
 import createAssociation from './internal/associations/createAssociation.js';
@@ -308,6 +312,8 @@ export default class DreamInstanceTransactionBuilder {
      * @returns A Query scoped to the specified association on the current instance
      */
     associationQuery(associationName, joinOnStatements) {
+        if (this.dreamInstance.isNewRecord)
+            throw new CannotAssociationQueryOnUnpersistedDream(this.dreamInstance, associationName);
         return associationQuery(this.dreamInstance, this.dreamTransaction, associationName, {
             joinOnStatements: joinOnStatements,
             bypassAllDefaultScopes: DEFAULT_BYPASS_ALL_DEFAULT_SCOPES,
@@ -339,6 +345,8 @@ export default class DreamInstanceTransactionBuilder {
      * @returns The number of updated records
      */
     async updateAssociation(associationName, attributes, updateAssociationOptions) {
+        if (this.dreamInstance.isNewRecord)
+            throw new CannotUpdateAssociationOnUnpersistedDream(this.dreamInstance, associationName);
         return await associationUpdateQuery(this.dreamInstance, this.dreamTransaction, associationName, {
             joinOnStatements: {
                 on: updateAssociationOptions?.on,
@@ -365,6 +373,8 @@ export default class DreamInstanceTransactionBuilder {
      * @returns The created association
      */
     async createAssociation(associationName, opts = {}) {
+        if (this.dreamInstance.isNewRecord)
+            throw new CannotCreateAssociationOnUnpersistedDream(this.dreamInstance, associationName);
         return await createAssociation(this.dreamInstance, this.dreamTransaction, associationName, opts);
     }
     /**
@@ -387,6 +397,8 @@ export default class DreamInstanceTransactionBuilder {
      * @returns The number of records deleted
      */
     async destroyAssociation(associationName, options) {
+        if (this.dreamInstance.isNewRecord)
+            throw new CannotDestroyAssociationOnUnpersistedDream(this.dreamInstance, associationName);
         return await destroyAssociation(this.dreamInstance, this.dreamTransaction, associationName, {
             ...destroyOptions(options),
             joinOnStatements: {
@@ -421,6 +433,8 @@ export default class DreamInstanceTransactionBuilder {
      * @returns The number of records deleted
      */
     async reallyDestroyAssociation(associationName, options) {
+        if (this.dreamInstance.isNewRecord)
+            throw new CannotDestroyAssociationOnUnpersistedDream(this.dreamInstance, associationName);
         return await destroyAssociation(this.dreamInstance, this.dreamTransaction, associationName, {
             ...reallyDestroyOptions(options),
             joinOnStatements: {

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

@@ -1,6 +1,5 @@
 import destroyAssociatedRecords from './destroyAssociatedRecords.js';
 import runHooksFor from './runHooksFor.js';
-import safelyRunCommitHooks from './safelyRunCommitHooks.js';
 import softDeleteDream from './softDeleteDream.js';
 /**
  * @internal
@@ -39,7 +38,7 @@ async function destroyDreamWithTransaction(dream, txn, options) {
     await maybeDestroyDream(dream, txn, reallyDestroy);
     if (!skipHooks) {
         await runHooksFor('afterDestroy', dream, true, null, txn || undefined);
-        await safelyRunCommitHooks(dream, 'afterDestroyCommit', true, null, txn);
+        await runHooksFor('afterDestroyCommit', dream, true, null, txn);
     }
     if (shouldSoftDelete(dream, reallyDestroy)) {
         await dream.txn(txn).reload();

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

@@ -1,47 +1,89 @@
 export default async function runHooksFor(key, dream, alreadyPersisted, beforeSaveChanges, txn) {
     const Base = dream.constructor;
-    for (const statement of Base['hooks'][key]) {
-        if (statement.ifChanging?.length) {
+    for (const hook of Base['hooks'][key]) {
+        if (hook.ifChanging?.length) {
             switch (key) {
                 case 'beforeCreate':
-                    await runConditionalBeforeHooksForCreate(dream, statement, txn);
+                    if (shouldRunBeforeCreateHook(dream, hook)) {
+                        await runHook(hook, dream, txn);
+                    }
                     break;
                 case 'beforeSave':
-                    if (alreadyPersisted)
-                        await runConditionalBeforeHooksForUpdate(dream, statement, txn);
-                    else
-                        await runConditionalBeforeHooksForCreate(dream, statement, txn);
+                    if ((alreadyPersisted && shouldRunBeforeUpdateHook(dream, hook)) ||
+                        (!alreadyPersisted && shouldRunBeforeCreateHook(dream, hook))) {
+                        await runHook(hook, dream, txn);
+                    }
                     break;
                 case 'beforeUpdate':
-                    await runConditionalBeforeHooksForUpdate(dream, statement, txn);
+                    if (shouldRunBeforeUpdateHook(dream, hook)) {
+                        await runHook(hook, dream, txn);
+                    }
                     break;
                 default:
                     throw new Error(`Unexpected statement key detected with ifChanging clause: ${key}`);
             }
         }
-        else if (statement.ifChanged?.length) {
+        else if (hook.ifChanged?.length) {
             switch (key) {
                 case 'afterCreate':
+                    if (shouldRunAfterCreateHook(dream, hook, beforeSaveChanges)) {
+                        await runHook(hook, dream, txn);
+                    }
+                    break;
                 case 'afterCreateCommit':
-                    await runConditionalAfterHooksForCreate(dream, statement, beforeSaveChanges, txn);
+                    if (shouldRunAfterCreateHook(dream, hook, beforeSaveChanges)) {
+                        if (txn)
+                            txn.addCommitHook(hook, dream);
+                        else
+                            await runHook(hook, dream);
+                    }
                     break;
                 case 'afterSave':
+                    if ((alreadyPersisted && shouldRunAfterUpdateHook(dream, hook)) ||
+                        (!alreadyPersisted && shouldRunAfterCreateHook(dream, hook, beforeSaveChanges))) {
+                        await runHook(hook, dream, txn);
+                    }
+                    break;
                 case 'afterSaveCommit':
-                    if (alreadyPersisted)
-                        await runConditionalAfterHooksForUpdate(dream, statement, txn);
-                    else
-                        await runConditionalAfterHooksForCreate(dream, statement, beforeSaveChanges, txn);
+                    if ((alreadyPersisted && shouldRunAfterUpdateHook(dream, hook)) ||
+                        (!alreadyPersisted && shouldRunAfterCreateHook(dream, hook, beforeSaveChanges))) {
+                        if (txn)
+                            txn.addCommitHook(hook, dream);
+                        else
+                            await runHook(hook, dream);
+                    }
                     break;
                 case 'afterUpdate':
+                    if (shouldRunAfterUpdateHook(dream, hook)) {
+                        await runHook(hook, dream, txn);
+                    }
+                    break;
                 case 'afterUpdateCommit':
-                    await runConditionalAfterHooksForUpdate(dream, statement, txn);
+                    if (shouldRunAfterUpdateHook(dream, hook)) {
+                        if (txn)
+                            txn.addCommitHook(hook, dream);
+                        else
+                            await runHook(hook, dream);
+                    }
                     break;
                 default:
                     throw new Error(`Unexpected statement key detected with ifChanged clause: ${key}`);
             }
         }
         else {
-            await runHook(statement, dream, txn);
+            switch (key) {
+                case 'afterCreateCommit':
+                case 'afterSaveCommit':
+                case 'afterUpdateCommit':
+                case 'afterDestroyCommit':
+                    if (txn)
+                        txn.addCommitHook(hook, dream);
+                    else
+                        await runHook(hook, dream);
+                    break;
+                default:
+                    await runHook(hook, dream, txn);
+            }
         }
     }
 }
@@ -56,40 +98,36 @@ Please make sure "${statement.method}" is defined on ${dream['sanitizedConstruct
     }
     await dream[statement.method](txn);
 }
-async function runConditionalBeforeHooksForCreate(dream, statement, txn) {
+function shouldRunBeforeCreateHook(dream, statement) {
     let shouldRun = false;
     for (const attribute of statement.ifChanging) {
         if (dream[attribute] !== undefined)
             shouldRun = true;
     }
-    if (shouldRun)
-        await runHook(statement, dream, txn);
+    return shouldRun;
 }
-async function runConditionalAfterHooksForCreate(dream, statement, beforeSaveChanges, txn) {
+function shouldRunAfterCreateHook(dream, statement, beforeSaveChanges) {
     let shouldRun = false;
     for (const attribute of statement.ifChanged) {
         if (beforeSaveChanges?.[attribute] &&
             beforeSaveChanges[attribute].was !== beforeSaveChanges[attribute].now)
             shouldRun = true;
     }
-    if (shouldRun)
-        await runHook(statement, dream, txn);
+    return shouldRun;
 }
-async function runConditionalBeforeHooksForUpdate(dream, statement, txn) {
+function shouldRunBeforeUpdateHook(dream, statement) {
     let shouldRun = false;
     for (const attribute of statement.ifChanging) {
         if (dream.willSaveChangeToAttribute(attribute))
             shouldRun = true;
     }
-    if (shouldRun)
-        await runHook(statement, dream, txn);
+    return shouldRun;
 }
-async function runConditionalAfterHooksForUpdate(dream, statement, txn) {
+function shouldRunAfterUpdateHook(dream, statement) {
     let shouldRun = false;
     for (const attribute of statement.ifChanged) {
         if (dream.savedChangeToAttribute(attribute))
             shouldRun = true;
     }
-    if (shouldRun)
-        await runHook(statement, dream, txn);
+    return shouldRun;
 }

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

@@ -5,7 +5,6 @@ import namespaceColumn from '../../helpers/namespaceColumn.js';
 import sqlAttributes from '../../helpers/sqlAttributes.js';
 import executeDatabaseQuery from './executeDatabaseQuery.js';
 import runHooksFor from './runHooksFor.js';
-import safelyRunCommitHooks from './safelyRunCommitHooks.js';
 export default async function saveDream(dream, txn = null, { skipHooks = false } = {}) {
     const db = txn?.kyselyTransaction || _db('primary');
     const alreadyPersisted = dream.isPersisted;
@@ -56,9 +55,8 @@ export default async function saveDream(dream, txn = null, { skipHooks = false }
             await runHooksFor('afterUpdate', dream, alreadyPersisted, beforeSaveChanges, txn);
         else
             await runHooksFor('afterCreate', dream, alreadyPersisted, beforeSaveChanges, txn);
-        const commitHookType = alreadyPersisted ? 'afterUpdateCommit' : 'afterCreateCommit';
-        await safelyRunCommitHooks(dream, commitHookType, alreadyPersisted, beforeSaveChanges, txn);
-        await safelyRunCommitHooks(dream, 'afterSaveCommit', alreadyPersisted, beforeSaveChanges, txn);
+        await runHooksFor(alreadyPersisted ? 'afterUpdateCommit' : 'afterCreateCommit', dream, alreadyPersisted, beforeSaveChanges, txn);
+        await runHooksFor('afterSaveCommit', dream, alreadyPersisted, beforeSaveChanges, txn);
     }
     return dream;
 }

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

@@ -1,6 +1,5 @@
 import { applySortableScopesToQuery } from '../../decorators/field/sortable/helpers/setPosition.js';
 import runHooksFor from './runHooksFor.js';
-import safelyRunCommitHooks from './safelyRunCommitHooks.js';
 /**
  * @internal
  *
@@ -38,7 +37,7 @@ async function undestroyDreamWithTransaction(dream, txn, options) {
     }
     if (!skipHooks) {
         await runHooksFor('afterUpdate', dream, true, null, txn);
-        await safelyRunCommitHooks(dream, 'afterUpdateCommit', true, null, txn);
+        await runHooksFor('afterUpdateCommit', dream, true, null, txn);
     }
     await dream.txn(txn).reload();
     return dream;

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

@@ -0,0 +1,15 @@
+export default class CannotAssociationQueryOnUnpersistedDream extends Error {
+    dream;
+    associationName;
+    constructor(dream, associationName) {
+        super();
+        this.dream = dream;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `Cannot perform associationQuery on an unpersisted Dream.
+Dream class: ${this.dream.sanitizedConstructorName}
+Association: ${this.associationName.toString()}
+    `;
+    }
+}

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

@@ -0,0 +1,15 @@
+export default class CannotCreateAssociationOnUnpersistedDream extends Error {
+    dream;
+    associationName;
+    constructor(dream, associationName) {
+        super();
+        this.dream = dream;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `Cannot perform createAssociation on an unpersisted Dream.
+Dream class: ${this.dream.sanitizedConstructorName}
+Association: ${this.associationName.toString()}
+    `;
+    }
+}

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

@@ -0,0 +1,15 @@
+export default class CannotDestroyAssociationOnUnpersistedDream extends Error {
+    dream;
+    associationName;
+    constructor(dream, associationName) {
+        super();
+        this.dream = dream;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `Cannot perform destroyAssociation on an unpersisted Dream.
+Dream class: ${this.dream.sanitizedConstructorName}
+Association: ${this.associationName.toString()}
+    `;
+    }
+}

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

@@ -0,0 +1,15 @@
+export default class CannotUpdateAssociationOnUnpersistedDream extends Error {
+    dream;
+    associationName;
+    constructor(dream, associationName) {
+        super();
+        this.dream = dream;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `Cannot perform updateAssociation on an unpersisted Dream.
+Dream class: ${this.dream.sanitizedConstructorName}
+Association: ${this.associationName.toString()}
+    `;
+    }
+}

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

@@ -0,0 +1,9 @@
+import colorfulLogo, { monochromeLogo } from './logos.js';
+export default class DreamLogos {
+    static colorful() {
+        return colorfulLogo();
+    }
+    static monochrome() {
+        return monochromeLogo();
+    }
+}

package/dist/esm/src/helpers/{DreamGlam/howyadoins/whaaaaaaaaaaok.js → DreamLogos/logos.js}

@@ -41,7 +41,7 @@ export default function whaaaaaaaaaaok() {
                                                          
                                                          `)));
 }
-export function whaaaaaaaaaaokBasic() {
+export function monochromeLogo() {
     return `
                                     ,▄█▄                 
     ]█▄▄                         ╓█████▌                 

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

@@ -0,0 +1,26 @@
+import CalendarDate from './CalendarDate.js';
+import { DateTime } from './DateTime.js';
+export default function areEqual(a, b) {
+    return areEqualOrUndefined(a, b) ?? areEqualOrUndefined(b, a) ?? JSON.stringify(a) === JSON.stringify(b);
+}
+function areEqualOrUndefined(a, b) {
+    if (a === null)
+        return b === null;
+    if (a === undefined)
+        return b === undefined;
+    if (typeof a === 'boolean')
+        return a === b;
+    if (typeof a === 'number')
+        return a === b;
+    if (typeof a === 'string')
+        return a === b;
+    if (a instanceof DateTime)
+        return b instanceof DateTime && a.equals(b);
+    if (a instanceof CalendarDate)
+        return b instanceof CalendarDate && a.equals(b);
+    if (Array.isArray(a))
+        return Array.isArray(b) && a.length === b.length && !a.find((value, index) => !areEqual(value, b[index]));
+    if (a?.isDreamInstance)
+        return a.equals(b);
+    return undefined;
+}

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

@@ -1,8 +1,8 @@
-import DreamGlam from '../DreamGlam/DreamGlam.js';
+import DreamLogos from '../DreamLogos/DreamLogos.js';
 export default function autogeneratedFileDisclaimer(startComment = '\n/*', endComment = '\n*/') {
     return `\
 ${startComment}
-${DreamGlam.whaaaaaaaaaaokBasic()}
+${DreamLogos.monochrome()}
 
 This file was automatically generated by my cat, Aster.
 He does not want you mucking about with his files,

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

@@ -75,7 +75,7 @@ public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)
     return `\
 import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'${uniq(modelImportStatements).join('')}
 
-const deco = new Decorators<InstanceType<typeof ${modelClassName}>>()
+const deco = new Decorators<typeof ${modelClassName}>()
 
 ${isSTI ? `\n@STI(${parentModelClassName})` : ''}
 export default class ${modelClassName} extends ${isSTI ? parentModelClassName : 'ApplicationModel'} {
@@ -86,7 +86,7 @@ ${isSTI
   }
 
 `}${serializer
-        ? `  public get serializers(): DreamSerializers<${modelClassName}> {
+        ? `  public ${isSTI ? 'override ' : ''}get serializers(): DreamSerializers<${modelClassName}> {
     return {
       default: '${serializerNameFromFullyQualifiedModelName(fullyQualifiedModelName)}',
       summary: '${serializerNameFromFullyQualifiedModelName(fullyQualifiedModelName, 'summary')}',

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

@@ -29,13 +29,13 @@ export default function generateSerializerContent({ fullyQualifiedModelName, col
   Passthrough extends object,
 >`;
     dreamSerializerTypeArgs = `<DataType, Passthrough>`;
-    const defaultSerialzerClassName = globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedModelName));
-    const summarySerialzerClassName = globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedModelName, 'summary'));
+    const defaultSerialzerClassName = serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedModelName));
+    const summarySerialzerClassName = serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedModelName), 'summary');
     const defaultSerialzerExtends = isSTI
-        ? globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedParentName))
+        ? serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedParentName))
         : summarySerialzerClassName;
     const summarySerialzerExtends = isSTI
-        ? globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedParentName, 'summary'))
+        ? serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedParentName), 'summary')
         : 'DreamSerializer';
     const additionalModelImports = [];
     columnsWithTypes.forEach(attr => {
@@ -98,8 +98,16 @@ function attributeOptionsSpecifier(type, attr) {
     }
 }
 function importStatementForSerializer(originModelName, destinationModelName) {
-    return `\nimport ${globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(destinationModelName))}, { ${globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(destinationModelName, 'summary'))} } from '${relativeDreamPath('serializers', 'serializers', originModelName, destinationModelName)}'`;
+    const defaultSerializer = globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(destinationModelName)));
+    const summarySerializer = globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(destinationModelName), 'summary'));
+    const importFrom = relativeDreamPath('serializers', 'serializers', originModelName, destinationModelName);
+    return `\nimport ${defaultSerializer}, { ${summarySerializer} } from '${importFrom}'`;
 }
 function importStatementForModel(originModelName, destinationModelName = originModelName) {
-    return `\nimport ${globalClassNameFromFullyQualifiedModelName(destinationModelName)} from '${relativeDreamPath('serializers', 'models', originModelName, destinationModelName)}'`;
+    const modelName = globalClassNameFromFullyQualifiedModelName(destinationModelName);
+    const importFrom = relativeDreamPath('serializers', 'models', originModelName, destinationModelName);
+    return `\nimport ${modelName} from '${importFrom}'`;
+}
+function fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedModelName) {
+    return fullyQualifiedModelName.split('/').pop() ?? '';
 }

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

@@ -0,0 +1,4 @@
+import areEqual from './areEqual.js';
+export default function (a, b) {
+    return !areEqual(a, b);
+}

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

@@ -3,15 +3,14 @@ export default function uniq(arr, toKey = undefined) {
         return uniqWith(arr, toKey);
     return uniqWith(arr, a => String(a));
 }
-function dreamKey(dream) {
-    return `${dream.constructor.globalName}:${dream.primaryKeyValue}`;
-}
 function uniqWith(arr, toKey) {
     const map = arr.reduce((acc, val) => {
         // Prefix with underscore to ensure that the values cannot be interpreted as integers.
         // If they can be interpreted as integers, then the keys are ordered not by the
         // order in which they were added, but in ascending numerical order.
-        const key = val?.isDreamInstance ? dreamKey(val) : `_${toKey(val)}`;
+        const key = val?.isDreamInstance
+            ? val.comparisonKey
+            : `_${toKey(val)}`;
         acc[key] ||= val;
         return acc;
     }, {});

package/dist/esm/src/index.js

@@ -31,7 +31,7 @@ export { default as generateDream } from './helpers/cli/generateDream.js';
 export { default as compact } from './helpers/compact.js';
 export { DateTime } from './helpers/DateTime.js';
 export { default as debug } from './helpers/debug.js';
-export { default as DreamGlam } from './helpers/DreamGlam/DreamGlam.js';
+export { default as DreamLogos } from './helpers/DreamLogos/DreamLogos.js';
 export { default as Env } from './helpers/Env.js';
 export { default as globalClassNameFromFullyQualifiedModelName } from './helpers/globalClassNameFromFullyQualifiedModelName.js';
 export { default as hyphenize } from './helpers/hyphenize.js';

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

@@ -1892,6 +1892,7 @@ export default class Dream {
      * @returns A boolean
      */
     equals(other: any): boolean;
+    get comparisonKey(): string;
     /**
      * @internal
      *