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

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

@@ -1,4 +1,5 @@
 import Dream from '../Dream.js';
+import { ClockTime, ClockTimeTz } from '../package-exports/index.js';
 import CalendarDate from '../utils/datetime/CalendarDate.js';
 import { DateTime } from '../utils/datetime/DateTime.js';
 /**
@@ -34,6 +35,10 @@ function areEqualOrUndefined(a, b) {
         return b instanceof DateTime && a.equals(b);
     if (a instanceof CalendarDate)
         return b instanceof CalendarDate && a.equals(b);
+    if (a instanceof ClockTime)
+        return b instanceof ClockTime && a.equals(b);
+    if (a instanceof ClockTimeTz)
+        return b instanceof ClockTimeTz && a.equals(b);
     if (Array.isArray(a))
         return Array.isArray(b) && a.length === b.length && !a.find((value, index) => !areEqual(value, b[index]));
     if (a instanceof Dream)

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

@@ -229,10 +229,19 @@ export default class ASTBuilder {
             dateTimeNamedImports // namedBindings
             );
             const dateTimeImportDeclaration = ts.factory.createImportDeclaration(undefined, dateTimeImportClause, ts.factory.createStringLiteral('../../src/utils/datetime/DateTime.js'));
-            return [calendarImportDeclaration, dateTimeImportDeclaration];
+            const clockTimeImport = ts.factory.createImportClause(true, f.createIdentifier('ClockTime'), undefined);
+            const clockTimeImportDeclaration = ts.factory.createImportDeclaration(undefined, clockTimeImport, ts.factory.createStringLiteral('../../src/utils/datetime/ClockTime.js'));
+            const clockTimeTzImport = ts.factory.createImportClause(true, f.createIdentifier('ClockTimeTz'), undefined);
+            const clockTimeTzImportDeclaration = ts.factory.createImportDeclaration(undefined, clockTimeTzImport, ts.factory.createStringLiteral('../../src/utils/datetime/ClockTimeTz.js'));
+            return [
+                calendarImportDeclaration,
+                dateTimeImportDeclaration,
+                clockTimeImportDeclaration,
+                clockTimeTzImportDeclaration,
+            ];
         }
         else {
-            const namedImports = ts.factory.createNamedImports(['CalendarDate', 'DateTime'].map(importName => f.createImportSpecifier(true, undefined, ts.factory.createIdentifier(importName))));
+            const namedImports = ts.factory.createNamedImports(['CalendarDate', 'DateTime', 'ClockTime', 'ClockTimeTz'].map(importName => f.createImportSpecifier(true, undefined, ts.factory.createIdentifier(importName))));
             const importClause = ts.factory.createImportClause(false, // isTypeOnly: false for the clause itself if not all imports are type only
             undefined, // name: undefined for default import
             namedImports // namedBindings
@@ -274,4 +283,47 @@ export default class ASTBuilder {
         const serializers = dreamApp.serializers;
         return Object.keys(serializers);
     }
+    /**
+     * @internal
+     *
+     * checks if a database type is a date type (with optional array suffix)
+     */
+    isDateDbType(dbType) {
+        return /^date[[\]]*$/.test(dbType);
+    }
+    /**
+     * @internal
+     *
+     * checks if a database type is a time without time zone type (with optional array suffix)
+     */
+    isTimeWithoutTimeZoneDbType(dbType) {
+        return /^time without time zone[[\]]*$/.test(dbType);
+    }
+    /**
+     * @internal
+     *
+     * checks if a database type is a time with time zone type (with optional array suffix)
+     */
+    isTimeWithTimeZoneDbType(dbType) {
+        return /^time with time zone[[\]]*$/.test(dbType);
+    }
+    /**
+     * @internal
+     *
+     * checks if a database type is any time type (with or without time zone, with optional array suffix)
+     */
+    isTimeDbType(dbType) {
+        return /^time (without|with) time zone(\[\])?$/.test(dbType);
+    }
+    /**
+     * @internal
+     *
+     * checks if a TypeScript type node represents a string-like type
+     * (string keyword, string type reference, or string literal)
+     */
+    isStringLikeType(node, sourceFile) {
+        return (node.kind === ts.SyntaxKind.StringKeyword ||
+            (ts.isTypeReferenceNode(node) && node.typeName.getText(sourceFile) === 'string') ||
+            (ts.isLiteralTypeNode(node) && ts.isStringLiteral(node.literal)));
+    }
 }

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

@@ -1,6 +1,7 @@
 import ts from 'typescript';
 import { CliFileWriter } from '../../cli/CliFileWriter.js';
 import camelize from '../camelize.js';
+import snakeify from '../snakeify.js';
 import ASTConnectionBuilder from './ASTConnectionBuilder.js';
 import autogeneratedFileDisclaimer from './autoGeneratedFileDisclaimer.js';
 const f = ts.factory;
@@ -25,6 +26,7 @@ export default class ASTKyselyCodegenEnhancer extends ASTConnectionBuilder {
         let dbSourceFile = await this.getDbSourceFile();
         dbSourceFile = this.camelizeKeys(dbSourceFile);
         dbSourceFile = this.replaceTimestampExport(dbSourceFile);
+        dbSourceFile = await this.replaceTimeFieldsInInterfaces(dbSourceFile);
         dbSourceFile = this.addMissingImports(dbSourceFile);
         dbSourceFile = this.replaceInt8Export(dbSourceFile);
         dbSourceFile = this.sortExportedInterfacesTransformer(dbSourceFile);
@@ -90,6 +92,88 @@ ${output}`);
         const result = ts.transform(dbSourceFile, [transformer]);
         return result.transformed[0];
     }
+    /**
+     * @internal
+     *
+     * Replaces string types with TimeWithZone or TimeWithoutZone for TIME columns
+     * based on the schema metadata from dream.ts
+     */
+    async replaceTimeFieldsInInterfaces(dbSourceFile) {
+        const schemaData = await this.getSchemaData();
+        const transformer = context => {
+            return sourceFile => {
+                const visitor = (node) => {
+                    if (ts.isInterfaceDeclaration(node) && node.name.text !== 'DB') {
+                        const tableName = snakeify(node.name.text);
+                        const tableSchema = schemaData[tableName];
+                        if (!tableSchema) {
+                            return ts.visitEachChild(node, visitor, context);
+                        }
+                        const updatedMembers = node.members.map(member => {
+                            if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                                const columnName = member.name.text;
+                                const columnSchema = tableSchema.columns[columnName];
+                                if (!columnSchema)
+                                    return member;
+                                const dbType = columnSchema.dbType;
+                                // Check if this is a TIME field that's currently typed as string
+                                if (this.isTimeDbType(dbType) && member.type) {
+                                    const isTimeTz = this.isTimeWithTimeZoneDbType(dbType);
+                                    const newType = this.replaceStringWithClockTimeType(member.type, sourceFile, isTimeTz);
+                                    if (newType !== member.type) {
+                                        return f.updatePropertySignature(member, member.modifiers, member.name, member.questionToken, newType);
+                                    }
+                                }
+                            }
+                            return member;
+                        });
+                        return f.updateInterfaceDeclaration(node, node.modifiers, node.name, node.typeParameters, node.heritageClauses, updatedMembers);
+                    }
+                    return ts.visitEachChild(node, visitor, context);
+                };
+                return ts.visitNode(sourceFile, visitor);
+            };
+        };
+        const result = ts.transform(dbSourceFile, [transformer]);
+        return result.transformed[0];
+    }
+    /**
+     * @internal
+     *
+     * Helper to replace string type references with ClockTime or ClockTimeTz type references
+     */
+    replaceStringWithClockTimeType(typeNode, sourceFile, isTimeTz) {
+        const toTimeType = () => f.createTypeReferenceNode(f.createIdentifier(isTimeTz ? 'ClockTimeTz' : 'ClockTime'));
+        // Handle union types (e.g., string | null)
+        if (ts.isUnionTypeNode(typeNode)) {
+            const updatedTypes = typeNode.types.map(t => this.replaceStringWithClockTimeType(t, sourceFile, isTimeTz));
+            return f.createUnionTypeNode(updatedTypes);
+        }
+        // Handle array syntax (e.g., string[])
+        if (ts.isArrayTypeNode(typeNode)) {
+            const elementType = this.isStringLikeType(typeNode.elementType, sourceFile)
+                ? toTimeType()
+                : this.replaceStringWithClockTimeType(typeNode.elementType, sourceFile, isTimeTz);
+            return f.createArrayTypeNode(elementType);
+        }
+        // Handle generic array syntax (e.g., Array<string>)
+        if (ts.isTypeReferenceNode(typeNode) &&
+            typeNode.typeName.getText(sourceFile) === 'Array' &&
+            typeNode.typeArguments?.length === 1) {
+            const arg = typeNode.typeArguments?.[0];
+            if (!arg)
+                return typeNode;
+            const nextArg = this.isStringLikeType(arg, sourceFile)
+                ? toTimeType()
+                : this.replaceStringWithClockTimeType(arg, sourceFile, isTimeTz);
+            return f.createTypeReferenceNode(f.createIdentifier('Array'), [nextArg]);
+        }
+        // Handle direct string type
+        if (this.isStringLikeType(typeNode, sourceFile)) {
+            return toTimeType();
+        }
+        return typeNode;
+    }
     /**
      * @internal
      *

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

@@ -262,7 +262,9 @@ ${output}`;
      */
     coercedType(dbSourceFile, propertySignature, dbType, importedModules) {
         const extractedPropertyTypes = this.extractTypeNodesFromTypeOrUnion(propertySignature);
-        const isDate = /^date[[\]]*$/.test(dbType);
+        const isDate = this.isDateDbType(dbType);
+        const isTime = this.isTimeWithoutTimeZoneDbType(dbType);
+        const isTimeTz = this.isTimeWithTimeZoneDbType(dbType);
         const types = compact(extractedPropertyTypes.map(typeNode => {
             const typeText = typeNode.getText(dbSourceFile);
             let defaultReturnNode = /^Generated/.test(typeText) ? this.getFirstGenericType(typeNode) : typeNode;
@@ -287,6 +289,20 @@ ${output}`;
                     return isDate
                         ? f.createArrayTypeNode(f.createTypeReferenceNode('CalendarDate'))
                         : f.createArrayTypeNode(f.createTypeReferenceNode('DateTime'));
+                case 'string':
+                    // Kysely-codegen types TIME columns as string, we need to check dbType
+                    if (isTime)
+                        return f.createTypeReferenceNode('ClockTime');
+                    if (isTimeTz)
+                        return f.createTypeReferenceNode('ClockTimeTz');
+                    return defaultReturnNode;
+                case 'string[]':
+                    // Kysely-codegen types TIME[] columns as string[], we need to check dbType
+                    if (isTime)
+                        return f.createArrayTypeNode(f.createTypeReferenceNode('ClockTime'));
+                    if (isTimeTz)
+                        return f.createArrayTypeNode(f.createTypeReferenceNode('ClockTimeTz'));
+                    return defaultReturnNode;
                 case 'Int8':
                     return f.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
                 case 'Int8[]':

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

@@ -97,6 +97,22 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
                 dreamImports.push('DateTime');
                 attributeDefaults.push(`${attributeVariable}: [DateTime.now()],`);
                 break;
+            case 'time':
+                dreamImports.push('ClockTime');
+                attributeDefaults.push(`${attributeVariable}: ClockTime.now(),`);
+                break;
+            case 'time[]':
+                dreamImports.push('ClockTime');
+                attributeDefaults.push(`${attributeVariable}: [ClockTime.now()],`);
+                break;
+            case 'timetz':
+                dreamImports.push('ClockTimeTz');
+                attributeDefaults.push(`${attributeVariable}: ClockTimeTz.now(),`);
+                break;
+            case 'timetz[]':
+                dreamImports.push('ClockTimeTz');
+                attributeDefaults.push(`${attributeVariable}: [ClockTimeTz.now()],`);
+                break;
             case 'uuid':
                 nodeImports.push('randomUUID');
                 attributeDefaults.push(`${attributeVariable}: randomUUID(),`);

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

@@ -1,5 +1,6 @@
 import Dream from '../Dream.js';
 import OpsStatement from '../ops/ops-statement.js';
+import BaseClockTime from '../utils/datetime/BaseClockTime.js';
 import CalendarDate from '../utils/datetime/CalendarDate.js';
 import { DateTime } from '../utils/datetime/DateTime.js';
 import isObject from './isObject.js';
@@ -24,14 +25,13 @@ export default function cloneDeepSafe(original, unsupportedTypeCloneFunction) {
         return original;
     if (['number', 'boolean', 'bigint', 'symbol'].includes(typeof original))
         return original;
-    if (original instanceof DateTime)
-        return original;
-    if (original instanceof CalendarDate)
-        return original;
-    if (original instanceof Range)
-        return original;
-    if (original instanceof OpsStatement)
+    if (original instanceof DateTime ||
+        original instanceof CalendarDate ||
+        original instanceof BaseClockTime ||
+        original instanceof Range ||
+        original instanceof OpsStatement) {
         return original;
+    }
     if (original instanceof Dream)
         return original['clone']();
     if (original?.isDreamQuery)
@@ -40,9 +40,20 @@ export default function cloneDeepSafe(original, unsupportedTypeCloneFunction) {
         return original;
     if (Array.isArray(original))
         return original.map(value => cloneDeepSafe(value, unsupportedTypeCloneFunction));
-    if (isObject(original) && original.constructor.name === 'Object') {
-        const clone = { ...original };
-        Object.keys(clone).forEach(key => (clone[key] = cloneDeepSafe(clone[key], unsupportedTypeCloneFunction)));
+    // complex check here to ensure that if the object to clone was
+    // created using Object.create(null), we cannot access the constructor,
+    // and instead of to check that the original prototype is null
+    const isObjectLike = isObject(original) &&
+        (original.constructor?.name === 'Object' || Object.getPrototypeOf(original) === null);
+    if (isObjectLike) {
+        // if we are provided with an object that has a null prototype, create a new
+        // object with a null prototype to append to. Otherwise, create a standard
+        // object clone.
+        const clone = Object.getPrototypeOf(original) === null ? Object.create(null) : { ...original };
+        Object.keys(original).forEach(key => {
+            ;
+            clone[key] = cloneDeepSafe(original[key], unsupportedTypeCloneFunction);
+        });
         return clone;
     }
     if (unsupportedTypeCloneFunction)

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

@@ -1,4 +1,6 @@
 import CalendarDate from '../utils/datetime/CalendarDate.js';
+import ClockTime from '../utils/datetime/ClockTime.js';
+import ClockTimeTz from '../utils/datetime/ClockTimeTz.js';
 import { DateTime } from '../utils/datetime/DateTime.js';
 export async function findEnumArrayOids(kyselyDb) {
     const result = await kyselyDb.selectFrom('pg_type').select('typarray').where('typtype', '=', 'e').execute();
@@ -24,7 +26,22 @@ export function parsePostgresDate(dateString) {
     return dateString ? CalendarDate.fromSQL(dateString) : dateString;
 }
 export function parsePostgresDatetime(datetimeString) {
-    return datetimeString ? DateTime.fromSQL(datetimeString, { zone: 'UTC' }) : datetimeString;
+    if (!datetimeString)
+        return datetimeString;
+    return DateTime.fromSQL(datetimeString, { zone: 'UTC' });
+}
+export function parsePostgresDatetimeTz(datetimeString) {
+    return parsePostgresDatetime(datetimeString);
+}
+export function parsePostgresTime(timeString) {
+    if (!timeString)
+        return timeString;
+    return ClockTime.fromSQL(timeString);
+}
+export function parsePostgresTimeTz(timeString) {
+    if (!timeString)
+        return timeString;
+    return ClockTimeTz.fromSQL(timeString, { zone: 'UTC' });
 }
 export function parsePostgresDecimal(numberString) {
     return numberString ? parseFloat(numberString) : numberString;

package/dist/esm/src/helpers/db/normalizeDataForDb.js

@@ -0,0 +1,81 @@
+import DataTypeColumnTypeMismatch from '../../errors/db/DataTypeColumnTypeMismatch.js';
+import BaseClockTime from '../../utils/datetime/BaseClockTime.js';
+import CalendarDate from '../../utils/datetime/CalendarDate.js';
+import ClockTime from '../../utils/datetime/ClockTime.js';
+import ClockTimeTz from '../../utils/datetime/ClockTimeTz.js';
+import { DateTime } from '../../utils/datetime/DateTime.js';
+import normalizeUnicode from '../normalizeUnicode.js';
+import { DATE_OR_DATE_ARRAY_COLUMN_CHECK_REGEXP, DATETIME_OR_DATETIME_ARRAY_COLUMN_CHECK_REGEXP, STRING_OR_STRING_ARRAY_COLUMN_CHECK_REGEXP, TIME_WITH_TIMEZONE_COLUMN_CHECK_REGEXP, TIME_WITHOUT_TIMEZONE_COLUMN_CHECK_REGEXP, } from './types/helpers.js';
+export function normalizeDataForDb({ val, dreamClass, column, }) {
+    const columnType = dreamClass['cachedTypeFor'](column);
+    if (val instanceof DateTime || DATETIME_OR_DATETIME_ARRAY_COLUMN_CHECK_REGEXP.test(columnType)) {
+        return dateTimeOrDateToSql(DateTime, val);
+        //
+    }
+    else if (val instanceof CalendarDate || DATE_OR_DATE_ARRAY_COLUMN_CHECK_REGEXP.test(columnType)) {
+        return dateTimeOrDateToSql(CalendarDate, val);
+        //
+    }
+    else if (val instanceof ClockTime || TIME_WITHOUT_TIMEZONE_COLUMN_CHECK_REGEXP.test(columnType)) {
+        return clockTimeOrClockTimeTzToSql(ClockTime, val);
+        //
+    }
+    else if (val instanceof ClockTimeTz || TIME_WITH_TIMEZONE_COLUMN_CHECK_REGEXP.test(columnType)) {
+        return clockTimeOrClockTimeTzToSql(ClockTimeTz, val);
+        //
+    }
+    else if (typeof val === 'string' || STRING_OR_STRING_ARRAY_COLUMN_CHECK_REGEXP.test(columnType)) {
+        return normalizedString(val);
+        //
+    }
+    else {
+        return val;
+    }
+}
+function normalizedString(_val) {
+    const alreadyAnArray = Array.isArray(_val);
+    const normalizedValueArray = (alreadyAnArray ? _val : [_val]).map(val => typeof val === 'string' ? normalizeUnicode(val) : val);
+    return alreadyAnArray ? normalizedValueArray : normalizedValueArray[0];
+}
+function dateTimeOrDateToSql(dateClass, _val) {
+    const alreadyAnArray = Array.isArray(_val);
+    const normalizedValueArray = (alreadyAnArray ? _val : [_val]).map(val => {
+        if (val === null || val === undefined)
+            return val;
+        if (val instanceof DateTime || val instanceof CalendarDate)
+            return val.toSQL();
+        try {
+            if (typeof val !== 'string') {
+                throw new DataTypeColumnTypeMismatch(new Error(`database column type error: invalid ${dateClass.name} (received ${typeof val})`));
+            }
+            return dateClass.fromISO(val, { zone: 'UTC' }).toSQL();
+        }
+        catch (error) {
+            throw new DataTypeColumnTypeMismatch(error instanceof Error
+                ? error
+                : new Error(`database column type error: invalid ${dateClass.name} (received ${typeof val}: ${val})`));
+        }
+    });
+    return alreadyAnArray ? normalizedValueArray : normalizedValueArray[0];
+}
+function clockTimeOrClockTimeTzToSql(clockTimeClass, _val) {
+    const alreadyAnArray = Array.isArray(_val);
+    const normalizedValueArray = (alreadyAnArray ? _val : [_val]).map(val => {
+        if (val === null || val === undefined)
+            return val;
+        if (val instanceof BaseClockTime)
+            return val.toSQL();
+        try {
+            if (typeof val !== 'string') {
+                throw new DataTypeColumnTypeMismatch(new Error(`database column type error: invalid ${clockTimeClass.name} (received ${typeof val})`));
+            }
+            return clockTimeClass.fromISO(val, { zone: 'UTC' }).toSQL();
+        }
+        catch (error) {
+            throw new DataTypeColumnTypeMismatch(error instanceof Error
+                ? error
+                : new Error(`database column type error: invalid ${clockTimeClass.name} (received ${typeof val}: ${val})`));
+        }
+    });
+    return alreadyAnArray ? normalizedValueArray : normalizedValueArray[0];
+}

package/dist/esm/src/helpers/db/types/helpers.js

@@ -0,0 +1,5 @@
+export const DATETIME_OR_DATETIME_ARRAY_COLUMN_CHECK_REGEXP = /^timestamp/;
+export const DATE_OR_DATE_ARRAY_COLUMN_CHECK_REGEXP = /^date/;
+export const TIME_WITH_TIMEZONE_COLUMN_CHECK_REGEXP = /^time with time zone/;
+export const TIME_WITHOUT_TIMEZONE_COLUMN_CHECK_REGEXP = /^time without time zone/;
+export const STRING_OR_STRING_ARRAY_COLUMN_CHECK_REGEXP = /^(text|character varying|citext)/;

package/dist/esm/src/helpers/db/types/isDatetimeOrDatetimeArrayColumn.js

@@ -1,3 +1,4 @@
+import { DATETIME_OR_DATETIME_ARRAY_COLUMN_CHECK_REGEXP } from './helpers.js';
 export default function isDatetimeOrDatetimeArrayColumn(dreamClass, column) {
-    return /^timestamp/.test(dreamClass['cachedTypeFor'](column));
+    return DATETIME_OR_DATETIME_ARRAY_COLUMN_CHECK_REGEXP.test(dreamClass['cachedTypeFor'](column));
 }

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

@@ -1,3 +1,4 @@
+import { ClockTime, ClockTimeTz } from '../package-exports/index.js';
 import CalendarDate from '../utils/datetime/CalendarDate.js';
 import { DateTime } from '../utils/datetime/DateTime.js';
 /**
@@ -26,11 +27,12 @@ export default function sortBy(array, valueToCompare) {
             return aPrime > bPrime ? 1 : aPrime < bPrime ? -1 : 0;
         if (typeof aPrime === 'string' && typeof bPrime === 'string')
             return aPrime.localeCompare(bPrime);
-        if (aPrime instanceof DateTime && bPrime instanceof DateTime)
-            return aPrime.valueOf() - bPrime.valueOf();
-        if ((aPrime instanceof DateTime || aPrime instanceof CalendarDate) &&
-            (bPrime instanceof DateTime || bPrime instanceof CalendarDate))
-            return (aPrime.toISO() ?? '').localeCompare(bPrime.toISO() ?? '');
+        if (((aPrime instanceof DateTime || aPrime instanceof CalendarDate) &&
+            (bPrime instanceof DateTime || bPrime instanceof CalendarDate)) ||
+            (aPrime instanceof ClockTime && bPrime instanceof ClockTime) ||
+            (aPrime instanceof ClockTimeTz && bPrime instanceof ClockTimeTz)) {
+            return aPrime.valueOf().localeCompare(bPrime.valueOf());
+        }
         throw new UnsupportedValueFromComparisonFunction(aPrime, bPrime);
     });
 }

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

@@ -1,61 +1,12 @@
-import DreamApp from '../dream-app/index.js';
-import DataTypeColumnTypeMismatch from '../errors/db/DataTypeColumnTypeMismatch.js';
-import CalendarDate from '../utils/datetime/CalendarDate.js';
-import { DateTime } from '../utils/datetime/DateTime.js';
-import isDatetimeOrDatetimeArrayColumn from './db/types/isDatetimeOrDatetimeArrayColumn.js';
-import isTextOrTextArrayColumn from './db/types/isTextOrTextArrayColumn.js';
-import normalizeUnicode from './normalizeUnicode.js';
+import { normalizeDataForDb } from './db/normalizeDataForDb.js';
 export default function sqlAttributes(dream) {
     const attributes = dream.dirtyAttributes();
     const dreamClass = dream.constructor;
-    const queryDriverClass = DreamApp.getOrFail().dbConnectionQueryDriverClass(dream.connectionName);
-    return Object.keys(attributes).reduce((result, key) => {
-        let val = attributes[key];
+    return Object.keys(attributes).reduce((result, column) => {
+        const val = attributes[column];
         if (val === undefined)
             return result;
-        if (Array.isArray(val)) {
-            if (isDatetimeOrDatetimeArrayColumn(dreamClass, key))
-                val = val.map(aVal => valueToDatetime(dream, aVal));
-            else if (isTextOrTextArrayColumn(dreamClass, key))
-                val = val.map(normalizeUnicode);
-        }
-        else {
-            if (isDatetimeOrDatetimeArrayColumn(dreamClass, key))
-                val = valueToDatetime(dream, val);
-            else if (isTextOrTextArrayColumn(dreamClass, key))
-                val = normalizeUnicode(val);
-        }
-        if (val instanceof DateTime || val instanceof CalendarDate) {
-            const dateOrDatetime = val instanceof DateTime ? 'datetime' : 'date';
-            // Converting toJSDate resulted in the correct timezone, but even with process.env.TZ=UTC,
-            // Kysely inserted into the database with the machine timezone, which can shift the date
-            // (e.g., toJSDate resulted in a JS Date that formats as "1987-04-07T00:00:00.000Z", but
-            // Kysely inserted "1907-04-06"  into the database). By converting to an SQL string before
-            // handing off to Kysely, we bypass Javascript dates altogether, sending the string into the
-            // database for storage as a date or datetime.
-            result[key] = queryDriverClass.serializeDbType(dateOrDatetime, val);
-        }
-        else {
-            result[key] = val;
-        }
+        result[column] = normalizeDataForDb({ val, dreamClass, column });
         return result;
     }, {});
 }
-/**
- * Convert datetimes to UTC
- */
-function valueToDatetime(dream, val) {
-    if (typeof val !== 'string')
-        return val;
-    let datetime;
-    try {
-        datetime = DateTime.fromISO(val, { zone: 'UTC' });
-    }
-    catch (error) {
-        throw new DataTypeColumnTypeMismatch({
-            dream,
-            error: error instanceof Error ? error : new Error('database column type error'),
-        });
-    }
-    return datetime.isValid ? datetime : val;
-}

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

@@ -1,4 +1,5 @@
 import Dream from '../Dream.js';
+import BaseClockTime from '../utils/datetime/BaseClockTime.js';
 import CalendarDate from '../utils/datetime/CalendarDate.js';
 import { DateTime } from '../utils/datetime/DateTime.js';
 import isObject from './isObject.js';
@@ -17,12 +18,12 @@ function recursiveStringCase(target, stringCaser) {
     if (Array.isArray(target))
         return target.map(s => recursiveStringCase(s, stringCaser));
     if (isObject(target)) {
-        if (target instanceof DateTime)
-            return target;
-        if (target instanceof CalendarDate)
-            return target;
-        if (target instanceof Dream)
+        if (target instanceof DateTime ||
+            target instanceof CalendarDate ||
+            target instanceof BaseClockTime ||
+            target instanceof Dream) {
             return target;
+        }
         return Object.keys(target).reduce((stringCasedObject, targetKey) => {
             stringCasedObject[stringCaser(targetKey)] = recursiveStringCase(target[targetKey], stringCaser);
             return stringCasedObject;

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

@@ -0,0 +1,17 @@
+/**
+ * @internal
+ *
+ * Returns a shallow copy of the object using a prototype-less container
+ * (Object.create(null)). Use when assigning untrusted keys so that keys like
+ * __proto__ or constructor cannot pollute Object.prototype.
+ */
+export function toSafeObject(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    const safe = Object.create(null);
+    for (const key of Object.keys(obj)) {
+        ;
+        safe[key] = obj[key];
+    }
+    return safe;
+}

package/dist/esm/src/package-exports/errors.js

@@ -11,4 +11,6 @@ export { default as RecordNotFound } from '../errors/RecordNotFound.js';
 export { default as MissingSerializersDefinition } from '../errors/serializers/MissingSerializersDefinition.js';
 export { default as ValidationError } from '../errors/ValidationError.js';
 export { InvalidCalendarDate } from '../utils/datetime/CalendarDate.js';
+export { InvalidClockTime } from '../utils/datetime/ClockTime.js';
+export { InvalidClockTimeTz } from '../utils/datetime/ClockTimeTz.js';
 export { InvalidDateTime } from '../utils/datetime/DateTime.js';

package/dist/esm/src/package-exports/index.js

@@ -12,4 +12,6 @@ export { default as ops } from '../ops/index.js';
 export { default as DreamSerializer } from '../serializer/DreamSerializer.js';
 export { default as ObjectSerializer } from '../serializer/ObjectSerializer.js';
 export { default as CalendarDate } from '../utils/datetime/CalendarDate.js';
+export { default as ClockTime } from '../utils/datetime/ClockTime.js';
+export { default as ClockTimeTz } from '../utils/datetime/ClockTimeTz.js';
 export { DateTime } from '../utils/datetime/DateTime.js';

package/dist/esm/src/serializer/SerializerRenderer.js

@@ -2,6 +2,7 @@ import RendersManyMustReceiveArray from '../errors/serializers/RendersManyMustRe
 import compact from '../helpers/compact.js';
 import round from '../helpers/round.js';
 import snakeify from '../helpers/snakeify.js';
+import BaseClockTime from '../utils/datetime/BaseClockTime.js';
 import CalendarDate from '../utils/datetime/CalendarDate.js';
 import { DateTime } from '../utils/datetime/DateTime.js';
 import DreamSerializerBuilder from './builders/DreamSerializerBuilder.js';
@@ -42,7 +43,7 @@ export default class SerializerRenderer {
                     const value = data[attribute.name] ?? attribute.options?.default;
                     if (value === undefined && attribute.options?.required === false)
                         return accumulator;
-                    accumulator[outputAttributeName] = applyRenderingOptionsToAttribute(value, attribute.options, this.passthroughData, this.renderOpts);
+                    accumulator[outputAttributeName] = applyRenderingOptionsToAttribute(data, value, attribute.name, attribute.options, this.passthroughData, this.renderOpts);
                     return accumulator;
                 }
                 /////////////////////
@@ -57,7 +58,7 @@ export default class SerializerRenderer {
                     const value = target?.[attribute.name] ?? attribute.options?.default;
                     if (value === undefined && attribute.options?.required === false)
                         return accumulator;
-                    accumulator[outputAttributeName] = applyRenderingOptionsToAttribute(value, attribute.options, this.passthroughData, this.renderOpts);
+                    accumulator[outputAttributeName] = applyRenderingOptionsToAttribute(target, value, attribute.name, attribute.options, this.passthroughData, this.renderOpts);
                     return accumulator;
                 }
                 //////////////////////////////
@@ -77,11 +78,11 @@ export default class SerializerRenderer {
                     if (attribute.options.flatten) {
                         return {
                             ...accumulator,
-                            ...applyRenderingOptionsToAttribute(value, {}, this.passthroughData, this.renderOpts),
+                            ...applyRenderingOptionsToAttribute(null, value, attribute.name, {}, this.passthroughData, this.renderOpts),
                         };
                     }
                     else {
-                        accumulator[outputAttributeName] = applyRenderingOptionsToAttribute(value, {}, this.passthroughData, this.renderOpts);
+                        accumulator[outputAttributeName] = applyRenderingOptionsToAttribute(null, value, attribute.name, {}, this.passthroughData, this.renderOpts);
                         return accumulator;
                     }
                 }
@@ -187,18 +188,17 @@ export default class SerializerRenderer {
         }
     }
 }
-function applyRenderingOptionsToAttribute(value, options, passthroughData, renderOptions) {
+function applyRenderingOptionsToAttribute(data, value, attributeName, options, passthroughData, renderOptions) {
     if (Array.isArray(value))
-        return value.map(val => _applyRenderingOptionsToAttribute(val, options, passthroughData, renderOptions));
-    return _applyRenderingOptionsToAttribute(value, options, passthroughData, renderOptions);
+        return value.map(val => _applyRenderingOptionsToAttribute(data, val, attributeName, options, passthroughData, renderOptions));
+    return _applyRenderingOptionsToAttribute(data, value, attributeName, options, passthroughData, renderOptions);
 }
-function _applyRenderingOptionsToAttribute(value, options, passthroughData, renderOptions) {
+function _applyRenderingOptionsToAttribute(data, value, attributeName, options, passthroughData, renderOptions) {
     if (value instanceof DreamSerializerBuilder || value instanceof ObjectSerializerBuilder)
         return value.render(passthroughData, renderOptions);
-    if (value instanceof DateTime)
-        return value.toISO();
-    if (value instanceof CalendarDate)
+    if (value instanceof DateTime || value instanceof CalendarDate || value instanceof BaseClockTime) {
         return value.toISO();
+    }
     if (typeof value === 'bigint')
         return value.toString();
     const precision = options?.precision;

package/dist/esm/src/types/clocktime.js

@@ -0,0 +1 @@
+export {};