@rvoh/dream 2.15.1 → 2.16.0

package/dist/cjs/src/decorators/class/STI.js

@@ -6,8 +6,6 @@ export const STI_SCOPE_NAME = 'dream:STI';
 export default function STI(dreamClass) {
     return function (stiChildClass) {
         const baseClass = dreamClass['sti'].baseClass || dreamClass;
-        if (Object.getOwnPropertyDescriptor(stiChildClass, 'associationMetadataByType'))
-            throw new StiChildCannotDefineNewAssociations(baseClass, stiChildClass);
         if (Object.getOwnPropertyDescriptor(stiChildClass, 'replicaSafe'))
             throw new StiChildIncompatibleWithReplicaSafeDecorator(stiChildClass);
         if (Object.getOwnPropertyDescriptor(stiChildClass, 'softDelete'))
@@ -28,3 +26,34 @@ export default function STI(dreamClass) {
         scopeImplementation(stiChildClass, STI_SCOPE_NAME, { default: true });
     };
 }
+export function validateStiChildAssociations(dreamClasses) {
+    dreamClasses.forEach(dreamClass => {
+        if (!dreamClass?.isDream)
+            return;
+        if (!dreamClass['sti'].active)
+            return;
+        const baseClass = dreamClass['sti'].baseClass;
+        if (!baseClass)
+            return;
+        if (hasAssociationsUnavailableOnBase(baseClass, dreamClass))
+            throw new StiChildCannotDefineNewAssociations(baseClass, dreamClass);
+    });
+}
+function hasAssociationsUnavailableOnBase(baseClass, stiChildClass) {
+    const baseAssociationKeys = associationKeysByTypeAndName(baseClass['associationMetadataByType']);
+    const childAssociationKeys = associationKeysByTypeAndName(stiChildClass['associationMetadataByType']);
+    for (const associationKey of childAssociationKeys) {
+        if (!baseAssociationKeys.has(associationKey))
+            return true;
+    }
+    return false;
+}
+function associationKeysByTypeAndName(associationMetadataByType) {
+    const res = new Set();
+    Object.entries(associationMetadataByType).forEach(([associationType, associations]) => {
+        associations.forEach((association) => {
+            res.add(`${associationType}:${association.as}`);
+        });
+    });
+    return res;
+}

package/dist/cjs/src/dream-app/helpers/importers/importModels.js

@@ -1,11 +1,21 @@
 import Dream from '../../../Dream.js';
+import { validateStiChildAssociations } from '../../../decorators/class/STI.js';
 import DreamMissingRequiredOverride from '../../../errors/DreamMissingRequiredOverride.js';
 import DreamImporter from '../DreamImporter.js';
 import globalModelKeyFromPath from '../globalModelKeyFromPath.js';
 let _models;
+let _importModelsPromise;
 export default async function importModels(modelsPath, modelImportCb) {
     if (_models)
         return _models;
+    if (_importModelsPromise)
+        return await _importModelsPromise;
+    _importModelsPromise = importModelsUncached(modelsPath, modelImportCb).finally(() => {
+        _importModelsPromise = undefined;
+    });
+    return await _importModelsPromise;
+}
+async function importModelsUncached(modelsPath, modelImportCb) {
     const modelClasses = await DreamImporter.importDreams(modelsPath, modelImportCb);
     /**
      * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
@@ -14,58 +24,65 @@ export default async function importModels(modelsPath, modelImportCb) {
      * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
      */
     Dream['globallyInitializingDecorators'] = true;
-    _models = {};
-    for (const [modelPath, modelClass] of modelClasses) {
-        // `?` in case modelClass is undefined (e.g. a file without a default export exists in the models directory hierarchy)
-        if (modelClass?.isDream) {
-            try {
-                // Don't create a global lookup for ApplicationModel
-                // ApplicationModel does not have a table
-                if (modelClass.table) {
-                    modelClass['defineAttributeAccessors']();
-                    const modelKey = globalModelKeyFromPath(modelPath, modelsPath);
-                    modelClass['setGlobalName'](modelKey);
-                    _models[modelKey] = modelClass;
+    const models = {};
+    try {
+        for (const [modelPath, modelClass] of modelClasses) {
+            // `?` in case modelClass is undefined (e.g. a file without a default export exists in the models directory hierarchy)
+            if (modelClass?.isDream) {
+                try {
+                    // Don't create a global lookup for ApplicationModel
+                    // ApplicationModel does not have a table
+                    if (modelClass.table) {
+                        modelClass['defineAttributeAccessors']();
+                        const modelKey = globalModelKeyFromPath(modelPath, modelsPath);
+                        modelClass['setGlobalName'](modelKey);
+                        models[modelKey] = modelClass;
+                    }
+                }
+                catch (error) {
+                    // ApplicationModel will automatically raise an exception here,
+                    // since it does not have a table.
+                    if (!(error instanceof DreamMissingRequiredOverride))
+                        throw error;
                 }
-            }
-            catch (error) {
-                // ApplicationModel will automatically raise an exception here,
-                // since it does not have a table.
-                if (!(error instanceof DreamMissingRequiredOverride))
-                    throw error;
             }
         }
-    }
-    for (const [, modelClass] of modelClasses) {
-        // `?` in case modelClass is undefined (e.g. a file without a default export exists in the models directory hierarchy)
-        if (modelClass?.isDream) {
-            try {
-                /**
-                 * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
-                 * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
-                 * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
-                 * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
-                 */
-                new modelClass({}, { _internalUseOnly: true });
-            }
-            catch (error) {
-                // ApplicationModel will automatically raise an exception here,
-                // since it does not have a table.
-                if (!(error instanceof DreamMissingRequiredOverride))
-                    throw error;
+        for (const [, modelClass] of modelClasses) {
+            // `?` in case modelClass is undefined (e.g. a file without a default export exists in the models directory hierarchy)
+            if (modelClass?.isDream) {
+                try {
+                    /**
+                     * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+                     * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+                     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+                     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+                     */
+                    new modelClass({}, { _internalUseOnly: true });
+                }
+                catch (error) {
+                    // ApplicationModel will automatically raise an exception here,
+                    // since it does not have a table.
+                    if (!(error instanceof DreamMissingRequiredOverride))
+                        throw error;
+                }
             }
         }
+        validateStiChildAssociations(modelClasses.map(([, modelClass]) => modelClass));
+        _models = models;
+        return _models;
+    }
+    finally {
+        /**
+         * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+         * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+         * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+         * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+         */
+        Dream['globallyInitializingDecorators'] = false;
     }
-    /**
-     * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
-     * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
-     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
-     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
-     */
-    Dream['globallyInitializingDecorators'] = false;
-    return _models;
 }
 export function setCachedModels(models) {
+    _importModelsPromise = undefined;
     _models = models;
 }
 export function getModelsOrFail() {

package/dist/esm/src/decorators/class/STI.js

@@ -6,8 +6,6 @@ export const STI_SCOPE_NAME = 'dream:STI';
 export default function STI(dreamClass) {
     return function (stiChildClass) {
         const baseClass = dreamClass['sti'].baseClass || dreamClass;
-        if (Object.getOwnPropertyDescriptor(stiChildClass, 'associationMetadataByType'))
-            throw new StiChildCannotDefineNewAssociations(baseClass, stiChildClass);
         if (Object.getOwnPropertyDescriptor(stiChildClass, 'replicaSafe'))
             throw new StiChildIncompatibleWithReplicaSafeDecorator(stiChildClass);
         if (Object.getOwnPropertyDescriptor(stiChildClass, 'softDelete'))
@@ -28,3 +26,34 @@ export default function STI(dreamClass) {
         scopeImplementation(stiChildClass, STI_SCOPE_NAME, { default: true });
     };
 }
+export function validateStiChildAssociations(dreamClasses) {
+    dreamClasses.forEach(dreamClass => {
+        if (!dreamClass?.isDream)
+            return;
+        if (!dreamClass['sti'].active)
+            return;
+        const baseClass = dreamClass['sti'].baseClass;
+        if (!baseClass)
+            return;
+        if (hasAssociationsUnavailableOnBase(baseClass, dreamClass))
+            throw new StiChildCannotDefineNewAssociations(baseClass, dreamClass);
+    });
+}
+function hasAssociationsUnavailableOnBase(baseClass, stiChildClass) {
+    const baseAssociationKeys = associationKeysByTypeAndName(baseClass['associationMetadataByType']);
+    const childAssociationKeys = associationKeysByTypeAndName(stiChildClass['associationMetadataByType']);
+    for (const associationKey of childAssociationKeys) {
+        if (!baseAssociationKeys.has(associationKey))
+            return true;
+    }
+    return false;
+}
+function associationKeysByTypeAndName(associationMetadataByType) {
+    const res = new Set();
+    Object.entries(associationMetadataByType).forEach(([associationType, associations]) => {
+        associations.forEach((association) => {
+            res.add(`${associationType}:${association.as}`);
+        });
+    });
+    return res;
+}

package/dist/esm/src/dream-app/helpers/importers/importModels.js

@@ -1,11 +1,21 @@
 import Dream from '../../../Dream.js';
+import { validateStiChildAssociations } from '../../../decorators/class/STI.js';
 import DreamMissingRequiredOverride from '../../../errors/DreamMissingRequiredOverride.js';
 import DreamImporter from '../DreamImporter.js';
 import globalModelKeyFromPath from '../globalModelKeyFromPath.js';
 let _models;
+let _importModelsPromise;
 export default async function importModels(modelsPath, modelImportCb) {
     if (_models)
         return _models;
+    if (_importModelsPromise)
+        return await _importModelsPromise;
+    _importModelsPromise = importModelsUncached(modelsPath, modelImportCb).finally(() => {
+        _importModelsPromise = undefined;
+    });
+    return await _importModelsPromise;
+}
+async function importModelsUncached(modelsPath, modelImportCb) {
     const modelClasses = await DreamImporter.importDreams(modelsPath, modelImportCb);
     /**
      * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
@@ -14,58 +24,65 @@ export default async function importModels(modelsPath, modelImportCb) {
      * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
      */
     Dream['globallyInitializingDecorators'] = true;
-    _models = {};
-    for (const [modelPath, modelClass] of modelClasses) {
-        // `?` in case modelClass is undefined (e.g. a file without a default export exists in the models directory hierarchy)
-        if (modelClass?.isDream) {
-            try {
-                // Don't create a global lookup for ApplicationModel
-                // ApplicationModel does not have a table
-                if (modelClass.table) {
-                    modelClass['defineAttributeAccessors']();
-                    const modelKey = globalModelKeyFromPath(modelPath, modelsPath);
-                    modelClass['setGlobalName'](modelKey);
-                    _models[modelKey] = modelClass;
+    const models = {};
+    try {
+        for (const [modelPath, modelClass] of modelClasses) {
+            // `?` in case modelClass is undefined (e.g. a file without a default export exists in the models directory hierarchy)
+            if (modelClass?.isDream) {
+                try {
+                    // Don't create a global lookup for ApplicationModel
+                    // ApplicationModel does not have a table
+                    if (modelClass.table) {
+                        modelClass['defineAttributeAccessors']();
+                        const modelKey = globalModelKeyFromPath(modelPath, modelsPath);
+                        modelClass['setGlobalName'](modelKey);
+                        models[modelKey] = modelClass;
+                    }
+                }
+                catch (error) {
+                    // ApplicationModel will automatically raise an exception here,
+                    // since it does not have a table.
+                    if (!(error instanceof DreamMissingRequiredOverride))
+                        throw error;
                 }
-            }
-            catch (error) {
-                // ApplicationModel will automatically raise an exception here,
-                // since it does not have a table.
-                if (!(error instanceof DreamMissingRequiredOverride))
-                    throw error;
             }
         }
-    }
-    for (const [, modelClass] of modelClasses) {
-        // `?` in case modelClass is undefined (e.g. a file without a default export exists in the models directory hierarchy)
-        if (modelClass?.isDream) {
-            try {
-                /**
-                 * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
-                 * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
-                 * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
-                 * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
-                 */
-                new modelClass({}, { _internalUseOnly: true });
-            }
-            catch (error) {
-                // ApplicationModel will automatically raise an exception here,
-                // since it does not have a table.
-                if (!(error instanceof DreamMissingRequiredOverride))
-                    throw error;
+        for (const [, modelClass] of modelClasses) {
+            // `?` in case modelClass is undefined (e.g. a file without a default export exists in the models directory hierarchy)
+            if (modelClass?.isDream) {
+                try {
+                    /**
+                     * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+                     * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+                     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+                     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+                     */
+                    new modelClass({}, { _internalUseOnly: true });
+                }
+                catch (error) {
+                    // ApplicationModel will automatically raise an exception here,
+                    // since it does not have a table.
+                    if (!(error instanceof DreamMissingRequiredOverride))
+                        throw error;
+                }
             }
         }
+        validateStiChildAssociations(modelClasses.map(([, modelClass]) => modelClass));
+        _models = models;
+        return _models;
+    }
+    finally {
+        /**
+         * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+         * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+         * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+         * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+         */
+        Dream['globallyInitializingDecorators'] = false;
     }
-    /**
-     * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
-     * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
-     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
-     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
-     */
-    Dream['globallyInitializingDecorators'] = false;
-    return _models;
 }
 export function setCachedModels(models) {
+    _importModelsPromise = undefined;
     _models = models;
 }
 export function getModelsOrFail() {

package/dist/types/src/decorators/class/STI.d.ts

@@ -1,3 +1,4 @@
 import Dream from '../../Dream.js';
 export declare const STI_SCOPE_NAME = "dream:STI";
 export default function STI(dreamClass: typeof Dream): (stiChildClass: typeof Dream) => void;
+export declare function validateStiChildAssociations(dreamClasses: (typeof Dream)[]): void;