@rvoh/dream 1.2.0 → 1.3.0

package/dist/esm/src/Dream.js

@@ -19,6 +19,7 @@ import destroyDream from './dream/internal/destroyDream.js';
 import { destroyOptions, reallyDestroyOptions, undestroyOptions, } from './dream/internal/destroyOptions.js';
 import ensureSTITypeFieldIsSet from './dream/internal/ensureSTITypeFieldIsSet.js';
 import findOrCreateBy from './dream/internal/findOrCreateBy.js';
+import printSerializerHierarchyLevel from './dream/internal/printSerializerHierarchyLevel.js';
 import reload from './dream/internal/reload.js';
 import runValidations from './dream/internal/runValidations.js';
 import saveDream from './dream/internal/saveDream.js';
@@ -47,10 +48,8 @@ import cloneDeepSafe from './helpers/cloneDeepSafe.js';
 import { DateTime } from './helpers/DateTime.js';
 import cachedTypeForAttribute from './helpers/db/cachedTypeForAttribute.js';
 import isJsonColumn from './helpers/db/types/isJsonColumn.js';
-import { indent } from './helpers/indent.js';
 import notEqual from './helpers/notEqual.js';
 import { inferSerializersFromDreamClassOrViewModelClass } from './serializer/helpers/inferSerializerFromDreamOrViewModel.js';
-import { serializerForAssociatedClass } from './serializer/helpers/serializerForAssociatedClass.js';
 export default class Dream {
     DB;
     /**
@@ -487,42 +486,65 @@ export default class Dream {
     static recursiveSerializationMap(serializer, { forDisplay = false, forDisplayDepth = 0, } = {}) {
         const serializerBuilder = serializer(undefined, undefined);
         const serializerAssociations = serializerBuilder['attributes'].filter(attribute => ['rendersOne', 'rendersMany', 'delegatedAttribute'].includes(attribute.type));
-        return serializerAssociations.reduce((acc, serializerAssociation) => {
+        return serializerAssociations.reduce((accumulator, serializerAssociation) => {
             const serializerAssociationName = serializerAssociation.targetName ??
                 serializerAssociation.name;
             const serializerAssociationType = serializerAssociation.type;
             const association = this['getAssociationMetadata'](serializerAssociationName);
             if (!association)
-                return acc;
-            const associatedClasses = association.modelCB();
-            const associatedClass = Array.isArray(associatedClasses) ? associatedClasses[0] : associatedClasses;
-            if (!associatedClass)
+                return accumulator;
+            const maybeAssociatedClasses = association.modelCB();
+            if (!maybeAssociatedClasses)
                 throw new Error(`No class defined on ${serializerAssociationName} association on ${this.sanitizedName}`);
-            const associationSerializer = serializerForAssociatedClass(this.prototype, serializerAssociationName, serializerAssociation.options);
-            if (!associationSerializer)
-                throw new Error(`No serializer found to render ${serializerAssociationName} on ${this.sanitizedName}`);
-            if (forDisplay && serializerAssociationType !== 'delegatedAttribute') {
-                const hierarchyLine = '└───';
-                const indentation = indent((hierarchyLine.length + 1) * forDisplayDepth, {
-                    tabWidth: 1,
-                });
-                const prefix = `${hierarchyLine} `;
-                const nestedAssociationDisplay = indentation + `${prefix}${serializerAssociationType} ${yoctocolors.cyan(serializerAssociationName)}`;
-                console.log(nestedAssociationDisplay);
-                console.log(yoctocolors.gray(indentation +
-                    indent(prefix.length, { tabWidth: 1 }) +
-                    associationSerializer.globalName));
-            }
-            acc[association.as] = {
-                parentDreamClass: this,
-                nestedSerializerInfo: serializerAssociation.type === 'delegatedAttribute'
-                    ? {}
-                    : associatedClass['recursiveSerializationMap'](associationSerializer, {
+            const associatedClasses = Array.isArray(maybeAssociatedClasses)
+                ? maybeAssociatedClasses
+                : [maybeAssociatedClasses];
+            /////////////////////////////////////////////////
+            // map associated classes to their serializers //
+            /////////////////////////////////////////////////
+            const associatedClassSerializerTuples = associatedClasses.flatMap(associatedClass => {
+                /**
+                 * `serializers` is an array because `associatedClass` may be an STI
+                 * base, with each of its STI children having its own serializer
+                 */
+                const serializers = serializerAssociation.options.serializer
+                    ? [serializerAssociation.options.serializer]
+                    : inferSerializersFromDreamClassOrViewModelClass(associatedClass, serializerAssociation.options.serializerKey);
+                if (!serializers.length)
+                    throw new Error(`No serializer found to render ${serializerAssociationName} on ${this.sanitizedName}`);
+                return serializers.map(serializer => [associatedClass, serializer]);
+            });
+            /////////////////////////////////////////////////////
+            // end:map associated classes to their serializers //
+            /////////////////////////////////////////////////////
+            ///////////////////////////////////////////////////////////////////////////////////////////////////
+            // reduce over all associated serializers, recursively building out their associated serializers //
+            ///////////////////////////////////////////////////////////////////////////////////////////////////
+            const innerAssociationSerializerInfo = associatedClassSerializerTuples.reduce((innerAccumulator, [associatedClass, associatedSerializer]) => {
+                if (forDisplay && serializerAssociationType !== 'delegatedAttribute') {
+                    printSerializerHierarchyLevel({
+                        serializerAssociationType,
+                        serializerAssociationName,
+                        associationSerializer: associatedSerializer,
+                        forDisplayDepth,
+                    });
+                }
+                return {
+                    ...innerAccumulator,
+                    ...associatedClass['recursiveSerializationMap'](associatedSerializer, {
                         forDisplay,
                         forDisplayDepth: forDisplayDepth + 1,
                     }),
+                };
+            }, {});
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////
+            // end:reduce over all associated serializers, recursively building out their associated serializers //
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////
+            accumulator[association.as] = {
+                parentDreamClass: this,
+                nestedSerializerInfo: serializerAssociation.type === 'delegatedAttribute' ? {} : innerAssociationSerializerInfo,
             };
-            return acc;
+            return accumulator;
         }, {});
     }
     /**
@@ -657,11 +679,57 @@ export default class Dream {
         return map;
     }
     /**
-     * @internal
+     * Checks whether the specified association has been defined on this Dream model.
+     *
+     * ```ts
+     * const user = User.new()
+     *
+     * user.hasAssociation('posts')
+     * // true (if User has a posts association defined)
+     *
+     * user.hasAssociation('nonExistentAssociation')
+     * // false
+     *
+     * // Useful for conditional association handling
+     * if (user.hasAssociation('posts')) {
+     *   user = await user.load('posts').execute()
+     * }
+     * ```
+     *
+     * @param associationName - The name of the association to check for
+     * @returns `true` if the association exists on this model, `false` otherwise
+     */
+    hasAssociation(associationName) {
+        return !!(this.associationMetadataByType.belongsTo.find(association => association.as === associationName) ||
+            this.associationMetadataByType.hasOne.find(association => association.as === associationName) ||
+            this.associationMetadataByType.hasMany.find(association => association.as === associationName));
+    }
+    /**
+     * Returns all of the association names for this Dream class.
+     * This includes all BelongsTo, HasOne, and HasMany associations
+     * defined on the model.
      *
-     * Returns all of the association names for this dream class
+     * This is useful for introspection, debugging, or dynamically working
+     * with all associations on a model.
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   @deco.HasMany('Post')
+     *   public posts: Post[]
+     *
+     *   @deco.HasOne('Profile')
+     *   public profile: Profile
+     *
+     *   @deco.BelongsTo('Company')
+     *   public company: Company
+     * }
+     *
+     * User.associationNames
+     * // ['posts', 'profile', 'company']
+     * })
+     * ```
      *
-     * @returns All of the association names for this dream class
+     * @returns An array containing all association names defined on this Dream class
      */
     static get associationNames() {
         const allAssociations = [

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

@@ -7,8 +7,12 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';
+const UNIQUE_CONSTRAINT_VIOLATION = 'UNIQUE_CONSTRAINT_VIOLATION';
+const INVALID_INPUT_SYNTAX = 'INVALID_INPUT_SYNTAX';
 export const PG_ERRORS = {
-    23505: 'UNIQUE_CONSTRAINT_VIOLATION',
+    '23505': UNIQUE_CONSTRAINT_VIOLATION,
+    '22P02': INVALID_INPUT_SYNTAX,
+    '22007': INVALID_INPUT_SYNTAX,
 };
 function pgErrorFromCode(code) {
     return PG_ERRORS[code] || null;

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

@@ -3,6 +3,7 @@ import pluralize from 'pluralize-esm';
 import writeSyncFile from '../../bin/helpers/sync.js';
 import { CliFileWriter } from '../../cli/CliFileWriter.js';
 import DreamCLI from '../../cli/index.js';
+import { pgErrorType } from '../../db/errors.js';
 import _db from '../../db/index.js';
 import associationToGetterSetterProp from '../../decorators/field/association/associationToGetterSetterProp.js';
 import PackageManager from '../../dream-app/helpers/PackageManager.js';
@@ -17,6 +18,7 @@ import MissingThroughAssociationSource from '../../errors/associations/MissingTh
 import ThroughAssociationConditionsIncompatibleWithThroughAssociationSource from '../../errors/associations/ThroughAssociationConditionsIncompatibleWithThroughAssociationSource.js';
 import CannotNegateSimilarityClause from '../../errors/CannotNegateSimilarityClause.js';
 import CannotPassUndefinedAsAValueToAWhereClause from '../../errors/CannotPassUndefinedAsAValueToAWhereClause.js';
+import DataTypeColumnTypeMismatch from '../../errors/db/DataTypeColumnTypeMismatch.js';
 import UnexpectedUndefined from '../../errors/UnexpectedUndefined.js';
 import CalendarDate from '../../helpers/CalendarDate.js';
 import camelize from '../../helpers/camelize.js';
@@ -29,6 +31,7 @@ import _dropDb from '../../helpers/db/dropDb.js';
 import loadPgClient from '../../helpers/db/loadPgClient.js';
 import runMigration from '../../helpers/db/runMigration.js';
 import EnvInternal from '../../helpers/EnvInternal.js';
+import groupBy from '../../helpers/groupBy.js';
 import isEmpty from '../../helpers/isEmpty.js';
 import namespaceColumn from '../../helpers/namespaceColumn.js';
 import normalizeUnicode from '../../helpers/normalizeUnicode.js';
@@ -413,19 +416,31 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     static async saveDream(dream, txn = null) {
         const db = txn?.kyselyTransaction ?? _db('primary');
         const sqlifiedAttributes = sqlAttributes(dream);
-        if (dream.isPersisted) {
-            const query = db
-                .updateTable(dream.table)
-                .set(sqlifiedAttributes)
-                .where(namespaceColumn(dream.primaryKey, dream.table), '=', dream.primaryKeyValue);
-            return await executeDatabaseQuery(query.returning([...dream.columns()]), 'executeTakeFirstOrThrow');
+        try {
+            if (dream.isPersisted) {
+                const query = db
+                    .updateTable(dream.table)
+                    .set(sqlifiedAttributes)
+                    .where(namespaceColumn(dream.primaryKey, dream.table), '=', dream.primaryKeyValue);
+                return await executeDatabaseQuery(query.returning([...dream.columns()]), 'executeTakeFirstOrThrow');
+            }
+            else {
+                const query = db
+                    .insertInto(dream.table)
+                    .values(sqlifiedAttributes)
+                    .returning([...dream.columns()]);
+                return await executeDatabaseQuery(query, 'executeTakeFirstOrThrow');
+            }
         }
-        else {
-            const query = db
-                .insertInto(dream.table)
-                .values(sqlifiedAttributes)
-                .returning([...dream.columns()]);
-            return await executeDatabaseQuery(query, 'executeTakeFirstOrThrow');
+        catch (error) {
+            switch (pgErrorType(error)) {
+                case 'INVALID_INPUT_SYNTAX':
+                    throw new DataTypeColumnTypeMismatch({
+                        dream,
+                        error: error instanceof Error ? error : new Error('database column type error'),
+                    });
+            }
+            throw error;
         }
     }
     dbConnectionType(sqlCommandType) {
@@ -1188,7 +1203,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         const keys = Object.keys(preloadStatement);
         for (const key of keys) {
             const nestedDreams = await this.applyOnePreload(key, dream, this.applyablePreloadOnStatements(preloadOnStatements[key]));
-            if (nestedDreams) {
+            if (nestedDreams.length) {
                 await this.applyPreload(preloadStatement[key], preloadOnStatements[key], nestedDreams);
             }
         }
@@ -1683,18 +1698,10 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      *
      * Used to preload polymorphic belongs to associations
      */
-    async preloadPolymorphicBelongsTo(association, dreams) {
-        if (!association.polymorphic)
-            throw new Error(`Association ${association.as} points to an array of models but is not designated polymorphic`);
-        if (association.type !== 'BelongsTo')
-            throw new Error(`Polymorphic association ${association.as} points to an array of models but is ${association.type}. Only BelongsTo associations may point to an array of models.`);
-        const nestedDreamsForNextRoundOfPreloading = [];
-        for (const associatedModel of association.modelCB()) {
-            await this.preloadPolymorphicAssociationModel(dreams, association, associatedModel, nestedDreamsForNextRoundOfPreloading);
-        }
-        return nestedDreamsForNextRoundOfPreloading;
+    async preloadPolymorphicBelongsTo(association, associatedModels, dreams) {
+        return compact(await Promise.all(associatedModels.map(associatedModel => this.preloadPolymorphicAssociationModel(dreams, association, associatedModel)))).flat();
     }
-    async preloadPolymorphicAssociationModel(dreams, association, associatedDreamClass, nestedDreamsForNextRoundOfPreloading) {
+    async preloadPolymorphicAssociationModel(dreams, association, associatedDreamClass) {
         const relevantAssociatedModels = dreams.filter((dream) => {
             const field = association.foreignKeyTypeField();
             return dream[field] === associatedDreamClass['stiBaseClassOrOwnClassName'] || dream[field] === null;
@@ -1713,7 +1720,6 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 [associatedDreamClass.primaryKey]: relevantAssociatedModels.map((dream) => dream[association.foreignKey()]),
             })
                 .all();
-            loadedAssociations.forEach((loadedAssociation) => nestedDreamsForNextRoundOfPreloading.push(loadedAssociation));
             //////////////////////////////////////////////////////////////////////////////////////////////
             // Associate each loaded association with each dream based on primary key and foreign key type
             //////////////////////////////////////////////////////////////////////////////////////////////
@@ -1728,6 +1734,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             // end: Associate each loaded association with each dream based on primary key and foreign key type
             ///////////////////////////////////////////////////////////////////////////////////////////////////
+            return loadedAssociations;
         }
     }
     /**
@@ -1766,12 +1773,18 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      *
      * Applies a preload statement
      */
-    async applyOnePreload(associationName, dreams, onStatement = {}) {
+    async applyOnePreload(associationNameAndMaybeAlias, dreams, onStatement = {}) {
         if (!Array.isArray(dreams))
             dreams = [dreams];
-        const dream = dreams.find(dream => dream['getAssociationMetadata'](associationName));
-        if (!dream)
-            return;
+        const { name: associationName } = associationStringToNameAndAlias(associationNameAndMaybeAlias);
+        dreams = dreams.filter(dream => dream.hasAssociation(associationName));
+        const groupedDreams = groupBy(dreams, dream => dream.sanitizedConstructorName);
+        return (await Promise.all(Object.keys(groupedDreams).map(key => this._applyOnePreload(associationName, groupedDreams[key], onStatement)))).flat();
+    }
+    async _applyOnePreload(associationName, dreams, onStatement = {}) {
+        if (!dreams.length)
+            return [];
+        const dream = dreams[0];
         const { name, alias: _alias } = associationStringToNameAndAlias(associationName);
         const alias = _alias || name;
         const association = dream['getAssociationMetadata'](name);
@@ -1779,8 +1792,10 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             throw new UnexpectedUndefined();
         const dreamClass = dream.constructor;
         const dreamClassToHydrate = association.modelCB();
-        if ((association.polymorphic && association.type === 'BelongsTo') || Array.isArray(dreamClassToHydrate))
-            return this.preloadPolymorphicBelongsTo(association, dreams);
+        if (Array.isArray(dreamClassToHydrate)) {
+            const preloadedPolymorphicBelongsTos = await this.preloadPolymorphicBelongsTo(association, dreamClassToHydrate, dreams);
+            return preloadedPolymorphicBelongsTos;
+        }
         const dreamClassToHydrateColumns = [...dreamClassToHydrate.columns()];
         const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), alias));
         columnsToPluck.push(this.namespaceColumn(dreamClass.primaryKey, dreamClass.table));

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

@@ -0,0 +1,14 @@
+import yoctocolors from 'yoctocolors';
+import { indent } from '../../helpers/indent.js';
+export default function printSerializerHierarchyLevel({ serializerAssociationType, serializerAssociationName, associationSerializer, forDisplayDepth, }) {
+    const hierarchyLine = '└───';
+    const indentation = indent((hierarchyLine.length + 1) * forDisplayDepth, {
+        tabWidth: 1,
+    });
+    const prefix = `${hierarchyLine} `;
+    const nestedAssociationDisplay = indentation + `${prefix}${serializerAssociationType} ${yoctocolors.cyan(serializerAssociationName)}`;
+    console.log(nestedAssociationDisplay);
+    console.log(yoctocolors.gray(indentation +
+        indent(prefix.length, { tabWidth: 1 }) +
+        associationSerializer.globalName));
+}

package/dist/esm/src/dream-app/cache.js

@@ -1,9 +1,19 @@
+import EnvInternal from '../helpers/EnvInternal.js';
 let _dreamApp = undefined;
 export function cacheDreamApp(dreamconf) {
     _dreamApp = dreamconf;
 }
 export function getCachedDreamAppOrFail() {
-    if (!_dreamApp)
-        throw new Error('Must call `initializeDreamApp` or `initializePsychicApp` before loading cached DreamApp.getOrFail()');
+    if (!_dreamApp) {
+        const baseErrorMessage = 'Must call `initializeDreamApp` or `initializePsychicApp` before loading cached DreamApp.getOrFail().';
+        if (EnvInternal.isTest) {
+            throw new Error(`${baseErrorMessage}
+
+Check for specs running directly in a \`describe\` or \`context\` block rather than nested within an \`it\` block.`);
+        }
+        else {
+            throw new Error(baseErrorMessage);
+        }
+    }
     return _dreamApp;
 }

package/dist/esm/src/errors/db/DataTypeColumnTypeMismatch.js

@@ -0,0 +1,16 @@
+export default class DataTypeColumnTypeMismatch extends Error {
+    dream;
+    error;
+    constructor({ dream, error }) {
+        super();
+        this.dream = dream;
+        this.error = error;
+    }
+    get message() {
+        return `\
+Failed to save ${this.dream.sanitizedConstructorName}:
+
+${this.error.message}
+`;
+    }
+}

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

@@ -19,6 +19,7 @@ export default async function generateMigration({ migrationName, columnsWithType
             table: snakeify(pluralize(pascalizePath(fullyQualifiedParentName))),
             columnsWithTypes,
             primaryKeyType: primaryKeyType(),
+            stiChildClassName: pascalizePath(fullyQualifiedModelName),
         });
     }
     else if (fullyQualifiedModelName) {

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

@@ -5,13 +5,17 @@ import foreignKeyTypeFromPrimaryKey from '../db/foreignKeyTypeFromPrimaryKey.js'
 import snakeify from '../snakeify.js';
 const STI_TYPE_COLUMN_NAME = 'type';
 const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME];
-export default function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', } = {}) {
+export default function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', stiChildClassName, } = {}) {
     const altering = createOrAlter === 'alter';
     let requireCitextExtension = false;
-    const { columnDefs, columnDrops, indexDefs, indexDrops } = columnsWithTypes.reduce((acc, attribute) => {
+    const checkConstraints = [];
+    const { columnDefs, columnDrops, indexDefs, indexDrops } = columnsWithTypes.reduce((acc, attributeDeclaration) => {
         const { columnDefs, columnDrops, indexDefs, indexDrops } = acc;
-        const [nonStandardAttributeName, attributeType, ...descriptors] = attribute.split(':');
-        const optional = optionalFromDescriptors(descriptors);
+        const [nonStandardAttributeName, attributeType, ...descriptors] = attributeDeclaration.split(':');
+        const userWantsThisOptional = optionalFromDescriptors(descriptors);
+        // when creating a migration for an STI child, we don't want to include notNull;
+        // instead, we'll add a check constraint that uses the STI child class name
+        const optional = userWantsThisOptional || !!stiChildClassName;
         const sqlAttributeType = getAttributeType(attributeType, descriptors);
         let attributeName = snakeify(nonStandardAttributeName);
         if (attributeName === undefined)
@@ -20,6 +24,17 @@ export default function generateMigrationContent({ table, columnsWithTypes = [],
             return acc;
         if (attributeType === 'citext')
             requireCitextExtension = true;
+        if (stiChildClassName && !userWantsThisOptional) {
+            checkConstraints.push(`
+
+  await db.schema
+    .alterTable('${table}')
+    .addCheckConstraint(
+      '${table}_not_null_${attributeName}',
+      sql\`type != '${stiChildClassName}' OR ${attributeName} IS NOT NULL\`,
+    )
+    .execute()`);
+        }
         switch (attributeType) {
             case 'belongs_to':
                 columnDefs.push(generateBelongsToStr(attributeName, {
@@ -96,7 +111,7 @@ ${citextExtension}${generateEnumStatements(columnsWithTypes)}  await db.schema
             ".addColumn('created_at', 'timestamp', col => col.notNull())" +
             newlineDoubleIndent +
             ".addColumn('updated_at', 'timestamp', col => col.notNull())"}
-    .execute()${indexDefs.length ? `\n${newlineIndent}` : ''}${indexDefs.join(newlineDoubleIndent)}
+    .execute()${indexDefs.length ? `\n${newlineIndent}` : ''}${indexDefs.join(newlineDoubleIndent)}${checkConstraints.join('')}
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

@@ -1,4 +1,10 @@
 import generateMigrationContent from './generateMigrationContent.js';
-export default function generateStiMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', } = {}) {
-    return generateMigrationContent({ table, columnsWithTypes, primaryKeyType, createOrAlter: 'alter' });
+export default function generateStiMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', stiChildClassName, }) {
+    return generateMigrationContent({
+        table,
+        columnsWithTypes,
+        primaryKeyType,
+        createOrAlter: 'alter',
+        stiChildClassName,
+    });
 }

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

@@ -37,6 +37,12 @@ export default function sqlAttributes(dream) {
         return result;
     }, {});
 }
+/**
+ * Convert datetimes to UTC
+ */
 function valueToDatetime(val) {
-    return typeof val === 'string' ? DateTime.fromISO(val, { zone: 'UTC' }) : val;
+    if (typeof val !== 'string')
+        return val;
+    const datetime = DateTime.fromISO(val, { zone: 'UTC' });
+    return datetime.isValid ? datetime : val;
 }

package/dist/esm/src/index.js

@@ -21,6 +21,7 @@ export { default as Query } from './dream/Query.js';
 export { default as Encrypt } from './encrypt/index.js';
 export { default as NonLoadedAssociation } from './errors/associations/NonLoadedAssociation.js';
 export { default as CreateOrFindByFailedToCreateAndFind } from './errors/CreateOrFindByFailedToCreateAndFind.js';
+export { default as DataTypeColumnTypeMismatch } from './errors/db/DataTypeColumnTypeMismatch.js';
 export { default as GlobalNameNotSet } from './errors/dream-app/GlobalNameNotSet.js';
 export { default as RecordNotFound } from './errors/RecordNotFound.js';
 export { default as ValidationError } from './errors/ValidationError.js';

package/dist/esm/src/serializer/helpers/serializerForAssociatedClass.js

@@ -11,7 +11,8 @@ export function serializerForAssociatedClass(object, associationName, options) {
         return null;
     const dream = object;
     const association = dream['getAssociationMetadata'](associationName);
-    const associatedClasses = association.modelCB();
-    const associatedClass = Array.isArray(associatedClasses) ? associatedClasses[0] : associatedClasses;
+    const associatedClass = association.modelCB();
+    if (Array.isArray(associatedClass))
+        throw new Error('rendersOne flatten is incompatible with a polymorphic belongs-to association');
     return inferSerializersFromDreamClassOrViewModelClass(associatedClass, options.serializerKey)[0] ?? null;
 }