@m2k-5f/pgtx 2.7.3 → 2.8.0

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

@@ -1,15 +1,31 @@
-import { prepareValue } from "../utils";
+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)
@@ -195,11 +211,17 @@ export class ConnectionRequestBuffer {
             .endRequest();
         return this;
     }
+    // ------ Binary writers of js values into Bind parameters ------
     writeBinaryBool(value) {
         this.writeInt32(1);
         this.writeByte(value ? 1 : 0);
         return this;
     }
+    writeBinaryString(value) {
+        this.writeInt32(Buffer.byteLength(value));
+        this.writeString(value);
+        return this;
+    }
     writeBinaryInt2(value) {
         this.writeInt32(2);
         this.writeInt16(value);
@@ -241,107 +263,309 @@ export class ConnectionRequestBuffer {
         this.writeBigInt64(micros);
         return this;
     }
-    writeNull() {
-        this.writeInt32(-1);
+    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;
     }
-    canWriteBinary(value, oid) {
-        if (value == null || !oid) {
-            return false;
+    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);
         }
-        switch (oid) {
-            case DataTypeOids.Bool:
-                return typeof value === "boolean";
-            case DataTypeOids.Int2:
-                return (typeof value === "number" &&
-                    Number.isInteger(value) &&
-                    value >= -32768 &&
-                    value <= 32767);
-            case DataTypeOids.Int4:
-                return (typeof value === "number" &&
-                    Number.isInteger(value) &&
-                    value >= -2147483648 &&
-                    value <= 2147483647);
-            case DataTypeOids.Int8:
-                return (typeof value === "bigint" ||
-                    (typeof value === "number" &&
-                        Number.isSafeInteger(value)));
-            case DataTypeOids.Float4:
-            case DataTypeOids.Float8:
-                return (typeof value === "number" &&
-                    Number.isFinite(value));
-            case DataTypeOids.Bytea:
-                return (Buffer.isBuffer(value) ||
-                    value instanceof Uint8Array);
-            case DataTypeOids.Timestamp:
-            case DataTypeOids.Timestamptz:
-                return value instanceof Date;
-            default:
-                return false;
+        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));
     }
-    writeBind(portName, statementName, params, parameterTypes) {
-        const binary = params.map((value, i) => this.canWriteBinary(value, parameterTypes?.[i]));
-        const request = this.startRequest(RequestTypes.Bind)
+    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(statementName)
+            .writeCString(meta.statement)
             .writeInt16(params.length);
-        for (const isBinary of binary) {
-            request.writeInt16(isBinary ? 1 : 0);
+        for (let i = 0; i < params.length; i++) {
+            this.writeInt16(1);
         }
-        request.writeInt16(params.length);
+        this.writeInt16(params.length);
         for (let i = 0; i < params.length; i++) {
             const value = params[i];
+            const oid = meta.parameters[i];
             if (value == null) {
-                request.writeNull();
+                this.writeNull();
                 continue;
             }
-            if (binary[i]) {
-                switch (parameterTypes[i]) {
-                    case DataTypeOids.Bool:
-                        request.writeBinaryBool(value);
-                        break;
-                    case DataTypeOids.Int2:
-                        request.writeBinaryInt2(value);
-                        break;
-                    case DataTypeOids.Int4:
-                        request.writeBinaryInt4(value);
-                        break;
-                    case DataTypeOids.Int8:
-                        typeof value === "bigint"
-                            ? request.writeBinaryBigInt8(value)
-                            : request.writeBinaryInt8(value);
-                        break;
-                    case DataTypeOids.Float4:
-                        request.writeBinaryFloat4(value);
-                        break;
-                    case DataTypeOids.Float8:
-                        request.writeBinaryFloat8(value);
-                        break;
-                    case DataTypeOids.Bytea:
-                        request.writeBinaryBytea(value);
-                        break;
-                    case DataTypeOids.Timestamp:
-                    case DataTypeOids.Timestamptz:
-                        request.writeBinaryTimestamp(value);
-                        break;
-                }
-                continue;
-            }
-            const prepared = prepareValue(value);
-            if (prepared === null) {
-                request.writeNull();
-            }
-            else {
-                request
-                    .writeInt32(Buffer.byteLength(prepared))
-                    .writeString(prepared);
+            const handler = handlers[oid];
+            if (!handler || !handler.validate(value)) {
+                this.rollback();
+                return createBindTypeError(i, oid, value);
             }
+            handler.write(this, value);
         }
-        request
+        this
             .writeInt16(1)
             .writeInt16(1)
             .endRequest();
-        return this;
+        return null;
     }
 }
+ConnectionRequestBuffer.PGSQL_AF_INET = 2;
+ConnectionRequestBuffer.PGSQL_AF_INET6 = 3;

package/dist/protocol/connection-response-reader.d.ts

@@ -6,29 +6,24 @@ export declare class ConnectionResponseBuffer {
     private caret;
     private constructor();
     static from(buffer: Buffer): ConnectionResponseBuffer;
+    hasMore(): boolean;
+    skipBytes(byteCount: number): void;
+    hasFullPacket(): boolean;
+    getResidualBuffer(): Buffer<ArrayBufferLike>;
     readChar(): string;
     readInt32(): number;
     readInt16(): number;
     readCString(): string;
     readRawString(length: number): string;
-    hasMore(): boolean;
-    readBinaryDate(): Date;
+    readUInt16(): number;
+    readUInt32(): number;
+    readFloat32(): number;
+    readFloat64(): number;
     readByte(): number;
-    readBinaryTimestamp(): Date;
-    readBinaryTime(): string;
-    skipBytes(byteCount: number): void;
-    hasFullPacket(): boolean;
-    getResidualBuffer(): Buffer<ArrayBufferLike>;
+    readBytes(length: number): Buffer<ArrayBuffer>;
     readBool(): boolean;
     readBigInt64(): bigint;
     readInt64(): number;
-    readNumeric(): string;
-    readBinaryTimetz(): string;
-    readFloat32(): number;
-    readFloat64(): number;
-    readUuid(): string;
-    readBytes(length: number): Buffer<ArrayBuffer>;
-    getBufferHash(length: number): number;
     readType(): {
         type: ResponseType;
         length: number;
@@ -48,12 +43,74 @@ export declare class ConnectionResponseBuffer {
     readSaslMechanisms(): string[];
     readSaslMessage(length: number): string;
     readRowDescription(): ColumnDescription[];
-    readDataRow(descriptions: ColumnDescription[], int8toBigint: boolean): Record<string, any>;
     readNotificationResponse(): {
         name: ChannelName;
         payload: string;
     };
     readCommandComplete(): string;
     readParameterDescription(): ParameterDescription;
+    readBinaryDate(): Date;
+    readBinaryTimestamp(): Date;
+    readBinaryTime(): string;
+    readBinaryTimetz(): string;
+    readBinaryNumeric(): string;
+    readBinaryInterval(): {
+        months: number;
+        days: number;
+        microseconds: bigint;
+    };
+    readBinaryJson(fieldLength: number): unknown;
+    readBinaryJsonb(fieldLength: number): unknown;
+    readBinaryMacaddr(): string;
+    readBinaryOid(): number;
+    readBinaryXid(): number;
+    readBinaryCid(): number;
+    readBinaryRegproc(): number;
+    readBinaryLseg(): {
+        a: {
+            x: number;
+            y: number;
+        };
+        b: {
+            x: number;
+            y: number;
+        };
+    };
+    readBinaryPath(): {
+        closed: boolean;
+        points: {
+            x: number;
+            y: number;
+        }[];
+    };
+    readBinaryBox(): {
+        high: {
+            x: number;
+            y: number;
+        };
+        low: {
+            x: number;
+            y: number;
+        };
+    };
+    readBinaryPolygon(): {
+        points: {
+            x: number;
+            y: number;
+        }[];
+    };
+    readBinaryLine(): {
+        a: number;
+        b: number;
+        c: number;
+    };
+    readBinaryUuid(): string;
+    readBinaryArray(fieldLength: number, elementParser: (length: number) => any): any[];
+    readBinaryInet(fieldLength: number): string;
+    readBinaryPoint(): {
+        x: number;
+        y: number;
+    };
+    readDataRow(descriptions: ColumnDescription[], int8toBigint: boolean): Record<string, any>;
 }
 //# sourceMappingURL=connection-response-reader.d.ts.map

package/dist/protocol/connection-response-reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection-response-reader.d.ts","sourceRoot":"","sources":["../../src/protocol/connection-response-reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAyC,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACxH,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAOxC,qBAAa,wBAAwB;IAI7B,OAAO,CAAC,MAAM;IAHlB,OAAO,CAAC,KAAK,CAAI;IAEjB,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B,QAAQ,IAAI,MAAM;IAOlB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,WAAW,IAAI,MAAM;IAQrB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOrC,OAAO,IAAI,OAAO;IAKlB,cAAc,IAAI,IAAI;IAOtB,QAAQ;IAKR,mBAAmB,IAAI,IAAI;IAO3B,cAAc,IAAI,MAAM;IAaxB,SAAS,CAAC,SAAS,EAAE,MAAM;IAK3B,aAAa,IAAI,OAAO;IAaxB,iBAAiB;IAIjB,QAAQ;IAMR,YAAY,IAAI,MAAM;IAOtB,SAAS;IAST,WAAW,IAAI,MAAM;IA2CrB,gBAAgB,IAAI,MAAM;IAY1B,WAAW;IAOX,WAAW,IAAI,MAAM;IAMrB,QAAQ;IAWR,SAAS,CAAC,MAAM,EAAE,MAAM;IAQxB,aAAa,CAAC,MAAM,EAAE,MAAM;IAY5B,QAAQ;cAC6B,YAAY;;;IAIjD,kBAAkB,IACa,kBAAkB;IAIjD,WAAW;IAKX,mBAAmB;;;;IAQnB,kBAAkB;;;;IAQlB,iBAAiB,IAAI,aAAa;IA4ClC,iBAAiB,IACa,iBAAiB;IAI/C,kBAAkB,IAAI,MAAM,EAAE;IAa9B,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAKvC,kBAAkB;IAsBlB,WAAW,CAAC,YAAY,EAAE,iBAAiB,EAAE,EAAE,YAAY,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IA0H1F,wBAAwB;;;;IASxB,mBAAmB,IAAI,MAAM;IAK7B,wBAAwB,IAAI,oBAAoB;CAWnD"}
+{"version":3,"file":"connection-response-reader.d.ts","sourceRoot":"","sources":["../../src/protocol/connection-response-reader.ts"],"names":[],"mappings":"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"}