linkgress-orm 0.4.49 → 0.4.52

package/dist/query/query-builder.js

@@ -1380,10 +1380,7 @@ class SelectQueryBuilder {
             return this.transformResults(processedRows, selectionResult);
         };
         const future = new future_query_1.FutureQuery(sql, params, transformFn, this.client, this.executor);
-        future._batchMeta = {
-            hasNestedPaths: nestedPaths.size > 0,
-            reviveJsonRow: this.buildJsonRowReviver(selectionResult),
-        };
+        future._batchMeta = this.buildBatchMeta(selectionResult, nestedPaths.size > 0);
         return future;
     }
     /**
@@ -1431,10 +1428,7 @@ class SelectQueryBuilder {
             return this.transformResults(processedRows, selectionResult);
         };
         const future = new future_query_1.FutureSingleQuery(sql, params, transformFn, this.client, this.executor);
-        future._batchMeta = {
-            hasNestedPaths: nestedPaths.size > 0,
-            reviveJsonRow: this.buildJsonRowReviver(selectionResult),
-        };
+        future._batchMeta = this.buildBatchMeta(selectionResult, nestedPaths.size > 0);
         return future;
     }
     /**
@@ -1476,56 +1470,135 @@ class SelectQueryBuilder {
      * Returns undefined when no selected column needs revival.
      * @internal
      */
-    buildJsonRowReviver(selection) {
+    buildBatchMeta(selection, hasNestedPaths) {
         const revivals = [];
+        const textColumns = [];
+        this.collectJsonRowRevivals(selection, undefined, revivals, textColumns);
+        const reviveJsonRow = revivals.length === 0
+            ? undefined
+            : (row) => {
+                for (const { key, revive } of revivals) {
+                    const value = row[key];
+                    if (value !== null && value !== undefined) {
+                        row[key] = revive(value);
+                    }
+                }
+                return row;
+            };
+        return {
+            hasNestedPaths,
+            reviveJsonRow,
+            textColumns: textColumns.length > 0 ? textColumns : undefined,
+        };
+    }
+    /**
+     * Walk a selection — including nested-object projections — collecting revival
+     * entries keyed by the FLAT column alias each leaf is delivered under: top-level
+     * keys as-is, nested leaves under the `__nested__<path>__<leaf>` path-encoded
+     * alias that tryBuildFlatNestedSelect emits (revival runs BEFORE nested
+     * reconstruction, so it must target the flat row shape). Only plain object
+     * literals are recursed into; collections, SqlFragments and subquery builders
+     * are skipped — they are delivered as json under standalone execution too, so
+     * they need no revival.
+     * @internal
+     */
+    collectJsonRowRevivals(selection, pathPrefix, revivals, textColumns) {
         for (const key in selection) {
             const value = selection[key];
-            if (!value || typeof value !== 'object' || !('__fieldName' in value)) {
+            if (!value || typeof value !== 'object' || Array.isArray(value)) {
                 continue;
             }
-            const config = this.resolveFieldColumnConfig(value);
-            if (!config) {
+            if ('__fieldName' in value) {
+                const config = this.resolveFieldColumnConfig(value);
+                if (!config) {
+                    continue;
+                }
+                const flatKey = pathPrefix ? `${pathPrefix}__${key}` : key;
+                // A custom fromDriver mapper is the column's type authority: it was
+                // written against the driver's RAW output (apps like gopass configure
+                // timestamp parser passthrough, so their mappers expect the
+                // text-protocol string). For mapper columns, revival reconstructs that
+                // text form — json's ISO 'T' separator back to the driver's space, a
+                // timestamptz's ':00' offset minutes collapsed to the driver's short
+                // form — and never hands the mapper a Date it does not expect.
+                const hasMapper = config.mapper != null;
+                if (config.type === 'timestamp') {
+                    revivals.push(hasMapper
+                        ? { key: flatKey, revive: (v) => (typeof v === 'string' ? v.replace('T', ' ') : v) }
+                        : { key: flatKey, revive: (v) => (typeof v === 'string' ? new Date(v) : v) });
+                }
+                else if (config.type === 'timestamptz') {
+                    revivals.push(hasMapper
+                        ? { key: flatKey, revive: (v) => (typeof v === 'string' ? v.replace('T', ' ').replace(/([+-]\d{2}):00$/, '$1') : v) }
+                        : { key: flatKey, revive: (v) => (typeof v === 'string' ? new Date(v) : v) });
+                }
+                else if (config.type === 'date') {
+                    if (hasMapper) {
+                        // json 'YYYY-MM-DD' IS the driver text form — the mapper gets it as-is.
+                        continue;
+                    }
+                    revivals.push({
+                        key: flatKey,
+                        revive: (v) => {
+                            if (typeof v !== 'string') {
+                                return v;
+                            }
+                            // Mirror the drivers' date parsing: local midnight, not UTC
+                            const [year, month, day] = v.split('-').map(Number);
+                            return new Date(year, month - 1, day);
+                        },
+                    });
+                }
+                else if (config.type === 'decimal' || config.type === 'numeric' || config.type === 'bigint') {
+                    // Values of these types can exceed float53 precision, and JSON.parse
+                    // silently collapses arbitrary-precision JSON numerals to floats —
+                    // unrecoverable here. The batch therefore casts them ::text
+                    // server-side (see the envelope in query-batch.ts); these fallback
+                    // revivals only normalize a NUMBER that slipped through (older
+                    // metadata without textColumns) and no-op on the cast strings.
+                    textColumns.push(flatKey);
+                    const scale = config.scale;
+                    revivals.push({
+                        key: flatKey,
+                        revive: (v) => (typeof v === 'number' ? (scale != null && config.type !== 'bigint' ? v.toFixed(scale) : String(v)) : v),
+                    });
+                }
+                else if (config.type === 'bytea') {
+                    // Driver delivery is a byte buffer; row_to_json emits the '\x…' hex text.
+                    revivals.push({
+                        key: flatKey,
+                        revive: (v) => {
+                            if (typeof v !== 'string' || !v.startsWith('\\x')) {
+                                return v;
+                            }
+                            const hex = v.slice(2);
+                            const bufferCtor = globalThis.Buffer;
+                            return bufferCtor
+                                ? bufferCtor.from(hex, 'hex')
+                                : Uint8Array.from(hex.match(/../g)?.map((pair) => parseInt(pair, 16)) ?? []);
+                        },
+                    });
+                }
                 continue;
             }
-            if (config.type === 'timestamp' || config.type === 'timestamptz') {
-                revivals.push({ key, revive: (v) => (typeof v === 'string' ? new Date(v) : v) });
-            }
-            else if (config.type === 'date') {
-                revivals.push({
-                    key,
-                    revive: (v) => {
-                        if (typeof v !== 'string') {
-                            return v;
-                        }
-                        // Mirror the drivers' date parsing: local midnight, not UTC
-                        const [year, month, day] = v.split('-').map(Number);
-                        return new Date(year, month - 1, day);
-                    },
-                });
-            }
-            else if (config.type === 'decimal' || config.type === 'numeric') {
-                const scale = config.scale;
-                revivals.push({
-                    key,
-                    revive: (v) => (typeof v === 'number' ? (scale != null ? v.toFixed(scale) : String(v)) : v),
-                });
-            }
-            else if (config.type === 'bigint') {
-                revivals.push({ key, revive: (v) => (typeof v === 'number' ? String(v) : v) });
+            // Recurse only into plain object literals — the nested-object projections
+            // tryBuildFlatNestedSelect flattens. Class instances (collections, SqlFragment,
+            // Subquery) and collection-result markers must not be walked.
+            const proto = Object.getPrototypeOf(value);
+            if ((proto === Object.prototype || proto === null) && !('__collectionResult' in value)) {
+                this.collectJsonRowRevivals(value, pathPrefix ? `${pathPrefix}__${key}` : `__nested__${key}`, revivals, textColumns);
             }
         }
-        if (revivals.length === 0) {
-            return undefined;
-        }
-        return (row) => {
-            for (const { key, revive } of revivals) {
-                const value = row[key];
-                if (value !== null && value !== undefined) {
-                    row[key] = revive(value);
-                }
-            }
-            return row;
-        };
+    }
+    /**
+     * Union-leg hook: builds the full batch metadata (reviver + text-cast column
+     * aliases) for a previously consumed union selection so
+     * UnionQueryBuilder.future() can attach it. Same mechanics as the standalone
+     * future factories.
+     * @internal
+     */
+    _buildUnionBatchMeta(selectionResult, hasNestedPaths) {
+        return this.buildBatchMeta(selectionResult, hasNestedPaths);
     }
     /**
      * Resolve the declared column config for a selected FieldRef: base table