@rebasepro/server-postgres 0.19.2-canary.gef769df → 0.20.1-canary.g4d882ca

package/dist/index.es.js

@@ -2537,12 +2537,49 @@ function coerceDeclaredNumber(value, property) {
 	const parsed = parseFloat(value);
 	return isNaN(parsed) ? null : parsed;
 }
-/** Apply {@link coerceDeclaredNumber} across a row, leaving every other column alone. */
-function coerceDeclaredNumbers(row, collection) {
+/**
+* Serve a `date` column as the timestamp this API says it serves.
+*
+* The OpenAPI document this server publishes types a `date` property as
+* `string, format: date-time` — RFC 3339 — and node-postgres hands over the
+* Postgres literal: `"2026-08-24 01:37:57.647+02"`, with a space where the `T`
+* belongs and a two-digit offset. V8 parses that by accident; Safari's
+* `new Date()` does not have to, and the spec never promised it. A column whose
+* documented type only parses in some browsers is not a contract.
+*
+* A date-only column (`mode: "date"`, `format: "date"` in the spec) is already
+* RFC 3339 as `YYYY-MM-DD` and is left alone — widening it to a timestamp would
+* invent a time of day and a timezone the column does not have.
+*/
+function toRestDate(value) {
+	if (value instanceof Date) return isNaN(value.getTime()) ? null : value.toISOString();
+	if (value && typeof value === "object" && value.__type === "date") return value.value ?? null;
+	if (typeof value !== "string" && typeof value !== "number") return value;
+	if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
+	const date = new Date(value);
+	return isNaN(date.getTime()) ? value : date.toISOString();
+}
+/**
+* One scalar, as REST serves it: declared numbers as numbers, declared dates as
+* RFC 3339, everything else exactly as the database returned it.
+*/
+function toRestScalar(value, property) {
+	if (property?.type === "date") return toRestDate(value);
+	return coerceDeclaredNumber(value, property);
+}
+/**
+* Apply {@link toRestScalar} across a row, leaving undeclared columns alone.
+*
+* Exported because the include loader attaches related rows itself, and a
+* target rendered differently from its parent is the shape bug this whole file
+* exists to prevent — a date was a string at the top level and a
+* `{ __type: "date" }` envelope one level down, in the same response.
+*/
+function toRestValues(row, collection) {
 	const properties = collection.properties;
 	if (!properties) return row;
 	const out = {};
-	for (const [key, value] of Object.entries(row)) out[key] = coerceDeclaredNumber(value, properties[key]);
+	for (const [key, value] of Object.entries(row)) out[key] = toRestScalar(value, properties[key]);
 	return out;
 }
 /** Render one target row in the requested style. */
@@ -2588,7 +2625,7 @@ function stripUnreadable(row, collection) {
 	return row;
 }
 function renderTarget(targetRow, targetCollection, style, registry) {
-	if (style === "inline") return stripUnreadable(coerceDeclaredNumbers({ ...targetRow }, targetCollection), targetCollection);
+	if (style === "inline") return stripUnreadable(toRestValues({ ...targetRow }, targetCollection), targetCollection);
 	const address = relationTargetAddress(targetRow, targetCollection, registry);
 	const path = targetCollection.slug;
 	return createRelationRefWithData(address, path, {
@@ -2638,9 +2675,9 @@ function toFlatRow(row, collection, registry) {
 *
 * Values are the ones the database returned, except where that contradicts the
 * declared type: a `number` property is served as a number (see
-* {@link coerceDeclaredNumber}). Dates stay as the database returned them —
-* JSON has its own opinions about dates that the admin's view-model does not
-* share.
+* {@link coerceDeclaredNumber}) and a `date` as RFC 3339, which is what this
+* server's own OpenAPI document says a date column is (see
+* {@link toRestDate}).
 *
 * Keyed by the row rather than by the relation list — a REST fetch only loads
 * the relations `include` asked for, so the row is the authority on which are
@@ -2653,7 +2690,7 @@ function toRestRow(row, collection, registry) {
 		const relation = findRelation(resolvedRelations, key);
 		if (relation && Array.isArray(value)) flat[key] = value.map((item) => renderTarget(isJunctionRelation(relation) ? unwrapJunctionRow(item) : item, relation.target(), "inline", registry));
 		else if (relation && typeof value === "object" && value !== null) flat[key] = renderTarget(value, relation.target(), "inline", registry);
-		else flat[key] = coerceDeclaredNumber(value, collection.properties?.[key]);
+		else flat[key] = toRestScalar(value, collection.properties?.[key]);
 	}
 	return stripUnreadable(flat, collection);
 }
@@ -3515,6 +3552,28 @@ function compareForSort(a, b, nullsLast) {
 * Service for handling all row read operations.
 * Handles fetching, searching, counting, and filtering rows.
 */
+/**
+* Which aggregate aliases hold a number that Postgres handed back as a string.
+*
+* `count`, `sum` and `avg` always do: bigint and numeric are returned as text
+* because they do not fit a JS number in general. `min` and `max` are uncast,
+* so they do it too — but only over a numeric column, and those are the two
+* functions that also apply to text and dates.
+*
+* Decided by the column's DECLARED type, not by trying `Number()` on the value.
+* `?select=avg(price),max(price)` used to answer `{avg_price: 5,
+* max_price: "8.5"}` — one column, two functions, two JSON types, and
+* arithmetic on the second one silently concatenates. Parsing whatever looks
+* numeric would fix that and break something worse: a `min(sku)` of `"00123"`
+* would come back as `123`, a different value, and no NaN check would catch it.
+*
+* Exported to be tested: the parsing itself needs a database, this decision
+* does not.
+*/
+function numericAggregateAliases(aggregates, properties) {
+	const isNumberField = (field) => Boolean(field) && properties[field]?.type === "number";
+	return new Set(aggregates.filter((a) => a.fn === "count" || a.fn === "sum" || a.fn === "avg" || (a.fn === "min" || a.fn === "max") && isNumberField(a.field)).map((a) => a.alias));
+}
 var FetchService = class FetchService {
 	db;
 	registry;
@@ -3909,7 +3968,7 @@ var FetchService = class FetchService {
 							row[key] = null;
 							continue;
 						}
-						const [shaped] = this.shapeRelatedRows([{ ...related.values }], node, targetCollection);
+						const [shaped] = this.shapeRelatedRows([toRestValues({ ...related.values }, targetCollection)], node, targetCollection);
 						row[key] = shaped;
 						loaded.push(shaped);
 					}
@@ -3917,7 +3976,7 @@ var FetchService = class FetchService {
 					const results = await this.relationService.batchFetchRelatedEntitiesMany(collectionPath, rowIds, key, relation, narrow);
 					for (const row of addressable) {
 						const related = results.get(String(addressOf(row))) ?? [];
-						const shaped = this.shapeRelatedRows(related.map((e) => ({ ...e.values })), node, targetCollection);
+						const shaped = this.shapeRelatedRows(related.map((e) => toRestValues({ ...e.values }, targetCollection)), node, targetCollection);
 						row[key] = shaped;
 						loaded.push(...shaped);
 					}
@@ -4355,7 +4414,7 @@ var FetchService = class FetchService {
 			if (options.limit) query = query.limit(options.limit);
 		}
 		const rows = await query;
-		const numericAliases = new Set(options.aggregates.filter((a) => a.fn === "count" || a.fn === "sum" || a.fn === "avg").map((a) => a.alias));
+		const numericAliases = numericAggregateAliases(options.aggregates, collection?.properties ?? {});
 		return rows.map((row) => {
 			const out = { ...row };
 			for (const alias of numericAliases) {
@@ -5120,7 +5179,7 @@ var PersistService = class {
 		} catch (error) {
 			throw this.toUserFriendlyError(error, collection.slug, collection);
 		}
-		const finalEntity = await this.fetchService.fetchOneForRest(collection.slug, savedId, void 0, databaseId);
+		const finalEntity = await this.fetchService.fetchOneForRest(collection.slug, savedId, void 0, databaseId, { withDeleted: true });
 		if (!finalEntity) throw new Error("Could not fetch row after save.");
 		return finalEntity;
 	}