postgrejs 2.12.0

package/esm/connection/prepared-statement.js

@@ -0,0 +1,213 @@
+import { coerceToBoolean } from 'putil-varhelpers';
+import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
+import { GlobalTypeMap } from '../data-type-map.js';
+import { Protocol } from '../protocol/protocol.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { convertRowToObject } from '../util/convert-row-to-object.js';
+import { getParsers } from '../util/get-parsers.js';
+import { parseRow } from '../util/parse-row.js';
+import { wrapRowDescription } from '../util/wrap-row-description.js';
+import { Cursor } from './cursor.js';
+import { getIntlConnection } from './intl-connection.js';
+import { Portal } from './portal.js';
+let statementCounter = 0;
+let portalCounter = 0;
+export class PreparedStatement extends SafeEventEmitter {
+    constructor(connection, sql, paramTypes) {
+        super();
+        this._sql = '';
+        this._name = '';
+        this._refCount = 0;
+        this._connection = connection;
+        this._name = 'S_' + ++statementCounter;
+        this._sql = sql;
+        this._paramTypes = paramTypes;
+        this._onErrorSavePoint = 'SP_' + Math.round(Math.random() * 100000000);
+    }
+    static async prepare(connection, sql, options) {
+        const intoCon = getIntlConnection(connection);
+        intoCon.assertConnected();
+        const socket = intoCon.socket;
+        const statement = new PreparedStatement(connection, sql, options?.paramTypes);
+        await intoCon.statementQueue
+            .enqueue(async () => {
+            intoCon.ref();
+            try {
+                socket.sendParseMessage({
+                    statement: statement.name,
+                    sql: statement.sql,
+                    paramTypes: statement.paramTypes,
+                });
+                socket.sendFlushMessage();
+                try {
+                    await socket.capture(async (code, msg, done) => {
+                        if (code === Protocol.BackendMessageCode.ParseComplete)
+                            done();
+                        // May be Protocol.BackendMessageCode.NoticeResponse
+                    });
+                }
+                finally {
+                    socket.sendSyncMessage();
+                    await socket.capture(async (code, msg, done) => {
+                        if (code === Protocol.BackendMessageCode.ReadyForQuery)
+                            done();
+                        // May be Protocol.BackendMessageCode.NoticeResponse
+                    });
+                }
+            }
+            finally {
+                intoCon.unref();
+            }
+        })
+            .toPromise();
+        statement._refCount = 1;
+        return statement;
+    }
+    get connection() {
+        return this._connection;
+    }
+    get name() {
+        return this._name;
+    }
+    get sql() {
+        return this._sql;
+    }
+    get paramTypes() {
+        return this._paramTypes;
+    }
+    async execute(options = {}) {
+        const intlCon = getIntlConnection(this.connection);
+        const transactionCommand = this.sql.match(/^(\bBEGIN\b|\bCOMMIT\b|\bSTART\b|\bROLLBACK|SAVEPOINT|RELEASE\b)/i);
+        let beginFirst = false;
+        let commitLast = false;
+        if (!transactionCommand) {
+            if (!intlCon.inTransaction &&
+                (options?.autoCommit != null ? options?.autoCommit : intlCon.config.autoCommit) === false) {
+                beginFirst = true;
+            }
+            if (intlCon.inTransaction && options?.autoCommit)
+                commitLast = true;
+        }
+        if (beginFirst)
+            await intlCon.execute('BEGIN');
+        const rollbackOnError = !transactionCommand &&
+            (options?.rollbackOnError != null
+                ? options.rollbackOnError
+                : coerceToBoolean(intlCon.config.rollbackOnError, true));
+        if (intlCon.inTransaction && rollbackOnError)
+            await intlCon.execute('SAVEPOINT ' + this._onErrorSavePoint);
+        try {
+            const result = await intlCon.statementQueue.enqueue(() => this._execute(options)).toPromise();
+            if (commitLast)
+                await intlCon.execute('COMMIT');
+            else if (intlCon.inTransaction && rollbackOnError)
+                await intlCon.execute('RELEASE ' + this._onErrorSavePoint + ';');
+            return result;
+        }
+        catch (e) {
+            if (intlCon.inTransaction && rollbackOnError)
+                await intlCon.execute('ROLLBACK TO ' + this._onErrorSavePoint + ';');
+            throw e;
+        }
+    }
+    async close() {
+        --this._refCount;
+        if (this._refCount > 0)
+            return;
+        const intoCon = getIntlConnection(this.connection);
+        await intoCon.statementQueue.enqueue(() => this._close()).toPromise();
+    }
+    async cancel() {
+        throw new Error('Not implemented yet');
+    }
+    async _execute(options = {}) {
+        let portal;
+        const intlCon = getIntlConnection(this.connection);
+        intlCon.ref();
+        try {
+            const result = { command: undefined };
+            const startTime = Date.now();
+            const t = Date.now();
+            // Create portal
+            const portalName = 'P_' + ++portalCounter;
+            portal = new Portal(this, portalName);
+            await portal.bind(options.params, options);
+            const fields = await portal.retrieveFields();
+            const typeMap = options.typeMap || GlobalTypeMap;
+            let parsers;
+            let resultFields;
+            if (fields) {
+                parsers = getParsers(typeMap, fields);
+                resultFields = wrapRowDescription(typeMap, fields, options.columnFormat || DEFAULT_COLUMN_FORMAT);
+                result.fields = resultFields;
+                result.rowType = options.objectRows ? 'object' : 'array';
+                if (options.cursor) {
+                    result.cursor = new Cursor(this, portal, resultFields, parsers, options);
+                    this._refCount++;
+                    portal = undefined;
+                    return result;
+                }
+            }
+            const executeResult = await portal.execute(options.fetchCount);
+            result.executeTime = Date.now() - t;
+            if (executeResult.command)
+                result.command = executeResult.command;
+            if (resultFields && parsers && executeResult.rows) {
+                if (!result.command)
+                    result.command = 'SELECT';
+                const rows = (result.rows = executeResult.rows);
+                const l = rows.length;
+                let row;
+                for (let i = 0; i < l; i++) {
+                    row = rows[i];
+                    parseRow(parsers, row, options);
+                    if (options.objectRows) {
+                        rows[i] = convertRowToObject(resultFields, row);
+                    }
+                }
+            }
+            if (result.command === 'DELETE' || result.command === 'INSERT' || result.command === 'UPDATE')
+                result.rowsAffected = executeResult.rowCount;
+            result.executeTime = Date.now() - startTime;
+            return result;
+        }
+        finally {
+            intlCon.unref();
+            if (portal)
+                await portal.close();
+        }
+    }
+    async _close() {
+        if (--this._refCount > 0)
+            return;
+        const intoCon = getIntlConnection(this.connection);
+        intoCon.ref();
+        try {
+            const socket = intoCon.socket;
+            socket.sendCloseMessage({ type: 'S', name: this.name });
+            socket.sendSyncMessage();
+            await socket.capture(async (code, msg, done) => {
+                switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        this.emit('notice', msg);
+                        break;
+                    case Protocol.BackendMessageCode.CloseComplete:
+                        break;
+                    case Protocol.BackendMessageCode.ReadyForQuery:
+                        intoCon.transactionStatus = msg.status;
+                        done();
+                        break;
+                    default:
+                        done(new Error(`Server returned unexpected response message (0x${code.toString(16)})`));
+                }
+            });
+        }
+        finally {
+            intoCon.unref();
+        }
+        this.emit('close');
+    }
+    [Symbol.asyncDispose]() {
+        return this.close();
+    }
+}

package/esm/constants.js

@@ -0,0 +1,247 @@
+import { Protocol } from './protocol/protocol.js';
+var DataFormat = Protocol.DataFormat;
+// @ts-ignore
+Symbol.asyncDispose ?? (Symbol.asyncDispose = Symbol('Symbol.asyncDispose'));
+export { DataFormat };
+export const DEFAULT_COLUMN_FORMAT = DataFormat.binary;
+export var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState[ConnectionState["CLOSED"] = 0] = "CLOSED";
+    ConnectionState[ConnectionState["CONNECTING"] = 1] = "CONNECTING";
+    ConnectionState[ConnectionState["AUTHORIZING"] = 3] = "AUTHORIZING";
+    ConnectionState[ConnectionState["READY"] = 2] = "READY";
+    ConnectionState[ConnectionState["CLOSING"] = 10] = "CLOSING";
+})(ConnectionState || (ConnectionState = {}));
+export const DataTypeOIDs = {
+    bool: 16,
+    bytea: 17,
+    char: 18,
+    name: 19,
+    int8: 20,
+    int2: 21,
+    int2vector: 22,
+    int4: 23,
+    regproc: 24,
+    text: 25,
+    oid: 26,
+    tid: 27,
+    xid: 28,
+    cid: 29,
+    oidvector: 30,
+    json: 114,
+    xml: 142,
+    point: 600,
+    lseg: 601,
+    path: 602,
+    box: 603,
+    polygon: 604,
+    line: 628,
+    cidr: 650,
+    float4: 700,
+    float8: 701,
+    unknown: 705,
+    circle: 718,
+    macaddr8: 774,
+    money: 790,
+    macaddr: 829,
+    inet: 869,
+    bpchar: 1042,
+    varchar: 1043,
+    date: 1082,
+    time: 1083,
+    timestamp: 1114,
+    timestamptz: 1184,
+    interval: 1186,
+    timetz: 1266,
+    bit: 1560,
+    varbit: 1562,
+    numeric: 1700,
+    refcursor: 1790,
+    regprocedure: 2202,
+    regoper: 2203,
+    regoperator: 2204,
+    regclass: 2205,
+    regtype: 2206,
+    record: 2249,
+    cstring: 2275,
+    any: 2276,
+    anyarray: 2277,
+    void: 2278,
+    trigger: 2279,
+    // eslint-disable-next-line camelcase
+    language_handler: 2280,
+    internal: 2281,
+    anyelement: 2283,
+    anynonarray: 2776,
+    uuid: 2950,
+    jsonb: 3802,
+    anyrange: 3831,
+    int4range: 3904,
+    numrange: 3906,
+    tsrange: 3908,
+    rstzrange: 3910,
+    daterange: 3912,
+    int8range: 3926,
+    _xml: 143,
+    _json: 199,
+    _xid8: 271,
+    _line: 629,
+    _cidr: 651,
+    _circle: 719,
+    _macaddr8: 775,
+    _money: 791,
+    _bool: 1000,
+    _bytea: 1001,
+    _char: 1002,
+    _name: 1003,
+    _int2: 1005,
+    _int2vector: 1006,
+    _int4: 1007,
+    _regproc: 1008,
+    _text: 1009,
+    _tid: 1010,
+    _xid: 1011,
+    _cid: 1012,
+    _oidvector: 1013,
+    _bpchar: 1014,
+    _varchar: 1015,
+    _int8: 1016,
+    _point: 1017,
+    _lseg: 1018,
+    _path: 1019,
+    _box: 1020,
+    _float4: 1021,
+    _float8: 1022,
+    _polygon: 1027,
+    _oid: 1028,
+    _macaddr: 1040,
+    _inet: 1041,
+    _timestamp: 1115,
+    _date: 1182,
+    _time: 1183,
+    _timestamptz: 1185,
+    _interval: 1187,
+    _numeric: 1231,
+    _cstring: 1263,
+    _timetz: 1270,
+    _bit: 1561,
+    _varbit: 1563,
+    _uuid: 2951,
+    _jsonb: 3807,
+};
+export const DataTypeNames = {
+    [DataTypeOIDs.bool]: 'bool',
+    [DataTypeOIDs.bytea]: 'bytea',
+    [DataTypeOIDs.char]: 'char',
+    [DataTypeOIDs.name]: 'name',
+    [DataTypeOIDs.int8]: 'int8',
+    [DataTypeOIDs.int2]: 'int2',
+    [DataTypeOIDs.int2vector]: 'int2vector',
+    [DataTypeOIDs.int4]: 'int4',
+    [DataTypeOIDs.regproc]: 'regproc',
+    [DataTypeOIDs.text]: 'text',
+    [DataTypeOIDs.oid]: 'oid',
+    [DataTypeOIDs.tid]: 'tid',
+    [DataTypeOIDs.xid]: 'xid',
+    [DataTypeOIDs.cid]: 'cid',
+    [DataTypeOIDs.oidvector]: 'oidvector',
+    [DataTypeOIDs.json]: 'json',
+    [DataTypeOIDs.xml]: 'xml',
+    [DataTypeOIDs.point]: 'point',
+    [DataTypeOIDs.lseg]: 'lseg',
+    [DataTypeOIDs.path]: 'path',
+    [DataTypeOIDs.box]: 'box',
+    [DataTypeOIDs.polygon]: 'polygon',
+    [DataTypeOIDs.line]: 'line',
+    [DataTypeOIDs.cidr]: 'cidr',
+    [DataTypeOIDs.float4]: 'float4',
+    [DataTypeOIDs.float8]: 'float8',
+    [DataTypeOIDs.unknown]: 'unknown',
+    [DataTypeOIDs.circle]: 'circle',
+    [DataTypeOIDs.macaddr8]: 'macaddr8',
+    [DataTypeOIDs.money]: 'money',
+    [DataTypeOIDs.macaddr]: 'macaddr',
+    [DataTypeOIDs.inet]: 'inet',
+    [DataTypeOIDs.bpchar]: 'bpchar',
+    [DataTypeOIDs.varchar]: 'varchar',
+    [DataTypeOIDs.date]: 'date',
+    [DataTypeOIDs.time]: 'time',
+    [DataTypeOIDs.timestamp]: 'timestamp',
+    [DataTypeOIDs.timestamptz]: 'timestamptz',
+    [DataTypeOIDs.interval]: 'interval',
+    [DataTypeOIDs.timetz]: 'timetz',
+    [DataTypeOIDs.bit]: 'bit',
+    [DataTypeOIDs.varbit]: 'varbit',
+    [DataTypeOIDs.numeric]: 'numeric',
+    [DataTypeOIDs.refcursor]: 'refcursor',
+    [DataTypeOIDs.regprocedure]: 'regprocedure',
+    [DataTypeOIDs.regoper]: 'regoper',
+    [DataTypeOIDs.regoperator]: 'regoperator',
+    [DataTypeOIDs.regclass]: 'regclass',
+    [DataTypeOIDs.regtype]: 'regtype',
+    [DataTypeOIDs.record]: 'record',
+    [DataTypeOIDs.cstring]: 'cstring',
+    [DataTypeOIDs.any]: 'any',
+    [DataTypeOIDs.anyarray]: 'anyarray',
+    [DataTypeOIDs.void]: 'void',
+    [DataTypeOIDs.trigger]: 'trigger',
+    [DataTypeOIDs.language_handler]: 'language_handler',
+    [DataTypeOIDs.internal]: 'internal',
+    [DataTypeOIDs.anyelement]: 'anyelement',
+    [DataTypeOIDs.anynonarray]: 'anynonarray',
+    [DataTypeOIDs.uuid]: 'uuid',
+    [DataTypeOIDs.jsonb]: 'jsonb',
+    [DataTypeOIDs.anyrange]: 'anyrange',
+    [DataTypeOIDs.int4range]: 'int4range',
+    [DataTypeOIDs.numrange]: 'numrange',
+    [DataTypeOIDs.tsrange]: 'tsrange',
+    [DataTypeOIDs.rstzrange]: 'rstzrange',
+    [DataTypeOIDs.daterange]: 'daterange',
+    [DataTypeOIDs.int8range]: 'int8range',
+    [DataTypeOIDs._xml]: '_xml',
+    [DataTypeOIDs._json]: '_json',
+    [DataTypeOIDs._xid8]: '_xid8',
+    [DataTypeOIDs._line]: '_line',
+    [DataTypeOIDs._cidr]: '_cidr',
+    [DataTypeOIDs._circle]: '_circle',
+    [DataTypeOIDs._macaddr8]: '_macaddr8',
+    [DataTypeOIDs._money]: '_money',
+    [DataTypeOIDs._bool]: '_bool',
+    [DataTypeOIDs._bytea]: '_bytea',
+    [DataTypeOIDs._char]: '_char',
+    [DataTypeOIDs._name]: '_name',
+    [DataTypeOIDs._int2]: '_int2',
+    [DataTypeOIDs._int2vector]: '_int2vector',
+    [DataTypeOIDs._int4]: '_int4',
+    [DataTypeOIDs._regproc]: '_regproc',
+    [DataTypeOIDs._text]: '_text',
+    [DataTypeOIDs._tid]: '_tid',
+    [DataTypeOIDs._xid]: '_xid',
+    [DataTypeOIDs._cid]: '_cid',
+    [DataTypeOIDs._oidvector]: '_oidvector',
+    [DataTypeOIDs._bpchar]: '_bpchar',
+    [DataTypeOIDs._varchar]: '_varchar',
+    [DataTypeOIDs._int8]: '_int8',
+    [DataTypeOIDs._point]: '_point',
+    [DataTypeOIDs._lseg]: '_lseg',
+    [DataTypeOIDs._path]: '_path',
+    [DataTypeOIDs._box]: '_box',
+    [DataTypeOIDs._float4]: '_float4',
+    [DataTypeOIDs._float8]: '_float8',
+    [DataTypeOIDs._polygon]: '_polygon',
+    [DataTypeOIDs._oid]: '_oid',
+    [DataTypeOIDs._macaddr]: '_macaddr',
+    [DataTypeOIDs._inet]: '_inet',
+    [DataTypeOIDs._timestamp]: '_timestamp',
+    [DataTypeOIDs._date]: '_date',
+    [DataTypeOIDs._time]: '_time',
+    [DataTypeOIDs._timestamptz]: '_timestamptz',
+    [DataTypeOIDs._interval]: '_interval',
+    [DataTypeOIDs._numeric]: '_numeric',
+    [DataTypeOIDs._cstring]: '_cstring',
+    [DataTypeOIDs._timetz]: '_timetz',
+    [DataTypeOIDs._bit]: '_bit',
+    [DataTypeOIDs._varbit]: '_varbit',
+    [DataTypeOIDs._uuid]: '_uuid',
+    [DataTypeOIDs._jsonb]: '_jsonb',
+};

package/esm/data-type-map.js

@@ -0,0 +1,115 @@
+import { DataTypeOIDs } from './constants.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 { 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 { 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 { ArrayJsonType, JsonType } from './data-types/json-type.js';
+import { ArrayJsonbType, JsonbType } from './data-types/jsonb-type.js';
+import { ArrayLsegType, LsegType } from './data-types/lseg-type.js';
+import { ArrayNumericType, NumericType } from './data-types/numeric-type.js';
+import { ArrayOidType, OidType, VectorOidType } from './data-types/oid-type.js';
+import { ArrayPointType, PointType } from './data-types/point-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 { ArrayUuidType, UuidType } from './data-types/uuid-type.js';
+import { ArrayVarcharType, VarcharType } from './data-types/varchar-type.js';
+export class DataTypeMap {
+    constructor(other) {
+        this._itemsByOID = {};
+        this._items = [];
+        if (other instanceof DataTypeMap)
+            Object.assign(this._items, other._items);
+    }
+    get(oid) {
+        return this._itemsByOID[oid];
+    }
+    register(dataTypes) {
+        dataTypes = Array.isArray(dataTypes) ? dataTypes : [dataTypes];
+        for (const t of dataTypes) {
+            this._itemsByOID[t.oid] = t;
+            const i = this._items.findIndex(tt => tt.oid === t.oid);
+            if (i >= 0)
+                this._items[i] = t;
+            else
+                this._items.push(t);
+        }
+    }
+    determine(value) {
+        if (value == null)
+            return DataTypeOIDs.unknown;
+        const valueIsArray = Array.isArray(value);
+        let i;
+        let t;
+        for (i = this._items.length - 1; i >= 0; i--) {
+            t = this._items[i];
+            if (valueIsArray) {
+                if (t.elementsOID && t.isType(value[0]))
+                    return t.oid;
+            }
+            else if (!t.elementsOID && t.isType(value))
+                return t.oid;
+        }
+        return DataTypeOIDs.unknown;
+    }
+}
+export const GlobalTypeMap = new DataTypeMap();
+GlobalTypeMap.register([OidType, VectorOidType, ArrayOidType]);
+GlobalTypeMap.register([JsonbType, ArrayJsonbType]);
+GlobalTypeMap.register([JsonType, ArrayJsonType]);
+GlobalTypeMap.register([BoolType, ArrayBoolType]);
+GlobalTypeMap.register([NumericType, ArrayNumericType]);
+GlobalTypeMap.register([Float4Type, ArrayFloat4Type]);
+GlobalTypeMap.register([Float8Type, ArrayFloat8Type]);
+GlobalTypeMap.register([Int2Type, ArrayInt2Type]);
+GlobalTypeMap.register([Int4Type, ArrayInt4Type]);
+GlobalTypeMap.register([Int8Type, ArrayInt8Type]);
+GlobalTypeMap.register([ByteaType, ArrayByteaType]);
+GlobalTypeMap.register([CircleType, ArrayCircleType]);
+GlobalTypeMap.register([PointType, ArrayPointType]);
+GlobalTypeMap.register([LsegType, ArrayLsegType]);
+GlobalTypeMap.register([BoxType, ArrayBoxType]);
+GlobalTypeMap.register([Int2VectorType, ArrayInt2VectorType]);
+GlobalTypeMap.register({ ...VarcharType, name: 'bpchar', oid: DataTypeOIDs.bpchar });
+GlobalTypeMap.register({
+    ...ArrayVarcharType,
+    name: '_bpchar',
+    oid: DataTypeOIDs._bpchar,
+    elementsOID: DataTypeOIDs.bpchar,
+});
+GlobalTypeMap.register({ ...VarcharType, name: 'name', oid: DataTypeOIDs.name });
+GlobalTypeMap.register({
+    ...ArrayVarcharType,
+    name: '_name',
+    oid: DataTypeOIDs._name,
+    elementsOID: DataTypeOIDs.name,
+});
+GlobalTypeMap.register({ ...VarcharType, name: 'text', oid: DataTypeOIDs.text });
+GlobalTypeMap.register({
+    ...ArrayVarcharType,
+    name: '_text',
+    oid: DataTypeOIDs._text,
+    elementsOID: DataTypeOIDs.text,
+});
+GlobalTypeMap.register({ ...VarcharType, name: 'xml', oid: DataTypeOIDs.xml });
+GlobalTypeMap.register({
+    ...ArrayVarcharType,
+    name: '_xml',
+    oid: DataTypeOIDs._xml,
+    elementsOID: DataTypeOIDs.xml,
+});
+GlobalTypeMap.register([VarcharType, ArrayVarcharType]);
+GlobalTypeMap.register([UuidType, ArrayUuidType]);
+GlobalTypeMap.register([CharType, ArrayCharType]);
+GlobalTypeMap.register([TimestamptzType, ArrayTimestamptzType]);
+GlobalTypeMap.register([TimeType, ArrayTimeType]);
+GlobalTypeMap.register([DateType, ArrayDateType]);
+GlobalTypeMap.register([TimestampType, ArrayTimestampType]);

package/esm/data-types/bool-type.js

@@ -0,0 +1,24 @@
+import { DataTypeOIDs } from '../constants.js';
+export const BoolType = {
+    name: 'bool',
+    oid: DataTypeOIDs.bool,
+    jsType: 'boolean',
+    parseBinary(v) {
+        return !!v.readUInt8();
+    },
+    encodeBinary(buf, v) {
+        buf.writeInt8(v ? 1 : 0);
+    },
+    parseText(v) {
+        return v === 'TRUE' || v === 't' || v === 'true' || v === 'y' || v === 'yes' || v === 'on' || v === '1';
+    },
+    isType(v) {
+        return typeof v === 'boolean';
+    },
+};
+export const ArrayBoolType = {
+    ...BoolType,
+    name: '_bool',
+    oid: DataTypeOIDs._bool,
+    elementsOID: DataTypeOIDs.bool,
+};

package/esm/data-types/box-type.js

@@ -0,0 +1,49 @@
+import { DataTypeOIDs } from '../constants.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',
+    arraySeparator: ';',
+    parseBinary(v) {
+        return {
+            x1: v.readDoubleBE(0),
+            y1: v.readDoubleBE(8),
+            x2: v.readDoubleBE(16),
+            y2: v.readDoubleBE(24),
+        };
+    },
+    encodeBinary(buf, v) {
+        buf.writeDoubleBE(v.x1);
+        buf.writeDoubleBE(v.y1);
+        buf.writeDoubleBE(v.x2);
+        buf.writeDoubleBE(v.y2);
+    },
+    parseText(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]),
+        };
+    },
+    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');
+    },
+};
+export const ArrayBoxType = {
+    ...BoxType,
+    name: '_box',
+    oid: DataTypeOIDs._box,
+    elementsOID: DataTypeOIDs.box,
+};

package/esm/data-types/bytea-type.js

@@ -0,0 +1,23 @@
+import decodeBytea from 'postgres-bytea';
+import { DataTypeOIDs } from '../constants.js';
+export const ByteaType = {
+    name: 'bytea',
+    oid: DataTypeOIDs.bytea,
+    jsType: 'Buffer',
+    parseBinary(v) {
+        return v;
+    },
+    encodeBinary(buf, v) {
+        buf.writeBuffer(v);
+    },
+    parseText: decodeBytea,
+    isType(v) {
+        return v instanceof Buffer;
+    },
+};
+export const ArrayByteaType = {
+    ...ByteaType,
+    name: '_bytea',
+    oid: DataTypeOIDs._bytea,
+    elementsOID: DataTypeOIDs.bytea,
+};

package/esm/data-types/char-type.js

@@ -0,0 +1,24 @@
+import { DataTypeOIDs } from '../constants.js';
+export const CharType = {
+    name: 'char',
+    oid: DataTypeOIDs.char,
+    jsType: 'string',
+    parseBinary(v) {
+        return v.toString('utf8');
+    },
+    encodeBinary(buf, v) {
+        buf.writeString((v ? '' + v : ' ')[0], 'utf8');
+    },
+    parseText(v) {
+        return '' + v;
+    },
+    isType(v) {
+        return typeof v === 'string' && v.length === 1;
+    },
+};
+export const ArrayCharType = {
+    ...CharType,
+    name: '_char',
+    oid: DataTypeOIDs._char,
+    elementsOID: DataTypeOIDs.char,
+};