grafeo-ogm 2.0.0 → 2.1.0

package/dist/cjs/utils/write-coercion.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coerceWriteValue = coerceWriteValue;
+exports.wrapTemporalWriteExpr = wrapTemporalWriteExpr;
+exports.wrapTemporalListItemExpr = wrapTemporalListItemExpr;
+exports.wrapTemporalWhereParam = wrapTemporalWhereParam;
+exports.resolveDefaultWriteValue = resolveDefaultWriteValue;
+const neo4j_driver_1 = require("neo4j-driver");
+const errors_1 = require("../errors");
+/**
+ * GraphQL scalar types whose Neo4j storage type is INTEGER (Long).
+ */
+const INTEGER_SCALAR_TYPES = new Set(['Int', 'BigInt']);
+/**
+ * Temporal scalar types → the Cypher constructor that parses their ISO
+ * string form into the native Neo4j temporal type. Writes wrap the
+ * *parameter* in the constructor instead of converting the value in JS,
+ * because Neo4j's own parsers handle everything JS `Date` cannot:
+ * nanosecond precision, bracket timezone names
+ * (`2024-01-15T10:30:00[America/New_York]`), and ISO-8601 durations.
+ */
+const TEMPORAL_CONSTRUCTORS = {
+    DateTime: 'datetime',
+    LocalDateTime: 'localdatetime',
+    Date: 'date',
+    Time: 'time',
+    LocalTime: 'localtime',
+    Duration: 'duration',
+};
+/**
+ * Where-operator suffixes whose parameter is compared against the field
+ * value (`''` = plain equality) and therefore needs the same temporal
+ * constructor treatment as writes. String operators (`_CONTAINS`,
+ * `_STARTS_WITH`, `_MATCHES`, ...) are excluded — their params are
+ * strings by definition.
+ */
+const TEMPORAL_COMPARABLE_SUFFIXES = new Set([
+    '',
+    '_NOT',
+    '_GT',
+    '_GTE',
+    '_LT',
+    '_LTE',
+    '_IN',
+    '_NOT_IN',
+]);
+/**
+ * Coerce a JS write value bound for an `Int`/`BigInt`-typed schema field
+ * into a Neo4j Integer so the stored property is a Long, not a Double.
+ *
+ * The driver packs EVERY JS `number` as a Bolt FLOAT64 (packstream:
+ * `typeof x === 'number'` → `packFloat`) — `disableLosslessIntegers`
+ * only affects the read direction. Reads convert Integer → number
+ * (ResultMapper), so without write-side coercion the round-trip is
+ * asymmetric: every OGM-written Int property lands as a Double. Once a
+ * field holds a mixed Long/Double population, Long-typed consumers break
+ * (e.g. `apoc.coll.sortMulti` throws `java.lang.Double cannot be cast to
+ * class java.lang.Long`).
+ *
+ * Non-integral numbers and non-integer strings for Int/BigInt fields
+ * throw instead of truncating or storing a String property, matching the
+ * v1.14 contract of rejecting inputs that would be silently corrupted.
+ * Values the coercion doesn't own — null/undefined, driver Integer
+ * instances, fields of any other scalar type, or fields absent from the
+ * schema — pass through untouched.
+ */
+function coerceWriteValue(value, propDef) {
+    if (propDef === undefined || value === null || value === undefined)
+        return value;
+    if (!INTEGER_SCALAR_TYPES.has(propDef.type))
+        return value;
+    if (propDef.isArray) {
+        if (!Array.isArray(value))
+            return value;
+        return value.map((element) => coerceIntegerElement(element, propDef));
+    }
+    return coerceIntegerElement(value, propDef);
+}
+function coerceIntegerElement(value, propDef) {
+    if (value === null || value === undefined)
+        return value;
+    // `int()` accepts strings in every driver major — `toString()` keeps
+    // bigint inputs working regardless of the installed driver's overloads.
+    if (typeof value === 'bigint')
+        return (0, neo4j_driver_1.int)(value.toString());
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value))
+            throw new errors_1.OGMError(`Expected an integer for ${propDef.type} field "${propDef.name}" but got ${value}. ` +
+                `Storing it would corrupt the property's integer type; pass a whole number ` +
+                `(or declare the field as Float).`);
+        return (0, neo4j_driver_1.int)(value);
+    }
+    if (typeof value === 'string') {
+        // The generated BigInt scalar declares `input: string` (64-bit values
+        // don't fit a JS number), so integer strings are the CANONICAL input
+        // shape for BigInt fields — binding them raw would store a String
+        // property. Same reject-don't-corrupt rule as numbers for anything
+        // that isn't a plain base-10 integer literal.
+        if (!/^-?\d+$/.test(value))
+            throw new errors_1.OGMError(`Expected an integer for ${propDef.type} field "${propDef.name}" but got the string "${value}". ` +
+                `Pass a base-10 integer literal string, a whole number, or a bigint.`);
+        return (0, neo4j_driver_1.int)(value);
+    }
+    // Already a driver Integer — pass through unchanged.
+    if ((0, neo4j_driver_1.isInt)(value))
+        return value;
+    return value;
+}
+/**
+ * Wrap a write RHS expression (`$param`, or an UNWIND item reference) in
+ * the field's temporal Cypher constructor, so ISO-string inputs are
+ * stored as native temporal properties instead of Strings. Reads convert
+ * native temporals → ISO strings (ResultMapper), so this is the write
+ * half of the same round-trip symmetry issue #5 fixed for integers.
+ *
+ * Only string values are wrapped — a driver temporal object already
+ * packs natively and binds raw. Temporal LIST fields wrap element-wise
+ * via a list comprehension when any element is a string.
+ */
+function wrapTemporalWriteExpr(expr, value, propDef) {
+    if (propDef === undefined)
+        return expr;
+    const ctor = TEMPORAL_CONSTRUCTORS[propDef.type];
+    if (ctor === undefined)
+        return expr;
+    if (propDef.isArray) {
+        if (!Array.isArray(value) || !value.some((el) => typeof el === 'string'))
+            return expr;
+        return `[wc_t IN ${expr} | ${ctor}(wc_t)]`;
+    }
+    if (typeof value !== 'string')
+        return expr;
+    return `${ctor}(${expr})`;
+}
+/**
+ * Temporal wrapping for UNWIND item references (`item.prop`,
+ * `connItem.edge.prop`), where ONE Cypher expression serves EVERY item in
+ * the batch: the wrap decision must hold for all items' values for the
+ * key. A mixed string/non-string column throws — a single expression
+ * cannot be correct for both representations.
+ */
+function wrapTemporalListItemExpr(expr, values, propDef) {
+    if (propDef === undefined)
+        return expr;
+    const ctor = TEMPORAL_CONSTRUCTORS[propDef.type];
+    if (ctor === undefined)
+        return expr;
+    const defined = values.filter((v) => v !== null && v !== undefined);
+    if (defined.length === 0)
+        return expr;
+    if (propDef.isArray) {
+        const anyString = defined.some((v) => Array.isArray(v) && v.some((el) => typeof el === 'string'));
+        return anyString ? `[wc_t IN ${expr} | ${ctor}(wc_t)]` : expr;
+    }
+    const stringCount = defined.filter((v) => typeof v === 'string').length;
+    if (stringCount === 0)
+        return expr;
+    if (stringCount !== defined.length)
+        throw new errors_1.OGMError(`Mixed input types for ${propDef.type} field "${propDef.name}": some items pass ISO ` +
+            `strings, others pass non-string values. Batched writes share one Cypher expression ` +
+            `per field, so every item must use the same representation.`);
+    return `${ctor}(${expr})`;
+}
+/**
+ * Wrap a WHERE parameter reference for a temporal field. With properties
+ * stored as native temporals, comparing them to a raw string param is a
+ * cross-type comparison — Neo4j evaluates it to NULL and silently drops
+ * the row. `suffix` is the operator suffix (`''` for plain equality);
+ * only comparison-shaped operators wrap, and `_IN`/`_NOT_IN` wrap their
+ * list param element-wise.
+ */
+function wrapTemporalWhereParam(paramRef, value, propDef, suffix) {
+    if (propDef === undefined)
+        return paramRef;
+    const ctor = TEMPORAL_CONSTRUCTORS[propDef.type];
+    if (ctor === undefined)
+        return paramRef;
+    if (!TEMPORAL_COMPARABLE_SUFFIXES.has(suffix))
+        return paramRef;
+    if (suffix === '_IN' || suffix === '_NOT_IN') {
+        if (!Array.isArray(value) || !value.some((el) => typeof el === 'string'))
+            return paramRef;
+        return `[wc_t IN ${paramRef} | ${ctor}(wc_t)]`;
+    }
+    if (typeof value !== 'string')
+        return paramRef;
+    return `${ctor}(${paramRef})`;
+}
+/**
+ * Materialize a parsed `@default` into a driver-ready bound value. The
+ * parser stores every default as a string (`'true'`, `'5'`, `'WELCOME'`);
+ * conversion is by declared scalar type, and Int/BigInt defaults route
+ * through the same Integer coercion as user input. Temporal defaults stay
+ * ISO strings here — they get their constructor wrapper at the binding
+ * site like any other temporal write.
+ */
+function resolveDefaultWriteValue(propDef) {
+    const raw = propDef.defaultValue;
+    if (raw === undefined)
+        return undefined;
+    switch (propDef.type) {
+        case 'Boolean':
+            return raw === 'true';
+        case 'Float':
+            return Number(raw);
+        case 'Int':
+        case 'BigInt':
+            return coerceWriteValue(raw, propDef);
+        default:
+            return raw;
+    }
+}
+//# sourceMappingURL=write-coercion.js.map

package/dist/cjs/utils/write-coercion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-coercion.js","sourceRoot":"","sources":["../../../src/utils/write-coercion.ts"],"names":[],"mappings":"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"}

package/dist/esm/compilers/mutation.compiler.d.ts

@@ -120,6 +120,13 @@ export declare class MutationCompiler {
      * Returns count of created nodes.
      */
     compileCreateMany(data: Record<string, unknown>[], nodeDef: NodeDefinition, skipDuplicates?: boolean, labels?: string[]): MutationResult;
+    /**
+     * Resolve the PropertyDefinition of an edge (relationship) property so
+     * Int/BigInt edge writes get the same Integer coercion as node writes.
+     * Returns undefined when the relationship declares no properties type
+     * (the coercion then passes the value through untouched).
+     */
+    private getEdgePropDef;
     private buildCreateProperties;
     private buildCreateRelationships;
     /**

package/dist/esm/compilers/mutation.compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation.compiler.d.ts","sourceRoot":"","sources":["../../../src/compilers/mutation.compiler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mutation.compiler.d.ts","sourceRoot":"","sources":["../../../src/compilers/mutation.compiler.ts"],"names":[],"mappings":"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"}

package/dist/esm/compilers/mutation.compiler.js

@@ -1,6 +1,7 @@
 import { OGMError } from '../errors';
 import { buildRelPattern, getTargetLabelString, resolveTargetDef, } from '../schema/utils';
 import { assertSafeIdentifier, assertSafeLabel, assertSafePropertyName, escapeIdentifier, mergeParams, } from '../utils/validation';
+import { coerceWriteValue, resolveDefaultWriteValue, wrapTemporalListItemExpr, wrapTemporalWhereParam, wrapTemporalWriteExpr, } from '../utils/write-coercion';
 import { WhereCompiler } from './where.compiler';
 /**
  * Relationship filter suffixes that require EXISTS subquery patterns.
@@ -179,9 +180,11 @@ export class MutationCompiler {
                 if (value === undefined)
                     continue;
                 assertSafePropertyName(key, 'update property');
+                const propDef = nodeDef.properties.get(key);
                 const paramName = `update_${key}`;
-                setClauses.push(`n.${escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
+                const valueExpr = wrapTemporalWriteExpr(`$${paramName}`, value, propDef);
+                setClauses.push(`n.${escapeIdentifier(key)} = ${valueExpr}`);
+                params[paramName] = coerceWriteValue(value, propDef);
             }
             if (setClauses.length > 0)
                 lines.push(`SET ${setClauses.join(', ')}`);
@@ -259,10 +262,12 @@ export class MutationCompiler {
             if (key.includes('_') && !nodeDef.properties.has(key))
                 continue;
             assertSafePropertyName(key, 'merge key');
+            const propDef = nodeDef.properties.get(key);
             const paramName = `merge_${key}`;
-            mergeProps.push(`${escapeIdentifier(key)}: $${paramName}`);
+            const valueExpr = wrapTemporalWriteExpr(`$${paramName}`, value, propDef);
+            mergeProps.push(`${escapeIdentifier(key)}: ${valueExpr}`);
             mergeKeyNames.push(key);
-            params[paramName] = value;
+            params[paramName] = coerceWriteValue(value, propDef);
         }
         if (mergeProps.length === 0)
             throw new OGMError('upsert requires at least one scalar property in "where" for MERGE key');
@@ -298,9 +303,29 @@ export class MutationCompiler {
             if (nodeDef.relationships.has(key))
                 continue;
             assertSafePropertyName(key, 'create property');
+            const propDef = nodeDef.properties.get(key);
             const paramName = `onCreate_${key}`;
-            createSets.push(`n.${escapeIdentifier(key)} = $${paramName}`);
-            params[paramName] = value;
+            const valueExpr = wrapTemporalWriteExpr(`$${paramName}`, value, propDef);
+            createSets.push(`n.${escapeIdentifier(key)} = ${valueExpr}`);
+            params[paramName] = coerceWriteValue(value, propDef);
+        }
+        // `@default` values apply to the ON CREATE branch — a defaulted
+        // property not supplied in `create` and not already fixed by the
+        // MERGE key gets its default, mirroring create().
+        for (const [, propDef] of nodeDef.properties) {
+            if (propDef.defaultValue === undefined)
+                continue;
+            if (propDef.isGenerated || propDef.isCypher)
+                continue;
+            if (create[propDef.name] !== undefined)
+                continue;
+            if (mergeKeyNames.includes(propDef.name))
+                continue;
+            const paramName = `onCreate_${propDef.name}`;
+            const bound = resolveDefaultWriteValue(propDef);
+            const valueExpr = wrapTemporalWriteExpr(`$${paramName}`, bound, propDef);
+            createSets.push(`n.${escapeIdentifier(propDef.name)} = ${valueExpr}`);
+            params[paramName] = bound;
         }
         if (createSets.length > 0)
             lines.push(`ON CREATE SET ${createSets.join(', ')}`);
@@ -312,9 +337,11 @@ export class MutationCompiler {
             if (nodeDef.relationships.has(key))
                 continue;
             assertSafePropertyName(key, 'update property');
+            const propDef = nodeDef.properties.get(key);
             const paramName = `onMatch_${key}`;
-            updateSets.push(`n.${escapeIdentifier(key)} = $${paramName}`);
-            params[paramName] = value;
+            const valueExpr = wrapTemporalWriteExpr(`$${paramName}`, value, propDef);
+            updateSets.push(`n.${escapeIdentifier(key)} = ${valueExpr}`);
+            params[paramName] = coerceWriteValue(value, propDef);
         }
         if (updateSets.length > 0)
             lines.push(`ON MATCH SET ${updateSets.join(', ')}`);
@@ -386,12 +413,24 @@ export class MutationCompiler {
         for (const [, propDef] of nodeDef.properties)
             if (propDef.isGenerated && !scalarKeys.includes(propDef.name))
                 generatedFields.push(propDef.name);
+        // Whole-column `@default`s: applied only when NO item supplies the
+        // field. Per-item gaps inside a provided column stay null — one
+        // createMany batch shares a single Cypher text, and a per-item
+        // default would need coalesce(), which would also override explicit
+        // nulls.
+        const defaultedProps = [];
+        for (const [, propDef] of nodeDef.properties)
+            if (propDef.defaultValue !== undefined &&
+                !propDef.isGenerated &&
+                !propDef.isCypher &&
+                !scalarKeys.includes(propDef.name))
+                defaultedProps.push(propDef);
         // Build sanitized items (strip undefined values)
         const sanitizedItems = data.map((item) => {
             const sanitized = {};
             for (const key of scalarKeys)
                 if (item[key] !== undefined)
-                    sanitized[key] = item[key];
+                    sanitized[key] = coerceWriteValue(item[key], nodeDef.properties.get(key));
             return sanitized;
         });
         params.items = sanitizedItems;
@@ -408,16 +447,22 @@ export class MutationCompiler {
                 throw new OGMError('createMany with skipDuplicates requires at least one @id or @unique field in data');
             // MERGE on unique key(s)
             const mergeProps = mergeKeys
-                .map((k) => `${escapeIdentifier(k)}: item.${escapeIdentifier(k)}`)
+                .map((k) => `${escapeIdentifier(k)}: ${wrapTemporalListItemExpr(`item.${escapeIdentifier(k)}`, data.map((d) => d[k]), nodeDef.properties.get(k))}`)
                 .join(', ');
             lines.push(`MERGE (n:${labelStr} { ${mergeProps} })`);
             // ON CREATE SET — remaining fields + generated IDs
             const onCreateSets = [];
             for (const key of scalarKeys)
                 if (!mergeKeys.includes(key))
-                    onCreateSets.push(`n.${escapeIdentifier(key)} = item.${escapeIdentifier(key)}`);
+                    onCreateSets.push(`n.${escapeIdentifier(key)} = ${wrapTemporalListItemExpr(`item.${escapeIdentifier(key)}`, data.map((d) => d[key]), nodeDef.properties.get(key))}`);
             for (const field of generatedFields)
                 onCreateSets.push(`n.${escapeIdentifier(field)} = randomUUID()`);
+            for (const propDef of defaultedProps) {
+                const paramName = `default_${propDef.name}`;
+                const bound = resolveDefaultWriteValue(propDef);
+                onCreateSets.push(`n.${escapeIdentifier(propDef.name)} = ${wrapTemporalWriteExpr(`$${paramName}`, bound, propDef)}`);
+                params[paramName] = bound;
+            }
             if (onCreateSets.length > 0)
                 lines.push(`ON CREATE SET ${onCreateSets.join(', ')}`);
         }
@@ -427,7 +472,13 @@ export class MutationCompiler {
             for (const field of generatedFields)
                 propParts.push(`${escapeIdentifier(field)}: randomUUID()`);
             for (const key of scalarKeys)
-                propParts.push(`${escapeIdentifier(key)}: item.${escapeIdentifier(key)}`);
+                propParts.push(`${escapeIdentifier(key)}: ${wrapTemporalListItemExpr(`item.${escapeIdentifier(key)}`, data.map((d) => d[key]), nodeDef.properties.get(key))}`);
+            for (const propDef of defaultedProps) {
+                const paramName = `default_${propDef.name}`;
+                const bound = resolveDefaultWriteValue(propDef);
+                propParts.push(`${escapeIdentifier(propDef.name)}: ${wrapTemporalWriteExpr(`$${paramName}`, bound, propDef)}`);
+                params[paramName] = bound;
+            }
             lines.push(`CREATE (n:${labelStr} { ${propParts.join(', ')} })`);
         }
         // Extra labels
@@ -439,6 +490,19 @@ export class MutationCompiler {
         return { cypher: lines.join('\n'), params };
     }
     // ─── Private helpers ──────────────────────────────────────────────
+    /**
+     * Resolve the PropertyDefinition of an edge (relationship) property so
+     * Int/BigInt edge writes get the same Integer coercion as node writes.
+     * Returns undefined when the relationship declares no properties type
+     * (the coercion then passes the value through untouched).
+     */
+    getEdgePropDef(relDef, propName) {
+        if (!relDef.properties)
+            return undefined;
+        return this.schema.relationshipProperties
+            .get(relDef.properties)
+            ?.properties.get(propName);
+    }
     buildCreateProperties(input, nodeDef, prefix) {
         const parts = [];
         const propParams = {};
@@ -453,9 +517,28 @@ export class MutationCompiler {
             if (value === undefined)
                 continue;
             assertSafePropertyName(key, 'create property');
+            const propDef = nodeDef.properties.get(key);
             const paramName = `${prefix}_${key}`;
-            parts.push(`${escapeIdentifier(key)}: $${paramName}`);
-            propParams[paramName] = value;
+            const valueExpr = wrapTemporalWriteExpr(`$${paramName}`, value, propDef);
+            parts.push(`${escapeIdentifier(key)}: ${valueExpr}`);
+            propParams[paramName] = coerceWriteValue(value, propDef);
+        }
+        // `@default` values — applied for any property with a default that the
+        // input leaves undefined. Explicit null is respected as null: the user
+        // asked for null, a default would override intent. Generated (@id) and
+        // @cypher (computed, not stored) properties never take defaults.
+        for (const [, propDef] of nodeDef.properties) {
+            if (propDef.defaultValue === undefined)
+                continue;
+            if (propDef.isGenerated || propDef.isCypher)
+                continue;
+            if (input[propDef.name] !== undefined)
+                continue;
+            const paramName = `${prefix}_${propDef.name}`;
+            const bound = resolveDefaultWriteValue(propDef);
+            const valueExpr = wrapTemporalWriteExpr(`$${paramName}`, bound, propDef);
+            parts.push(`${escapeIdentifier(propDef.name)}: ${valueExpr}`);
+            propParams[paramName] = bound;
         }
         return { propString: parts.join(', '), propParams };
     }
@@ -560,9 +643,10 @@ export class MutationCompiler {
                         if (val === undefined)
                             continue;
                         assertSafePropertyName(prop, 'edge property');
+                        const edgePropDef = this.getEdgePropDef(relDef, prop);
                         const paramName = `${prefix}_create${ci}_edge_${prop}`;
-                        setItems.push(`${relVar}.${escapeIdentifier(prop)} = $${paramName}`);
-                        params[paramName] = val;
+                        setItems.push(`${relVar}.${escapeIdentifier(prop)} = ${wrapTemporalWriteExpr(`$${paramName}`, val, edgePropDef)}`);
+                        params[paramName] = coerceWriteValue(val, edgePropDef);
                     }
                     if (setItems.length > 0)
                         lines.push(`SET ${setItems.join(', ')}`);
@@ -612,9 +696,10 @@ export class MutationCompiler {
                         if (val === undefined)
                             continue;
                         assertSafePropertyName(prop, 'edge property');
+                        const edgePropDef = this.getEdgePropDef(relDef, prop);
                         const paramName = `${prefix}_conn${ci}_edge_${prop}`;
-                        setItems.push(`r_conn_${startCounter + counter - 1}.${escapeIdentifier(prop)} = $${paramName}`);
-                        params[paramName] = val;
+                        setItems.push(`r_conn_${startCounter + counter - 1}.${escapeIdentifier(prop)} = ${wrapTemporalWriteExpr(`$${paramName}`, val, edgePropDef)}`);
+                        params[paramName] = coerceWriteValue(val, edgePropDef);
                     }
                     if (setItems.length > 0)
                         lines.push(`SET ${setItems.join(', ')}`);
@@ -683,9 +768,10 @@ export class MutationCompiler {
                                 if (val === undefined)
                                     continue;
                                 assertSafePropertyName(prop, 'edge property');
+                                const edgePropDef = this.getEdgePropDef(relDef, prop);
                                 const paramName = `connect_${fieldName}_${ci}_edge_${prop}`;
-                                setItems.push(`${relVar}.${escapeIdentifier(prop)} = $${paramName}`);
-                                params[paramName] = val;
+                                setItems.push(`${relVar}.${escapeIdentifier(prop)} = ${wrapTemporalWriteExpr(`$${paramName}`, val, edgePropDef)}`);
+                                params[paramName] = coerceWriteValue(val, edgePropDef);
                             }
                             if (setItems.length > 0)
                                 lines.push(`SET ${setItems.join(', ')}`);
@@ -713,7 +799,7 @@ export class MutationCompiler {
                         const cleaned = {};
                         for (const [k, v] of Object.entries(edge))
                             if (v !== undefined)
-                                cleaned[k] = v;
+                                cleaned[k] = coerceWriteValue(v, this.getEdgePropDef(relDef, k));
                         return { ...item, edge: cleaned };
                     });
                     lines.push('WITH n');
@@ -737,7 +823,7 @@ export class MutationCompiler {
                                 `silently dropped. Split into separate connect calls, or normalise the items ` +
                                 `to share the same shape.`);
                     }
-                    const whereConditions = this.extractConnectWhereConditions(firstItem, 'target', 'connItem');
+                    const whereConditions = this.extractConnectWhereConditions(firstItem, 'target', 'connItem', targetNodeDef);
                     const policyPredicate = this.buildTargetPolicyPredicate(targetNodeDef, 'target', params, policyContext, paramCounter);
                     const unwindConditions = policyPredicate
                         ? [...whereConditions, policyPredicate]
@@ -762,7 +848,7 @@ export class MutationCompiler {
                         // Replace MERGE line with one that has a variable
                         lines[lines.length - 1] = `MERGE ${mergeWithVar}`;
                         // r.prop is relationship property (escape), connItem.edge.prop is parameter map (no escape)
-                        const setItems = edgeProps.map((p) => `r.${escapeIdentifier(p)} = connItem.edge.${p}`);
+                        const setItems = edgeProps.map((p) => `r.${escapeIdentifier(p)} = ${wrapTemporalListItemExpr(`connItem.edge.${p}`, spec.map((it) => it.edge?.[p]), this.getEdgePropDef(relDef, p))}`);
                         lines.push(`SET ${setItems.join(', ')}`);
                     }
                 }
@@ -793,9 +879,10 @@ export class MutationCompiler {
                     for (const [prop, val] of Object.entries(edgeInput)) {
                         if (val === undefined)
                             continue;
+                        const edgePropDef = this.getEdgePropDef(relDef, prop);
                         const paramName = `connect_${fieldName}_edge_${prop}`;
-                        setItems.push(`r.${escapeIdentifier(prop)} = $${paramName}`);
-                        params[paramName] = val;
+                        setItems.push(`r.${escapeIdentifier(prop)} = ${wrapTemporalWriteExpr(`$${paramName}`, val, edgePropDef)}`);
+                        params[paramName] = coerceWriteValue(val, edgePropDef);
                     }
                     if (setItems.length > 0)
                         lines.push(`SET ${setItems.join(', ')}`);
@@ -1108,9 +1195,10 @@ export class MutationCompiler {
                                 if (val === undefined)
                                     continue;
                                 assertSafePropertyName(prop, 'edge property');
+                                const edgePropDef = this.getEdgePropDef(relDef, prop);
                                 const paramName = `${itemPrefix}_conn${ci}_edge_${prop}`;
-                                setItems.push(`r_conn_${key}_${ci}.${escapeIdentifier(prop)} = $${paramName}`);
-                                params[paramName] = val;
+                                setItems.push(`r_conn_${key}_${ci}.${escapeIdentifier(prop)} = ${wrapTemporalWriteExpr(`$${paramName}`, val, edgePropDef)}`);
+                                params[paramName] = coerceWriteValue(val, edgePropDef);
                             }
                             if (setItems.length > 0)
                                 lines.push(`SET ${setItems.join(', ')}`);
@@ -1146,9 +1234,10 @@ export class MutationCompiler {
                         if (val === undefined)
                             continue;
                         assertSafePropertyName(prop, 'nested update property');
+                        const nodePropDef = targetNodeDef.properties.get(prop);
                         const paramName = `${itemPrefix}_set_${prop}`;
-                        setClauses.push(`${updateVar}.${escapeIdentifier(prop)} = $${paramName}`);
-                        setParams[paramName] = val;
+                        setClauses.push(`${updateVar}.${escapeIdentifier(prop)} = ${wrapTemporalWriteExpr(`$${paramName}`, val, nodePropDef)}`);
+                        setParams[paramName] = coerceWriteValue(val, nodePropDef);
                     }
                     // Pre-compute SET clauses for edge (relationship) properties
                     const edgeClauses = [];
@@ -1158,9 +1247,10 @@ export class MutationCompiler {
                             if (val === undefined)
                                 continue;
                             assertSafePropertyName(prop, 'edge update property');
+                            const edgePropDef = this.getEdgePropDef(relDef, prop);
                             const paramName = `${itemPrefix}_edge_${prop}`;
-                            edgeClauses.push(`${relVar}.${escapeIdentifier(prop)} = $${paramName}`);
-                            edgeParams[paramName] = val;
+                            edgeClauses.push(`${relVar}.${escapeIdentifier(prop)} = ${wrapTemporalWriteExpr(`$${paramName}`, val, edgePropDef)}`);
+                            edgeParams[paramName] = coerceWriteValue(val, edgePropDef);
                         }
                     // Pre-compute nested relationship operations
                     const nestedParams = {};
@@ -1246,15 +1336,16 @@ export class MutationCompiler {
                     assertSafePropertyName(baseProp, 'where property');
                     const paramName = `${prefix}_NOT_${notProp}`;
                     const escapedProp = escapeIdentifier(baseProp);
+                    const paramRef = wrapTemporalWhereParam(`$${paramName}`, notVal, targetNodeDef?.properties.get(baseProp), notProp.slice(baseProp.length));
                     let expr;
                     if (template === '%v = $%p')
                         // Simple equality → negate to <>
-                        expr = `${targetVar}.${escapedProp} <> $${paramName}`;
+                        expr = `${targetVar}.${escapedProp} <> ${paramRef}`;
                     else {
                         // Operator suffix — wrap with NOT if not already negated
                         const resolved = template
                             .replace('%v', `${targetVar}.${escapedProp}`)
-                            .replace('$%p', `$${paramName}`);
+                            .replace('$%p', paramRef);
                         expr = resolved.startsWith('NOT ') ? resolved : `NOT ${resolved}`;
                     }
                     conditions.push(expr);
@@ -1271,9 +1362,10 @@ export class MutationCompiler {
                 const { baseProp, template } = this.parseOperatorSuffix(prop);
                 assertSafePropertyName(baseProp, 'where property');
                 const paramName = `${prefix}_${prop}`;
+                const paramRef = wrapTemporalWhereParam(`$${paramName}`, val, targetNodeDef?.properties.get(baseProp), prop.slice(baseProp.length));
                 conditions.push(template
                     .replace('%v', `${targetVar}.${escapeIdentifier(baseProp)}`)
-                    .replace('$%p', `$${paramName}`));
+                    .replace('$%p', paramRef));
                 params[paramName] = val;
             }
         return conditions;
@@ -1438,7 +1530,7 @@ export class MutationCompiler {
         }
         return false;
     }
-    extractConnectWhereConditions(item, targetVar, itemVar) {
+    extractConnectWhereConditions(item, targetVar, itemVar, targetNodeDef) {
         const conditions = [];
         const whereSpec = item.where;
         if (!whereSpec)
@@ -1449,7 +1541,9 @@ export class MutationCompiler {
             assertSafePropertyName(baseProp, 'connect where property');
             // Replace template placeholders with dynamic UNWIND references
             // Note: itemVar map access is NOT escaped (parameter map keys, not Cypher identifiers)
-            const valueRef = `${itemVar}.where.node.${key}`;
+            // Temporal wrap keys off the FIRST item's value type — the UNWIND
+            // fast path already requires shape-homogeneous items.
+            const valueRef = wrapTemporalWhereParam(`${itemVar}.where.node.${key}`, nodeWhere[key], targetNodeDef?.properties.get(baseProp), key.slice(baseProp.length));
             conditions.push(template
                 .replace('%v', `${targetVar}.${escapeIdentifier(baseProp)}`)
                 .replace('$%p', valueRef));