postgrejs 3.6.0 → 3.7.0

package/util/resolve-column-formats.d.ts

@@ -1,3 +1,4 @@
+import type { DataTypeMap } from '../data-type-map.js';
 import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
 import { Protocol } from '../protocol/protocol.js';
 import type { Maybe, OID } from '../types.js';
@@ -23,7 +24,7 @@ export interface ColumnFormatOptions extends DataMappingOptions {
  * Returns `columnFormat` untouched when there is nothing to do, so the
  * common case allocates nothing and keeps sending a single format code.
  */
-export declare function resolveColumnFormats(fields: Maybe<Protocol.RowDescription[]>, options: ColumnFormatOptions): Protocol.DataFormat | Protocol.DataFormat[];
+export declare function resolveColumnFormats(fields: Maybe<Protocol.RowDescription[]>, options: ColumnFormatOptions, typeMap?: DataTypeMap): Protocol.DataFormat | Protocol.DataFormat[];
 /**
  * Whether two `fetchAsString` lists select the same columns. Used to tell
  * a cached set of parsers apart from one built for a different list, which

package/util/resolve-column-formats.js

@@ -1,6 +1,18 @@
 import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
 import { Protocol } from '../protocol/protocol.js';
 const DataFormat = Protocol.DataFormat;
+/**
+ * Whether this client could read the column if it arrived in `format`.
+ * Only ever answers no for binary: a column with no registered type at
+ * all still decodes as text, into the string the server printed, which is
+ * the whole point of asking for it that way.
+ */
+function canDecode(typeMap, oid, format) {
+    if (format !== DataFormat.binary)
+        return true;
+    const reg = typeMap.get(oid);
+    return !!reg && typeof reg.decodeBinary === 'function';
+}
 /**
  * Turns `fetchAsString`'s OID list into the positional result format codes
  * a Bind message actually carries.
@@ -20,28 +32,43 @@ const DataFormat = Protocol.DataFormat;
  * Returns `columnFormat` untouched when there is nothing to do, so the
  * common case allocates nothing and keeps sending a single format code.
  */
-export function resolveColumnFormats(fields, options) {
+export function resolveColumnFormats(fields, options, typeMap) {
     const base = options.columnFormat != null ? options.columnFormat : DEFAULT_COLUMN_FORMAT;
     const asString = options.fetchAsString;
-    if (!fields || !asString || !asString.length)
+    // unknownTypesAsString needs the type map to answer "could this be
+    // decoded", so it is inert without one - the call sites that have no
+    // map in hand are the ones that have no fields either.
+    const unknownAsString = !!options.unknownTypesAsString && !!typeMap;
+    const named = !!asString && asString.length > 0;
+    if (!fields || (!named && !unknownAsString))
         return base;
     const l = fields.length;
     const baseIsArray = Array.isArray(base);
     const out = new Array(l);
     let hit = false;
     let i;
+    let oid;
+    let format;
     for (i = 0; i < l; i++) {
-        if (asString.includes(fields[i].dataTypeId)) {
+        oid = fields[i].dataTypeId;
+        format = baseIsArray
+            ? (base[i] ?? DEFAULT_COLUMN_FORMAT)
+            : base;
+        if (named && asString.includes(oid)) {
             // fetchAsString names the value the caller wants verbatim, so it
             // overrides an explicit columnFormat for its own columns - the two
             // cannot both be honored and the OID list is the more specific ask.
-            out[i] = DataFormat.text;
+            format = DataFormat.text;
+            hit = true;
+        }
+        else if (unknownAsString && !canDecode(typeMap, oid, format)) {
+            // Nothing here could read the binary, so the bytes would reach the
+            // caller as a Buffer. Text at least arrives as what the server
+            // printed.
+            format = DataFormat.text;
             hit = true;
         }
-        else
-            out[i] = baseIsArray
-                ? (base[i] ?? DEFAULT_COLUMN_FORMAT)
-                : base;
+        out[i] = format;
     }
     return hit ? out : base;
 }

package/util/stringify-for-sql.js

@@ -1,9 +1,41 @@
+import { DataTypeOIDs } from '../constants.js';
+import { GlobalTypeMap } from '../data-type-map.js';
 import { UuidType } from '../data-types/uuid-type.js';
 import { escapeLiteral } from './escape-literal.js';
 export function stringifyArrayForSQL(v, options, encode) {
     const arr = v.map(x => stringifyValueForSQL(x, options, encode));
     return 'ARRAY[' + arr.join(',') + ']';
 }
+/**
+ * Which type an object is is asked rather than assumed.
+ *
+ * Every geometric class, Interval, Range, Date and Buffer has a
+ * registered `encodeText()` that writes exactly the literal PostgreSQL
+ * reads back, and `determine()` already knows which type each one is -
+ * it is what the same value is sent as when it is bound as a parameter.
+ * Without asking, all of them became `::json`, and since these classes
+ * have a `toJSON()` returning their own literal the result was not even
+ * a JSON object but a JSON string holding one, which casts to nothing:
+ * `'"(1,2)"'::json` where `'(1,2)'::point` was meant. A Date became its
+ * ISO string and a Buffer leaked its bytes as `{"type":"Buffer",...}`.
+ */
+function stringifyObjectForSQL(v, options) {
+    // determine() throws for a class that must carry a type OID and does
+    // not - a Range built without one - and that throw is deliberate: the
+    // alternative is writing a literal for a type nobody chose.
+    const oid = GlobalTypeMap.determine(v);
+    const dataType = GlobalTypeMap.get(oid);
+    // json and jsonb are the fallback below; reaching them through their
+    // own encodeText would only add a cast the literal does not need.
+    // Anything with no registered text encoder lands there too.
+    if (dataType?.encodeText &&
+        oid !== DataTypeOIDs.json &&
+        oid !== DataTypeOIDs.jsonb)
+        return (escapeLiteral(dataType.encodeText(v, options || {})) +
+            '::' +
+            dataType.name);
+    return escapeLiteral(JSON.stringify(v)) + '::json';
+}
 export function stringifyValueForSQL(v, options, encode) {
     if (v == null)
         return 'null';
@@ -20,6 +52,10 @@ export function stringifyValueForSQL(v, options, encode) {
     if (typeof v === 'string' && UuidType.isType(v))
         return escapeLiteral('' + v) + '::uuid';
     if (typeof v === 'object')
-        return escapeLiteral(JSON.stringify(v)) + '::json';
+        return stringifyObjectForSQL(v, options);
+    // A string is deliberately written bare. determine() would answer
+    // varchar, but an unadorned literal is `unknown` and takes the type of
+    // wherever it lands - `insert into t(n) values('5')` works and
+    // `'5'::varchar` would not.
     return escapeLiteral('' + v);
 }