@rvoh/dream 0.33.0 → 0.35.0

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/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/index.js

@@ -1,8 +1,8 @@
 export { default as DreamBin } from './bin/index.js';
 export { default as DreamCLI } from './cli/index.js';
-export { closeAllDbConnections, default as DreamDbConnection, dreamDbConnections, } from './db/DreamDbConnection.js';
+export { closeAllDbConnections, dreamDbConnections } from './db/DreamDbConnection.js';
 export { pgErrorType } from './db/errors.js';
-export { default as db } from './db/index.js';
+export { default as untypedDb } from './db/index.js';
 export { default as DreamMigrationHelpers } from './db/migration-helpers/DreamMigrationHelpers.js';
 export { default as validateColumn } from './db/validators/validateColumn.js';
 export { default as validateTable } from './db/validators/validateTable.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/decorators/Decorators.d.ts

@@ -6,15 +6,15 @@ import { HasOneOptions, HasOneThroughOptions, PolymorphicHasOneOptions } from '.
 import { DreamColumnNames, GlobalModelNameTableMap, SortableOptions } from '../types/dream.js';
 import { AfterHookOpts, BeforeHookOpts } from '../types/lifecycle.js';
 import { ValidationType } from '../types/validation.js';
-export default class Decorators<T extends Dream> {
-    BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: NonPolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
-    BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: PolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
-    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyOptions<T, AssociationGlobalName>): any;
-    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyThroughOptions<T, AssociationGlobalName>): any;
-    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasManyOptions<T, AssociationGlobalName>): any;
-    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneOptions<T, AssociationGlobalName>): any;
-    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneThroughOptions<T, AssociationGlobalName>): any;
-    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasOneOptions<T, AssociationGlobalName>): any;
+export default class Decorators<TD extends typeof Dream, T extends Dream = InstanceType<TD>> {
+    BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: NonPolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
+    BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: PolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyOptions<T, AssociationGlobalName>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyThroughOptions<T, AssociationGlobalName>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasManyOptions<T, AssociationGlobalName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneOptions<T, AssociationGlobalName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneThroughOptions<T, AssociationGlobalName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasOneOptions<T, AssociationGlobalName>): any;
     /**
      * The Encrypted decorator automatically encrypts (upon setting)
      * and decrypts (upon getting) so that the encrypted value is
@@ -37,7 +37,7 @@ export default class Decorators<T extends Dream> {
      * @param column — if omitted, then 'encrypted' is prepended to the Pascal cased version of the decorated field
      * @returns An Encrypted decorator
      */
-    Encrypted(this: Decorators<T>, column?: DreamColumnNames<T>): any;
+    Encrypted(this: Decorators<TD>, column?: DreamColumnNames<T>): any;
     /**
      * The Scope decorator decorates a static method that accepts
      * and returns a Dream Query.
@@ -55,7 +55,7 @@ export default class Decorators<T extends Dream> {
      * @param opts.default - boolean: if true, then this scope will be applied to all queries involving this model
      * @returns A Scope decorator
      */
-    Scope(this: Decorators<T>, opts?: {
+    Scope(this: Decorators<TD>, opts?: {
         default?: boolean;
     }): any;
     /**
@@ -74,7 +74,7 @@ export default class Decorators<T extends Dream> {
      * @param scope - The column, association, or combination there-of which you would like to restrict the incrementing logic to
      * @returns A Sortable decorator
      */
-    Sortable(this: Decorators<T>, opts?: SortableOptions<T>): any;
+    Sortable(this: Decorators<TD>, opts?: SortableOptions<T>): any;
     /**
      * The Validate decorator decorates a method to run
      * before saving a model to the database.
@@ -97,7 +97,7 @@ export default class Decorators<T extends Dream> {
      *
      * @returns A Validate decorator
      */
-    Validate(this: Decorators<T>): any;
+    Validate(this: Decorators<TD>): any;
     /**
      * The Validates decorator decorates a field to validate
      * according to the specified validator and options.
@@ -120,7 +120,7 @@ export default class Decorators<T extends Dream> {
     } : VT extends 'length' ? {
         min: number;
         max?: number;
-    } : VT extends 'contains' ? string | RegExp : never>(this: Decorators<T>, type: VT, args?: VTArgs): any;
+    } : VT extends 'contains' ? string | RegExp : never>(this: Decorators<TD>, type: VT, args?: VTArgs): any;
     /**
      * The Virtual decorator enables setting of fields as if they
      * corresponded to columns in the model's table so they can
@@ -182,7 +182,7 @@ export default class Decorators<T extends Dream> {
      *
      * @returns An Virtual decorator
      */
-    Virtual(this: Decorators<T>, type?: SerializableTypes): any;
+    Virtual(this: Decorators<TD>, type?: SerializableTypes): any;
     /**
      * BeforeCreate decorator
      *
@@ -198,7 +198,7 @@ export default class Decorators<T extends Dream> {
      * @returns The BeforeCreate decorator
      *
      */
-    BeforeCreate(this: Decorators<T>, opts?: BeforeHookOpts<T>): any;
+    BeforeCreate(this: Decorators<TD>, opts?: BeforeHookOpts<T>): any;
     /**
      * BeforeSave decorator
      *
@@ -214,7 +214,7 @@ export default class Decorators<T extends Dream> {
      * @returns The BeforeSave decorator
      *
      */
-    BeforeSave(this: Decorators<T>, opts?: BeforeHookOpts<T>): any;
+    BeforeSave(this: Decorators<TD>, opts?: BeforeHookOpts<T>): any;
     /**
      * BeforeUpdate decorator
      *
@@ -230,7 +230,7 @@ export default class Decorators<T extends Dream> {
      * @returns The BeforeUpdate decorator
      *
      */
-    BeforeUpdate(this: Decorators<T>, opts?: BeforeHookOpts<T>): any;
+    BeforeUpdate(this: Decorators<TD>, opts?: BeforeHookOpts<T>): any;
     /**
      * BeforeDestroy decorator
      *
@@ -245,7 +245,7 @@ export default class Decorators<T extends Dream> {
      *
      * @returns The BeforeDestroy decorator
      */
-    BeforeDestroy(this: Decorators<T>): any;
+    BeforeDestroy(this: Decorators<TD>): any;
     /**
      * AfterCreate decorator
      *
@@ -261,7 +261,7 @@ export default class Decorators<T extends Dream> {
      * @returns The AfterCreate decorator
      *
      */
-    AfterCreate(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    AfterCreate(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
     /**
      * AfterCreateCommit decorator
      *
@@ -276,7 +276,7 @@ export default class Decorators<T extends Dream> {
      *
      * @returns The AfterCreateCommit decorator
      */
-    AfterCreateCommit(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    AfterCreateCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
     /**
      * AfterSave decorator
      *
@@ -292,7 +292,7 @@ export default class Decorators<T extends Dream> {
      * @returns The AfterSave decorator
      *
      */
-    AfterSave(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    AfterSave(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
     /**
      * AfterSaveCommit decorator
      *
@@ -308,7 +308,7 @@ export default class Decorators<T extends Dream> {
      * @returns The AfterSaveCommit decorator
      *
      */
-    AfterSaveCommit(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    AfterSaveCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
     /**
      * AfterUpdate decorator
      *
@@ -324,7 +324,7 @@ export default class Decorators<T extends Dream> {
      * @returns The AfterUpdate decorator
      *
      */
-    AfterUpdate(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    AfterUpdate(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
     /**
      * AfterUpdateCommit decorator
      *
@@ -340,7 +340,7 @@ export default class Decorators<T extends Dream> {
      * @returns The AfterUpdateCommit decorator
      *
      */
-    AfterUpdateCommit(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    AfterUpdateCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
     /**
      * AfterDestroy decorator
      *
@@ -356,7 +356,7 @@ export default class Decorators<T extends Dream> {
      * @returns The AfterDestroy decorator
      *
      */
-    AfterDestroy(this: Decorators<T>): any;
+    AfterDestroy(this: Decorators<TD>): any;
     /**
      * AfterDestroyCommit decorator
      *
@@ -372,5 +372,5 @@ export default class Decorators<T extends Dream> {
      * @returns The AfterDestroyCommit decorator
      *
      */
-    AfterDestroyCommit(this: Decorators<T>): any;
+    AfterDestroyCommit(this: Decorators<TD>): any;
 }

package/dist/types/src/errors/associations/CannotAssociationQueryOnUnpersistedDream.d.ts

@@ -0,0 +1,7 @@
+import Dream from '../../Dream.js';
+export default class CannotAssociationQueryOnUnpersistedDream extends Error {
+    dream: Dream;
+    associationName: string | number | symbol;
+    constructor(dream: Dream, associationName: string | number | symbol);
+    get message(): string;
+}

package/dist/types/src/errors/associations/CannotCreateAssociationOnUnpersistedDream.d.ts

@@ -0,0 +1,7 @@
+import Dream from '../../Dream.js';
+export default class CannotCreateAssociationOnUnpersistedDream extends Error {
+    dream: Dream;
+    associationName: string | number | symbol;
+    constructor(dream: Dream, associationName: string | number | symbol);
+    get message(): string;
+}