postgrejs 2.12.0

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

@@ -0,0 +1,78 @@
+import { DataTypeOIDs } from '../constants.js';
+import { parseDateTime } from '../util/parse-datetime.js';
+const timeShift = 946684800000;
+const timeMul = 4294967296;
+export const TimestampType = {
+    name: 'timestamp',
+    oid: DataTypeOIDs.timestamp,
+    jsType: 'Date',
+    parseBinary(v, options) {
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(DataTypeOIDs.timestamp);
+        const hi = v.readInt32BE();
+        const lo = v.readUInt32BE(4);
+        if (lo === 0xffffffff && hi === 0x7fffffff)
+            return fetchAsString ? 'infinity' : Infinity;
+        if (lo === 0x00000000 && hi === -0x80000000)
+            return fetchAsString ? '-infinity' : -Infinity;
+        // Shift from 2000 to 1970
+        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
+        if (fetchAsString || !options.utcDates)
+            d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+        return fetchAsString ? dateToTimestampString(d) : d;
+    },
+    encodeBinary(buf, v, options) {
+        if (typeof v === 'string')
+            v = parseDateTime(v, true, false, options.utcDates);
+        if (v === Infinity) {
+            buf.writeInt32BE(0x7fffffff); // hi
+            buf.writeUInt32BE(0xffffffff); // lo
+            return;
+        }
+        if (v === -Infinity) {
+            buf.writeInt32BE(-0x80000000); // hi
+            buf.writeUInt32BE(0x00000000); // lo
+            return;
+        }
+        if (!(v instanceof Date))
+            v = new Date(v);
+        // Postgresql ignores timezone data so we are
+        let n = options.utcDates ? v.getTime() : v.getTime() - v.getTimezoneOffset() * 60 * 1000;
+        n = (n - timeShift) * 1000;
+        const hi = Math.floor(n / timeMul);
+        const lo = n - hi * timeMul;
+        buf.writeInt32BE(hi);
+        buf.writeUInt32BE(lo);
+    },
+    parseText(v, options) {
+        if (options.fetchAsString && options.fetchAsString.includes(DataTypeOIDs.timestamp))
+            return v;
+        return parseDateTime(v, true, false, options.utcDates);
+    },
+    isType(v) {
+        return (v instanceof Date &&
+            !(v.getFullYear() === 1970 && v.getMonth() === 0 && v.getDate() === 1) &&
+            !(v.getHours() === 0 && v.getMinutes() === 0 && v.getSeconds() === 0 && v.getMilliseconds() === 0));
+    },
+};
+function padZero(v) {
+    return v < 9 ? '0' + v : '' + v;
+}
+function dateToTimestampString(d) {
+    return (d.getFullYear() +
+        '-' +
+        padZero(d.getMonth() + 1) +
+        '-' +
+        padZero(d.getDate()) +
+        ' ' +
+        padZero(d.getHours()) +
+        ':' +
+        padZero(d.getMinutes()) +
+        ':' +
+        padZero(d.getSeconds()));
+}
+export const ArrayTimestampType = {
+    ...TimestampType,
+    name: '_timestamp',
+    oid: DataTypeOIDs._timestamp,
+    elementsOID: DataTypeOIDs.timestamp,
+};

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

@@ -0,0 +1,70 @@
+import { DataTypeOIDs } from '../constants.js';
+import { parseDateTime } from '../util/parse-datetime.js';
+const timeShift = 946684800000;
+const timeMul = 4294967296;
+export const TimestamptzType = {
+    name: 'timestamptz',
+    oid: DataTypeOIDs.timestamptz,
+    jsType: 'Date',
+    parseBinary(v, options) {
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(DataTypeOIDs.timestamptz);
+        const hi = v.readInt32BE();
+        const lo = v.readUInt32BE(4);
+        if (lo === 0xffffffff && hi === 0x7fffffff)
+            return fetchAsString ? 'infinity' : Infinity;
+        if (lo === 0x00000000 && hi === -0x80000000)
+            return fetchAsString ? '-infinity' : -Infinity;
+        // Shift from 2000 to 1970
+        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
+        if (fetchAsString || !options.utcDates)
+            d = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+        return fetchAsString ? dateToTimestamptzString(d) : d;
+    },
+    encodeBinary(buf, v, options) {
+        if (typeof v === 'string')
+            v = parseDateTime(v, true, true, options.utcDates);
+        if (v === Infinity) {
+            buf.writeInt32BE(0x7fffffff); // hi
+            buf.writeUInt32BE(0xffffffff); // lo
+            return;
+        }
+        if (v === -Infinity) {
+            buf.writeInt32BE(-0x80000000); // hi
+            buf.writeUInt32BE(0x00000000); // lo
+            return;
+        }
+        if (!(v instanceof Date))
+            v = new Date(v);
+        let n = v.getTime();
+        n = (n - timeShift) * 1000;
+        const hi = Math.floor(n / timeMul);
+        const lo = n - hi * timeMul;
+        buf.writeInt32BE(hi);
+        buf.writeUInt32BE(lo);
+    },
+    parseText(v, options) {
+        const d = parseDateTime(v, true, true, options.utcDates);
+        if (options.fetchAsString && options.fetchAsString.includes(DataTypeOIDs.timestamptz)) {
+            if (d instanceof Date)
+                return dateToTimestamptzString(d);
+            if (d === Infinity)
+                return 'infinity';
+            if (d === -Infinity)
+                return '-infinity';
+            return '';
+        }
+        return d;
+    },
+    isType(v) {
+        return v instanceof Date;
+    },
+};
+function dateToTimestamptzString(d) {
+    return d.toISOString().replace('T', ' ');
+}
+export const ArrayTimestamptzType = {
+    ...TimestamptzType,
+    name: '_timestamptz',
+    oid: DataTypeOIDs._timestamptz,
+    elementsOID: DataTypeOIDs.timestamptz,
+};

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

@@ -0,0 +1,36 @@
+import { DataTypeOIDs } from '../constants.js';
+const GUID_PATTERN = /^[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}$/;
+export const UuidType = {
+    name: 'uuid',
+    oid: DataTypeOIDs.uuid,
+    jsType: 'String',
+    parseBinary(v) {
+        return (v.toString('hex', 0, 4) +
+            '-' +
+            v.toString('hex', 4, 6) +
+            '-' +
+            v.toString('hex', 6, 8) +
+            '-' +
+            v.toString('hex', 8, 10) +
+            '-' +
+            v.toString('hex', 10, 16));
+    },
+    encodeBinary(buf, v) {
+        if (!GUID_PATTERN.test(v))
+            throw new Error(`"${v}" is not a valid guid value`);
+        const b = Buffer.from(v.replace(/-/g, ''), 'hex');
+        buf.writeBuffer(b);
+    },
+    parseText(v) {
+        return v;
+    },
+    isType(v) {
+        return typeof v === 'string' && GUID_PATTERN.test(v);
+    },
+};
+export const ArrayUuidType = {
+    ...UuidType,
+    name: '_uuid',
+    oid: DataTypeOIDs._uuid,
+    elementsOID: DataTypeOIDs.uuid,
+};

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

@@ -0,0 +1,24 @@
+import { DataTypeOIDs } from '../constants.js';
+export const VarcharType = {
+    name: 'varchar',
+    oid: DataTypeOIDs.varchar,
+    jsType: 'string',
+    parseBinary(v) {
+        return v.toString('utf8');
+    },
+    encodeBinary(buf, v) {
+        buf.writeString('' + v, 'utf8');
+    },
+    parseText(v) {
+        return '' + v;
+    },
+    isType(v) {
+        return typeof v === 'string';
+    },
+};
+export const ArrayVarcharType = {
+    ...VarcharType,
+    name: '_varchar',
+    oid: DataTypeOIDs._varchar,
+    elementsOID: DataTypeOIDs.varchar,
+};

package/esm/index.js

@@ -0,0 +1,25 @@
+export * from './constants.js';
+export * from './data-type-map.js';
+export * from './types.js';
+export * from './connection/bind-param.js';
+export * from './connection/connection.js';
+export * from './connection/cursor.js';
+export * from './connection/pool.js';
+export * from './connection/prepared-statement.js';
+export * from './interfaces/command-result.js';
+export * from './interfaces/data-mapping-options.js';
+export * from './interfaces/data-type.js';
+export * from './interfaces/database-connection-params.js';
+export * from './interfaces/field-info.js';
+export * from './interfaces/query-options.js';
+export * from './interfaces/query-result.js';
+export * from './interfaces/script-execute-options.js';
+export * from './interfaces/script-result.js';
+export * from './interfaces/statement-prepare-options.js';
+export * from './util/connection-config.js';
+export * from './util/escape-literal.js';
+export * from './util/parse-datetime.js';
+export * from './util/stringify-arrayliteral.js';
+export * from './util/stringify-for-sql.js';
+export * from './protocol/smart-buffer.js';
+export * from './protocol/database-error.js';

package/esm/interfaces/command-result.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/data-mapping-options.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/data-type.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/database-connection-params.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/field-info.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/query-options.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/query-result.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/script-execute-options.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/script-result.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/statement-prepare-options.js

@@ -0,0 +1 @@
+export {};

package/esm/protocol/backend.js

@@ -0,0 +1,252 @@
+import { BufferReader } from './buffer-reader.js';
+import { Protocol } from './protocol.js';
+// 1 byte message type, 4 byte frame length
+const HEADER_LENGTH = 5;
+const ErrorFieldTypes = {
+    M: 'message',
+    S: 'severity',
+    V: 'severity',
+    C: 'code',
+    D: 'detail',
+    H: 'hint',
+    P: 'position',
+    p: 'internalPosition',
+    q: 'internalQuery',
+    W: 'where',
+    s: 'schema',
+    t: 'table',
+    c: 'column',
+    d: 'dataType',
+    n: 'constraint',
+    F: 'file',
+    L: 'line',
+    R: 'routine',
+};
+export class Backend {
+    reset() {
+        this._buf = undefined;
+    }
+    parse(data, callback) {
+        if (this._buf) {
+            data = Buffer.concat([this._buf, data]);
+            this._buf = undefined;
+        }
+        const io = new BufferReader(data);
+        let offsetBookmark;
+        while (io.length - io.offset >= HEADER_LENGTH) {
+            offsetBookmark = io.offset;
+            const code = io.readUInt8();
+            const len = io.readUInt32BE();
+            // Check if frame data not received yet
+            if (io.length - io.offset < len - 4) {
+                io.offset = offsetBookmark;
+                this._buf = io.readBuffer();
+                return;
+            }
+            const parser = MessageParsers[code];
+            const v = parser && parser(io, code, len);
+            callback(code, v);
+            // Set offset to next message
+            io.offset = offsetBookmark + len + 1;
+        }
+        if (io.offset < io.length)
+            this._buf = io.readBuffer(io.length - io.offset);
+    }
+}
+const MessageParsers = {
+    [Protocol.BackendMessageCode.Authentication]: parseAuthentication,
+    [Protocol.BackendMessageCode.BackendKeyData]: parseBackendKeyData,
+    [Protocol.BackendMessageCode.CommandComplete]: parseCommandComplete,
+    [Protocol.BackendMessageCode.CopyData]: parseCopyData,
+    [Protocol.BackendMessageCode.CopyInResponse]: parseCopyResponse,
+    [Protocol.BackendMessageCode.CopyOutResponse]: parseCopyResponse,
+    [Protocol.BackendMessageCode.CopyBothResponse]: parseCopyResponse,
+    [Protocol.BackendMessageCode.DataRow]: parseDataRow,
+    [Protocol.BackendMessageCode.ErrorResponse]: parseErrorResponse,
+    [Protocol.BackendMessageCode.NoticeResponse]: parseErrorResponse,
+    [Protocol.BackendMessageCode.NotificationResponse]: parseNotificationResponse,
+    [Protocol.BackendMessageCode.FunctionCallResponse]: parseFunctionCallResponse,
+    [Protocol.BackendMessageCode.NegotiateProtocolVersion]: parseNegotiateProtocolVersion,
+    [Protocol.BackendMessageCode.ParameterDescription]: parseParameterDescription,
+    [Protocol.BackendMessageCode.ParameterStatus]: parseParameterStatus,
+    [Protocol.BackendMessageCode.ReadyForQuery]: parseReadyForQuery,
+    [Protocol.BackendMessageCode.RowDescription]: parseRowDescription,
+};
+function parseAuthentication(io, code, len) {
+    const kind = io.readUInt32BE();
+    switch (kind) {
+        case 0:
+            return; // AuthenticationOk
+        case 2:
+            return {
+                kind: 'KerberosV5',
+            };
+        case 3:
+            return {
+                kind: 'CleartextPassword',
+            };
+        case 5:
+            return {
+                kind: 'MD5Password',
+                salt: io.readBuffer(len - 8),
+            };
+        case 6:
+            return {
+                kind: 'SCMCredential',
+            };
+        case 7:
+            return {
+                kind: 'GSS',
+            };
+        case 9:
+            return {
+                kind: 'SSPI',
+            };
+        case 8:
+            return {
+                kind: 'GSSContinue',
+                data: io.readBuffer(len - 8),
+            };
+        case 10: {
+            const out = {
+                kind: 'SASL',
+                mechanisms: [],
+            };
+            let mechanism;
+            while ((mechanism = io.readCString())) {
+                out.mechanisms.push(mechanism);
+            }
+            return out;
+        }
+        case 11:
+            return {
+                kind: 'SASLContinue',
+                data: io.readLString(len - 8, 'utf8'),
+            };
+        case 12:
+            return {
+                kind: 'SASLFinal',
+                data: io.readLString(len - 8, 'utf8'),
+            };
+        default:
+            throw new Error(`Unknown authentication kind (${kind})`);
+    }
+}
+function parseBackendKeyData(io) {
+    return {
+        processID: io.readUInt32BE(),
+        secretKey: io.readUInt32BE(),
+    };
+}
+function parseCommandComplete(io) {
+    return {
+        command: io.readCString('utf8'),
+    };
+}
+function parseCopyData(io, code, len) {
+    return {
+        data: io.readBuffer(len - 4),
+    };
+}
+function parseCopyResponse(io) {
+    const out = {
+        overallFormat: io.readUInt8() === 0 ? Protocol.DataFormat.text : Protocol.DataFormat.binary,
+        columnCount: io.readUInt16BE(),
+    };
+    if (out.columnCount) {
+        out.columnFormats = [];
+        for (let i = 0; i < out.columnCount; i++) {
+            out.columnFormats.push(io.readUInt16BE() === 0 ? Protocol.DataFormat.text : Protocol.DataFormat.binary);
+        }
+    }
+    return out;
+}
+function parseDataRow(io) {
+    const out = {
+        columnCount: io.readUInt16BE(),
+    };
+    if (out.columnCount) {
+        out.columns = [];
+        for (let i = 0; i < out.columnCount; i++) {
+            // The length of the column value, in bytes (this count does not include itself).
+            // Can be zero. As a special case, -1 indicates a NULL column value.
+            // No value bytes follow in the NULL case.
+            const l = io.readInt32BE();
+            if (l < 0)
+                out.columns.push(null);
+            else
+                out.columns.push(io.readBuffer(l));
+        }
+    }
+    return out;
+}
+function parseErrorResponse(io) {
+    const out = {};
+    let fieldType;
+    while ((fieldType = io.readLString(1)) !== '\0') {
+        const value = io.readCString('utf8');
+        const key = ErrorFieldTypes[fieldType];
+        if (key)
+            out[key] = value;
+    }
+    return out;
+}
+function parseNotificationResponse(io) {
+    return {
+        processId: io.readUInt32BE(),
+        channel: io.readCString(),
+        payload: io.readCString(),
+    };
+}
+function parseFunctionCallResponse(io, code, len) {
+    return {
+        result: io.readBuffer(len - 4),
+    };
+}
+function parseNegotiateProtocolVersion(io) {
+    return {
+        supportedVersionMinor: io.readUInt32BE(),
+        numberOfNotSupportedVersions: io.readUInt32BE(),
+        option: io.readCString('utf8'),
+    };
+}
+function parseParameterDescription(io) {
+    const out = {
+        parameterCount: io.readUInt32BE(),
+        parameterIds: [],
+    };
+    for (let i = 0; i < out.parameterCount; i++) {
+        out.parameterIds.push(io.readUInt32BE());
+    }
+    return out;
+}
+function parseParameterStatus(io) {
+    return {
+        name: io.readCString('utf8'),
+        value: io.readCString('utf8'),
+    };
+}
+function parseReadyForQuery(io) {
+    return {
+        status: io.readLString(1),
+    };
+}
+function parseRowDescription(io) {
+    const fieldCount = io.readUInt16BE();
+    const out = {
+        fields: [],
+    };
+    for (let i = 0; i < fieldCount; i++) {
+        const field = {
+            fieldName: io.readCString('utf8'),
+            tableId: io.readInt32BE(),
+            columnId: io.readInt16BE(),
+            dataTypeId: io.readInt32BE(),
+            fixedSize: io.readInt16BE(),
+            modifier: io.readInt32BE(),
+            format: io.readInt16BE() === 0 ? Protocol.DataFormat.text : Protocol.DataFormat.binary,
+        };
+        out.fields.push(field);
+    }
+    return out;
+}

package/esm/protocol/buffer-reader.js

@@ -0,0 +1,74 @@
+export class BufferReader {
+    constructor(buffer) {
+        this.offset = 0;
+        this.buffer = buffer;
+    }
+    get length() {
+        return this.buffer.length;
+    }
+    readUInt8() {
+        this._checkReadable(1);
+        const v = this.buffer.readUInt8(this.offset);
+        this.offset++;
+        return v;
+    }
+    readUInt16BE() {
+        this._checkReadable(2);
+        const v = this.buffer.readUInt16BE(this.offset);
+        this.offset += 2;
+        return v;
+    }
+    readInt16BE() {
+        this._checkReadable(2);
+        const v = this.buffer.readInt16BE(this.offset);
+        this.offset += 2;
+        return v;
+    }
+    readUInt32BE() {
+        this._checkReadable(4);
+        const v = this.buffer.readUInt32BE(this.offset);
+        this.offset += 4;
+        return v;
+    }
+    readInt32BE() {
+        this._checkReadable(4);
+        const v = this.buffer.readInt32BE(this.offset);
+        this.offset += 4;
+        return v;
+    }
+    readCString(encoding) {
+        const idx = this.buffer.indexOf(0, this.offset);
+        const v = this.buffer.toString(encoding, this.offset, idx);
+        this.offset = idx + 1;
+        return v;
+    }
+    readLString(len, encoding) {
+        if (len < 0)
+            return null;
+        this._checkReadable(len);
+        const v = this.buffer.toString(encoding, this.offset, this.offset + len);
+        this.offset += len;
+        return v;
+    }
+    readBuffer(len) {
+        if (len)
+            this._checkReadable(len);
+        const end = len !== undefined ? this.offset + len : this.length;
+        const buf = this.buffer.slice(this.offset, end);
+        this.offset = end;
+        return buf;
+    }
+    moveBy(n) {
+        return this.moveTo(this.offset + n);
+    }
+    moveTo(pos) {
+        if (pos >= this.length)
+            throw new Error('Eof in buffer detected');
+        this.offset = pos;
+        return this;
+    }
+    _checkReadable(size) {
+        if (this.offset + size - 1 >= this.length)
+            throw new Error('Eof in buffer detected');
+    }
+}

package/esm/protocol/database-error.js

@@ -0,0 +1,13 @@
+export class DatabaseError extends Error {
+    constructor(msg) {
+        super(msg.message);
+        Object.assign(this, {
+            ...msg,
+            line: undefined,
+            file: undefined,
+            routine: undefined,
+        });
+        if (msg.position)
+            this.position = parseInt(msg.position, 10) || undefined;
+    }
+}