postgrejs 2.12.0

package/cjs/connection/prepared-statement.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparedStatement = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+const constants_js_1 = require("../constants.js");
+const data_type_map_js_1 = require("../data-type-map.js");
+const protocol_js_1 = require("../protocol/protocol.js");
+const safe_event_emitter_js_1 = require("../safe-event-emitter.js");
+const convert_row_to_object_js_1 = require("../util/convert-row-to-object.js");
+const get_parsers_js_1 = require("../util/get-parsers.js");
+const parse_row_js_1 = require("../util/parse-row.js");
+const wrap_row_description_js_1 = require("../util/wrap-row-description.js");
+const cursor_js_1 = require("./cursor.js");
+const intl_connection_js_1 = require("./intl-connection.js");
+const portal_js_1 = require("./portal.js");
+let statementCounter = 0;
+let portalCounter = 0;
+class PreparedStatement extends safe_event_emitter_js_1.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 = (0, intl_connection_js_1.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_js_1.Protocol.BackendMessageCode.ParseComplete)
+                            done();
+                        // May be Protocol.BackendMessageCode.NoticeResponse
+                    });
+                }
+                finally {
+                    socket.sendSyncMessage();
+                    await socket.capture(async (code, msg, done) => {
+                        if (code === protocol_js_1.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 = (0, intl_connection_js_1.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
+                : (0, putil_varhelpers_1.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 = (0, intl_connection_js_1.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 = (0, intl_connection_js_1.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_js_1.Portal(this, portalName);
+            await portal.bind(options.params, options);
+            const fields = await portal.retrieveFields();
+            const typeMap = options.typeMap || data_type_map_js_1.GlobalTypeMap;
+            let parsers;
+            let resultFields;
+            if (fields) {
+                parsers = (0, get_parsers_js_1.getParsers)(typeMap, fields);
+                resultFields = (0, wrap_row_description_js_1.wrapRowDescription)(typeMap, fields, options.columnFormat || constants_js_1.DEFAULT_COLUMN_FORMAT);
+                result.fields = resultFields;
+                result.rowType = options.objectRows ? 'object' : 'array';
+                if (options.cursor) {
+                    result.cursor = new cursor_js_1.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];
+                    (0, parse_row_js_1.parseRow)(parsers, row, options);
+                    if (options.objectRows) {
+                        rows[i] = (0, convert_row_to_object_js_1.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 = (0, intl_connection_js_1.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_js_1.Protocol.BackendMessageCode.NoticeResponse:
+                        this.emit('notice', msg);
+                        break;
+                    case protocol_js_1.Protocol.BackendMessageCode.CloseComplete:
+                        break;
+                    case protocol_js_1.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();
+    }
+}
+exports.PreparedStatement = PreparedStatement;

package/cjs/constants.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTypeNames = exports.DataTypeOIDs = exports.ConnectionState = exports.DEFAULT_COLUMN_FORMAT = exports.DataFormat = void 0;
+const protocol_js_1 = require("./protocol/protocol.js");
+var DataFormat = protocol_js_1.Protocol.DataFormat;
+exports.DataFormat = DataFormat;
+// @ts-ignore
+Symbol.asyncDispose ?? (Symbol.asyncDispose = Symbol('Symbol.asyncDispose'));
+exports.DEFAULT_COLUMN_FORMAT = DataFormat.binary;
+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 || (exports.ConnectionState = ConnectionState = {}));
+exports.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,
+};
+exports.DataTypeNames = {
+    [exports.DataTypeOIDs.bool]: 'bool',
+    [exports.DataTypeOIDs.bytea]: 'bytea',
+    [exports.DataTypeOIDs.char]: 'char',
+    [exports.DataTypeOIDs.name]: 'name',
+    [exports.DataTypeOIDs.int8]: 'int8',
+    [exports.DataTypeOIDs.int2]: 'int2',
+    [exports.DataTypeOIDs.int2vector]: 'int2vector',
+    [exports.DataTypeOIDs.int4]: 'int4',
+    [exports.DataTypeOIDs.regproc]: 'regproc',
+    [exports.DataTypeOIDs.text]: 'text',
+    [exports.DataTypeOIDs.oid]: 'oid',
+    [exports.DataTypeOIDs.tid]: 'tid',
+    [exports.DataTypeOIDs.xid]: 'xid',
+    [exports.DataTypeOIDs.cid]: 'cid',
+    [exports.DataTypeOIDs.oidvector]: 'oidvector',
+    [exports.DataTypeOIDs.json]: 'json',
+    [exports.DataTypeOIDs.xml]: 'xml',
+    [exports.DataTypeOIDs.point]: 'point',
+    [exports.DataTypeOIDs.lseg]: 'lseg',
+    [exports.DataTypeOIDs.path]: 'path',
+    [exports.DataTypeOIDs.box]: 'box',
+    [exports.DataTypeOIDs.polygon]: 'polygon',
+    [exports.DataTypeOIDs.line]: 'line',
+    [exports.DataTypeOIDs.cidr]: 'cidr',
+    [exports.DataTypeOIDs.float4]: 'float4',
+    [exports.DataTypeOIDs.float8]: 'float8',
+    [exports.DataTypeOIDs.unknown]: 'unknown',
+    [exports.DataTypeOIDs.circle]: 'circle',
+    [exports.DataTypeOIDs.macaddr8]: 'macaddr8',
+    [exports.DataTypeOIDs.money]: 'money',
+    [exports.DataTypeOIDs.macaddr]: 'macaddr',
+    [exports.DataTypeOIDs.inet]: 'inet',
+    [exports.DataTypeOIDs.bpchar]: 'bpchar',
+    [exports.DataTypeOIDs.varchar]: 'varchar',
+    [exports.DataTypeOIDs.date]: 'date',
+    [exports.DataTypeOIDs.time]: 'time',
+    [exports.DataTypeOIDs.timestamp]: 'timestamp',
+    [exports.DataTypeOIDs.timestamptz]: 'timestamptz',
+    [exports.DataTypeOIDs.interval]: 'interval',
+    [exports.DataTypeOIDs.timetz]: 'timetz',
+    [exports.DataTypeOIDs.bit]: 'bit',
+    [exports.DataTypeOIDs.varbit]: 'varbit',
+    [exports.DataTypeOIDs.numeric]: 'numeric',
+    [exports.DataTypeOIDs.refcursor]: 'refcursor',
+    [exports.DataTypeOIDs.regprocedure]: 'regprocedure',
+    [exports.DataTypeOIDs.regoper]: 'regoper',
+    [exports.DataTypeOIDs.regoperator]: 'regoperator',
+    [exports.DataTypeOIDs.regclass]: 'regclass',
+    [exports.DataTypeOIDs.regtype]: 'regtype',
+    [exports.DataTypeOIDs.record]: 'record',
+    [exports.DataTypeOIDs.cstring]: 'cstring',
+    [exports.DataTypeOIDs.any]: 'any',
+    [exports.DataTypeOIDs.anyarray]: 'anyarray',
+    [exports.DataTypeOIDs.void]: 'void',
+    [exports.DataTypeOIDs.trigger]: 'trigger',
+    [exports.DataTypeOIDs.language_handler]: 'language_handler',
+    [exports.DataTypeOIDs.internal]: 'internal',
+    [exports.DataTypeOIDs.anyelement]: 'anyelement',
+    [exports.DataTypeOIDs.anynonarray]: 'anynonarray',
+    [exports.DataTypeOIDs.uuid]: 'uuid',
+    [exports.DataTypeOIDs.jsonb]: 'jsonb',
+    [exports.DataTypeOIDs.anyrange]: 'anyrange',
+    [exports.DataTypeOIDs.int4range]: 'int4range',
+    [exports.DataTypeOIDs.numrange]: 'numrange',
+    [exports.DataTypeOIDs.tsrange]: 'tsrange',
+    [exports.DataTypeOIDs.rstzrange]: 'rstzrange',
+    [exports.DataTypeOIDs.daterange]: 'daterange',
+    [exports.DataTypeOIDs.int8range]: 'int8range',
+    [exports.DataTypeOIDs._xml]: '_xml',
+    [exports.DataTypeOIDs._json]: '_json',
+    [exports.DataTypeOIDs._xid8]: '_xid8',
+    [exports.DataTypeOIDs._line]: '_line',
+    [exports.DataTypeOIDs._cidr]: '_cidr',
+    [exports.DataTypeOIDs._circle]: '_circle',
+    [exports.DataTypeOIDs._macaddr8]: '_macaddr8',
+    [exports.DataTypeOIDs._money]: '_money',
+    [exports.DataTypeOIDs._bool]: '_bool',
+    [exports.DataTypeOIDs._bytea]: '_bytea',
+    [exports.DataTypeOIDs._char]: '_char',
+    [exports.DataTypeOIDs._name]: '_name',
+    [exports.DataTypeOIDs._int2]: '_int2',
+    [exports.DataTypeOIDs._int2vector]: '_int2vector',
+    [exports.DataTypeOIDs._int4]: '_int4',
+    [exports.DataTypeOIDs._regproc]: '_regproc',
+    [exports.DataTypeOIDs._text]: '_text',
+    [exports.DataTypeOIDs._tid]: '_tid',
+    [exports.DataTypeOIDs._xid]: '_xid',
+    [exports.DataTypeOIDs._cid]: '_cid',
+    [exports.DataTypeOIDs._oidvector]: '_oidvector',
+    [exports.DataTypeOIDs._bpchar]: '_bpchar',
+    [exports.DataTypeOIDs._varchar]: '_varchar',
+    [exports.DataTypeOIDs._int8]: '_int8',
+    [exports.DataTypeOIDs._point]: '_point',
+    [exports.DataTypeOIDs._lseg]: '_lseg',
+    [exports.DataTypeOIDs._path]: '_path',
+    [exports.DataTypeOIDs._box]: '_box',
+    [exports.DataTypeOIDs._float4]: '_float4',
+    [exports.DataTypeOIDs._float8]: '_float8',
+    [exports.DataTypeOIDs._polygon]: '_polygon',
+    [exports.DataTypeOIDs._oid]: '_oid',
+    [exports.DataTypeOIDs._macaddr]: '_macaddr',
+    [exports.DataTypeOIDs._inet]: '_inet',
+    [exports.DataTypeOIDs._timestamp]: '_timestamp',
+    [exports.DataTypeOIDs._date]: '_date',
+    [exports.DataTypeOIDs._time]: '_time',
+    [exports.DataTypeOIDs._timestamptz]: '_timestamptz',
+    [exports.DataTypeOIDs._interval]: '_interval',
+    [exports.DataTypeOIDs._numeric]: '_numeric',
+    [exports.DataTypeOIDs._cstring]: '_cstring',
+    [exports.DataTypeOIDs._timetz]: '_timetz',
+    [exports.DataTypeOIDs._bit]: '_bit',
+    [exports.DataTypeOIDs._varbit]: '_varbit',
+    [exports.DataTypeOIDs._uuid]: '_uuid',
+    [exports.DataTypeOIDs._jsonb]: '_jsonb',
+};

package/cjs/data-type-map.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalTypeMap = exports.DataTypeMap = void 0;
+const constants_js_1 = require("./constants.js");
+const bool_type_js_1 = require("./data-types/bool-type.js");
+const box_type_js_1 = require("./data-types/box-type.js");
+const bytea_type_js_1 = require("./data-types/bytea-type.js");
+const char_type_js_1 = require("./data-types/char-type.js");
+const circle_type_js_1 = require("./data-types/circle-type.js");
+const date_type_js_1 = require("./data-types/date-type.js");
+const float4_type_js_1 = require("./data-types/float4-type.js");
+const float8_type_js_1 = require("./data-types/float8-type.js");
+const int2_type_js_1 = require("./data-types/int2-type.js");
+const int2_vector_type_js_1 = require("./data-types/int2-vector-type.js");
+const int4_type_js_1 = require("./data-types/int4-type.js");
+const int8_type_js_1 = require("./data-types/int8-type.js");
+const json_type_js_1 = require("./data-types/json-type.js");
+const jsonb_type_js_1 = require("./data-types/jsonb-type.js");
+const lseg_type_js_1 = require("./data-types/lseg-type.js");
+const numeric_type_js_1 = require("./data-types/numeric-type.js");
+const oid_type_js_1 = require("./data-types/oid-type.js");
+const point_type_js_1 = require("./data-types/point-type.js");
+const time_type_js_1 = require("./data-types/time-type.js");
+const timestamp_type_js_1 = require("./data-types/timestamp-type.js");
+const timestamptz_type_js_1 = require("./data-types/timestamptz-type.js");
+const uuid_type_js_1 = require("./data-types/uuid-type.js");
+const varchar_type_js_1 = require("./data-types/varchar-type.js");
+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 constants_js_1.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 constants_js_1.DataTypeOIDs.unknown;
+    }
+}
+exports.DataTypeMap = DataTypeMap;
+exports.GlobalTypeMap = new DataTypeMap();
+exports.GlobalTypeMap.register([oid_type_js_1.OidType, oid_type_js_1.VectorOidType, oid_type_js_1.ArrayOidType]);
+exports.GlobalTypeMap.register([jsonb_type_js_1.JsonbType, jsonb_type_js_1.ArrayJsonbType]);
+exports.GlobalTypeMap.register([json_type_js_1.JsonType, json_type_js_1.ArrayJsonType]);
+exports.GlobalTypeMap.register([bool_type_js_1.BoolType, bool_type_js_1.ArrayBoolType]);
+exports.GlobalTypeMap.register([numeric_type_js_1.NumericType, numeric_type_js_1.ArrayNumericType]);
+exports.GlobalTypeMap.register([float4_type_js_1.Float4Type, float4_type_js_1.ArrayFloat4Type]);
+exports.GlobalTypeMap.register([float8_type_js_1.Float8Type, float8_type_js_1.ArrayFloat8Type]);
+exports.GlobalTypeMap.register([int2_type_js_1.Int2Type, int2_type_js_1.ArrayInt2Type]);
+exports.GlobalTypeMap.register([int4_type_js_1.Int4Type, int4_type_js_1.ArrayInt4Type]);
+exports.GlobalTypeMap.register([int8_type_js_1.Int8Type, int8_type_js_1.ArrayInt8Type]);
+exports.GlobalTypeMap.register([bytea_type_js_1.ByteaType, bytea_type_js_1.ArrayByteaType]);
+exports.GlobalTypeMap.register([circle_type_js_1.CircleType, circle_type_js_1.ArrayCircleType]);
+exports.GlobalTypeMap.register([point_type_js_1.PointType, point_type_js_1.ArrayPointType]);
+exports.GlobalTypeMap.register([lseg_type_js_1.LsegType, lseg_type_js_1.ArrayLsegType]);
+exports.GlobalTypeMap.register([box_type_js_1.BoxType, box_type_js_1.ArrayBoxType]);
+exports.GlobalTypeMap.register([int2_vector_type_js_1.Int2VectorType, int2_vector_type_js_1.ArrayInt2VectorType]);
+exports.GlobalTypeMap.register({ ...varchar_type_js_1.VarcharType, name: 'bpchar', oid: constants_js_1.DataTypeOIDs.bpchar });
+exports.GlobalTypeMap.register({
+    ...varchar_type_js_1.ArrayVarcharType,
+    name: '_bpchar',
+    oid: constants_js_1.DataTypeOIDs._bpchar,
+    elementsOID: constants_js_1.DataTypeOIDs.bpchar,
+});
+exports.GlobalTypeMap.register({ ...varchar_type_js_1.VarcharType, name: 'name', oid: constants_js_1.DataTypeOIDs.name });
+exports.GlobalTypeMap.register({
+    ...varchar_type_js_1.ArrayVarcharType,
+    name: '_name',
+    oid: constants_js_1.DataTypeOIDs._name,
+    elementsOID: constants_js_1.DataTypeOIDs.name,
+});
+exports.GlobalTypeMap.register({ ...varchar_type_js_1.VarcharType, name: 'text', oid: constants_js_1.DataTypeOIDs.text });
+exports.GlobalTypeMap.register({
+    ...varchar_type_js_1.ArrayVarcharType,
+    name: '_text',
+    oid: constants_js_1.DataTypeOIDs._text,
+    elementsOID: constants_js_1.DataTypeOIDs.text,
+});
+exports.GlobalTypeMap.register({ ...varchar_type_js_1.VarcharType, name: 'xml', oid: constants_js_1.DataTypeOIDs.xml });
+exports.GlobalTypeMap.register({
+    ...varchar_type_js_1.ArrayVarcharType,
+    name: '_xml',
+    oid: constants_js_1.DataTypeOIDs._xml,
+    elementsOID: constants_js_1.DataTypeOIDs.xml,
+});
+exports.GlobalTypeMap.register([varchar_type_js_1.VarcharType, varchar_type_js_1.ArrayVarcharType]);
+exports.GlobalTypeMap.register([uuid_type_js_1.UuidType, uuid_type_js_1.ArrayUuidType]);
+exports.GlobalTypeMap.register([char_type_js_1.CharType, char_type_js_1.ArrayCharType]);
+exports.GlobalTypeMap.register([timestamptz_type_js_1.TimestamptzType, timestamptz_type_js_1.ArrayTimestamptzType]);
+exports.GlobalTypeMap.register([time_type_js_1.TimeType, time_type_js_1.ArrayTimeType]);
+exports.GlobalTypeMap.register([date_type_js_1.DateType, date_type_js_1.ArrayDateType]);
+exports.GlobalTypeMap.register([timestamp_type_js_1.TimestampType, timestamp_type_js_1.ArrayTimestampType]);

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayBoolType = exports.BoolType = void 0;
+const constants_js_1 = require("../constants.js");
+exports.BoolType = {
+    name: 'bool',
+    oid: constants_js_1.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';
+    },
+};
+exports.ArrayBoolType = {
+    ...exports.BoolType,
+    name: '_bool',
+    oid: constants_js_1.DataTypeOIDs._bool,
+    elementsOID: constants_js_1.DataTypeOIDs.bool,
+};

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayBoxType = exports.BoxType = void 0;
+const constants_js_1 = require("../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*)$/;
+exports.BoxType = {
+    name: 'box',
+    oid: constants_js_1.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');
+    },
+};
+exports.ArrayBoxType = {
+    ...exports.BoxType,
+    name: '_box',
+    oid: constants_js_1.DataTypeOIDs._box,
+    elementsOID: constants_js_1.DataTypeOIDs.box,
+};