@rvoh/dream 2.3.0-alpha.6 → 2.3.0-alpha.8

package/dist/cjs/src/Dream.js

@@ -44,14 +44,13 @@ import DreamMissingRequiredOverride from './errors/DreamMissingRequiredOverride.
 import NonExistentScopeProvidedToResort from './errors/NonExistentScopeProvidedToResort.js';
 import RecordNotFound from './errors/RecordNotFound.js';
 import MissingSerializersDefinition from './errors/serializers/MissingSerializersDefinition.js';
+import areEqual from './helpers/areEqual.js';
 import cloneDeepSafe from './helpers/cloneDeepSafe.js';
 import compact from './helpers/compact.js';
 import cachedTypeForAttribute from './helpers/db/cachedTypeForAttribute.js';
 import isJsonColumn from './helpers/db/types/isJsonColumn.js';
 import notEqual from './helpers/notEqual.js';
 import { inferSerializersFromDreamClassOrViewModelClass } from './serializer/helpers/inferSerializerFromDreamOrViewModel.js';
-import CalendarDate from './utils/datetime/CalendarDate.js';
-import { DateTime } from './utils/datetime/DateTime.js';
 const RECURSIVE_SERIALIZATION_MAX_REPEATS = 4;
 export default class Dream {
     DB;
@@ -2890,7 +2889,6 @@ export default class Dream {
     dirtyAttributes() {
         const obj = {};
         this.columns().forEach(column => {
-            // TODO: clean up types
             if (this.attributeIsDirty(column))
                 obj[column] = this.getAttribute(column);
         });
@@ -2902,45 +2900,9 @@ export default class Dream {
      * @returns A boolean
      */
     attributeIsDirty(attribute) {
-        const frozenValue = this.frozenAttributes[attribute];
-        const currentValue = this.getAttribute(attribute);
         if (this.isNewRecord)
             return true;
-        if (frozenValue instanceof DateTime) {
-            return frozenValue.toMicroseconds() !== this.unknownValueToMicroseconds(currentValue);
-        }
-        else if (frozenValue instanceof CalendarDate) {
-            return frozenValue.toISO() !== this.unknownValueToDateString(currentValue);
-        }
-        else {
-            return frozenValue !== currentValue;
-        }
-    }
-    /**
-     * @internal
-     */
-    unknownValueToMicroseconds(currentValue) {
-        if (!currentValue)
-            return;
-        if (typeof currentValue === 'string')
-            currentValue = DateTime.fromISO(currentValue);
-        if (currentValue instanceof CalendarDate)
-            currentValue = currentValue.toDateTime();
-        if (currentValue instanceof DateTime)
-            return currentValue.toMicroseconds();
-    }
-    /**
-     * @internal
-     */
-    unknownValueToDateString(currentValue) {
-        if (!currentValue)
-            return;
-        if (typeof currentValue === 'string')
-            currentValue = CalendarDate.fromISO(currentValue);
-        if (currentValue instanceof DateTime)
-            currentValue = CalendarDate.fromDateTime(currentValue);
-        if (currentValue instanceof CalendarDate)
-            return currentValue.toISO();
+        return !areEqual(this.frozenAttributes[attribute], this.getAttribute(attribute));
     }
     /**
      * Deletes the record represented by this instance

package/dist/cjs/src/cli/index.js

@@ -32,6 +32,10 @@ ${INDENT}    - date
 ${INDENT}    - date[]
 ${INDENT}    - datetime
 ${INDENT}    - datetime[]
+${INDENT}    - time
+${INDENT}    - time[]
+${INDENT}    - timetz
+${INDENT}    - timetz[]
 ${INDENT}    - integer
 ${INDENT}    - integer[]
 ${INDENT}

package/dist/cjs/src/dream/Query.js

@@ -15,6 +15,7 @@ import cloneDeepSafe from '../helpers/cloneDeepSafe.js';
 import isObject from '../helpers/isObject.js';
 import namespaceColumn from '../helpers/namespaceColumn.js';
 import protectAgainstPollutingAssignment from '../helpers/protectAgainstPollutingAssignment.js';
+import { toSafeObject } from '../helpers/toSafeObject.js';
 import ops from '../ops/index.js';
 import computedPaginatePage from './internal/computedPaginatePage.js';
 import convertDreamClassAndAssociationNameTupleArrayToPreloadArgs from './internal/convertDreamClassAndAssociationNameTupleArrayToPreloadArgs.js';
@@ -543,8 +544,8 @@ export default class Query {
      */
     innerJoin(...args) {
         const innerJoinDreamClasses = [...this.innerJoinDreamClasses];
-        const innerJoinStatements = cloneDeepSafe(this.innerJoinStatements);
-        const innerJoinAndStatements = cloneDeepSafe(this.innerJoinAndStatements);
+        const innerJoinStatements = toSafeObject(cloneDeepSafe(this.innerJoinStatements));
+        const innerJoinAndStatements = toSafeObject(cloneDeepSafe(this.innerJoinAndStatements));
         this.fleshOutJoinStatements(innerJoinDreamClasses, innerJoinStatements, innerJoinAndStatements, null, [...args]);
         return this.clone({
             innerJoinDreamClasses,
@@ -560,8 +561,8 @@ export default class Query {
      */
     leftJoin(...args) {
         const innerJoinDreamClasses = [...this.innerJoinDreamClasses];
-        const leftJoinStatements = cloneDeepSafe(this.leftJoinStatements);
-        const leftJoinAndStatements = cloneDeepSafe(this.leftJoinAndStatements);
+        const leftJoinStatements = toSafeObject(cloneDeepSafe(this.leftJoinStatements));
+        const leftJoinAndStatements = toSafeObject(cloneDeepSafe(this.leftJoinAndStatements));
         this.fleshOutJoinStatements(innerJoinDreamClasses, leftJoinStatements, leftJoinAndStatements, null, [
             ...args,
         ]);
@@ -582,13 +583,15 @@ export default class Query {
         }
         else if (typeof nextAssociationStatement === 'string') {
             const nextStatement = nextAssociationStatement;
-            if (!joinStatements[nextStatement])
-                joinStatements[protectAgainstPollutingAssignment(nextStatement)] = {};
-            if (!joinAndStatements[nextStatement])
-                joinAndStatements[protectAgainstPollutingAssignment(nextStatement)] = {};
+            const safeKey = protectAgainstPollutingAssignment(nextStatement);
+            // Use prototype-less containers so assigning untrusted keys cannot pollute Object.prototype.
+            if (!joinStatements[safeKey])
+                joinStatements[safeKey] = Object.create(null);
+            if (!joinAndStatements[safeKey])
+                joinAndStatements[safeKey] = Object.create(null);
             const nextDreamClass = this.addAssociatedDreamClassToInnerJoinDreamClasses(previousDreamClass, nextStatement, innerJoinDreamClasses);
-            const nextJoinsStatements = joinStatements[nextStatement];
-            const nextJoinsOnStatements = joinAndStatements[nextStatement];
+            const nextJoinsStatements = joinStatements[safeKey];
+            const nextJoinsOnStatements = joinAndStatements[safeKey];
             this.fleshOutJoinStatements(innerJoinDreamClasses, nextJoinsStatements, nextJoinsOnStatements, nextStatement, associationStatements, nextDreamClass);
             //
         }
@@ -598,7 +601,7 @@ export default class Query {
                 this.addAssociatedDreamClassToInnerJoinDreamClasses(previousDreamClass, associationName, innerJoinDreamClasses);
             });
             nextAssociationStatement.forEach(associationStatement => {
-                joinStatements[protectAgainstPollutingAssignment(associationStatement)] = {};
+                joinStatements[protectAgainstPollutingAssignment(associationStatement)] = Object.create(null);
             });
             //
         }

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

@@ -1,5 +1,3 @@
-import CalendarDate from '../../utils/datetime/CalendarDate.js';
-import { DateTime } from '../../utils/datetime/DateTime.js';
 export default class QueryDriverBase {
     query;
     dreamClass;
@@ -176,18 +174,6 @@ export default class QueryDriverBase {
     allTableAssociationData) {
         throw new Error('implement getColumnData in child class');
     }
-    static serializeDbType(type, val) {
-        switch (type) {
-            case 'datetime':
-            case 'date':
-                if (val instanceof DateTime || val instanceof CalendarDate) {
-                    return val.toSQL();
-                }
-                throw new Error(`unrecognized value found when trying to serialize for date/datetime: ${val}`);
-            default:
-                return val;
-        }
-    }
     /**
      * @internal
      *

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

@@ -17,6 +17,7 @@ import { default as _db } from '../../db/index.js';
 import associationToGetterSetterProp from '../../decorators/field/association/associationToGetterSetterProp.js';
 import PackageManager from '../../dream-app/helpers/PackageManager.js';
 import DreamApp from '../../dream-app/index.js';
+import Dream from '../../Dream.js';
 import ArrayTargetIncompatibleWithThroughAssociation from '../../errors/associations/ArrayTargetIncompatibleWithThroughAssociation.js';
 import CannotJoinPolymorphicBelongsToError from '../../errors/associations/CannotJoinPolymorphicBelongsToError.js';
 import JoinAttemptedOnMissingAssociation from '../../errors/associations/JoinAttemptedOnMissingAssociation.js';
@@ -37,12 +38,12 @@ import ASTGlobalSchemaBuilder from '../../helpers/cli/ASTGlobalSchemaBuilder.js'
 import ASTSchemaBuilder from '../../helpers/cli/ASTSchemaBuilder.js';
 import generateMigration from '../../helpers/cli/generateMigration.js';
 import compact from '../../helpers/compact.js';
+import { normalizeDataForDb } from '../../helpers/db/normalizeDataForDb.js';
 import EnvInternal from '../../helpers/EnvInternal.js';
 import groupBy from '../../helpers/groupBy.js';
 import isEmpty from '../../helpers/isEmpty.js';
 import maybeNamespacedColumnNameToColumnName from '../../helpers/maybeNamespacedColumnNameToColumnName.js';
 import namespaceColumn from '../../helpers/namespaceColumn.js';
-import normalizeUnicode from '../../helpers/normalizeUnicode.js';
 import objectPathsToArrays from '../../helpers/objectPathsToArrays.js';
 import pascalize from '../../helpers/pascalize.js';
 import protectAgainstPollutingAssignment from '../../helpers/protectAgainstPollutingAssignment.js';
@@ -52,13 +53,12 @@ import sqlAttributes from '../../helpers/sqlAttributes.js';
 import uniq from '../../helpers/uniq.js';
 import CurriedOpsStatement from '../../ops/curried-ops-statement.js';
 import OpsStatement from '../../ops/ops-statement.js';
-import CalendarDate from '../../utils/datetime/CalendarDate.js';
-import { DateTime } from '../../utils/datetime/DateTime.js';
 import { DreamConst, primaryKeyTypes } from '../constants.js';
 import DreamTransaction from '../DreamTransaction.js';
 import throughAssociationHasOptionsBesidesThroughAndSource from '../internal/associations/throughAssociationHasOptionsBesidesThroughAndSource.js';
 import associationStringToNameAndAlias from '../internal/associationStringToNameAndAlias.js';
 import executeDatabaseQuery from '../internal/executeDatabaseQuery.js';
+import extractAssignableAssociationAttributes from '../internal/extractAssignableAssociationAttributes.js';
 import orderByDirection from '../internal/orderByDirection.js';
 import shouldBypassDefaultScope from '../internal/shouldBypassDefaultScope.js';
 import SimilarityBuilder from '../internal/similarity/SimilarityBuilder.js';
@@ -614,25 +614,13 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         catch (error) {
             switch (pgErrorType(error)) {
                 case COLUMN_OVERFLOW:
-                    throw new ColumnOverflow({
-                        dream,
-                        error: error instanceof Error ? error : new Error('database column overflow'),
-                    });
+                    throw new ColumnOverflow(error instanceof Error ? error : new Error('database column overflow'));
                 case INVALID_INPUT_SYNTAX:
-                    throw new DataTypeColumnTypeMismatch({
-                        dream,
-                        error: error instanceof Error ? error : new Error('database column type error'),
-                    });
+                    throw new DataTypeColumnTypeMismatch(error instanceof Error ? error : new Error('database column type error'));
                 case NOT_NULL_VIOLATION:
-                    throw new NotNullViolation({
-                        dream,
-                        error: error instanceof Error ? error : new Error('not null violation'),
-                    });
+                    throw new NotNullViolation(error instanceof Error ? error : new Error('not null violation'));
                 case CHECK_VIOLATION:
-                    throw new CheckConstraintViolation({
-                        dream,
-                        error: error instanceof Error ? error : new Error('check constraint violation'),
-                    });
+                    throw new CheckConstraintViolation(error instanceof Error ? error : new Error('check constraint violation'));
             }
             throw error;
         }
@@ -959,35 +947,35 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         });
         return dream;
     }
-    applyJoinAndStatement(join, joinAndStatement, rootTableOrAssociationAlias) {
+    applyJoinAndStatement(dreamClass, join, joinAndStatement, rootTableOrAssociationAlias) {
         if (!joinAndStatement)
             return join;
-        join = this._applyJoinAndStatements(join, joinAndStatement.and, rootTableOrAssociationAlias);
-        join = this._applyJoinAndStatements(join, joinAndStatement.andNot, rootTableOrAssociationAlias, {
+        join = this._applyJoinAndStatements(dreamClass, join, joinAndStatement.and, rootTableOrAssociationAlias);
+        join = this._applyJoinAndStatements(dreamClass, join, joinAndStatement.andNot, rootTableOrAssociationAlias, {
             negate: true,
         });
-        join = this._applyJoinAndAnyStatements(join, joinAndStatement.andAny, rootTableOrAssociationAlias);
+        join = this._applyJoinAndAnyStatements(dreamClass, join, joinAndStatement.andAny, rootTableOrAssociationAlias);
         return join;
     }
-    _applyJoinAndStatements(join, joinAndStatement, rootTableOrAssociationAlias, { negate = false, } = {}) {
+    _applyJoinAndStatements(dreamClass, join, joinAndStatement, rootTableOrAssociationAlias, { negate = false, } = {}) {
         if (!joinAndStatement)
             return join;
-        return join.on((eb) => this.joinAndStatementToExpressionWrapper(joinAndStatement, rootTableOrAssociationAlias, eb, {
+        return join.on((eb) => this.joinAndStatementToExpressionWrapper(dreamClass, joinAndStatement, rootTableOrAssociationAlias, eb, {
             negate,
             disallowSimilarityOperator: negate,
         }));
     }
-    _applyJoinAndAnyStatements(join, joinAndAnyStatement, rootTableOrAssociationAlias) {
+    _applyJoinAndAnyStatements(dreamClass, join, joinAndAnyStatement, rootTableOrAssociationAlias) {
         if (!joinAndAnyStatement)
             return join;
         if (!joinAndAnyStatement.length)
             return join;
         return join.on((eb) => {
-            return eb.or(joinAndAnyStatement.map(joinAndStatement => this.joinAndStatementToExpressionWrapper(joinAndStatement, rootTableOrAssociationAlias, eb)));
+            return eb.or(joinAndAnyStatement.map(joinAndStatement => this.joinAndStatementToExpressionWrapper(dreamClass, joinAndStatement, rootTableOrAssociationAlias, eb)));
         });
     }
-    joinAndStatementToExpressionWrapper(joinAndStatement, rootTableOrAssociationAlias, eb, { negate = false, disallowSimilarityOperator = true, } = {}) {
-        return this.whereStatementToExpressionWrapper(eb, Object.keys(joinAndStatement).reduce((agg, key) => {
+    joinAndStatementToExpressionWrapper(dreamClass, joinAndStatement, rootTableOrAssociationAlias, eb, { negate = false, disallowSimilarityOperator = true, } = {}) {
+        return this.whereStatementToExpressionWrapper(dreamClass, eb, Object.keys(joinAndStatement).reduce((agg, key) => {
             agg[this.namespaceColumn(key.toString(), rootTableOrAssociationAlias)] = joinAndStatement[key];
             return agg;
         }, {}), {
@@ -1032,16 +1020,18 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             query['whereNotStatements'].length ||
             query['whereAnyStatements'].length) {
             kyselyQuery = kyselyQuery.where((eb) => eb.and([
-                ...this.aliasWhereStatements(query['whereStatements'], query['baseSqlAlias']).map(whereStatement => this.whereStatementToExpressionWrapper(eb, whereStatement, {
+                ...this.aliasWhereStatements(query['whereStatements'], query['baseSqlAlias']).map(whereStatement => this.whereStatementToExpressionWrapper(this.dreamClass, eb, whereStatement, {
                     disallowSimilarityOperator: false,
                 })),
-                ...this.aliasWhereStatements(query['whereNotStatements'], query['baseSqlAlias']).map(whereNotStatement => this.whereStatementToExpressionWrapper(eb, whereNotStatement, { negate: true })),
-                ...query['whereAnyStatements'].map(whereAnyStatements => eb.or(this.aliasWhereStatements(whereAnyStatements, query['baseSqlAlias']).map(whereAnyStatement => this.whereStatementToExpressionWrapper(eb, whereAnyStatement)))),
+                ...this.aliasWhereStatements(query['whereNotStatements'], query['baseSqlAlias']).map(whereNotStatement => this.whereStatementToExpressionWrapper(this.dreamClass, eb, whereNotStatement, {
+                    negate: true,
+                })),
+                ...query['whereAnyStatements'].map(whereAnyStatements => eb.or(this.aliasWhereStatements(whereAnyStatements, query['baseSqlAlias']).map(whereAnyStatement => this.whereStatementToExpressionWrapper(this.dreamClass, eb, whereAnyStatement)))),
             ]));
         }
         return kyselyQuery;
     }
-    whereStatementToExpressionWrapper(eb, whereStatement, { negate = false, disallowSimilarityOperator = true, } = {}) {
+    whereStatementToExpressionWrapper(dreamClass, eb, whereStatement, { negate = false, disallowSimilarityOperator = true, } = {}) {
         const clauses = compact(Object.keys(whereStatement)
             .filter(key => whereStatement[key] !== DreamConst.required)
             .map(attr => {
@@ -1054,7 +1044,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 // and should be ommited from the where clause directly
                 return;
             }
-            const { a, b, c, a2, b2, c2 } = this.dreamWhereStatementToExpressionBuilderParts(attr, val);
+            const { a, b, c, a2, b2, c2 } = this.dreamWhereStatementToExpressionBuilderParts(dreamClass, attr, val);
             // postgres is unable to handle WHERE IN statements with blank arrays, such as in
             // "WHERE id IN ()", meaning that:
             // 1. If we receive a blank array during an IN comparison,
@@ -1138,23 +1128,36 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             return eb.and([eb(a, 'not in', compactedC), isNotNullStatement]);
         return isNotNullStatement;
     }
-    dreamWhereStatementToExpressionBuilderParts(attr, val) {
+    dreamWhereStatementToExpressionBuilderParts(dreamClass, attr, val) {
         let a;
         let b;
         let c;
         let a2 = null;
         let b2 = null;
         let c2 = null;
+        const isolatedColumn = maybeNamespacedColumnNameToColumnName(attr);
         if (val instanceof Function && val !== DreamConst.passthrough) {
             val = val();
         }
         else if (val === DreamConst.passthrough) {
-            const column = maybeNamespacedColumnNameToColumnName(attr);
-            if (this.query['passthroughOnStatement'][column] === undefined)
-                throw new MissingRequiredPassthroughForAssociationAndClause(column);
-            val = this.query['passthroughOnStatement'][column];
+            if (this.query['passthroughOnStatement'][isolatedColumn] === undefined)
+                throw new MissingRequiredPassthroughForAssociationAndClause(isolatedColumn);
+            val = this.query['passthroughOnStatement'][isolatedColumn];
+        }
+        if (dreamClass.associationNames.includes(isolatedColumn) && val instanceof Dream) {
+            const association = dreamClass['associationMetadataMap']()[isolatedColumn];
+            const associationAttrs = extractAssignableAssociationAttributes(association, val);
+            const attrKeys = Object.keys(associationAttrs);
+            a = attrKeys[0];
+            b = '=';
+            c = associationAttrs[attrKeys[0]];
+            if (attrKeys.length > 1) {
+                a2 = attrKeys[1];
+                b2 = '=';
+                c2 = associationAttrs[attrKeys[1]];
+            }
         }
-        if (val === null) {
+        else if (val === null) {
             a = attr;
             b = 'is';
             c = val;
@@ -1167,14 +1170,10 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         else if (Array.isArray(val)) {
             a = attr;
             b = 'in';
-            c = val.map(v => v instanceof DateTime || v instanceof CalendarDate
-                ? v.toSQL()
-                : typeof v === 'string'
-                    ? normalizeUnicode(v)
-                    : v);
+            c = val;
         }
         else if (val instanceof CurriedOpsStatement) {
-            val = val.toOpsStatement(this.dreamClass, attr);
+            val = val.toOpsStatement(dreamClass, attr);
             a = attr;
             b = val.operator;
             c = val.value;
@@ -1212,20 +1211,21 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             b = '=';
             c = val;
         }
-        if (c instanceof DateTime || c instanceof CalendarDate)
-            c = c.toSQL();
-        else if (typeof c === 'string')
-            c = normalizeUnicode(c);
-        if (c2 instanceof DateTime || c2 instanceof CalendarDate)
-            c2 = c2.toSQL();
-        else if (typeof c2 === 'string')
-            c2 = normalizeUnicode(c2);
+        c = this.normalizedWhereValue(dreamClass, attr, c);
+        c2 = this.normalizedWhereValue(dreamClass, attr, c2);
         if (a && c === undefined)
             throw new CannotPassUndefinedAsAValueToAWhereClause(this.dreamClass, a);
         if (a2 && c2 === undefined)
             throw new CannotPassUndefinedAsAValueToAWhereClause(this.dreamClass, a2);
         return { a, b, c, a2, b2, c2 };
     }
+    normalizedWhereValue(dreamClass, attr, val) {
+        return normalizeDataForDb({
+            val,
+            dreamClass,
+            column: maybeNamespacedColumnNameToColumnName(attr),
+        });
+    }
     recursivelyJoin({ query, joinStatement, joinAndStatements, dreamClass, previousTableAlias, joinType, }) {
         for (const associationString of Object.keys(joinStatement)) {
             const joinAndStatement = joinAndStatements[associationString];
@@ -1398,13 +1398,16 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             const value = preloadOnStatements[key];
             if (value === undefined)
                 throw new UnexpectedUndefined();
-            // filter out plain objects, but not ops and not and/andNot/andAny statements
-            // because plain objects are just the next level of nested preload
+            // filter out plain objects and prototype-less containers (used for nested preload),
+            // but not ops and not and/andNot/andAny statements
+            const isNestedPreloadContainer = typeof value === 'object' &&
+                value !== null &&
+                (value.constructor === Object || Object.getPrototypeOf(value) === null);
             if (key === 'and' ||
                 key === 'andNot' ||
                 key === 'andAny' ||
                 value === null ||
-                value.constructor !== Object) {
+                !isNestedPreloadContainer) {
                 agg[key] = value;
             }
             return agg;
@@ -1561,18 +1564,18 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 dreamClassThroughAssociationWantsToHydrate: undefined,
             });
         }
-        const dreamClassWithSourceAssociation = associationReferencedByThroughAssociation.modelCB();
-        if (Array.isArray(dreamClassWithSourceAssociation))
+        const associatedDreamClass = associationReferencedByThroughAssociation.modelCB();
+        if (Array.isArray(associatedDreamClass))
             throw new ArrayTargetIncompatibleWithThroughAssociation({
                 dreamClass: dreamClassTheAssociationIsDefinedOn,
                 association: throughAssociation,
             });
-        const sourceAssociation = getSourceAssociation(dreamClassWithSourceAssociation, throughAssociation.source);
+        const sourceAssociation = getSourceAssociation(associatedDreamClass, throughAssociation.source);
         if (!sourceAssociation)
             throw new MissingThroughAssociationSource({
                 dreamClass: dreamClassTheAssociationIsDefinedOn,
                 association: throughAssociation,
-                throughClass: dreamClassWithSourceAssociation,
+                throughClass: associatedDreamClass,
             });
         /**
          * When the source is a polymorphic BelongsTo association, use the target of the through
@@ -1588,7 +1591,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
          */
         return this.applyOneJoin({
             query: recursiveResult.query,
-            dreamClass: dreamClassWithSourceAssociation,
+            dreamClass: associatedDreamClass,
             association: sourceAssociation,
             // since joinsBridgeThroughAssociations passes undefined to explicitAlias recursively, we know this is only set on the
             // first call to joinsBridgeThroughAssociations, which corresponds to the outermoset through association and therefore
@@ -1668,6 +1671,10 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      */
     previousTableAlias, selfTableAlias, joinAndStatement, previousThroughAssociation, joinType, dreamClassThroughAssociationWantsToHydrate, }) {
         const currentTableAlias = explicitAlias ?? association.as;
+        const _associatedDreamClass = association.modelCB();
+        const associatedDreamClass = Array.isArray(_associatedDreamClass)
+            ? _associatedDreamClass[0]
+            : _associatedDreamClass;
         if (previousThroughAssociation?.type === 'HasMany') {
             if (query?.distinctOn && previousThroughAssociation.distinct) {
                 query = query.distinctOn(this.distinctColumnNameForAssociation({
@@ -1700,11 +1707,12 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 }), currentTableAlias));
                 if (previousThroughAssociation) {
                     if (dreamClassThroughAssociationWantsToHydrate) {
-                        join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement({
+                        join = join.on((eb) => this.whereStatementToExpressionWrapper(dreamClass, eb, this.aliasWhereStatement({
                             [association.foreignKeyTypeField()]: dreamClassThroughAssociationWantsToHydrate.sanitizedName,
                         }, previousThroughAssociation.through)));
                     }
                     join = this.applyAssociationAndStatementsToJoinStatement({
+                        dreamClass,
                         join,
                         association: previousThroughAssociation,
                         currentTableAlias,
@@ -1713,12 +1721,13 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     });
                 }
                 join = this.conditionallyApplyDefaultScopesDependentOnAssociation({
+                    dreamClass,
                     join,
                     tableNameOrAlias: currentTableAlias,
                     association,
                     throughAssociatedClassOverride: dreamClassThroughAssociationWantsToHydrate,
                 });
-                join = this.applyJoinAndStatement(join, joinAndStatement, currentTableAlias);
+                join = this.applyJoinAndStatement(associatedDreamClass, join, joinAndStatement, currentTableAlias);
                 return join;
             });
         }
@@ -1728,7 +1737,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             query = query[(joinType === 'inner' ? 'innerJoin' : 'leftJoin')](joinTableExpression, (join) => {
                 join = join.onRef(this.namespaceColumn(association.primaryKey(), previousTableAlias), '=', this.namespaceColumn(association.foreignKey(), currentTableAlias));
                 if (association.polymorphic) {
-                    join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement({
+                    join = join.on((eb) => this.whereStatementToExpressionWrapper(dreamClass, eb, this.aliasWhereStatement({
                         [association.foreignKeyTypeField()]: dreamClassThroughAssociationWantsToHydrate
                             ? dreamClassThroughAssociationWantsToHydrate.referenceTypeString
                             : dreamClass.referenceTypeString,
@@ -1736,6 +1745,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 }
                 if (previousThroughAssociation) {
                     join = this.applyAssociationAndStatementsToJoinStatement({
+                        dreamClass,
                         join,
                         association: previousThroughAssociation,
                         currentTableAlias,
@@ -1744,6 +1754,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     });
                 }
                 join = this.applyAssociationAndStatementsToJoinStatement({
+                    dreamClass,
                     join,
                     association,
                     currentTableAlias,
@@ -1751,12 +1762,13 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     joinAndStatement,
                 });
                 join = this.conditionallyApplyDefaultScopesDependentOnAssociation({
+                    dreamClass,
                     join,
                     tableNameOrAlias: currentTableAlias,
                     association,
                     throughAssociatedClassOverride: dreamClassThroughAssociationWantsToHydrate,
                 });
-                join = this.applyJoinAndStatement(join, joinAndStatement, currentTableAlias);
+                join = this.applyJoinAndStatement(associatedDreamClass, join, joinAndStatement, currentTableAlias);
                 return join;
             });
             if (association.type === 'HasMany') {
@@ -1804,26 +1816,26 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             return this.namespaceColumn(foreignKey, tableNameOrAlias);
         return this.namespaceColumn(association.distinct, tableNameOrAlias);
     }
-    applyAssociationAndStatementsToJoinStatement({ join, currentTableAlias, selfTableAlias, association, joinAndStatement, }) {
+    applyAssociationAndStatementsToJoinStatement({ dreamClass, join, currentTableAlias, selfTableAlias, association, joinAndStatement, }) {
         if (association.and) {
             this.throwUnlessAllRequiredWhereClausesProvided(association, currentTableAlias, joinAndStatement);
-            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(association.and, currentTableAlias), { disallowSimilarityOperator: false }));
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(dreamClass, eb, this.aliasWhereStatement(association.and, currentTableAlias), { disallowSimilarityOperator: false }));
         }
         if (association.andNot) {
-            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(association.andNot, currentTableAlias), { negate: true }));
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(dreamClass, eb, this.aliasWhereStatement(association.andNot, currentTableAlias), { negate: true }));
         }
         if (association.andAny) {
-            join = join.on((eb) => eb.or(association.andAny.map(whereAnyStatement => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(whereAnyStatement, currentTableAlias), { disallowSimilarityOperator: false }))));
+            join = join.on((eb) => eb.or(association.andAny.map(whereAnyStatement => this.whereStatementToExpressionWrapper(dreamClass, eb, this.aliasWhereStatement(whereAnyStatement, currentTableAlias), { disallowSimilarityOperator: false }))));
         }
         if (association.selfAnd) {
-            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.rawifiedSelfOnClause({
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(dreamClass, eb, this.rawifiedSelfOnClause({
                 associationAlias: association.as,
                 selfAlias: selfTableAlias,
                 selfAndClause: association.selfAnd,
             })));
         }
         if (association.selfAndNot) {
-            join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.rawifiedSelfOnClause({
+            join = join.on((eb) => this.whereStatementToExpressionWrapper(dreamClass, eb, this.rawifiedSelfOnClause({
                 associationAlias: association.as,
                 selfAlias: selfTableAlias,
                 selfAndClause: association.selfAndNot,
@@ -1842,7 +1854,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         if (missingRequiredWhereStatements.length)
             throw new MissingRequiredAssociationAndClause(association, missingRequiredWhereStatements[0]);
     }
-    conditionallyApplyDefaultScopesDependentOnAssociation({ join, tableNameOrAlias, association, throughAssociatedClassOverride, }) {
+    conditionallyApplyDefaultScopesDependentOnAssociation({ dreamClass, join, tableNameOrAlias, association, throughAssociatedClassOverride, }) {
         let scopesQuery = new Query(this.dreamInstance);
         const associationClass = throughAssociatedClassOverride ?? association.modelCB();
         const associationScopes = associationClass['scopes'].default;
@@ -1864,7 +1876,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             }
         }
         if (scopesQuery['whereStatements'].length) {
-            join = join.on((eb) => eb.and(scopesQuery['whereStatements'].flatMap(whereStatement => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement(whereStatement, tableNameOrAlias), { disallowSimilarityOperator: false }))));
+            join = join.on((eb) => eb.and(scopesQuery['whereStatements'].flatMap(whereStatement => this.whereStatementToExpressionWrapper(dreamClass, eb, this.aliasWhereStatement(whereStatement, tableNameOrAlias), { disallowSimilarityOperator: false }))));
         }
         return join;
     }

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

@@ -12,7 +12,7 @@ import DreamCLI from '../../cli/index.js';
 import { isPrimitiveDataType } from '../../db/dataTypes.js';
 import DreamApp from '../../dream-app/index.js';
 import camelize from '../../helpers/camelize.js';
-import { findCitextArrayOid, findCorrespondingArrayOid, findEnumArrayOids, parsePostgresBigint, parsePostgresDate, parsePostgresDatetime, parsePostgresDecimal, } from '../../helpers/customPgParsers.js';
+import { findCitextArrayOid, findCorrespondingArrayOid, findEnumArrayOids, parsePostgresBigint, parsePostgresDate, parsePostgresDatetime, parsePostgresDatetimeTz, parsePostgresDecimal, parsePostgresTime, parsePostgresTimeTz, } from '../../helpers/customPgParsers.js';
 import EnvInternal from '../../helpers/EnvInternal.js';
 import createDb from './helpers/pg/createDb.js';
 import _dropDb from './helpers/pg/dropDb.js';
@@ -70,7 +70,9 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
         const kyselyDb = this.dbFor(connectionName, 'primary');
         pgTypes.setTypeParser(pgTypes.builtins.DATE, parsePostgresDate);
         pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMP, parsePostgresDatetime);
-        pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMPTZ, parsePostgresDatetime);
+        pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMPTZ, parsePostgresDatetimeTz);
+        pgTypes.setTypeParser(pgTypes.builtins.TIME, parsePostgresTime);
+        pgTypes.setTypeParser(pgTypes.builtins.TIMETZ, parsePostgresTimeTz);
         pgTypes.setTypeParser(pgTypes.builtins.NUMERIC, parsePostgresDecimal);
         pgTypes.setTypeParser(pgTypes.builtins.INT8, parsePostgresBigint);
         const textArrayOid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TEXT);
@@ -97,6 +99,12 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
             oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TIMESTAMPTZ);
             if (oid)
                 pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDatetime));
+            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TIME);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresTime));
+            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TIMETZ);
+            if (oid)
+                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresTimeTz));
             oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.NUMERIC);
             if (oid)
                 pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDecimal));

package/dist/cjs/src/dream/internal/extractAssignableAssociationAttributes.js

@@ -0,0 +1,9 @@
+export default function extractAssignableAssociationAttributes(association, dreamInstance) {
+    const returnObj = {
+        [association.foreignKey()]: association.primaryKeyValue(dreamInstance),
+    };
+    if (association.polymorphic) {
+        returnObj[association.foreignKeyTypeField()] = dreamInstance.referenceTypeString;
+    }
+    return returnObj;
+}

package/dist/cjs/src/errors/db/DataIncompatibleWithDatabaseField.js

@@ -1,9 +1,7 @@
 export default class DataIncompatibleWithDatabaseField extends Error {
-    dream;
     error;
-    constructor({ dream, error }) {
+    constructor(error) {
         super();
-        this.dream = dream;
         this.error = error;
     }
     get message() {