postgrejs 2.12.0

package/typings/protocol/protocol.d.ts

@@ -0,0 +1,180 @@
+/// <reference types="node" />
+import { Nullable } from '../types.js';
+export declare namespace Protocol {
+    const VERSION_MAJOR = 3;
+    const VERSION_MINOR = 0;
+    enum BackendMessageCode {
+        Authentication = 82,// R
+        BackendKeyData = 75,// K
+        BindComplete = 50,// 2
+        CloseComplete = 51,// 3
+        CommandComplete = 67,// C
+        CopyData = 100,// d
+        CopyDone = 99,// c
+        CopyInResponse = 103,// G
+        CopyOutResponse = 72,// H
+        CopyBothResponse = 87,// W
+        DataRow = 68,// D
+        EmptyQueryResponse = 73,// I
+        ErrorResponse = 69,// E
+        FunctionCallResponse = 86,// V
+        NegotiateProtocolVersion = 118,// v
+        NoData = 110,// n
+        NoticeResponse = 78,// N
+        NotificationResponse = 65,// A
+        ParameterDescription = 116,// t
+        ParameterStatus = 83,// S
+        ParseComplete = 49,// 1
+        PortalSuspended = 115,// s
+        ReadyForQuery = 90,// Z
+        RowDescription = 84
+    }
+    enum FrontendMessageCode {
+        Bind = 66,// R
+        Close = 67,// C
+        CopyData = 100,// d
+        CopyDone = 99,// c
+        CopyFail = 102,// f
+        Describe = 68,// D
+        Execute = 69,// E
+        Flush = 72,// H
+        FunctionCall = 70,// F
+        Parse = 80,// P
+        PasswordMessage = 112,// p
+        Query = 81,// Q
+        Sync = 83,// S
+        Terminate = 88
+    }
+    enum AuthenticationMessageKind {
+        KerberosV5 = "KerberosV5",
+        CleartextPassword = "CleartextPassword",
+        MD5Password = "MD5Password",
+        SCMCredential = "SCMCredential",
+        GSS = "GSS",
+        SSPI = "SSPI",
+        GSSContinue = "GSSContinue",
+        SASL = "SASL",
+        SASLContinue = "SASLContinue",
+        SASLFinal = "SASLFinal"
+    }
+    enum DataFormat {
+        text = 0,
+        binary = 1
+    }
+    interface AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind;
+    }
+    interface AuthenticationKerberosV5Message extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.KerberosV5;
+    }
+    interface AuthenticationCleartextPasswordMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.CleartextPassword;
+    }
+    interface AuthenticationMD5PasswordMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.MD5Password;
+        salt: Buffer;
+    }
+    interface AuthenticationSCMCredentialMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.SCMCredential;
+    }
+    interface AuthenticationGSSMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.GSS;
+    }
+    interface AuthenticationSSPIMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.SSPI;
+    }
+    interface AuthenticationGSSContinueMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.GSSContinue;
+        data: Buffer;
+    }
+    interface AuthenticationSASLMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.SASL;
+        mechanisms: string[];
+    }
+    interface AuthenticationSASLContinueMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.SASLContinue;
+        data: string;
+    }
+    interface AuthenticationSASLFinalMessage extends AuthenticationRequiredMessage {
+        kind: AuthenticationMessageKind.SASLFinal;
+        data: string;
+    }
+    interface BackendKeyDataMessage {
+        processID: number;
+        secretKey: number;
+    }
+    interface CommandCompleteMessage {
+        command: string;
+        oid?: number;
+        rowCount?: number;
+    }
+    interface CopyDataMessage {
+        data: Buffer;
+    }
+    interface CopyResponseMessage {
+        overallFormat: DataFormat;
+        columnCount: number;
+        columnFormats?: DataFormat[];
+    }
+    interface DataRow {
+    }
+    interface DataRowMessage {
+        columnCount: number;
+        columns: Nullable<Buffer>[];
+    }
+    interface ErrorResponseMessage {
+        severity?: string;
+        code?: string;
+        message?: string;
+        detail?: string;
+        hint?: string;
+        position?: string;
+        internalPosition?: string;
+        internalQuery?: string;
+        where?: string;
+        schema?: string;
+        table?: string;
+        column?: string;
+        dataType?: string;
+        constraint?: string;
+        file?: string;
+        line?: string;
+        routine?: string;
+    }
+    interface NotificationResponseMessage {
+        processId: number;
+        channel: string;
+        payload: string;
+    }
+    interface FunctionCallResponseMessage {
+        result: Buffer;
+    }
+    interface NegotiateProtocolVersionMessage {
+        supportedVersionMinor: number;
+        numberOfNotSupportedVersions: number;
+        option: string;
+    }
+    interface ParameterDescriptionMessage {
+        parameterCount: number;
+        parameterIds: number[];
+    }
+    interface ParameterStatusMessage {
+        name: string;
+        value: string;
+    }
+    interface ReadyForQueryMessage {
+        status: string;
+    }
+    interface RowDescription {
+        fieldName: string;
+        tableId: number;
+        columnId: number;
+        dataTypeId: number;
+        fixedSize?: number;
+        modifier?: number;
+        format: DataFormat;
+    }
+    interface RowDescriptionMessage {
+        fields: RowDescription[];
+    }
+}

package/typings/protocol/sasl.d.ts

@@ -0,0 +1,13 @@
+export declare namespace SASL {
+    interface Session {
+        username: string;
+        mechanism: string;
+        nonce: string;
+        clientFirstMessage: string;
+        clientFinalMessage: string;
+        serverSignature: string;
+    }
+    function createSession(username: string, mechanism: string): Session;
+    function continueSession(session: Session, password: string, data: string): void;
+    function finalizeSession(session: Session, data: string): void;
+}

package/typings/protocol/smart-buffer.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+import { BufferReader } from './buffer-reader.js';
+export interface SmartBufferConfig {
+    pageSize?: number;
+    maxLength?: number;
+    houseKeepInterval?: number;
+}
+export declare class SmartBuffer extends BufferReader {
+    static DEFAULT_PAGE_SIZE: number;
+    static DEFAULT_MAX_SIZE: number;
+    private readonly _houseKeepInterval;
+    private _houseKeepTimer?;
+    private _lastHouseKeep;
+    private _stMaxPages;
+    private _length;
+    readonly pageSize: number;
+    readonly maxSize: number;
+    constructor(cfg?: SmartBufferConfig);
+    get capacity(): number;
+    get length(): number;
+    start(): this;
+    flush(): Buffer;
+    growSize(len: number): this;
+    fill(value?: number, len?: number): this;
+    writeCString(str: string, encoding?: BufferEncoding): this;
+    writeLString(str?: string, encoding?: BufferEncoding): this;
+    writeString(str: string, encoding?: BufferEncoding): this;
+    writeInt8(n: number): this;
+    writeUInt8(n: number): this;
+    writeUInt16BE(n: number): this;
+    writeUInt32BE(n: number): this;
+    writeInt16BE(n: number): this;
+    writeInt32BE(n: number): this;
+    writeBigInt64BE(n: bigint | number): this;
+    writeFloatBE(n: number): this;
+    writeDoubleBE(n: number): this;
+    writeBuffer(buffer: Buffer): this;
+    private _houseKeep;
+}

package/typings/safe-event-emitter.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export declare class SafeEventEmitter extends EventEmitter {
+    emit(event: string | symbol, ...args: any[]): boolean;
+}

package/typings/types.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import type { DataMappingOptions } from './interfaces/data-mapping-options.js';
+import type { SmartBuffer } from './protocol/smart-buffer';
+export type OID = number;
+export type Maybe<T> = T | undefined;
+export type Nullable<T> = T | null;
+export type Row = any;
+export type Callback = (err?: Error, value?: any) => void;
+export type DecodeBinaryFunction = (buf: Buffer, options: DataMappingOptions & Record<string, any>) => any;
+export type EncodeBinaryFunction = (buf: SmartBuffer, v: any, options: DataMappingOptions) => void;
+export type EncodeCalculateDimFunction = (v: any[]) => number[];
+export type ParseTextFunction = (v: any, options: DataMappingOptions) => any;
+export type EncodeTextFunction = (v: any, options: DataMappingOptions) => string;
+export type AnyParseFunction = ParseTextFunction | DecodeBinaryFunction;
+export type DebugLogger = (namespace: string, format: any, ...args: any[]) => void;

package/typings/util/array-calculatedim.d.ts

@@ -0,0 +1 @@
+export declare function arrayCalculateDim(arr: any[]): number[];

package/typings/util/bigint-methods.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare function readBigInt64BE(buf: Buffer, offset?: number): bigint;
+export declare function writeBigUInt64BE(buf: Buffer, value: BigInt, offset?: number): number;

package/typings/util/config-from-env.d.ts

@@ -0,0 +1,2 @@
+import { ConnectionConfiguration } from '../interfaces/database-connection-params.js';
+export declare function configFromEnv(): ConnectionConfiguration;

package/typings/util/connection-config.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectionConfiguration } from '../interfaces/database-connection-params.js';
+export declare function getConnectionConfig(config?: ConnectionConfiguration | string): ConnectionConfiguration;
+export declare function parseConnectionString(str: string): ConnectionConfiguration;

package/typings/util/convert-row-to-object.d.ts

@@ -0,0 +1,2 @@
+import { FieldInfo } from '../interfaces/field-info.js';
+export declare function convertRowToObject(fields: FieldInfo[], row: any[]): any;

package/typings/util/decode-binaryarray.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+import type { DecodeBinaryFunction, Nullable } from '../types.js';
+export declare function decodeBinaryArray<T = any>(buf: Buffer, decoder: DecodeBinaryFunction, options?: DataMappingOptions): Nullable<T[]>;

package/typings/util/encode-binaryarray.d.ts

@@ -0,0 +1,5 @@
+import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+import type { SmartBuffer } from '../protocol/smart-buffer.js';
+import type { EncodeBinaryFunction, OID } from '../types.js';
+import { EncodeCalculateDimFunction } from '../types.js';
+export declare function encodeBinaryArray(io: SmartBuffer, value: any[], itemOid: OID, options: DataMappingOptions, encode: EncodeBinaryFunction, encodeCalculateDimFn?: EncodeCalculateDimFunction): void;

package/typings/util/escape-literal.d.ts

@@ -0,0 +1 @@
+export declare function escapeLiteral(str: string): string;

package/typings/util/fast-parseint.d.ts

@@ -0,0 +1 @@
+export declare function fastParseInt(str: string | number): number;

package/typings/util/get-parsers.d.ts

@@ -0,0 +1,4 @@
+import { DataTypeMap } from '../data-type-map.js';
+import { Protocol } from '../protocol/protocol.js';
+import { AnyParseFunction } from '../types.js';
+export declare function getParsers(typeMap: DataTypeMap, fields: Protocol.RowDescription[]): AnyParseFunction[];

package/typings/util/parse-array.d.ts

@@ -0,0 +1,5 @@
+import type { Maybe } from '../types.js';
+export declare function parsePostgresArray(s: string, opts?: {
+    transform?: (v: string) => any;
+    separator?: string;
+}): Maybe<any[]>;

package/typings/util/parse-datetime.d.ts

@@ -0,0 +1 @@
+export declare function parseDateTime(str: string, parseTime?: boolean, parseTimeZone?: boolean, utc?: boolean): Date | number;

package/typings/util/parse-row.d.ts

@@ -0,0 +1,3 @@
+import { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+import { AnyParseFunction } from '../types.js';
+export declare function parseRow(parsers: AnyParseFunction[], row: any[], options: DataMappingOptions): void;

package/typings/util/parse-time.d.ts

@@ -0,0 +1,3 @@
+export declare const STRICT_TIME_PATTERN: RegExp;
+export declare const TIME_PATTERN: RegExp;
+export declare function parseTime(str: string, parseTimeZone?: boolean, utc?: boolean): Date;

package/typings/util/stringify-arrayliteral.d.ts

@@ -0,0 +1,3 @@
+import { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+import { EncodeTextFunction } from '../types.js';
+export declare function stringifyArrayLiteral(value: any[], options?: DataMappingOptions, encode?: EncodeTextFunction): string;

package/typings/util/stringify-for-sql.d.ts

@@ -0,0 +1,4 @@
+import { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+import { EncodeTextFunction } from '../types.js';
+export declare function stringifyArrayForSQL(v: any[], options?: DataMappingOptions, encode?: EncodeTextFunction): string;
+export declare function stringifyValueForSQL(v: any, options?: DataMappingOptions, encode?: EncodeTextFunction): string;

package/typings/util/wrap-row-description.d.ts

@@ -0,0 +1,5 @@
+import { DataFormat } from '../constants.js';
+import { DataTypeMap } from '../data-type-map.js';
+import { FieldInfo } from '../interfaces/field-info.js';
+import { Protocol } from '../protocol/protocol.js';
+export declare function wrapRowDescription(typeMap: DataTypeMap, fields: Protocol.RowDescription[], columnFormat: DataFormat | DataFormat[]): FieldInfo[];