@m2k-5f/pgtx 2.7.2 → 2.8.0

package/dist/protocol/connection-request-writer.js

@@ -1,13 +1,31 @@
-import { RequestTypes } from "./constants";
+import { createBindTypeError } from "../error";
+import { DataTypeOids, RequestTypes } from "./constants";
+import { handlers } from "./types";
+const POSTGRES_EPOCH = Date.UTC(2000, 0, 1);
 export class ConnectionRequestBuffer {
-    constructor(buffer, offset = 0, lastRequestLenByteOffset = 0) {
+    constructor(buffer, offset = 0, lastRequestLenByteOffset = 0, _markedCaret = 0) {
         this.buffer = buffer;
         this.offset = offset;
         this.lastRequestLenByteOffset = lastRequestLenByteOffset;
+        this._markedCaret = _markedCaret;
     }
     static new(capacity) {
         return new ConnectionRequestBuffer(Buffer.allocUnsafe(capacity));
     }
+    get isEmpty() {
+        return !this.buffer.length;
+    }
+    get hasMore() {
+        return !!this.buffer.length;
+    }
+    mark() {
+        this._markedCaret = this.offset;
+        return this;
+    }
+    rollback() {
+        this.offset = this._markedCaret;
+        return this;
+    }
     ensureCapacity(needed) {
         const required = needed + this.offset;
         if (required <= this.buffer.length)
@@ -33,26 +51,73 @@ export class ConnectionRequestBuffer {
         this.offset += this.buffer.write(string, this.offset, 'utf-8');
         return this;
     }
-    writeInt32(number) {
-        this.ensureCapacity(4);
-        this.buffer.writeInt32BE(number, this.offset);
-        this.offset += 4;
-        return this;
-    }
     writeInt16(number) {
         this.ensureCapacity(2);
         this.buffer.writeInt16BE(number, this.offset);
         this.offset += 2;
         return this;
     }
+    writeInt32(number) {
+        this.ensureCapacity(4);
+        this.buffer.writeInt32BE(number, this.offset);
+        this.offset += 4;
+        return this;
+    }
     writeChar(char) {
         this.ensureCapacity(1);
         this.buffer[this.offset] = char.charCodeAt(0);
         this.offset++;
         return this;
     }
+    writeByte(byte) {
+        this.ensureCapacity(1);
+        this.buffer[this.offset++] = byte;
+        return this;
+    }
+    writeBigInt64(value) {
+        this.ensureCapacity(8);
+        this.buffer.writeBigInt64BE(value, this.offset);
+        this.offset += 8;
+        return this;
+    }
+    writeUInt16(value) {
+        this.ensureCapacity(2);
+        this.buffer.writeUInt16BE(value, this.offset);
+        this.offset += 2;
+        return this;
+    }
+    writeUInt32(value) {
+        this.ensureCapacity(4);
+        this.buffer.writeUInt32BE(value, this.offset);
+        this.offset += 4;
+        return this;
+    }
+    writeBytes(value) {
+        this.ensureCapacity(value.byteLength);
+        this.buffer.set(value, this.offset);
+        this.offset += value.byteLength;
+        return this;
+    }
+    writeInt64(number) {
+        this.ensureCapacity(8);
+        this.buffer.writeBigInt64BE(BigInt(number), this.offset);
+        this.offset += 8;
+        return this;
+    }
+    writeFloat32(number) {
+        this.ensureCapacity(4);
+        this.buffer.writeFloatBE(number, this.offset);
+        this.offset += 4;
+        return this;
+    }
+    writeFloat64(number) {
+        this.ensureCapacity(8);
+        this.buffer.writeDoubleBE(number, this.offset);
+        this.offset += 8;
+        return this;
+    }
     startRequest(requestType) {
-        this.writeChar(requestType);
+        this.writeByte(requestType);
         this.lastRequestLenByteOffset = this.offset;
         return this.writeInt32(0);
     }
@@ -72,57 +137,36 @@ export class ConnectionRequestBuffer {
         this.offset = 0;
         this.lastRequestLenByteOffset = 0;
     }
-}
-export class ConnectionRequestWriter {
-    constructor(buffer) {
-        this.buffer = buffer;
-    }
-    static new() {
-        return new ConnectionRequestWriter(ConnectionRequestBuffer.new(65536));
-    }
     writeQuery(text) {
-        this.buffer.startRequest(RequestTypes.SimpleQuery)
+        this.startRequest(RequestTypes.SimpleQuery)
             .writeCString(text)
             .endRequest();
         return this;
     }
     writeParse(name, text) {
-        this.buffer.startRequest(RequestTypes.Parse)
+        this.startRequest(RequestTypes.Parse)
             .writeCString(name)
             .writeCString(text)
             .writeInt16(0)
             .endRequest();
         return this;
     }
-    writeDescribe(statementName) {
-        this.buffer.startRequest(RequestTypes.Describe)
-            .writeChar('S')
-            .writeCString(statementName)
+    writeDescribe(type, name) {
+        this.startRequest(RequestTypes.Describe)
+            .writeChar(type)
+            .writeCString(name)
             .endRequest();
         return this;
     }
-    writeBind(portName, statementName, params) {
-        const request = this.buffer.startRequest(RequestTypes.Bind)
-            .writeCString(portName)
-            .writeCString(statementName)
-            .writeInt16(0)
-            .writeInt16(params.length);
-        params.forEach(param => {
-            request.writeInt32(param ? Buffer.byteLength(param) : -1);
-            param && request.writeString(param);
-        });
-        request.writeInt16(1).writeInt16(1).endRequest();
-        return this;
-    }
     writeClose(name) {
-        this.buffer.startRequest(RequestTypes.Close)
+        this.startRequest(RequestTypes.Close)
             .writeChar("P")
             .writeCString(name)
             .endRequest();
         return this;
     }
     writeStartup(user, database) {
-        this.buffer.startMessage()
+        this.startMessage()
             .writeInt32(196608)
             .writeCString('user').writeCString(user)
             .writeCString('database').writeCString(database)
@@ -131,30 +175,30 @@ export class ConnectionRequestWriter {
         return this;
     }
     writeExecute(portName) {
-        this.buffer.startRequest(RequestTypes.Execute)
+        this.startRequest(RequestTypes.Execute)
             .writeCString(portName)
             .writeInt32(0)
             .endRequest();
         return this;
     }
     writeSync() {
-        this.buffer.startRequest(RequestTypes.Sync).endRequest();
+        this.startRequest(RequestTypes.Sync).endRequest();
         return this;
     }
     writeSSLRequest() {
-        this.buffer.startMessage()
+        this.startMessage()
             .writeInt32(80877103)
             .endRequest();
         return this;
     }
     writePassword(password) {
-        this.buffer.startRequest(RequestTypes.Password)
+        this.startRequest(RequestTypes.Password)
             .writeCString(password)
             .endRequest();
         return this;
     }
     writeSaslInitial(mechanism, clientFirstMessage) {
-        this.buffer.startRequest(RequestTypes.Password)
+        this.startRequest(RequestTypes.Password)
             .writeCString(mechanism)
             .writeInt32(Buffer.byteLength(clientFirstMessage, 'utf-8'))
             .writeString(clientFirstMessage)
@@ -162,16 +206,366 @@ export class ConnectionRequestWriter {
         return this;
     }
     writeSaslResponse(clientFinalMessage) {
-        this.buffer.startRequest(RequestTypes.Password)
+        this.startRequest(RequestTypes.Password)
             .writeString(clientFinalMessage)
             .endRequest();
         return this;
     }
-    asBuffer() {
-        return this.buffer.asBuffer();
+    // ------ Binary writers of js values into Bind parameters ------
+    writeBinaryBool(value) {
+        this.writeInt32(1);
+        this.writeByte(value ? 1 : 0);
+        return this;
     }
-    clear() {
-        this.buffer.clear();
+    writeBinaryString(value) {
+        this.writeInt32(Buffer.byteLength(value));
+        this.writeString(value);
+        return this;
+    }
+    writeBinaryInt2(value) {
+        this.writeInt32(2);
+        this.writeInt16(value);
+        return this;
+    }
+    writeBinaryInt4(value) {
+        this.writeInt32(4);
+        this.writeInt32(value);
+        return this;
+    }
+    writeBinaryInt8(value) {
+        this.writeInt32(8);
+        this.writeInt64(value);
+        return this;
+    }
+    writeBinaryBigInt8(value) {
+        this.writeInt32(8);
+        this.writeBigInt64(value);
+        return this;
+    }
+    writeBinaryFloat4(value) {
+        this.writeInt32(4);
+        this.writeFloat32(value);
+        return this;
+    }
+    writeBinaryFloat8(value) {
+        this.writeInt32(8);
+        this.writeFloat64(value);
+        return this;
+    }
+    writeBinaryBytea(value) {
+        this.writeInt32(value.byteLength);
+        this.writeBytes(value);
+        return this;
+    }
+    writeBinaryTimestamp(value) {
+        const micros = BigInt(value.getTime() - POSTGRES_EPOCH) * 1000n;
+        this.writeInt32(8);
+        this.writeBigInt64(micros);
         return this;
     }
+    writeBinaryPoint(value) {
+        this.writeInt32(16);
+        this.writeFloat64(value.x);
+        this.writeFloat64(value.y);
+        return this;
+    }
+    writeBinaryNumeric(value) {
+        const negative = value.startsWith('-');
+        const unsigned = negative ? value.slice(1) : value;
+        const [intPartRaw, fracPartRaw = ''] = unsigned.split('.');
+        const intPart = intPartRaw === '' ? '0' : intPartRaw;
+        const fracPart = fracPartRaw;
+        const dscale = fracPart.length;
+        const intPad = (4 - (intPart.length % 4)) % 4;
+        const paddedInt = '0'.repeat(intPad) + intPart;
+        const fracPad = (4 - (fracPart.length % 4)) % 4;
+        const paddedFrac = fracPart + '0'.repeat(fracPad);
+        const digitsStr = paddedInt + paddedFrac;
+        const digits = [];
+        for (let i = 0; i < digitsStr.length; i += 4) {
+            digits.push(parseInt(digitsStr.slice(i, i + 4), 10));
+        }
+        let weight = paddedInt.length / 4 - 1;
+        let start = 0;
+        while (start < digits.length && digits[start] === 0) {
+            start++;
+            weight--;
+        }
+        let end = digits.length;
+        while (end > start && digits[end - 1] === 0) {
+            end--;
+        }
+        const trimmed = digits.slice(start, end);
+        const isZero = trimmed.length === 0;
+        this.writeInt32(8 + trimmed.length * 2);
+        this.writeInt16(trimmed.length);
+        this.writeInt16(isZero ? 0 : weight);
+        this.writeUInt16(negative && !isZero ? 0x4000 : 0x0000);
+        this.writeUInt16(dscale);
+        for (const digit of trimmed) {
+            this.writeInt16(digit);
+        }
+        return this;
+    }
+    writeBinaryDate(value) {
+        const days = Math.round((Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate()) - POSTGRES_EPOCH)
+            / 86400000);
+        this.writeInt32(4);
+        this.writeInt32(days);
+        return this;
+    }
+    writeBinaryTime(value) {
+        const [time, ms] = value.split('.');
+        const [hours, minutes, seconds] = time.split(':').map(Number);
+        const micros = (hours * 3600000 +
+            minutes * 60000 +
+            seconds * 1000 +
+            Number(ms)) *
+            1000;
+        this.writeInt32(8);
+        this.writeBigInt64(BigInt(micros));
+        return this;
+    }
+    writeBinaryTimetz(value) {
+        const time = value.slice(0, 12);
+        const offset = value.slice(12);
+        const [hours, minutes, seconds] = time
+            .slice(0, 8)
+            .split(':')
+            .map(Number);
+        const ms = Number(time.slice(9, 12));
+        const sign = offset[0];
+        const offHours = Number(offset.slice(1, 3));
+        const offMinutes = Number(offset.slice(4, 6));
+        const micros = (hours * 3600000 +
+            minutes * 60000 +
+            seconds * 1000 +
+            ms) *
+            1000;
+        const offsetSeconds = (offHours * 60 + offMinutes) * 60 * (sign === '+' ? -1 : 1);
+        this.writeInt32(12);
+        this.writeBigInt64(BigInt(micros));
+        this.writeInt32(offsetSeconds);
+        return this;
+    }
+    writeBinaryInterval(value) {
+        this.writeInt32(16);
+        this.writeBigInt64(typeof value.microseconds === 'bigint'
+            ? value.microseconds
+            : BigInt(value.microseconds));
+        this.writeInt32(value.days);
+        this.writeInt32(value.months);
+        return this;
+    }
+    writeBinaryJson(value) {
+        const json = typeof value === 'string' ? value : JSON.stringify(value);
+        this.writeInt32(Buffer.byteLength(json));
+        this.writeString(json);
+        return this;
+    }
+    writeBinaryJsonb(value) {
+        const json = typeof value === 'string' ? value : JSON.stringify(value);
+        const byteLen = Buffer.byteLength(json);
+        this.writeInt32(byteLen + 1);
+        this.writeByte(1);
+        this.writeString(json);
+        return this;
+    }
+    writeBinaryUuid(value) {
+        const hex = value.replace(/-/g, '');
+        this.writeInt32(16);
+        this.writeBytes(Buffer.from(hex, 'hex'));
+        return this;
+    }
+    ipv4ToBytes(addr) {
+        return Uint8Array.from(addr.split('.').map(Number));
+    }
+    ipv6ToBytes(addr) {
+        const [head, tail] = addr.split('::');
+        const headParts = head ? head.split(':') : [];
+        const tailParts = tail !== undefined ? (tail ? tail.split(':') : []) : [];
+        const missing = 8 - headParts.length - tailParts.length;
+        const groups = [...headParts, ...Array(Math.max(missing, 0)).fill('0'), ...tailParts];
+        const bytes = new Uint8Array(16);
+        groups.forEach((g, i) => {
+            const val = parseInt(g || '0', 16);
+            bytes[i * 2] = (val >> 8) & 0xff;
+            bytes[i * 2 + 1] = val & 0xff;
+        });
+        return bytes;
+    }
+    writeBinaryInet(value, isCidr = false) {
+        const [addr, prefixStr] = value.split('/');
+        const isIPv6 = addr.includes(':');
+        const family = isIPv6 ? ConnectionRequestBuffer.PGSQL_AF_INET6 : ConnectionRequestBuffer.PGSQL_AF_INET;
+        const addrBytes = isIPv6 ? this.ipv6ToBytes(addr) : this.ipv4ToBytes(addr);
+        const bits = prefixStr !== undefined ? parseInt(prefixStr, 10) : (isIPv6 ? 128 : 32);
+        this.writeInt32(4 + addrBytes.length);
+        this.writeByte(family);
+        this.writeByte(bits);
+        this.writeByte(isCidr ? 1 : 0);
+        this.writeByte(addrBytes.length);
+        this.writeBytes(addrBytes);
+        return this;
+    }
+    writeBinaryCidr(value) {
+        return this.writeBinaryInet(value, true);
+    }
+    writeBinaryMacaddr(value) {
+        const bytes = Uint8Array.from(value.split(':').map(h => parseInt(h, 16)));
+        this.writeInt32(6);
+        this.writeBytes(bytes);
+        return this;
+    }
+    writeBinaryOid(value) {
+        this.writeInt32(4);
+        this.writeUInt32(value);
+        return this;
+    }
+    writeBinaryXid(value) {
+        return this.writeBinaryOid(value);
+    }
+    writeBinaryCid(value) {
+        return this.writeBinaryOid(value);
+    }
+    writeBinaryRegproc(value) {
+        return this.writeBinaryOid(value);
+    }
+    writeBinaryLseg(value) {
+        this.writeInt32(32);
+        this.writeFloat64(value.a.x);
+        this.writeFloat64(value.a.y);
+        this.writeFloat64(value.b.x);
+        this.writeFloat64(value.b.y);
+        return this;
+    }
+    writeBinaryPath(value) {
+        this.writeInt32(1 + 4 + value.points.length * 16);
+        this.writeByte(value.closed ? 1 : 0);
+        this.writeInt32(value.points.length);
+        for (const p of value.points) {
+            this.writeFloat64(p.x);
+            this.writeFloat64(p.y);
+        }
+        return this;
+    }
+    writeBinaryBox(value) {
+        this.writeInt32(32);
+        this.writeFloat64(value.high.x);
+        this.writeFloat64(value.high.y);
+        this.writeFloat64(value.low.x);
+        this.writeFloat64(value.low.y);
+        return this;
+    }
+    writeBinaryPolygon(value) {
+        this.writeInt32(4 + value.points.length * 16);
+        this.writeInt32(value.points.length);
+        for (const p of value.points) {
+            this.writeFloat64(p.x);
+            this.writeFloat64(p.y);
+        }
+        return this;
+    }
+    writeBinaryLine(value) {
+        this.writeInt32(24);
+        this.writeFloat64(value.a);
+        this.writeFloat64(value.b);
+        this.writeFloat64(value.c);
+        return this;
+    }
+    writeLengthPrefixed(writeContent) {
+        this.ensureCapacity(4);
+        const lengthOffset = this.offset;
+        this.writeInt32(0);
+        const contentStart = this.offset;
+        writeContent();
+        const length = this.offset - contentStart;
+        this.buffer.writeInt32BE(length, lengthOffset);
+        return this;
+    }
+    writeBinaryArray(arr, elementOid, elementWriter) {
+        const hasNull = arr.some(v => v == null);
+        this.writeLengthPrefixed(() => {
+            this.writeInt32(1);
+            this.writeInt32(hasNull ? 1 : 0);
+            this.writeInt32(elementOid);
+            this.writeInt32(arr.length);
+            this.writeInt32(1);
+            for (const val of arr) {
+                if (val == null) {
+                    this.writeNull();
+                }
+                else {
+                    elementWriter(val);
+                }
+            }
+        });
+        return this;
+    }
+    writeBinaryBoolArray(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Bool, v => this.writeBinaryBool(v));
+    }
+    writeBinaryInt2Array(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Int2, v => this.writeBinaryInt2(v));
+    }
+    writeBinaryInt4Array(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Int4, v => this.writeBinaryInt4(v));
+    }
+    writeBinaryInt8Array(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Int8, v => typeof v === 'bigint' ? this.writeBinaryBigInt8(v) : this.writeBinaryInt8(v));
+    }
+    writeBinaryTextArray(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Text, v => this.writeBinaryString(v));
+    }
+    writeBinaryVarcharArray(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Varchar, v => this.writeBinaryString(v));
+    }
+    writeBinaryJsonArray(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Json, v => this.writeBinaryJson(v));
+    }
+    writeBinaryJsonbArray(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Jsonb, v => this.writeBinaryJsonb(v));
+    }
+    writeBinaryUuidArray(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Uuid, v => this.writeBinaryUuid(v));
+    }
+    writeBinaryNumericArray(value) {
+        return this.writeBinaryArray(value, DataTypeOids.Numeric, v => this.writeBinaryNumeric(v));
+    }
+    writeNull() {
+        this.writeInt32(-1);
+        return this;
+    }
+    writeBind(portName, meta, params) {
+        this.mark();
+        this.startRequest(RequestTypes.Bind)
+            .writeCString(portName)
+            .writeCString(meta.statement)
+            .writeInt16(params.length);
+        for (let i = 0; i < params.length; i++) {
+            this.writeInt16(1);
+        }
+        this.writeInt16(params.length);
+        for (let i = 0; i < params.length; i++) {
+            const value = params[i];
+            const oid = meta.parameters[i];
+            if (value == null) {
+                this.writeNull();
+                continue;
+            }
+            const handler = handlers[oid];
+            if (!handler || !handler.validate(value)) {
+                this.rollback();
+                return createBindTypeError(i, oid, value);
+            }
+            handler.write(this, value);
+        }
+        this
+            .writeInt16(1)
+            .writeInt16(1)
+            .endRequest();
+        return null;
+    }
 }
+ConnectionRequestBuffer.PGSQL_AF_INET = 2;
+ConnectionRequestBuffer.PGSQL_AF_INET6 = 3;