@rvoh/dream 1.3.2 → 1.3.3

package/dist/cjs/src/Dream.js

@@ -363,26 +363,41 @@ class Dream {
         return this.sti.baseClass || this;
     }
     /**
-     * @internal
-     *
-     * Returns either the base STI class name, or else this class name
-     *
-     * NOTE: This is necessary due to changes in esbuild strategy WRT esm,
-     * compiled class names can contain a prefixing underscore if they contain
-     * private fields.
-     *
-     * This can create confusion when the class name is used as an attribute,
-     * as is done in the case of polymorphic associations, which use the class
-     * name as the "type" value for the polymorphic association.
-     *
-     * As such, any time the class name is being used as a value, it should be
-     * done using this value, rather than going to the class name directly.
+     * Returns the string value representing this model type that will be stored in the
+     * database for STI children or polymorphic associations.
+     *
+     * This value is used to identify the specific model class when querying polymorphic
+     * associations or STI records. For STI models, this returns the base class' sanitized name.
+     * For regular models, it returns the model's sanitized class name.
+     *
+     * When building queries manually, use this method for the type or polymorphic type part of
+     * the query. For example:
+     *
+     * ```ts
+     * // Using in polymorphic queries
+     * const localizedTexts = await LocalizedText.passthrough({ locale })
+     *   .whereAny(
+     *     modelsWithTextAssociation.map(
+     *       model => ({
+     *         localizableId: model.primaryKeyValue,
+     *         localizableType: model.referenceTypeString,
+     *       })
+     *     )
+     *   )
+     *   .all()
+     *
+     * // Example values for different model types
+     * const user = User.new()
+     * user.referenceTypeString // 'User'
      *
-     * see https://github.com/evanw/esbuild/issues/1260 for more information
+     * // For STI child classes, returns the base class name
+     * const mylarBalloon = MylarBalloon.new() // extends Balloon (STI base)
+     * mylarBalloon.referenceTypeString // 'Balloon'
+     * ```
      *
-     * @returns string
+     * @returns The string identifier for this model type used in database storage
      */
-    static get stiBaseClassOrOwnClassName() {
+    static get referenceTypeString() {
         return this.stiBaseClassOrOwnClass.sanitizedName;
     }
     /**
@@ -410,14 +425,42 @@ class Dream {
         return this.constructor.stiBaseClassOrOwnClass;
     }
     /**
-     * @internal
+     * Returns the string value representing this model type that will be stored in the
+     * database for STI children or polymorphic associations.
      *
-     * Shadows .stiBaseClassOrOwnClassName. Returns a string
+     * This value is used to identify the specific model class when querying polymorphic
+     * associations or STI records. For STI models, this returns the base class' sanitized name.
+     * For regular models, it returns the model's sanitized class name.
      *
-     * @returns A string
+     * When building queries manually, use this method for the type or polymorphic type part of
+     * the query. For example:
+     *
+     * ```ts
+     * // Using in polymorphic queries
+     * const localizedTexts = await LocalizedText.passthrough({ locale })
+     *   .whereAny(
+     *     modelsWithTextAssociation.map(
+     *       model => ({
+     *         localizableId: model.primaryKeyValue,
+     *         localizableType: model.referenceTypeString,
+     *       })
+     *     )
+     *   )
+     *   .all()
+     *
+     * // Example values for different model types
+     * const user = User.new()
+     * user.referenceTypeString // 'User'
+     *
+     * // For STI child classes, returns the base class name
+     * const mylarBalloon = MylarBalloon.new() // extends Balloon (STI base)
+     * mylarBalloon.referenceTypeString // 'Balloon'
+     * ```
+     *
+     * @returns The string identifier for this model type used in database storage
      */
-    get stiBaseClassOrOwnClassName() {
-        return this.constructor.stiBaseClassOrOwnClassName;
+    get referenceTypeString() {
+        return this.constructor.referenceTypeString;
     }
     /**
      * this.constructor.name may be prefixed with an underscore during conversion to Javascript.
@@ -2307,7 +2350,7 @@ class Dream {
                 }
                 if (belongsToAssociationMetaData.polymorphic) {
                     const foreignKeyTypeField = belongsToAssociationMetaData.foreignKeyTypeField();
-                    returnValues[foreignKeyTypeField] = associatedObject?.stiBaseClassOrOwnClassName;
+                    returnValues[foreignKeyTypeField] = associatedObject?.referenceTypeString;
                     setAttributeOnDreamInstance(foreignKeyTypeField, returnValues[foreignKeyTypeField]);
                 }
             }

package/dist/cjs/src/decorators/field/association/shared.js

@@ -90,7 +90,7 @@ function applyGetterAndSetter(target, partialAssociation, { foreignKeyBase, isBe
                     partialAssociation.primaryKeyValue(associatedModel);
                 if (partialAssociation.polymorphic)
                     this[foreignKeyTypeField(foreignKeyBase, dreamClass, partialAssociation)] =
-                        associatedModel?.['stiBaseClassOrOwnClassName'];
+                        associatedModel?.referenceTypeString;
             }
         },
     });

package/dist/cjs/src/dream/QueryDriver/Kysely.js

@@ -1566,8 +1566,8 @@ class KyselyQueryDriver extends Base_js_1.default {
                 if (association.polymorphic) {
                     join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement({
                         [association.foreignKeyTypeField()]: dreamClassThroughAssociationWantsToHydrate
-                            ? dreamClassThroughAssociationWantsToHydrate['stiBaseClassOrOwnClassName']
-                            : dreamClass['stiBaseClassOrOwnClassName'],
+                            ? dreamClassThroughAssociationWantsToHydrate.referenceTypeString
+                            : dreamClass.referenceTypeString,
                     }, currentTableAlias)));
                 }
                 if (previousThroughAssociation) {
@@ -1718,7 +1718,7 @@ class KyselyQueryDriver extends Base_js_1.default {
     async preloadPolymorphicAssociationModel(dreams, association, associatedDreamClass) {
         const relevantAssociatedModels = dreams.filter((dream) => {
             const field = association.foreignKeyTypeField();
-            return dream[field] === associatedDreamClass['stiBaseClassOrOwnClassName'] || dream[field] === null;
+            return dream[field] === associatedDreamClass.referenceTypeString || dream[field] === null;
         });
         if (relevantAssociatedModels.length) {
             dreams.forEach((dream) => {
@@ -1739,7 +1739,7 @@ class KyselyQueryDriver extends Base_js_1.default {
             //////////////////////////////////////////////////////////////////////////////////////////////
             for (const loadedAssociation of loadedAssociations) {
                 dreams
-                    .filter((dream) => dream[association.foreignKeyTypeField()] === loadedAssociation['stiBaseClassOrOwnClassName'] &&
+                    .filter((dream) => dream[association.foreignKeyTypeField()] === loadedAssociation.referenceTypeString &&
                     dream[association.foreignKey()] === association.primaryKeyValue(loadedAssociation))
                     .forEach((dream) => {
                     dream[association.as] = loadedAssociation;

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

@@ -31,7 +31,7 @@ async function createAssociation(dream, txn = null, associationName, opts = {})
                 ...opts,
             };
             if (hasAssociation.polymorphic) {
-                modifiedOpts[hasAssociation.foreignKeyTypeField()] = dream['stiBaseClassOrOwnClassName'];
+                modifiedOpts[hasAssociation.foreignKeyTypeField()] = dream.referenceTypeString;
             }
             hasresult = await associationClass.txn(txn).create(modifiedOpts);
             return hasresult;

package/dist/esm/src/Dream.js

@@ -361,26 +361,41 @@ export default class Dream {
         return this.sti.baseClass || this;
     }
     /**
-     * @internal
-     *
-     * Returns either the base STI class name, or else this class name
-     *
-     * NOTE: This is necessary due to changes in esbuild strategy WRT esm,
-     * compiled class names can contain a prefixing underscore if they contain
-     * private fields.
-     *
-     * This can create confusion when the class name is used as an attribute,
-     * as is done in the case of polymorphic associations, which use the class
-     * name as the "type" value for the polymorphic association.
-     *
-     * As such, any time the class name is being used as a value, it should be
-     * done using this value, rather than going to the class name directly.
+     * Returns the string value representing this model type that will be stored in the
+     * database for STI children or polymorphic associations.
+     *
+     * This value is used to identify the specific model class when querying polymorphic
+     * associations or STI records. For STI models, this returns the base class' sanitized name.
+     * For regular models, it returns the model's sanitized class name.
+     *
+     * When building queries manually, use this method for the type or polymorphic type part of
+     * the query. For example:
+     *
+     * ```ts
+     * // Using in polymorphic queries
+     * const localizedTexts = await LocalizedText.passthrough({ locale })
+     *   .whereAny(
+     *     modelsWithTextAssociation.map(
+     *       model => ({
+     *         localizableId: model.primaryKeyValue,
+     *         localizableType: model.referenceTypeString,
+     *       })
+     *     )
+     *   )
+     *   .all()
+     *
+     * // Example values for different model types
+     * const user = User.new()
+     * user.referenceTypeString // 'User'
      *
-     * see https://github.com/evanw/esbuild/issues/1260 for more information
+     * // For STI child classes, returns the base class name
+     * const mylarBalloon = MylarBalloon.new() // extends Balloon (STI base)
+     * mylarBalloon.referenceTypeString // 'Balloon'
+     * ```
      *
-     * @returns string
+     * @returns The string identifier for this model type used in database storage
      */
-    static get stiBaseClassOrOwnClassName() {
+    static get referenceTypeString() {
         return this.stiBaseClassOrOwnClass.sanitizedName;
     }
     /**
@@ -408,14 +423,42 @@ export default class Dream {
         return this.constructor.stiBaseClassOrOwnClass;
     }
     /**
-     * @internal
+     * Returns the string value representing this model type that will be stored in the
+     * database for STI children or polymorphic associations.
      *
-     * Shadows .stiBaseClassOrOwnClassName. Returns a string
+     * This value is used to identify the specific model class when querying polymorphic
+     * associations or STI records. For STI models, this returns the base class' sanitized name.
+     * For regular models, it returns the model's sanitized class name.
      *
-     * @returns A string
+     * When building queries manually, use this method for the type or polymorphic type part of
+     * the query. For example:
+     *
+     * ```ts
+     * // Using in polymorphic queries
+     * const localizedTexts = await LocalizedText.passthrough({ locale })
+     *   .whereAny(
+     *     modelsWithTextAssociation.map(
+     *       model => ({
+     *         localizableId: model.primaryKeyValue,
+     *         localizableType: model.referenceTypeString,
+     *       })
+     *     )
+     *   )
+     *   .all()
+     *
+     * // Example values for different model types
+     * const user = User.new()
+     * user.referenceTypeString // 'User'
+     *
+     * // For STI child classes, returns the base class name
+     * const mylarBalloon = MylarBalloon.new() // extends Balloon (STI base)
+     * mylarBalloon.referenceTypeString // 'Balloon'
+     * ```
+     *
+     * @returns The string identifier for this model type used in database storage
      */
-    get stiBaseClassOrOwnClassName() {
-        return this.constructor.stiBaseClassOrOwnClassName;
+    get referenceTypeString() {
+        return this.constructor.referenceTypeString;
     }
     /**
      * this.constructor.name may be prefixed with an underscore during conversion to Javascript.
@@ -2305,7 +2348,7 @@ export default class Dream {
                 }
                 if (belongsToAssociationMetaData.polymorphic) {
                     const foreignKeyTypeField = belongsToAssociationMetaData.foreignKeyTypeField();
-                    returnValues[foreignKeyTypeField] = associatedObject?.stiBaseClassOrOwnClassName;
+                    returnValues[foreignKeyTypeField] = associatedObject?.referenceTypeString;
                     setAttributeOnDreamInstance(foreignKeyTypeField, returnValues[foreignKeyTypeField]);
                 }
             }

package/dist/esm/src/decorators/field/association/shared.js

@@ -81,7 +81,7 @@ export function applyGetterAndSetter(target, partialAssociation, { foreignKeyBas
                     partialAssociation.primaryKeyValue(associatedModel);
                 if (partialAssociation.polymorphic)
                     this[foreignKeyTypeField(foreignKeyBase, dreamClass, partialAssociation)] =
-                        associatedModel?.['stiBaseClassOrOwnClassName'];
+                        associatedModel?.referenceTypeString;
             }
         },
     });

package/dist/esm/src/dream/QueryDriver/Kysely.js

@@ -1564,8 +1564,8 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 if (association.polymorphic) {
                     join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement({
                         [association.foreignKeyTypeField()]: dreamClassThroughAssociationWantsToHydrate
-                            ? dreamClassThroughAssociationWantsToHydrate['stiBaseClassOrOwnClassName']
-                            : dreamClass['stiBaseClassOrOwnClassName'],
+                            ? dreamClassThroughAssociationWantsToHydrate.referenceTypeString
+                            : dreamClass.referenceTypeString,
                     }, currentTableAlias)));
                 }
                 if (previousThroughAssociation) {
@@ -1716,7 +1716,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     async preloadPolymorphicAssociationModel(dreams, association, associatedDreamClass) {
         const relevantAssociatedModels = dreams.filter((dream) => {
             const field = association.foreignKeyTypeField();
-            return dream[field] === associatedDreamClass['stiBaseClassOrOwnClassName'] || dream[field] === null;
+            return dream[field] === associatedDreamClass.referenceTypeString || dream[field] === null;
         });
         if (relevantAssociatedModels.length) {
             dreams.forEach((dream) => {
@@ -1737,7 +1737,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             //////////////////////////////////////////////////////////////////////////////////////////////
             for (const loadedAssociation of loadedAssociations) {
                 dreams
-                    .filter((dream) => dream[association.foreignKeyTypeField()] === loadedAssociation['stiBaseClassOrOwnClassName'] &&
+                    .filter((dream) => dream[association.foreignKeyTypeField()] === loadedAssociation.referenceTypeString &&
                     dream[association.foreignKey()] === association.primaryKeyValue(loadedAssociation))
                     .forEach((dream) => {
                     dream[association.as] = loadedAssociation;

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

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

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

@@ -277,26 +277,41 @@ export default class Dream {
      */
     private static get stiBaseClassOrOwnClass();
     /**
-     * @internal
-     *
-     * Returns either the base STI class name, or else this class name
-     *
-     * NOTE: This is necessary due to changes in esbuild strategy WRT esm,
-     * compiled class names can contain a prefixing underscore if they contain
-     * private fields.
-     *
-     * This can create confusion when the class name is used as an attribute,
-     * as is done in the case of polymorphic associations, which use the class
-     * name as the "type" value for the polymorphic association.
-     *
-     * As such, any time the class name is being used as a value, it should be
-     * done using this value, rather than going to the class name directly.
+     * Returns the string value representing this model type that will be stored in the
+     * database for STI children or polymorphic associations.
+     *
+     * This value is used to identify the specific model class when querying polymorphic
+     * associations or STI records. For STI models, this returns the base class' sanitized name.
+     * For regular models, it returns the model's sanitized class name.
+     *
+     * When building queries manually, use this method for the type or polymorphic type part of
+     * the query. For example:
+     *
+     * ```ts
+     * // Using in polymorphic queries
+     * const localizedTexts = await LocalizedText.passthrough({ locale })
+     *   .whereAny(
+     *     modelsWithTextAssociation.map(
+     *       model => ({
+     *         localizableId: model.primaryKeyValue,
+     *         localizableType: model.referenceTypeString,
+     *       })
+     *     )
+     *   )
+     *   .all()
+     *
+     * // Example values for different model types
+     * const user = User.new()
+     * user.referenceTypeString // 'User'
      *
-     * see https://github.com/evanw/esbuild/issues/1260 for more information
+     * // For STI child classes, returns the base class name
+     * const mylarBalloon = MylarBalloon.new() // extends Balloon (STI base)
+     * mylarBalloon.referenceTypeString // 'Balloon'
+     * ```
      *
-     * @returns string
+     * @returns The string identifier for this model type used in database storage
      */
-    private static get stiBaseClassOrOwnClassName();
+    static get referenceTypeString(): string;
     /**
      * @internal
      *
@@ -318,13 +333,41 @@ export default class Dream {
      */
     private get stiBaseClassOrOwnClass();
     /**
-     * @internal
+     * Returns the string value representing this model type that will be stored in the
+     * database for STI children or polymorphic associations.
      *
-     * Shadows .stiBaseClassOrOwnClassName. Returns a string
+     * This value is used to identify the specific model class when querying polymorphic
+     * associations or STI records. For STI models, this returns the base class' sanitized name.
+     * For regular models, it returns the model's sanitized class name.
      *
-     * @returns A string
+     * When building queries manually, use this method for the type or polymorphic type part of
+     * the query. For example:
+     *
+     * ```ts
+     * // Using in polymorphic queries
+     * const localizedTexts = await LocalizedText.passthrough({ locale })
+     *   .whereAny(
+     *     modelsWithTextAssociation.map(
+     *       model => ({
+     *         localizableId: model.primaryKeyValue,
+     *         localizableType: model.referenceTypeString,
+     *       })
+     *     )
+     *   )
+     *   .all()
+     *
+     * // Example values for different model types
+     * const user = User.new()
+     * user.referenceTypeString // 'User'
+     *
+     * // For STI child classes, returns the base class name
+     * const mylarBalloon = MylarBalloon.new() // extends Balloon (STI base)
+     * mylarBalloon.referenceTypeString // 'Balloon'
+     * ```
+     *
+     * @returns The string identifier for this model type used in database storage
      */
-    private get stiBaseClassOrOwnClassName();
+    get referenceTypeString(): string;
     /**
      * this.constructor.name may be prefixed with an underscore during conversion to Javascript.
      * This method returns the constructor name without a leading underscore.

package/docs/assets/search.js

@@ -1 +1 @@
-window.searchData = "data:application/octet-stream;base64,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";
+window.searchData = "data:application/octet-stream;base64,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";