@metaobjectsdev/runtime-ts 0.9.0-rc.1 → 0.10.0

package/src/type-coercer.ts

@@ -1,22 +1,107 @@
-// v0.1 only handles SQLite's int↔boolean. Date/timestamp coercion (ISO string ↔ Date) is deferred.
+// Read/write value coercion at the persistence boundary.
+//
+//  - SQLite has no native boolean: booleans are stored as 0/1 ints, so we map
+//    boolean↔int on the way in/out for that dialect only.
+//  - JSONB-backed object/map fields: the driver (node-postgres) does NOT
+//    serialize a plain JS object to a jsonb column — it must arrive as a JSON
+//    string, or the write fails / writes "[object Object]". A `field.object`
+//    (default + `@storage: jsonb`) and any field carrying `@dbColumnType: jsonb`
+//    whose value is an object are JSON.stringify'd on write. (Read-back parsing
+//    is handled by node-pg's jsonb parser, which returns a parsed object.)
+//
+// Date/timestamp coercion (ISO string ↔ Date) is deferred: pg accepts ISO
+// strings for temporal columns directly, and the temporal read parsers pin the
+// wire form.
 
 import type { MetaData } from "@metaobjectsdev/metadata";
-import { TYPE_FIELD, FIELD_SUBTYPE_BOOLEAN } from "@metaobjectsdev/metadata";
+import {
+  TYPE_FIELD,
+  FIELD_SUBTYPE_BOOLEAN,
+  FIELD_SUBTYPE_OBJECT,
+  FIELD_ATTR_STORAGE,
+  FIELD_ATTR_DB_COLUMN_TYPE,
+  STORAGE_JSONB,
+  STORAGE_FLATTENED,
+  DB_COLUMN_TYPE_JSONB,
+} from "@metaobjectsdev/metadata";
 import type { Dialect, Row } from "./persistence-driver.js";
 
 export function coerceRowOnRead(entity: MetaData, row: Row, dialect: Dialect): Row {
-  if (dialect !== "sqlite") return row;
-  return mapBooleansFromInt(entity, row);
+  const hydrated = deserializeJsonbObjectFields(entity, row);
+  if (dialect !== "sqlite") return hydrated;
+  return mapBooleansFromInt(entity, hydrated);
 }
 
 export function coerceRowOnWrite(entity: MetaData, row: Row, dialect: Dialect): Row {
-  if (dialect !== "sqlite") return row;
-  return mapBooleansToInt(entity, row);
+  const jsonbColumned = serializeJsonbColumns(entity, row);
+  if (dialect !== "sqlite") return jsonbColumned;
+  return mapBooleansToInt(entity, jsonbColumned);
+}
+
+/**
+ * A `field.object` lands in a single JSONB column unless its `@storage` is
+ * `flattened` (then it expands to prefixed columns and has no column of its own).
+ * Default (no `@storage`) and `@storage: jsonb` both store one jsonb column.
+ */
+function isJsonbObjectField(child: MetaData): boolean {
+  if (child.subType !== FIELD_SUBTYPE_OBJECT) return false;
+  return child.ownAttr(FIELD_ATTR_STORAGE) !== STORAGE_FLATTENED;
+}
+
+/** A field explicitly pinned to a JSONB physical column via `@dbColumnType`. */
+function isJsonbColumnTypeField(child: MetaData): boolean {
+  return child.ownAttr(FIELD_ATTR_DB_COLUMN_TYPE) === DB_COLUMN_TYPE_JSONB;
+}
+
+function serializeJsonbColumns(entity: MetaData, row: Row): Row {
+  let out: Row | null = null;
+  for (const child of entity.ownChildren()) {
+    if (child.type !== TYPE_FIELD) continue;
+    if (!isJsonbObjectField(child) && !isJsonbColumnTypeField(child)) continue;
+    if (!(child.name in row)) continue;
+    const v = row[child.name];
+    // Only objects/arrays need stringifying; an already-serialized string passes
+    // through unchanged (the existing Asset.payload contract), as does null.
+    if (v === null || v === undefined || typeof v !== "object") continue;
+    out ??= { ...row };
+    out[child.name] = JSON.stringify(v);
+  }
+  return out ?? row;
+}
+
+/**
+ * Read-side complement of `serializeJsonbColumns`: a `field.object` jsonb column
+ * is the structured-VO storage and must round-trip as a native object (ADR-0019),
+ * not the serialized string. node-pg's jsonb parser already returns a parsed
+ * object for the postgres driver, so this only acts on a still-stringified value
+ * (the in-memory test driver, or any driver that does not parse jsonb) — an
+ * already-parsed object/array passes through untouched. Only `field.object`
+ * columns are hydrated; a `field.string @dbColumnType: jsonb` stays the raw
+ * string it is declared to be. A non-JSON string is left as-is.
+ */
+function deserializeJsonbObjectFields(entity: MetaData, row: Row): Row {
+  let out: Row | null = null;
+  for (const child of entity.ownChildren()) {
+    if (child.type !== TYPE_FIELD) continue;
+    if (!isJsonbObjectField(child)) continue;
+    if (!(child.name in row)) continue;
+    const v = row[child.name];
+    if (typeof v !== "string") continue;
+    try {
+      const parsed = JSON.parse(v);
+      out ??= { ...row };
+      out[child.name] = parsed;
+    } catch {
+      // Not JSON — leave the raw string in place.
+    }
+  }
+  return out ?? row;
 }
 
 function mapBooleansFromInt(entity: MetaData, row: Row): Row {
   const out: Row = { ...row };
-  for (const child of entity.ownChildren()) {
+  // Effective children so a TPH subtype coerces inherited boolean fields too.
+  for (const child of entity.children()) {
     if (child.type !== TYPE_FIELD) continue;
     if (child.subType !== FIELD_SUBTYPE_BOOLEAN) continue;
     const v = out[child.name];
@@ -28,7 +113,8 @@ function mapBooleansFromInt(entity: MetaData, row: Row): Row {
 
 function mapBooleansToInt(entity: MetaData, row: Row): Row {
   const out: Row = { ...row };
-  for (const child of entity.ownChildren()) {
+  // Effective children so a TPH subtype coerces inherited boolean fields too.
+  for (const child of entity.children()) {
     if (child.type !== TYPE_FIELD) continue;
     if (child.subType !== FIELD_SUBTYPE_BOOLEAN) continue;
     const v = out[child.name];

package/src/validator-runner.ts

@@ -6,7 +6,7 @@ import {
   TYPE_FIELD, TYPE_VALIDATOR,
   VALIDATOR_SUBTYPE_REQUIRED, VALIDATOR_SUBTYPE_LENGTH, VALIDATOR_SUBTYPE_REGEX,
   FIELD_SUBTYPE_STRING, FIELD_SUBTYPE_INT, FIELD_SUBTYPE_LONG,
-  FIELD_SUBTYPE_SHORT, FIELD_SUBTYPE_BYTE, FIELD_SUBTYPE_DOUBLE, FIELD_SUBTYPE_FLOAT,
+  FIELD_SUBTYPE_DOUBLE, FIELD_SUBTYPE_FLOAT, FIELD_SUBTYPE_CURRENCY,
   FIELD_SUBTYPE_BOOLEAN, FIELD_SUBTYPE_UUID,
   FIELD_ATTR_REQUIRED, FIELD_ATTR_MAX_LENGTH, FIELD_ATTR_DEFAULT,
   VALIDATOR_ATTR_MIN, VALIDATOR_ATTR_MAX, VALIDATOR_ATTR_PATTERN,
@@ -17,11 +17,25 @@ export type ValidationResult =
   | { ok: true }
   | { ok: false; errors: ValidationFailure[] };
 
+// JS-safe numeric fields: must arrive as a JS `number` (they fit in 2^53).
 const NUMERIC_FIELD_SUBTYPES = new Set<string>([
-  FIELD_SUBTYPE_INT, FIELD_SUBTYPE_LONG, FIELD_SUBTYPE_SHORT, FIELD_SUBTYPE_BYTE,
+  FIELD_SUBTYPE_INT,
   FIELD_SUBTYPE_DOUBLE, FIELD_SUBTYPE_FLOAT,
 ]);
 
+// 64-bit integer fields (BIGINT on the wire). A full int64 (> 2^53) cannot
+// survive a JS `number`, so the write contract additionally accepts a numeric
+// `string` or a `bigint` for these — the runtime passes them through unchanged
+// so the BIGINT round-trips exactly (read-back is BIGINT→string per
+// normalization.md / ADR-0019). `field.currency` is integer minor units → BIGINT.
+const INT64_FIELD_SUBTYPES = new Set<string>([
+  FIELD_SUBTYPE_LONG, FIELD_SUBTYPE_CURRENCY,
+]);
+
+// A base-10 signed integer literal with no fractional/exponent part — the only
+// string shape accepted for an int64 field (a "1.5" or "1e3" is rejected).
+const INT64_STRING_RE = /^-?\d+$/;
+
 export interface RunValidatorsOpts {
   /** Partial-update mode: required-checks only fire for fields whose key is present in `data`. */
   partial?: boolean;
@@ -34,7 +48,8 @@ export function runValidators(
 ): ValidationResult {
   const errors: ValidationFailure[] = [];
 
-  for (const field of entity.ownChildren()) {
+  // Effective children so a TPH subtype validates inherited base fields too.
+  for (const field of entity.children()) {
     if (field.type !== TYPE_FIELD) continue;
     const present = Object.prototype.hasOwnProperty.call(data, field.name);
     const value = data[field.name];
@@ -161,6 +176,11 @@ function checkType(subType: string, value: unknown): string | null {
     if (typeof value !== "string") return `expected string`;
   } else if (NUMERIC_FIELD_SUBTYPES.has(subType)) {
     if (typeof value !== "number") return `expected number`;
+  } else if (INT64_FIELD_SUBTYPES.has(subType)) {
+    // number (in-band) | bigint | base-10 integer string (full int64 fidelity).
+    if (typeof value === "number" || typeof value === "bigint") return null;
+    if (typeof value === "string" && INT64_STRING_RE.test(value)) return null;
+    return `expected a 64-bit integer (number, bigint, or numeric string)`;
   } else if (subType === FIELD_SUBTYPE_BOOLEAN) {
     if (typeof value !== "boolean") return `expected boolean`;
   }