joist-core 2.3.0-next.7 → 2.3.0-next.71

package/build/serde.js

@@ -1,517 +1,486 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodSerde = exports.JsonSerde = exports.SuperstructSerde = exports.EnumArrayFieldSerde = exports.EnumFieldSerde = exports.PolymorphicKeySerde = exports.KeySerde = exports.DecimalToNumberSerde = exports.BigIntSerde = exports.ZonedDateTimeSerde = exports.PlainDateTimeSerde = exports.PlainTimeSerde = exports.PlainDateSerde = exports.DateSerde = exports.PrimitiveSerde = exports.CustomSerdeAdapter = void 0;
-exports.hasSerde = hasSerde;
-const EntityMetadata_1 = require("./EntityMetadata");
-const index_1 = require("./index");
-const runtimeConfig_1 = require("./runtimeConfig");
-const temporal_1 = require("./temporal");
-const temporalMappers_1 = require("./temporalMappers");
-const utils_1 = require("./utils");
-function hasSerde(field) {
-    return !!field.serde;
-}
-class CustomSerdeAdapter {
-    fieldName;
-    columnName;
-    dbType;
-    mapper;
-    columns = [this];
-    isArray = false;
-    isNullableArray = false;
-    constructor(fieldName, columnName, dbType, mapper, 
-    // Allow subtypes to override isArray
-    isArray, isNullableArray = false) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-        this.dbType = dbType;
-        this.mapper = mapper;
-        if (isArray !== undefined)
-            this.isArray = isArray;
-        this.isNullableArray = isNullableArray;
-    }
-    setOnEntity(data, row) {
-        const value = maybeNullToUndefined(row[this.columnName]);
-        data[this.fieldName] =
-            value !== undefined
-                ? this.isArray
-                    ? value.map((value) => this.mapper.fromDb(value))
-                    : this.mapper.fromDb(value)
-                : undefined;
-    }
-    dbValue(data) {
-        const fieldData = data[this.fieldName];
-        return fieldData !== undefined
-            ? this.isArray
-                ? fieldData.map((value) => this.mapper.toDb(value))
-                : this.mapper.toDb(fieldData)
-            : undefined;
-    }
-    rowValue(data) {
-        return this.dbValue(data);
-    }
-    mapToDb(value) {
-        return value === null ? value : this.mapper.toDb(value);
-    }
-    mapFromJsonAgg(value) {
-        // Assume the database JSON value matches the ResultSet value
-        return value;
-        // return value === null
-        //   ? value
-        //   : this.isArray
-        //     ? value.map((value: any) => this.mapper.fromDb(value))
-        //     : this.mapper.fromDb(value);
-    }
-}
-exports.CustomSerdeAdapter = CustomSerdeAdapter;
+import { keyToNumber, keyToTaggedId, maybeResolveReferenceToId } from "./keys.js";
+import { requireTemporal } from "./temporal.js";
+import { arrayOutputType, canonicalDbType } from "./TypeInfo.js";
+import { getRuntimeConfig } from "./runtimeConfig.js";
+import { plainDateMapper, plainDateTimeMapper, plainTimeMapper, zonedDateTimeMapper } from "./temporalMappers.js";
+import "./index.js";
+import { isDefined } from "./EntityManager.js";
+import { createRequire } from "node:module";
+//#region src/serde.ts
+const runtimeRequire = createRequire(import.meta.url);
+var CustomSerdeAdapter = class CustomSerdeAdapter {
+	dbType;
+	mapper;
+	isArray = false;
+	constructor(dbType, mapper, isArray) {
+		this.dbType = dbType;
+		this.mapper = mapper;
+		if (isArray !== void 0) this.isArray = isArray;
+	}
+	/** Only known adapters share their mapper's identity and elementwise array conversion. */
+	get outputType() {
+		if (this.isArray !== this.dbType.endsWith("[]") || this.constructor !== CustomSerdeAdapter && this.constructor !== PlainDateSerde && this.constructor !== PlainTimeSerde && this.constructor !== PlainDateTimeSerde && this.constructor !== ZonedDateTimeSerde) return;
+		const dbType = canonicalDbType(this.dbType);
+		const elementType = this.isArray ? dbType.slice(0, -2) : dbType;
+		const outputType = {
+			dbType: elementType,
+			domain: this.mapper,
+			arrayElementSafe: elementType !== "numeric"
+		};
+		if (!this.isArray) return outputType;
+		return arrayOutputType(outputType) || [
+			"date",
+			"time",
+			"timestamp",
+			"timestamptz"
+		].includes(elementType) ? {
+			dbType,
+			domain: this.mapper
+		} : void 0;
+	}
+	/** Encodes each physical array element once. */
+	mapToDbValue(value) {
+		return value !== void 0 ? this.isArray ? value.map((element) => this.mapper.toDb(element)) : this.mapper.toDb(value) : void 0;
+	}
+	mapToRow(value) {
+		return this.mapToDbValue(value);
+	}
+	mapToDb(value) {
+		return value === null ? value : this.isArray ? value.map((element) => this.mapper.toDb(element)) : this.mapper.toDb(value);
+	}
+	/** Converts a driver value with the custom mapper, including array elements. */
+	mapFromDb(value) {
+		const dbValue = maybeNullToUndefined(value);
+		return dbValue !== void 0 ? this.isArray ? dbValue.map((value) => this.mapper.fromDb(value)) : this.mapper.fromDb(dbValue) : void 0;
+	}
+	mapFromJsonAgg(value) {
+		return value;
+	}
+};
 /**
- * Supports `string`, `int`, etc., as well as `string[]`, `int[]`, etc.
- *
- * This is not generally meant for subclassing, because it assumes things like
- * `string[]`s can be mapped 1:1. See `CustomSerdeAdapter` a good base class
- * that will handle converting individual elements.
- */
-class PrimitiveSerde {
-    fieldName;
-    columnName;
-    dbType;
-    isArray;
-    isNullableArray;
-    columns = [this];
-    constructor(fieldName, columnName, dbType, isArray = false, isNullableArray = false) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-        this.dbType = dbType;
-        this.isArray = isArray;
-        this.isNullableArray = isNullableArray;
-    }
-    setOnEntity(data, row) {
-        data[this.fieldName] = maybeNullToUndefined(row[this.columnName]);
-    }
-    dbValue(data) {
-        return this.mapToDb(data[this.fieldName]);
-    }
-    rowValue(data) {
-        return this.dbValue(data);
-    }
-    mapToDb(value) {
-        return value;
-    }
-    mapFromJsonAgg(value) {
-        return value;
-    }
-}
-exports.PrimitiveSerde = PrimitiveSerde;
-class DateSerde extends PrimitiveSerde {
-    /** Accept the caller's date as-is. */
-    mapFromNow(now) {
-        return now;
-    }
-    mapFromJsonAgg(value) {
-        if (value === null)
-            return value;
-        return new Date(value);
-    }
-    mapToDb(value) {
-        // bun.sql needs this, node-pg does it out of the box
-        return value?.toISOString();
-    }
-}
-exports.DateSerde = DateSerde;
+* Supports `string`, `int`, etc., as well as `string[]`, `int[]`, etc.
+*
+* This is not generally meant for subclassing, because it assumes things like
+* `string[]`s can be mapped 1:1. See `CustomSerdeAdapter` a good base class
+* that will handle converting individual elements.
+*/
+var PrimitiveSerde = class PrimitiveSerde {
+	dbType;
+	isArray;
+	constructor(dbType, isArray = false) {
+		this.dbType = dbType;
+		this.isArray = isArray;
+	}
+	/** Exact-class checks prevent an unknown subclass's overridden converters from sharing this codec. */
+	get outputType() {
+		if (this.constructor !== PrimitiveSerde) return void 0;
+		const dbType = canonicalDbType(this.dbType);
+		const elementType = dbType.endsWith("[]") ? dbType.slice(0, -2) : dbType;
+		if (this.isArray !== dbType.endsWith("[]")) return void 0;
+		const outputType = {
+			dbType: elementType,
+			domain: primitiveOutputDomain(elementType),
+			arrayElementSafe: elementType !== "numeric"
+		};
+		return this.isArray ? arrayOutputType(outputType) : outputType;
+	}
+	/** Primitive writes share their scalar/filter conversion, including subclass overrides. */
+	mapToDbValue(value) {
+		return this.mapToDb(value);
+	}
+	mapToRow(value) {
+		return this.mapToDbValue(value);
+	}
+	mapToDb(value) {
+		return value;
+	}
+	/** Keeps driver values as-is, with SQL NULL represented as an unset entity field. */
+	mapFromDb(value) {
+		return maybeNullToUndefined(value);
+	}
+	mapFromJsonAgg(value) {
+		return value;
+	}
+};
+var DateSerde = class DateSerde extends PrimitiveSerde {
+	/** Date bindings use ISO strings; mapToDb does not support physical Date arrays. */
+	get outputType() {
+		return this.constructor === DateSerde && !this.isArray && !this.dbType.endsWith("[]") ? {
+			dbType: canonicalDbType(this.dbType),
+			domain: DateSerde
+		} : void 0;
+	}
+	/** Accept the caller's date as-is. */
+	mapFromNow(now) {
+		return now;
+	}
+	mapFromJsonAgg(value) {
+		if (value === null) return value;
+		return new Date(value);
+	}
+	/**
+	* Returns the `Date` a driver hands back on a read, and not `mapToDb`'s ISO string.
+	*
+	* Otherwise callers that round-trip a row through `rowValue` and back through `fromRow` (i.e.
+	* `RunPlugin` mirroring writes into the test em) turn every date into a string, because our
+	* `mapFromDb` returns the row value as-is.
+	*/
+	mapToRow(value) {
+		return value;
+	}
+	mapToDb(value) {
+		return value?.toISOString();
+	}
+};
 /** Converts `DATE`s `Temporal.PlainDate`s. */
-class PlainDateSerde extends CustomSerdeAdapter {
-    constructor(fieldName, columnName, dbType, isArray = false, isNullableArray = false) {
-        super(fieldName, columnName, dbType, temporalMappers_1.plainDateMapper, isArray, isNullableArray);
-    }
-}
-exports.PlainDateSerde = PlainDateSerde;
+var PlainDateSerde = class extends CustomSerdeAdapter {
+	constructor(dbType, isArray = false) {
+		super(dbType, plainDateMapper, isArray);
+	}
+};
 /** Converts `TIME`s to `Temporal.PlainTime`s. */
-class PlainTimeSerde extends CustomSerdeAdapter {
-    constructor(fieldName, columnName, dbType, isArray = false, isNullableArray = false) {
-        super(fieldName, columnName, dbType, temporalMappers_1.plainTimeMapper, isArray, isNullableArray);
-    }
-}
-exports.PlainTimeSerde = PlainTimeSerde;
+var PlainTimeSerde = class extends CustomSerdeAdapter {
+	constructor(dbType, isArray = false) {
+		super(dbType, plainTimeMapper, isArray);
+	}
+};
 /** Converts `TIMESTAMP`s to `Temporal.PlainDateTime`s. */
-class PlainDateTimeSerde extends CustomSerdeAdapter {
-    constructor(fieldName, columnName, dbType, isArray = false, isNullableArray = false) {
-        super(fieldName, columnName, dbType, temporalMappers_1.plainDateTimeMapper, isArray, isNullableArray);
-    }
-    mapFromNow(now) {
-        const { timeZone } = (0, runtimeConfig_1.getRuntimeConfig)().temporal;
-        return (0, temporal_1.requireTemporal)().toTemporalInstant.call(now).toZonedDateTimeISO(timeZone).toPlainDateTime();
-    }
-}
-exports.PlainDateTimeSerde = PlainDateTimeSerde;
+var PlainDateTimeSerde = class extends CustomSerdeAdapter {
+	constructor(dbType, isArray = false) {
+		super(dbType, plainDateTimeMapper, isArray);
+	}
+	mapFromNow(now) {
+		const { timeZone } = getRuntimeConfig().temporal;
+		return requireTemporal().toTemporalInstant.call(now).toZonedDateTimeISO(timeZone).toPlainDateTime();
+	}
+};
 /** Converts `TIMESTAMP WITH TIME ZONE`s to `Temporal.ZonedDateTime`s. */
-class ZonedDateTimeSerde extends CustomSerdeAdapter {
-    constructor(fieldName, columnName, dbType, isArray = false, isNullableArray = false) {
-        super(fieldName, columnName, dbType, temporalMappers_1.zonedDateTimeMapper, isArray, isNullableArray);
-    }
-    mapFromNow(now) {
-        const { timeZone } = (0, runtimeConfig_1.getRuntimeConfig)().temporal;
-        return (0, temporal_1.requireTemporal)().toTemporalInstant.call(now).toZonedDateTimeISO(timeZone);
-    }
-}
-exports.ZonedDateTimeSerde = ZonedDateTimeSerde;
-class BigIntSerde {
-    fieldName;
-    columnName;
-    isArray = false;
-    isNullableArray = false;
-    columns = [this];
-    dbType = "bigint";
-    constructor(fieldName, columnName) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-    }
-    setOnEntity(data, row) {
-        const value = maybeNullToUndefined(row[this.columnName]);
-        data[this.fieldName] = value ? BigInt(value) : value;
-    }
-    dbValue(data) {
-        return data[this.fieldName];
-    }
-    rowValue(data) {
-        return this.dbValue(data);
-    }
-    mapToDb(value) {
-        return value;
-    }
-    mapFromJsonAgg(value) {
-        return value === null ? value : BigInt(value);
-    }
-}
-exports.BigIntSerde = BigIntSerde;
+var ZonedDateTimeSerde = class extends CustomSerdeAdapter {
+	constructor(dbType, isArray = false) {
+		super(dbType, zonedDateTimeMapper, isArray);
+	}
+	mapFromNow(now) {
+		const { timeZone } = getRuntimeConfig().temporal;
+		return requireTemporal().toTemporalInstant.call(now).toZonedDateTimeISO(timeZone);
+	}
+};
+var BigIntSerde = class BigIntSerde {
+	isArray;
+	dbType;
+	constructor(isArray = false) {
+		this.isArray = isArray;
+		this.dbType = isArray ? "bigint[]" : "bigint";
+	}
+	/** BigInt conversion is distinct from both the driver's int8 value and Number aggregates. */
+	get outputType() {
+		if (this.constructor !== BigIntSerde) return void 0;
+		const elementType = {
+			dbType: "int8",
+			domain: BigIntSerde,
+			arrayElementSafe: true
+		};
+		return this.isArray ? arrayOutputType(elementType) : elementType;
+	}
+	/** Drivers accept native bigint values without conversion. */
+	mapToDbValue(value) {
+		if (this.isArray) assertFlatNumericArray(value);
+		return value;
+	}
+	mapToRow(value) {
+		return this.mapToDbValue(value);
+	}
+	mapToDb(value) {
+		return value;
+	}
+	/** Converts the driver's bigint representation to the entity value. */
+	mapFromDb(value) {
+		const dbValue = maybeNullToUndefined(value);
+		if (this.isArray && dbValue !== void 0) {
+			assertFlatNumericArray(dbValue);
+			return dbValue.map((element) => element === null ? null : BigInt(element));
+		}
+		return dbValue ? BigInt(dbValue) : dbValue;
+	}
+	mapFromJsonAgg(value) {
+		return value === null ? value : this.isArray ? this.mapFromDb(value) : BigInt(value);
+	}
+};
 /**
- * Maps `decimal(...)` database types to the JS `number`.
- *
- * Note that we assume the db values are within the range of the JS `number`;
- * we should eventually sanity check that.
- *
- * Also note that knex/pg accept `number`s as input, so we only need
- * to handle from-database -> to JS translation.
- */
-class DecimalToNumberSerde {
-    fieldName;
-    columnName;
-    dbType = "decimal";
-    isArray = false;
-    isNullableArray = false;
-    columns = [this];
-    constructor(fieldName, columnName) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-    }
-    setOnEntity(data, row) {
-        const value = maybeNullToUndefined(row[this.columnName]);
-        data[this.fieldName] = value !== undefined ? Number(value) : value;
-    }
-    dbValue(data) {
-        return data[this.fieldName];
-    }
-    rowValue(data) {
-        return this.dbValue(data);
-    }
-    mapToDb(value) {
-        return value;
-    }
-    mapFromJsonAgg(value) {
-        return value === null ? value : Number(value);
-    }
-}
-exports.DecimalToNumberSerde = DecimalToNumberSerde;
+* Maps `decimal(...)` database types to the JS `number`.
+*
+* Note that we assume the db values are within the range of the JS `number`;
+* we should eventually sanity check that.
+*
+* Also note that knex/pg accept `number`s as input, so we only need
+* to handle from-database -> to JS translation.
+*/
+var DecimalToNumberSerde = class DecimalToNumberSerde {
+	isArray;
+	dbType;
+	constructor(isArray = false) {
+		this.isArray = isArray;
+		this.dbType = isArray ? "numeric[]" : "decimal";
+	}
+	/** Numeric aggregates use the same Number conversion and identity binding encoder. */
+	get outputType() {
+		if (this.constructor !== DecimalToNumberSerde) return void 0;
+		const elementType = {
+			dbType: "numeric",
+			domain: Number,
+			arrayElementSafe: true
+		};
+		return this.isArray ? arrayOutputType(elementType) : elementType;
+	}
+	/** Drivers accept decimal numbers without conversion. */
+	mapToDbValue(value) {
+		if (this.isArray) assertFlatNumericArray(value);
+		return value;
+	}
+	mapToRow(value) {
+		return this.mapToDbValue(value);
+	}
+	mapToDb(value) {
+		return value;
+	}
+	/** Converts a driver decimal value to a JavaScript number. */
+	mapFromDb(value) {
+		const dbValue = maybeNullToUndefined(value);
+		if (this.isArray && dbValue !== void 0) {
+			assertFlatNumericArray(dbValue);
+			return dbValue.map((element) => element === null ? null : Number(element));
+		}
+		return dbValue !== void 0 ? Number(dbValue) : dbValue;
+	}
+	mapFromJsonAgg(value) {
+		return value === null ? value : this.isArray ? this.mapFromDb(value) : Number(value);
+	}
+};
 /** Maps physical integer keys to logical string IDs "because GraphQL". */
-class KeySerde {
-    fieldName;
-    columnName;
-    dbType;
-    isArray = false;
-    isNullableArray = false;
-    columns = [this];
-    meta;
-    constructor(tagName, fieldName, columnName, dbType) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-        this.dbType = dbType;
-        this.meta = { tagName, idDbType: dbType };
-    }
-    setOnEntity(data, row) {
-        data[this.fieldName] = (0, index_1.keyToTaggedId)(this.meta, row[this.columnName]);
-    }
-    dbValue(data, entity, tableName, fixups) {
-        const value = data[this.fieldName];
-        if (fixups &&
-            (0, index_1.isEntity)(value) &&
-            value.isNewEntity &&
-            (0, EntityMetadata_1.getMetadata)(value).nonDeferredFkOrder &&
-            (0, EntityMetadata_1.getMetadata)(entity).nonDeferredFkOrder &&
-            (0, EntityMetadata_1.getMetadata)(value).nonDeferredFkOrder >= (0, EntityMetadata_1.getMetadata)(entity).nonDeferredFkOrder) {
-            fixups.push({
-                entity,
-                tableName,
-                column: this,
-                value: (0, index_1.keyToNumber)(this.meta, (0, index_1.maybeResolveReferenceToId)(value)),
-            });
-            return null;
-        }
-        return (0, index_1.keyToNumber)(this.meta, (0, index_1.maybeResolveReferenceToId)(value));
-    }
-    rowValue(data) {
-        // we don't have any fixups since we are trying to recreate what comes out of the db, so this is safe
-        return this.dbValue(data, undefined, undefined, undefined);
-    }
-    mapToDb(value) {
-        // Sometimes the nilIdValue will pass -1 as already a number, but usually this should be a tagged id
-        return value === null || typeof value === "number"
-            ? value
-            : // We go through `maybeResolveReferenceToId` because filters like `in: [a1, a2]` will pass the
-                // entity directly into mapToDb and not convert it to a tagged id first.
-                (0, index_1.keyToNumber)(this.meta, (0, index_1.maybeResolveReferenceToId)(value));
-    }
-    mapFromJsonAgg(value) {
-        return value === null ? value : value;
-    }
-}
-exports.KeySerde = KeySerde;
-class PolymorphicKeySerde {
-    meta;
-    fieldName;
-    constructor(meta, fieldName) {
-        this.meta = meta;
-        this.fieldName = fieldName;
-    }
-    setOnEntity(data, row) {
-        this.columns
-            .filter((column) => !!row[column.columnName])
-            .forEach((column) => {
-            data[this.fieldName] ??= (0, index_1.keyToTaggedId)(column.otherMetadata(), row[column.columnName]);
-        });
-    }
-    // Lazy b/c we use PolymorphicField which we can't access in our cstr
-    get columns() {
-        const { fieldName } = this;
-        // If our poly has multiple components from the same base type, i.e.
-        // `parent_small_publisher_id` and `parent_large_publisher_id`, then we
-        // need slightly different logic...
-        const hasMultipleComponentsWithSameBaseType = [
-            ...(0, utils_1.groupBy)(this.field.components, (comp) => (0, EntityMetadata_1.getBaseMeta)(comp.otherMetadata()).type).values(),
-        ].some((group) => group.length > 1);
-        return this.field.components.map((comp) => ({
-            columnName: comp.columnName,
-            dbType: comp.otherMetadata().idDbType,
-            isArray: false,
-            isNullableArray: false,
-            otherMetadata: comp.otherMetadata,
-            dbValue(data) {
-                const id = (0, index_1.maybeResolveReferenceToId)(data[fieldName]);
-                const cstr = id ? (0, index_1.getConstructorFromTaggedId)(id) : undefined;
-                // We'll have multiple columns, i.e. [parent_author_id, parent_book_id], and each column
-                // will only return a value if the `id` matches its type, i.e. `parent_author_id=a:1` will
-                // return 1, but `parent_book_id` will return null.
-                const idAppliesToThisColumn = hasMultipleComponentsWithSameBaseType
-                    ? cstr === comp.otherMetadata().cstr
-                    : cstr === (0, EntityMetadata_1.getBaseMeta)(comp.otherMetadata()).cstr;
-                return idAppliesToThisColumn ? (0, index_1.keyToNumber)(comp.otherMetadata(), id) : undefined;
-            },
-            mapToDb(value) {
-                return (0, index_1.keyToNumber)(comp.otherMetadata(), (0, index_1.maybeResolveReferenceToId)(value));
-            },
-            mapFromJsonAgg(value) {
-                return value === null ? value : value;
-            },
-            rowValue(data) {
-                return this.dbValue(data);
-            },
-        }));
-    }
-    get columnName() {
-        throw new Error("Unsupported");
-    }
-    // Lazy b/c we use PolymorphicField which we can't access in our cstr
-    get field() {
-        return this.meta().fields[this.fieldName];
-    }
-}
-exports.PolymorphicKeySerde = PolymorphicKeySerde;
-class EnumFieldSerde {
-    fieldName;
-    columnName;
-    dbType;
-    enumObject;
-    isArray = false;
-    isNullableArray = false;
-    columns = [this];
-    constructor(fieldName, columnName, dbType, enumObject) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-        this.dbType = dbType;
-        this.enumObject = enumObject;
-    }
-    setOnEntity(data, row) {
-        data[this.fieldName] = this.enumObject.findById(row[this.columnName])?.code;
-    }
-    dbValue(data) {
-        return this.enumObject.findByCode(data[this.fieldName])?.id;
-    }
-    rowValue(data) {
-        return this.dbValue(data);
-    }
-    mapToDb(value) {
-        return this.enumObject.findByCode(value)?.id;
-    }
-    mapFromJsonAgg(value) {
-        return value === null ? value : value;
-    }
-}
-exports.EnumFieldSerde = EnumFieldSerde;
-class EnumArrayFieldSerde {
-    fieldName;
-    columnName;
-    dbType;
-    isNullableArray;
-    enumObject;
-    isArray = true;
-    columns = [this];
-    constructor(fieldName, columnName, dbType, isNullableArray, enumObject) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-        this.dbType = dbType;
-        this.isNullableArray = isNullableArray;
-        this.enumObject = enumObject;
-    }
-    setOnEntity(data, row) {
-        data[this.fieldName] = row[this.columnName]?.map((id) => this.enumObject.findById(id).code) || [];
-    }
-    dbValue(data) {
-        return data[this.fieldName]?.map((code) => this.enumObject.getByCode(code).id) || [];
-    }
-    rowValue(data) {
-        return this.dbValue(data);
-    }
-    mapToDb(value) {
-        return !value ? [] : value.map((code) => this.enumObject.getByCode(code).id);
-    }
-    mapFromJsonAgg(value) {
-        return value === null ? value : value;
-    }
-}
-exports.EnumArrayFieldSerde = EnumArrayFieldSerde;
-function maybeNullToUndefined(value) {
-    return value === null ? undefined : value;
-}
+var KeySerde = class KeySerde {
+	dbType;
+	isArray = false;
+	meta;
+	constructor(tagName, dbType) {
+		this.dbType = dbType;
+		this.meta = {
+			tagName,
+			idDbType: dbType
+		};
+	}
+	/** PKs and FKs share a tag and SQL representation; the alias supplies the exact target idMeta. */
+	get outputType() {
+		return this.constructor === KeySerde && !this.isArray ? {
+			dbType: canonicalDbType(this.dbType),
+			domain: `key:${this.meta.tagName}`,
+			arrayElementSafe: true
+		} : void 0;
+	}
+	/** Resolves references and tagged, untagged, or numeric ids using the column's tag and storage type. */
+	mapToDbValue(value) {
+		return keyToNumber(this.meta, typeof value === "number" ? value : maybeResolveReferenceToId(value));
+	}
+	mapToRow(value) {
+		return this.mapToDbValue(value);
+	}
+	mapToDb(value) {
+		if (value === null || typeof value === "number") return value;
+		return keyToNumber(this.meta, maybeResolveReferenceToId(value));
+	}
+	/** Converts a physical primary or foreign key to a tagged id. */
+	mapFromDb(value) {
+		return keyToTaggedId(this.meta, value);
+	}
+	mapFromJsonAgg(value) {
+		return value === null ? value : value;
+	}
+};
+var EnumFieldSerde = class EnumFieldSerde {
+	dbType;
+	enumObject;
+	isArray = false;
+	constructor(dbType, enumObject) {
+		this.dbType = dbType;
+		this.enumObject = enumObject;
+	}
+	/** Separate fields of the same generated enum share its code/id mapping. */
+	get outputType() {
+		return this.constructor === EnumFieldSerde && !this.isArray ? {
+			dbType: canonicalDbType(this.dbType),
+			domain: this.enumObject,
+			arrayElementSafe: true
+		} : void 0;
+	}
+	/** Resolves the enum code to its stored id, leaving an unknown code unset. */
+	mapToDbValue(value) {
+		return this.enumObject.findByCode(value)?.id;
+	}
+	mapToRow(value) {
+		return this.mapToDbValue(value);
+	}
+	mapToDb(value) {
+		return this.enumObject.findByCode(value)?.id;
+	}
+	/** Converts a stored enum id to its enum code. */
+	mapFromDb(value) {
+		return this.enumObject.findById(value)?.code;
+	}
+	mapFromJsonAgg(value) {
+		return value === null ? value : value;
+	}
+};
+var EnumArrayFieldSerde = class {
+	dbType;
+	enumObject;
+	isArray = true;
+	constructor(dbType, enumObject) {
+		this.dbType = dbType;
+		this.enumObject = enumObject;
+	}
+	/** Physical enum arrays reject null elements, unlike scalar enum arrayAgg; leave them unknown. */
+	get outputType() {}
+	/** Resolves each enum code to its stored id, retaining the entity's empty-array default. */
+	mapToDbValue(value) {
+		return value?.map((code) => this.enumObject.getByCode(code).id) || [];
+	}
+	mapToRow(value) {
+		return this.mapToDbValue(value);
+	}
+	mapToDb(value) {
+		return !value ? [] : value.map((code) => this.enumObject.getByCode(code).id);
+	}
+	/** Converts stored enum ids to codes, defaulting an unset entity field to an empty array. */
+	mapFromDb(value) {
+		return value?.map((id) => this.enumObject.findById(id).code) || [];
+	}
+	mapFromJsonAgg(value) {
+		return value === null ? value : value;
+	}
+};
 /** Similar to SimpleSerde, but applies the superstruct `assert` function when reading values from the db. */
-class SuperstructSerde {
-    fieldName;
-    columnName;
-    superstruct;
-    dbType = "jsonb";
-    isArray = false;
-    isNullableArray = false;
-    columns = [this];
-    // Use a dynamic require so that downstream projects don't have to depend on superstruct
-    // until they want to, i.e. we don't have superstruct in the joist-orm package.json.
-    assert = require("superstruct").assert;
-    constructor(fieldName, columnName, superstruct) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-        this.superstruct = superstruct;
-    }
-    setOnEntity(data, row) {
-        const value = maybeNullToUndefined(row[this.columnName]);
-        if (value) {
-            this.assert(value, this.superstruct);
-        }
-        data[this.fieldName] = value;
-    }
-    dbValue(data) {
-        return JSON.stringify(data[this.fieldName]);
-    }
-    // JSON is returned by postgres already parsed, so we should just be able to return our data directly. Unlike with
-    // JsonSerde, we can assume that superstruct would have parsed any complex types in the json correctly so we don't
-    // need to do a round trip through JSON.stringify.
-    rowValue(data) {
-        return data[this.fieldName];
-    }
-    mapToDb(value) {
-        return JSON.stringify(value);
-    }
-    mapFromJsonAgg(value) {
-        return value === null ? value : value;
-    }
+var SuperstructSerde = class SuperstructSerde {
+	superstruct;
+	dbType = "jsonb";
+	isArray = false;
+	assert = runtimeRequire("superstruct").assert;
+	constructor(superstruct) {
+		this.superstruct = superstruct;
+	}
+	/** JSON schemas describe a jsonb value, even when that value is a JSON array. */
+	get outputType() {
+		return this.constructor === SuperstructSerde && !this.isArray ? {
+			dbType: canonicalDbType(this.dbType),
+			domain: this.superstruct,
+			arrayElementSafe: true
+		} : void 0;
+	}
+	/** Serializes the domain JSON value without running the read-time schema validation. */
+	mapToDbValue(value) {
+		return JSON.stringify(value);
+	}
+	mapToRow(value) {
+		return value;
+	}
+	mapToDb(value) {
+		return JSON.stringify(value);
+	}
+	/** Validates a driver JSON value with the field's Superstruct schema. */
+	mapFromDb(value) {
+		const dbValue = maybeNullToUndefined(value);
+		if (dbValue) this.assert(dbValue, this.superstruct);
+		return dbValue;
+	}
+	mapFromJsonAgg(value) {
+		return value === null ? value : value;
+	}
+};
+var JsonSerde = class JsonSerde {
+	dbType = "jsonb";
+	isArray = false;
+	constructor() {}
+	/** Unvalidated JSON uses its own encoder, not a primitive or schema-specific codec. */
+	get outputType() {
+		return this.constructor === JsonSerde && !this.isArray ? {
+			dbType: canonicalDbType(this.dbType),
+			domain: JsonSerde,
+			arrayElementSafe: true
+		} : void 0;
+	}
+	/** Serializes the whole JSON value, including JSON arrays and custom toJSON methods. */
+	mapToDbValue(value) {
+		return JSON.stringify(value);
+	}
+	mapToRow(value) {
+		const json = JSON.stringify(value);
+		return isDefined(json) ? JSON.parse(json) : void 0;
+	}
+	mapToDb(value) {
+		return JSON.stringify(value);
+	}
+	/** Keeps the driver's parsed JSON value, normalizing SQL NULL for entity fields. */
+	mapFromDb(value) {
+		return maybeNullToUndefined(value);
+	}
+	mapFromJsonAgg(value) {
+		return value === null ? value : value;
+	}
+};
+/** Similar to SimpleSerde, but applies the zod's `parse` function when reading values from the db. */
+var ZodSerde = class ZodSerde {
+	zodSchema;
+	dbType = "jsonb";
+	isArray = false;
+	constructor(zodSchema) {
+		this.zodSchema = zodSchema;
+	}
+	/** Parsing and transformations are compatible only for the same schema object. */
+	get outputType() {
+		return this.constructor === ZodSerde && !this.isArray ? {
+			dbType: canonicalDbType(this.dbType),
+			domain: this.zodSchema,
+			arrayElementSafe: true
+		} : void 0;
+	}
+	/** Serializes the domain JSON value without running the read-time Zod parser or transforms. */
+	mapToDbValue(value) {
+		return JSON.stringify(value);
+	}
+	mapToRow(value) {
+		return value;
+	}
+	mapToDb(value) {
+		return JSON.stringify(value);
+	}
+	/** Parses a driver JSON value with the field's Zod schema. */
+	mapFromDb(value) {
+		const dbValue = maybeNullToUndefined(value);
+		return dbValue ? this.zodSchema.parse(dbValue) : dbValue;
+	}
+	mapFromJsonAgg(value) {
+		return value === null ? value : value;
+	}
+};
+/** PostgreSQL does not enforce declared array dimensions; reject nested values rather than coercing subarrays. */
+function assertFlatNumericArray(value) {
+	if (Array.isArray(value) && value.some(Array.isArray)) throw new Error("Native numeric arrays must be one-dimensional");
 }
-exports.SuperstructSerde = SuperstructSerde;
-class JsonSerde {
-    fieldName;
-    columnName;
-    dbType = "jsonb";
-    isArray = false;
-    isNullableArray = false;
-    columns = [this];
-    constructor(fieldName, columnName) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-    }
-    setOnEntity(data, row) {
-        data[this.fieldName] = maybeNullToUndefined(row[this.columnName]);
-    }
-    dbValue(data) {
-        return JSON.stringify(data[this.fieldName]);
-    }
-    // JSON is returned by postgres already parsed, so if we are trying to recreate then we need to stringify, then parse.
-    // It's necessary to do this instead of just returning the object directly because any complex types in the json need
-    // to be stringified to correctly reflect the db value.
-    rowValue(data) {
-        const json = JSON.stringify(data[this.fieldName]);
-        return (0, index_1.isDefined)(json) ? JSON.parse(json) : undefined;
-    }
-    mapToDb(value) {
-        return JSON.stringify(value);
-    }
-    mapFromJsonAgg(value) {
-        return value === null ? value : value;
-    }
+/** Only driver-native numbers agree with Number aggregates; int8/numeric identity values do not. */
+function primitiveOutputDomain(dbType) {
+	switch (dbType) {
+		case "int2":
+		case "int4":
+		case "float4":
+		case "float8": return Number;
+		case "text":
+		case "varchar":
+		case "bpchar": return String;
+		default: return PrimitiveSerde;
+	}
 }
-exports.JsonSerde = JsonSerde;
-/** Similar to SimpleSerde, but applies the zod's `parse` function when reading values from the db. */
-class ZodSerde {
-    fieldName;
-    columnName;
-    zodSchema;
-    dbType = "jsonb";
-    isArray = false;
-    isNullableArray = false;
-    columns = [this];
-    constructor(fieldName, columnName, zodSchema) {
-        this.fieldName = fieldName;
-        this.columnName = columnName;
-        this.zodSchema = zodSchema;
-    }
-    setOnEntity(data, row) {
-        const value = maybeNullToUndefined(row[this.columnName]);
-        if (value) {
-            data[this.fieldName] = this.zodSchema.parse(value);
-        }
-        else {
-            data[this.fieldName] = value;
-        }
-    }
-    dbValue(data) {
-        // assume the data is already valid b/c it came from the entity
-        return JSON.stringify(data[this.fieldName]);
-    }
-    // JSON is returned by postgres already parsed, so we should just be able to return our data directly. Unlike with
-    // JsonSerde, we can assume that zod would have parsed any complex types in the json correctly so we don't need to
-    // do a round trip through JSON.stringify.
-    rowValue(data) {
-        return data[this.fieldName];
-    }
-    mapToDb(value) {
-        return JSON.stringify(value);
-    }
-    mapFromJsonAgg(value) {
-        return value === null ? value : value;
-    }
+/** Normalizes SQL NULL to an unset entity field. */
+function maybeNullToUndefined(value) {
+	return value === null ? void 0 : value;
 }
-exports.ZodSerde = ZodSerde;
+//#endregion
+export { BigIntSerde, CustomSerdeAdapter, DateSerde, DecimalToNumberSerde, EnumArrayFieldSerde, EnumFieldSerde, JsonSerde, KeySerde, PlainDateSerde, PlainDateTimeSerde, PlainTimeSerde, PrimitiveSerde, SuperstructSerde, ZodSerde, ZonedDateTimeSerde };
+
 //# sourceMappingURL=serde.js.map