postgrejs 3.6.0 → 3.7.0

package/constants.js

@@ -30,6 +30,7 @@ export const DataTypeOIDs = {
     oidvector: 30,
     json: 114,
     xml: 142,
+    pg_node_tree: 194,
     point: 600,
     lseg: 601,
     path: 602,
@@ -45,6 +46,7 @@ export const DataTypeOIDs = {
     money: 790,
     macaddr: 829,
     inet: 869,
+    aclitem: 1033,
     bpchar: 1042,
     varchar: 1043,
     date: 1082,
@@ -73,14 +75,40 @@ export const DataTypeOIDs = {
     anyelement: 2283,
     anynonarray: 2776,
     uuid: 2950,
+    txid_snapshot: 2970,
+    pg_lsn: 3220,
+    pg_ndistinct: 3361,
+    pg_dependencies: 3402,
+    tsvector: 3614,
+    tsquery: 3615,
+    gtsvector: 3642,
+    regconfig: 3734,
+    regdictionary: 3769,
     jsonb: 3802,
     anyrange: 3831,
     int4range: 3904,
     numrange: 3906,
     tsrange: 3908,
+    tstzrange: 3910,
+    /** @deprecated Misspelling of `tstzrange`, kept so it keeps resolving. */
     rstzrange: 3910,
     daterange: 3912,
     int8range: 3926,
+    jsonpath: 4072,
+    regnamespace: 4089,
+    regrole: 4096,
+    regcollation: 4191,
+    int4multirange: 4451,
+    nummultirange: 4532,
+    tsmultirange: 4533,
+    tstzmultirange: 4534,
+    datemultirange: 4535,
+    int8multirange: 4536,
+    pg_brin_bloom_summary: 4600,
+    pg_brin_minmax_multi_summary: 4601,
+    pg_mcv_list: 5017,
+    pg_snapshot: 5038,
+    xid8: 5069,
     _xml: 143,
     _json: 199,
     _xid8: 271,
@@ -113,6 +141,7 @@ export const DataTypeOIDs = {
     _float8: 1022,
     _polygon: 1027,
     _oid: 1028,
+    _aclitem: 1034,
     _macaddr: 1040,
     _inet: 1041,
     _timestamp: 1115,
@@ -125,8 +154,39 @@ export const DataTypeOIDs = {
     _timetz: 1270,
     _bit: 1561,
     _varbit: 1563,
+    _refcursor: 2201,
+    _regprocedure: 2207,
+    _regoper: 2208,
+    _regoperator: 2209,
+    _regclass: 2210,
+    _regtype: 2211,
+    _record: 2287,
+    _txid_snapshot: 2949,
     _uuid: 2951,
+    _pg_lsn: 3221,
+    _tsvector: 3643,
+    _gtsvector: 3644,
+    _tsquery: 3645,
+    _regconfig: 3735,
+    _regdictionary: 3770,
     _jsonb: 3807,
+    _int4range: 3905,
+    _numrange: 3907,
+    _tsrange: 3909,
+    _tstzrange: 3911,
+    _daterange: 3913,
+    _int8range: 3927,
+    _jsonpath: 4073,
+    _regnamespace: 4090,
+    _regrole: 4097,
+    _regcollation: 4192,
+    _pg_snapshot: 5039,
+    _int4multirange: 6150,
+    _nummultirange: 6151,
+    _tsmultirange: 6152,
+    _tstzmultirange: 6153,
+    _datemultirange: 6155,
+    _int8multirange: 6157,
 };
 export const DataTypeNames = {
     [DataTypeOIDs.bool]: 'bool',
@@ -146,6 +206,7 @@ export const DataTypeNames = {
     [DataTypeOIDs.oidvector]: 'oidvector',
     [DataTypeOIDs.json]: 'json',
     [DataTypeOIDs.xml]: 'xml',
+    [DataTypeOIDs.pg_node_tree]: 'pg_node_tree',
     [DataTypeOIDs.point]: 'point',
     [DataTypeOIDs.lseg]: 'lseg',
     [DataTypeOIDs.path]: 'path',
@@ -161,6 +222,7 @@ export const DataTypeNames = {
     [DataTypeOIDs.money]: 'money',
     [DataTypeOIDs.macaddr]: 'macaddr',
     [DataTypeOIDs.inet]: 'inet',
+    [DataTypeOIDs.aclitem]: 'aclitem',
     [DataTypeOIDs.bpchar]: 'bpchar',
     [DataTypeOIDs.varchar]: 'varchar',
     [DataTypeOIDs.date]: 'date',
@@ -189,14 +251,38 @@ export const DataTypeNames = {
     [DataTypeOIDs.anyelement]: 'anyelement',
     [DataTypeOIDs.anynonarray]: 'anynonarray',
     [DataTypeOIDs.uuid]: 'uuid',
+    [DataTypeOIDs.txid_snapshot]: 'txid_snapshot',
+    [DataTypeOIDs.pg_lsn]: 'pg_lsn',
+    [DataTypeOIDs.pg_ndistinct]: 'pg_ndistinct',
+    [DataTypeOIDs.pg_dependencies]: 'pg_dependencies',
+    [DataTypeOIDs.tsvector]: 'tsvector',
+    [DataTypeOIDs.tsquery]: 'tsquery',
+    [DataTypeOIDs.gtsvector]: 'gtsvector',
+    [DataTypeOIDs.regconfig]: 'regconfig',
+    [DataTypeOIDs.regdictionary]: 'regdictionary',
     [DataTypeOIDs.jsonb]: 'jsonb',
     [DataTypeOIDs.anyrange]: 'anyrange',
     [DataTypeOIDs.int4range]: 'int4range',
     [DataTypeOIDs.numrange]: 'numrange',
     [DataTypeOIDs.tsrange]: 'tsrange',
-    [DataTypeOIDs.rstzrange]: 'rstzrange',
+    [DataTypeOIDs.tstzrange]: 'tstzrange',
     [DataTypeOIDs.daterange]: 'daterange',
     [DataTypeOIDs.int8range]: 'int8range',
+    [DataTypeOIDs.jsonpath]: 'jsonpath',
+    [DataTypeOIDs.regnamespace]: 'regnamespace',
+    [DataTypeOIDs.regrole]: 'regrole',
+    [DataTypeOIDs.regcollation]: 'regcollation',
+    [DataTypeOIDs.int4multirange]: 'int4multirange',
+    [DataTypeOIDs.nummultirange]: 'nummultirange',
+    [DataTypeOIDs.tsmultirange]: 'tsmultirange',
+    [DataTypeOIDs.tstzmultirange]: 'tstzmultirange',
+    [DataTypeOIDs.datemultirange]: 'datemultirange',
+    [DataTypeOIDs.int8multirange]: 'int8multirange',
+    [DataTypeOIDs.pg_brin_bloom_summary]: 'pg_brin_bloom_summary',
+    [DataTypeOIDs.pg_brin_minmax_multi_summary]: 'pg_brin_minmax_multi_summary',
+    [DataTypeOIDs.pg_mcv_list]: 'pg_mcv_list',
+    [DataTypeOIDs.pg_snapshot]: 'pg_snapshot',
+    [DataTypeOIDs.xid8]: 'xid8',
     [DataTypeOIDs._xml]: '_xml',
     [DataTypeOIDs._json]: '_json',
     [DataTypeOIDs._xid8]: '_xid8',
@@ -229,6 +315,7 @@ export const DataTypeNames = {
     [DataTypeOIDs._float8]: '_float8',
     [DataTypeOIDs._polygon]: '_polygon',
     [DataTypeOIDs._oid]: '_oid',
+    [DataTypeOIDs._aclitem]: '_aclitem',
     [DataTypeOIDs._macaddr]: '_macaddr',
     [DataTypeOIDs._inet]: '_inet',
     [DataTypeOIDs._timestamp]: '_timestamp',
@@ -241,6 +328,37 @@ export const DataTypeNames = {
     [DataTypeOIDs._timetz]: '_timetz',
     [DataTypeOIDs._bit]: '_bit',
     [DataTypeOIDs._varbit]: '_varbit',
+    [DataTypeOIDs._refcursor]: '_refcursor',
+    [DataTypeOIDs._regprocedure]: '_regprocedure',
+    [DataTypeOIDs._regoper]: '_regoper',
+    [DataTypeOIDs._regoperator]: '_regoperator',
+    [DataTypeOIDs._regclass]: '_regclass',
+    [DataTypeOIDs._regtype]: '_regtype',
+    [DataTypeOIDs._record]: '_record',
+    [DataTypeOIDs._txid_snapshot]: '_txid_snapshot',
     [DataTypeOIDs._uuid]: '_uuid',
+    [DataTypeOIDs._pg_lsn]: '_pg_lsn',
+    [DataTypeOIDs._tsvector]: '_tsvector',
+    [DataTypeOIDs._gtsvector]: '_gtsvector',
+    [DataTypeOIDs._tsquery]: '_tsquery',
+    [DataTypeOIDs._regconfig]: '_regconfig',
+    [DataTypeOIDs._regdictionary]: '_regdictionary',
     [DataTypeOIDs._jsonb]: '_jsonb',
+    [DataTypeOIDs._int4range]: '_int4range',
+    [DataTypeOIDs._numrange]: '_numrange',
+    [DataTypeOIDs._tsrange]: '_tsrange',
+    [DataTypeOIDs._tstzrange]: '_tstzrange',
+    [DataTypeOIDs._daterange]: '_daterange',
+    [DataTypeOIDs._int8range]: '_int8range',
+    [DataTypeOIDs._jsonpath]: '_jsonpath',
+    [DataTypeOIDs._regnamespace]: '_regnamespace',
+    [DataTypeOIDs._regrole]: '_regrole',
+    [DataTypeOIDs._regcollation]: '_regcollation',
+    [DataTypeOIDs._pg_snapshot]: '_pg_snapshot',
+    [DataTypeOIDs._int4multirange]: '_int4multirange',
+    [DataTypeOIDs._nummultirange]: '_nummultirange',
+    [DataTypeOIDs._tsmultirange]: '_tsmultirange',
+    [DataTypeOIDs._tstzmultirange]: '_tstzmultirange',
+    [DataTypeOIDs._datemultirange]: '_datemultirange',
+    [DataTypeOIDs._int8multirange]: '_int8multirange',
 };

package/data-type-map.js

@@ -1,28 +1,43 @@
 import { DataTypeOIDs } from './constants.js';
+import { ArrayBitType, ArrayVarbitType, BitType, VarbitType, } from './data-types/bit-type.js';
 import { ArrayBoolType, BoolType } from './data-types/bool-type.js';
 import { ArrayBoxType, BoxType } from './data-types/box-type.js';
 import { ArrayByteaType, ByteaType } from './data-types/bytea-type.js';
 import { ArrayCharType, CharType } from './data-types/char-type.js';
 import { ArrayCircleType, CircleType } from './data-types/circle-type.js';
+import { getTypeOid, REQUIRES_TYPE_OID, } from './data-types/classes/type-oid.js';
 import { ArrayDateType, DateType } from './data-types/date-type.js';
 import { ArrayFloat4Type, Float4Type } from './data-types/float4-type.js';
 import { ArrayFloat8Type, Float8Type } from './data-types/float8-type.js';
+import { ArrayCidrType, ArrayInetType, CidrType, InetType, } from './data-types/inet-type.js';
 import { ArrayInt2Type, Int2Type } from './data-types/int2-type.js';
 import { ArrayInt2VectorType, Int2VectorType, } from './data-types/int2-vector-type.js';
 import { ArrayInt4Type, Int4Type } from './data-types/int4-type.js';
 import { ArrayInt8Type, Int8Type } from './data-types/int8-type.js';
+import { ArrayIntervalType, IntervalType } from './data-types/interval-type.js';
 import { ArrayJsonType, JsonType } from './data-types/json-type.js';
 import { ArrayJsonbType, JsonbType } from './data-types/jsonb-type.js';
+import { ArrayJsonPathType, JsonPathType } from './data-types/jsonpath-type.js';
+import { ArrayLineType, LineType } from './data-types/line-type.js';
 import { ArrayLsegType, LsegType } from './data-types/lseg-type.js';
+import { ArrayMacaddr8Type, ArrayMacaddrType, Macaddr8Type, MacaddrType, } from './data-types/macaddr-type.js';
 import { ArrayNumericType, NumericType } from './data-types/numeric-type.js';
 import { ArrayOidType, OidType } from './data-types/oid-type.js';
 import { ArrayOidVectorType, OidVectorType, } from './data-types/oid-vector-type.js';
+import { ArrayPathType, ArrayPolygonType, PathType, PolygonType, } from './data-types/path-type.js';
+import { ArrayPgLsnType, PgLsnType } from './data-types/pg-lsn-type.js';
 import { ArrayPointType, PointType } from './data-types/point-type.js';
+import { RangeTypes } from './data-types/range-type.js';
+import { ArrayPgSnapshotType, ArrayTxidSnapshotType, PgSnapshotType, TxidSnapshotType, } from './data-types/snapshot-type.js';
+import { ArrayTidType, TidType } from './data-types/tid-type.js';
 import { ArrayTimeType, TimeType } from './data-types/time-type.js';
 import { ArrayTimestampType, TimestampType, } from './data-types/timestamp-type.js';
 import { ArrayTimestamptzType, TimestamptzType, } from './data-types/timestamptz-type.js';
+import { ArrayTimeTzType, TimeTzType } from './data-types/timetz-type.js';
+import { ArrayTsQueryType, ArrayTsVectorType, TsQueryType, TsVectorType, } from './data-types/tsvector-type.js';
 import { ArrayUuidType, UuidType } from './data-types/uuid-type.js';
 import { ArrayVarcharType, VarcharType } from './data-types/varchar-type.js';
+import { ArrayCidType, ArrayXid8Type, ArrayXidType, CidType, Xid8Type, XidType, } from './data-types/xid-type.js';
 export class DataTypeMap {
     _itemsByOID = {};
     _items = [];
@@ -60,6 +75,25 @@ export class DataTypeMap {
     determine(value) {
         if (value == null)
             return DataTypeOIDs.unknown;
+        if (typeof value === 'object') {
+            // A value that already knows which type it came from says so,
+            // rather than being matched by shape - which is the only thing
+            // that can work when several types share one JavaScript class.
+            const carried = getTypeOid(value);
+            if (carried !== undefined)
+                return carried;
+            const ctor = value
+                .constructor;
+            if (ctor && ctor[REQUIRES_TYPE_OID]) {
+                // Checked before the walk below rather than after it: JsonType
+                // takes any object, so left to the walk this value would quietly
+                // go out declared `json` and come back looking right.
+                throw new TypeError(`A ${ctor.name} carries no type OID, and ` +
+                    'which PostgreSQL type it is cannot be told from the value - ' +
+                    'give it one (`new Range(lower, upper, bounds, oid)`) or name ' +
+                    'it at the call site (`new BindParam(oid, value)`)');
+            }
+        }
         const valueIsArray = Array.isArray(value);
         let i;
         let t;
@@ -97,6 +131,9 @@ GlobalTypeMap.register([CircleType, ArrayCircleType]);
 GlobalTypeMap.register([PointType, ArrayPointType]);
 GlobalTypeMap.register([LsegType, ArrayLsegType]);
 GlobalTypeMap.register([BoxType, ArrayBoxType]);
+GlobalTypeMap.register([LineType, ArrayLineType]);
+GlobalTypeMap.register([PathType, ArrayPathType]);
+GlobalTypeMap.register([PolygonType, ArrayPolygonType]);
 GlobalTypeMap.register([Int2VectorType, ArrayInt2VectorType]);
 GlobalTypeMap.register({
     ...VarcharType,
@@ -138,10 +175,55 @@ GlobalTypeMap.register({
     oid: DataTypeOIDs._xml,
     elementsOID: DataTypeOIDs.xml,
 });
+// `refcursor` is a cursor's name and `pg_node_tree` a catalog blob, and
+// both are literally text on the wire - `refcursor`'s own typsend is
+// textsend. Registered before varchar the way bpchar and the rest are,
+// and marked uninferrable on top of that: a plain string is not evidence
+// of either, and sending one declared `refcursor` where `text` was meant
+// would be refused by the server.
+GlobalTypeMap.register({
+    ...VarcharType,
+    name: 'refcursor',
+    oid: DataTypeOIDs.refcursor,
+    inferrable: false,
+});
+GlobalTypeMap.register({
+    ...ArrayVarcharType,
+    name: '_refcursor',
+    oid: DataTypeOIDs._refcursor,
+    elementsOID: DataTypeOIDs.refcursor,
+    inferrable: false,
+});
+// pg_node_tree has no array type of its own.
+GlobalTypeMap.register({
+    ...VarcharType,
+    name: 'pg_node_tree',
+    oid: DataTypeOIDs.pg_node_tree,
+    inferrable: false,
+});
 GlobalTypeMap.register([VarcharType, ArrayVarcharType]);
 GlobalTypeMap.register([UuidType, ArrayUuidType]);
 GlobalTypeMap.register([CharType, ArrayCharType]);
 GlobalTypeMap.register([TimestamptzType, ArrayTimestamptzType]);
 GlobalTypeMap.register([TimeType, ArrayTimeType]);
+GlobalTypeMap.register([TimeTzType, ArrayTimeTzType]);
 GlobalTypeMap.register([DateType, ArrayDateType]);
 GlobalTypeMap.register([TimestampType, ArrayTimestampType]);
+GlobalTypeMap.register([IntervalType, ArrayIntervalType]);
+GlobalTypeMap.register(RangeTypes);
+GlobalTypeMap.register([InetType, ArrayInetType]);
+GlobalTypeMap.register([CidrType, ArrayCidrType]);
+GlobalTypeMap.register([BitType, ArrayBitType]);
+GlobalTypeMap.register([VarbitType, ArrayVarbitType]);
+GlobalTypeMap.register([JsonPathType, ArrayJsonPathType]);
+GlobalTypeMap.register([TsVectorType, ArrayTsVectorType]);
+GlobalTypeMap.register([TsQueryType, ArrayTsQueryType]);
+GlobalTypeMap.register([XidType, ArrayXidType]);
+GlobalTypeMap.register([Xid8Type, ArrayXid8Type]);
+GlobalTypeMap.register([CidType, ArrayCidType]);
+GlobalTypeMap.register([TidType, ArrayTidType]);
+GlobalTypeMap.register([PgLsnType, ArrayPgLsnType]);
+GlobalTypeMap.register([PgSnapshotType, ArrayPgSnapshotType]);
+GlobalTypeMap.register([TxidSnapshotType, ArrayTxidSnapshotType]);
+GlobalTypeMap.register([MacaddrType, ArrayMacaddrType]);
+GlobalTypeMap.register([Macaddr8Type, ArrayMacaddr8Type]);

package/data-types/bit-type.d.ts

@@ -0,0 +1,5 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const BitType: DataType;
+export declare const ArrayBitType: DataType;
+export declare const VarbitType: DataType;
+export declare const ArrayVarbitType: DataType;

package/data-types/bit-type.js

@@ -0,0 +1,91 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * `bit` and `varbit` are one type on the wire - the length is a property
+ * of the column, not of the value - so they share a codec and differ
+ * only in which OID they register under.
+ *
+ * Both decode to a string of `0` and `1`, which is what the type is:
+ * PostgreSQL prints it that way, accepts it back that way, and the
+ * alternatives are all worse. A number loses leading zeroes and anything
+ * past 53 bits; a Buffer loses the bit count, so `1` and `10000000`
+ * become the same eight padded bits. `pg` leaves it a string too.
+ */
+/** Every byte's eight bits, so decoding is one lookup per byte. */
+const BYTE_BITS = new Array(256);
+for (let i = 0; i < 256; i++)
+    BYTE_BITS[i] = i.toString(2).padStart(8, '0');
+const BIT_PATTERN = /^[01]*$/;
+/**
+ * An int32 bit count, then the bits themselves packed most-significant
+ * first and the last byte zero-padded. A zero-length value is the count
+ * and nothing else.
+ */
+function decode(v, offset) {
+    const bits = v.readInt32BE(offset);
+    const whole = bits >> 3;
+    const start = offset + 4;
+    let out = '';
+    let i;
+    for (i = 0; i < whole; i++)
+        out += BYTE_BITS[v[start + i]];
+    const rest = bits & 7;
+    if (rest)
+        out += BYTE_BITS[v[start + whole]].slice(0, rest);
+    return out;
+}
+function encode(buf, v, name) {
+    if (typeof v !== 'string' || !BIT_PATTERN.test(v))
+        throw new Error(`"${v}" is not a valid ${name} value - a string of 0 and 1 is`);
+    const bits = v.length;
+    buf.writeInt32BE(bits);
+    const bytes = Buffer.alloc((bits + 7) >> 3);
+    let i;
+    for (i = 0; i < bits; i++)
+        if (v.charCodeAt(i) === 49)
+            bytes[i >> 3] |= 128 >> (i & 7);
+    buf.writeBytes(bytes);
+}
+function createType(name, oid) {
+    return {
+        name,
+        oid,
+        jsType: 'string',
+        // `0` and `1` are ordinary characters, and a string of them is far
+        // more often text than a bit string - inferring this type would send
+        // `bit` where `text` was meant. See inet-type.ts.
+        inferrable: false,
+        encodeText(v) {
+            return '' + v;
+        },
+        encodeBinary(buf, v) {
+            encode(buf, v, name);
+        },
+        decodeBinary(v, offset = 0) {
+            return decode(v, offset);
+        },
+        decodeText(v) {
+            return v;
+        },
+        // Two characters, both ASCII - see inet-type.ts for why 'latin1'.
+        decodeTextBuffer(buf, offset, len) {
+            return buf.toString('latin1', offset, offset + len);
+        },
+        isType(v) {
+            return typeof v === 'string' && BIT_PATTERN.test(v);
+        },
+    };
+}
+export const BitType = createType('bit', DataTypeOIDs.bit);
+export const ArrayBitType = {
+    ...BitType,
+    name: '_bit',
+    oid: DataTypeOIDs._bit,
+    elementsOID: DataTypeOIDs.bit,
+};
+export const VarbitType = createType('varbit', DataTypeOIDs.varbit);
+export const ArrayVarbitType = {
+    ...VarbitType,
+    name: '_varbit',
+    oid: DataTypeOIDs._varbit,
+    elementsOID: DataTypeOIDs.varbit,
+};

package/data-types/box-type.js

@@ -1,11 +1,12 @@
 import { DataTypeOIDs } from '../constants.js';
+import { Box, TwoPoints } from './classes/geometric.js';
 const BOX_PATTERN1 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *\)$/;
 const BOX_PATTERN2 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
 const BOX_PATTERN3 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
 export const BoxType = {
     name: 'box',
     oid: DataTypeOIDs.box,
-    jsType: 'object',
+    jsType: 'Box',
     arraySeparator: ';',
     encodeText(v) {
         return `(${v.x1},${v.y1}),(${v.x2},${v.y2})`;
@@ -17,34 +18,23 @@ export const BoxType = {
         buf.writeDoubleBE(v.y2);
     },
     decodeBinary(v, offset = 0) {
-        return {
-            x1: v.readDoubleBE(offset),
-            y1: v.readDoubleBE(offset + 8),
-            x2: v.readDoubleBE(offset + 16),
-            y2: v.readDoubleBE(offset + 24),
-        };
+        return new Box(v.readDoubleBE(offset), v.readDoubleBE(offset + 8), v.readDoubleBE(offset + 16), v.readDoubleBE(offset + 24));
     },
     decodeText(v) {
         const m = v.match(BOX_PATTERN1) || v.match(BOX_PATTERN2) || v.match(BOX_PATTERN3);
         if (!m)
             return undefined;
-        return {
-            x1: parseFloat(m[1]),
-            y1: parseFloat(m[2]),
-            x2: parseFloat(m[3]),
-            y2: parseFloat(m[4]),
-        };
+        return new Box(parseFloat(m[1]), parseFloat(m[2]), parseFloat(m[3]), parseFloat(m[4]));
     },
     decodeTextBuffer(buf, offset, len, options) {
         return BoxType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    // A plain object of the four numbers is still accepted - it is what
+    // this type returned before these classes existed - but only a plain
+    // one: box and lseg carry the same four, so an instance of the other
+    // must not be claimed here.
     isType(v) {
-        return (typeof v === 'object' &&
-            Object.keys(v).length === 4 &&
-            typeof v.x1 === 'number' &&
-            typeof v.y1 === 'number' &&
-            typeof v.x2 === 'number' &&
-            typeof v.y2 === 'number');
+        return v instanceof Box || TwoPoints.isTwoPointsLike(v);
     },
 };
 export const ArrayBoxType = {

package/data-types/circle-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+import { Circle } from './classes/geometric.js';
 const CIRCLE_PATTERN1 = /^< *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*) *>$/;
 const CIRCLE_PATTERN2 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*) *\)$/;
 const CIRCLE_PATTERN3 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*)$/;
@@ -6,7 +7,7 @@ const CIRCLE_PATTERN4 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
 export const CircleType = {
     name: 'circle',
     oid: DataTypeOIDs.circle,
-    jsType: 'object',
+    jsType: 'Circle',
     encodeText(v) {
         return `<(${v.x},${v.y}),${v.r}>`;
     },
@@ -16,11 +17,7 @@ export const CircleType = {
         buf.writeDoubleBE(v.r);
     },
     decodeBinary(v, offset = 0) {
-        return {
-            x: v.readDoubleBE(offset),
-            y: v.readDoubleBE(offset + 8),
-            r: v.readDoubleBE(offset + 16),
-        };
+        return new Circle(v.readDoubleBE(offset), v.readDoubleBE(offset + 8), v.readDoubleBE(offset + 16));
     },
     decodeText(v) {
         const m = v.match(CIRCLE_PATTERN1) ||
@@ -29,22 +26,15 @@ export const CircleType = {
             v.match(CIRCLE_PATTERN4);
         if (!m)
             return undefined;
-        return {
-            x: parseFloat(m[1]),
-            y: parseFloat(m[2]),
-            r: parseFloat(m[3]),
-        };
+        return new Circle(parseFloat(m[1]), parseFloat(m[2]), parseFloat(m[3]));
     },
     // See box-type.ts's decodeTextBuffer comment - same rationale.
     decodeTextBuffer(buf, offset, len, options) {
         return CircleType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    // See point-type.ts: the plain object shape is still accepted.
     isType(v) {
-        return (typeof v === 'object' &&
-            Object.keys(v).length === 3 &&
-            typeof v.x === 'number' &&
-            typeof v.y === 'number' &&
-            typeof v.r === 'number');
+        return v instanceof Circle || Circle.isCircleLike(v);
     },
 };
 export const ArrayCircleType = {

package/data-types/classes/geometric.d.ts

@@ -0,0 +1,105 @@
+/** A `point`: one position. */
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    /** As PostgreSQL prints it, so it casts back through `::point`. */
+    toString(): string;
+    toJSON(): string;
+    static isPointLike(v: any): boolean;
+}
+/** A `circle`: a centre and a radius. */
+export declare class Circle {
+    x: number;
+    y: number;
+    r: number;
+    constructor(x?: number, y?: number, r?: number);
+    /** As PostgreSQL prints it, so it casts back through `::circle`. */
+    toString(): string;
+    toJSON(): string;
+    static isCircleLike(v: any): boolean;
+}
+/**
+ * Two corners, which is how both `box` and `lseg` are carried - and why
+ * they are two classes rather than one shared shape. They were
+ * indistinguishable as plain objects: both types' isType() accepted
+ * `{x1, y1, x2, y2}`, so `determine()` answered `box` for every one of
+ * them and an lseg parameter could not be expressed at all.
+ */
+declare abstract class TwoPoints {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    constructor(x1?: number, y1?: number, x2?: number, y2?: number);
+    toJSON(): string;
+    static isTwoPointsLike(v: any): boolean;
+}
+/** A `box`: a rectangle given by two opposite corners. */
+export declare class Box extends TwoPoints {
+    /** As PostgreSQL prints it, so it casts back through `::box`. */
+    toString(): string;
+}
+/** An `lseg`: the straight line between two points. */
+export declare class LineSegment extends TwoPoints {
+    /** As PostgreSQL prints it, so it casts back through `::lseg`. */
+    toString(): string;
+}
+/**
+ * A `line`: the infinite line Ax + By + C = 0.
+ *
+ * PostgreSQL stores and prints the three coefficients whatever form the
+ * literal took - `line '((0,0),(1,1))'` comes back as `{1,-1,0}` - so
+ * that is what this carries. A pair of points would be a second, lossy
+ * spelling of the same thing, since a line through them is not the
+ * points.
+ */
+export declare class Line {
+    a: number;
+    b: number;
+    c: number;
+    constructor(a?: number, b?: number, c?: number);
+    /** As PostgreSQL prints it, so it casts back through `::line`. */
+    toString(): string;
+    toJSON(): string;
+    static isLineLike(v: any): boolean;
+}
+/**
+ * The list of points `path` and `polygon` share. They are two classes
+ * rather than one for the same reason `Box` and `LineSegment` are: the
+ * values are indistinguishable by shape, so only the class can say which
+ * type a parameter is meant for.
+ */
+declare abstract class PointList {
+    points: Point[];
+    /** Plain `{x, y}` objects are accepted and kept as Points. */
+    constructor(points?: (Point | {
+        x: number;
+        y: number;
+    })[]);
+    toJSON(): string;
+    protected join(): string;
+}
+/**
+ * A `path`: a series of points, open or closed.
+ *
+ * Closed is the default because it is PostgreSQL's - a literal written
+ * without brackets, `path '1,2,3,4'`, comes back closed. The flag is
+ * part of the value and not a formatting choice: the server stores it
+ * and prints `[...]` for an open path against `(...)` for a closed one.
+ */
+export declare class Path extends PointList {
+    isClosed: boolean;
+    constructor(points?: (Point | {
+        x: number;
+        y: number;
+    })[], isClosed?: boolean);
+    /** As PostgreSQL prints it, so it casts back through `::path`. */
+    toString(): string;
+}
+/** A `polygon`: a closed series of points. */
+export declare class Polygon extends PointList {
+    /** As PostgreSQL prints it, so it casts back through `::polygon`. */
+    toString(): string;
+}
+export { PointList, TwoPoints };