postgrejs 2.12.0

package/typings/data-types/date-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const DateType: DataType;
+export declare const ArrayDateType: DataType;

package/typings/data-types/float4-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const Float4Type: DataType;
+export declare const ArrayFloat4Type: DataType;

package/typings/data-types/float8-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const Float8Type: DataType;
+export declare const ArrayFloat8Type: DataType;

package/typings/data-types/int2-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const Int2Type: DataType;
+export declare const ArrayInt2Type: DataType;

package/typings/data-types/int2-vector-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const Int2VectorType: DataType;
+export declare const ArrayInt2VectorType: DataType;

package/typings/data-types/int4-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const Int4Type: DataType;
+export declare const ArrayInt4Type: DataType;

package/typings/data-types/int8-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const Int8Type: DataType;
+export declare const ArrayInt8Type: DataType;

package/typings/data-types/json-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const JsonType: DataType;
+export declare const ArrayJsonType: DataType;

package/typings/data-types/jsonb-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const JsonbType: DataType;
+export declare const ArrayJsonbType: DataType;

package/typings/data-types/lseg-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const LsegType: DataType;
+export declare const ArrayLsegType: DataType;

package/typings/data-types/numeric-type.d.ts

@@ -0,0 +1,12 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const NumericType: DataType;
+export declare const ArrayNumericType: DataType;
+/**
+ * Convert a number from binary representation to text representation.
+ * @param digits array of shorts that can be decoded as the number String
+ * @param scale the scale of the number binary representation
+ * @param weight the weight of the number binary representation
+ * @param sign the sign of the number
+ * @return String the number as String
+ */
+export declare function numberBytesToString(digits: number[], scale: number, weight: number, sign: number): string;

package/typings/data-types/oid-type.d.ts

@@ -0,0 +1,4 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const OidType: DataType;
+export declare const ArrayOidType: DataType;
+export declare const VectorOidType: DataType;

package/typings/data-types/point-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const PointType: DataType;
+export declare const ArrayPointType: DataType;

package/typings/data-types/time-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const TimeType: DataType;
+export declare const ArrayTimeType: DataType;

package/typings/data-types/timestamp-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const TimestampType: DataType;
+export declare const ArrayTimestampType: DataType;

package/typings/data-types/timestamptz-type.d.ts

@@ -0,0 +1,3 @@
+import { DataType } from '../interfaces/data-type.js';
+export declare const TimestamptzType: DataType;
+export declare const ArrayTimestamptzType: DataType;

package/typings/data-types/uuid-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const UuidType: DataType;
+export declare const ArrayUuidType: DataType;

package/typings/data-types/varchar-type.d.ts

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const VarcharType: DataType;
+export declare const ArrayVarcharType: DataType;

package/typings/index.d.ts

@@ -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/typings/interfaces/command-result.d.ts

@@ -0,0 +1,28 @@
+import { Row } from '../types.js';
+import type { FieldInfo } from './field-info.js';
+export interface CommandResult {
+    /**
+     * Name of the command (INSERT, SELECT, UPDATE, etc.)
+     */
+    command?: string;
+    /**
+     * Contains information about fields in column order
+     */
+    fields?: FieldInfo[];
+    /**
+     * Contains array of row data
+     */
+    rows?: Row[];
+    /**
+     * Contains row type
+     */
+    rowType?: 'array' | 'object';
+    /**
+     * Time elapsed to execute command
+     */
+    executeTime?: number;
+    /**
+     * How many rows affected
+     */
+    rowsAffected?: number;
+}

package/typings/interfaces/data-mapping-options.d.ts

@@ -0,0 +1,9 @@
+import type { OID } from '../types.js';
+export interface DataMappingOptions {
+    /**
+     * If true UTC time will be used for date decoding, else system time offset will be used
+     * @default false
+     */
+    utcDates?: boolean;
+    fetchAsString?: OID[];
+}

package/typings/interfaces/data-type.d.ts

@@ -0,0 +1,31 @@
+import type { DecodeBinaryFunction, EncodeBinaryFunction, EncodeTextFunction, OID, ParseTextFunction } from '../types.js';
+import { EncodeCalculateDimFunction } from '../types.js';
+export interface DataType {
+    oid: OID;
+    name: string;
+    elementsOID?: OID;
+    isArray?: boolean;
+    jsType: string;
+    arraySeparator?: string;
+    isType: (v: any) => boolean;
+    parseBinary: DecodeBinaryFunction;
+    parseText: ParseTextFunction;
+    encodeBinary?: EncodeBinaryFunction;
+    encodeText?: EncodeTextFunction;
+    encodeCalculateDim?: EncodeCalculateDimFunction;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Circle {
+    x: number;
+    y: number;
+    r: number;
+}
+export interface Rectangle {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}

package/typings/interfaces/database-connection-params.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import type { PoolConfiguration as LPoolConfiguration } from 'lightning-pool';
+import type { ConnectionOptions as TlsConnectionOptions } from 'tls';
+import type { SmartBufferConfig } from '../protocol/smart-buffer.js';
+import type { DebugLogger } from '../types.js';
+export interface DatabaseConnectionParams {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string | (() => string | Promise<string>);
+    database?: string;
+    applicationName?: string;
+    ssl?: TlsConnectionOptions;
+    timezone?: string;
+    schema?: string;
+    connectTimeoutMs?: number;
+    /**
+     * Specifies weather execute query in auto-commit mode
+     * @default false
+     */
+    autoCommit?: boolean;
+    /**
+     * When on, if a statement in a transaction block generates an error,
+     * the error is ignored and the transaction continues.
+     * When off (the default), a statement in a transaction block that generates an error aborts the entire transaction
+     * @default true
+     */
+    rollbackOnError?: boolean;
+    debugLogger?: DebugLogger;
+}
+export interface SocketOptions {
+    keepAlive?: boolean;
+}
+export interface ConnectionConfiguration extends DatabaseConnectionParams, SocketOptions {
+    buffer?: SmartBufferConfig;
+}
+export interface PoolConfiguration extends ConnectionConfiguration, LPoolConfiguration {
+}

package/typings/interfaces/field-info.d.ts

@@ -0,0 +1,46 @@
+export interface FieldInfo {
+    /**
+     * Name of the field
+     */
+    fieldName: string;
+    /**
+     * OID of the table
+     */
+    tableId?: number;
+    /**
+     * OID of the column
+     */
+    columnId?: number;
+    /**
+     * OID of the data type
+     */
+    dataTypeId: number;
+    /**
+     * Name of the data type
+     */
+    dataTypeName: string;
+    /**
+     * OID of the elements data type if field is an array
+     */
+    elementDataTypeId?: number;
+    /**
+     * Name of the elements data type if field is an array
+     */
+    elementDataTypeName?: string;
+    /**
+     * JS type name that data type mapped
+     */
+    jsType: string;
+    /**
+     * Data length if data type has a fixed size
+     */
+    fixedSize?: number;
+    /**
+     * Modifier of the data type
+     */
+    modifier?: number;
+    /**
+     * Whether the data type is an array
+     */
+    isArray?: boolean;
+}

package/typings/interfaces/query-options.d.ts

@@ -0,0 +1,46 @@
+import type { BindParam } from '../connection/bind-param';
+import type { DataFormat } from '../constants.js';
+import type { DataTypeMap } from '../data-type-map';
+import type { DataMappingOptions } from './data-mapping-options.js';
+export interface QueryOptions extends DataMappingOptions {
+    /**
+     * Specifies weather execute query in auto-commit mode
+     * @default true
+     */
+    autoCommit?: boolean;
+    /**
+     * Specifies if rows will be fetched as <FieldName, Value> pair objects or array of values
+     * @default false
+     */
+    objectRows?: boolean;
+    /**
+     * Data type map instance
+     * @default GlobalTypeMap
+     */
+    typeMap?: DataTypeMap;
+    /**
+     * If true, returns Cursor instance instead of rows
+     */
+    cursor?: boolean;
+    /**
+     * Query execution parameters
+     */
+    params?: (BindParam | any)[];
+    /**
+     * Specifies transfer format (binary or text) for each column
+     * @default DataFormat.binary
+     */
+    columnFormat?: DataFormat | DataFormat[];
+    /**
+     * Specifies how many rows will be fetched. For Cursor, this value specifies how many rows will be fetched in a batch
+     * @default 100
+     */
+    fetchCount?: number;
+    /**
+     * When on, if a statement in a transaction block generates an error,
+     * the error is ignored and the transaction continues.
+     * When off (the default), a statement in a transaction block that generates an error aborts the entire transaction
+     * @default true
+     */
+    rollbackOnError?: boolean;
+}

package/typings/interfaces/query-result.d.ts

@@ -0,0 +1,8 @@
+import type { Cursor } from '../connection/cursor';
+import type { CommandResult } from './command-result.js';
+export interface QueryResult extends CommandResult {
+    /**
+     * Cursor instance
+     */
+    cursor?: Cursor;
+}

package/typings/interfaces/script-execute-options.d.ts

@@ -0,0 +1,26 @@
+import type { DataTypeMap } from '../data-type-map';
+import type { DataMappingOptions } from './data-mapping-options.js';
+export interface ScriptExecuteOptions extends DataMappingOptions {
+    /**
+     * Specifies weather execute query in auto-commit mode
+     * @default true
+     */
+    autoCommit?: boolean;
+    /**
+     * Specifies if rows will be fetched as <FieldName, Value> pair objects or array of values
+     * @default false
+     */
+    objectRows?: boolean;
+    /**
+     * Data type map instance
+     * @default GlobalTypeMap
+     */
+    typeMap?: DataTypeMap;
+    /**
+     * When on, if a statement in a transaction block generates an error,
+     * the error is ignored and the transaction continues.
+     * When off (the default), a statement in a transaction block that generates an error aborts the entire transaction
+     * @default true
+     */
+    rollbackOnError?: boolean;
+}

package/typings/interfaces/script-result.d.ts

@@ -0,0 +1,15 @@
+import type { CommandResult } from './command-result.js';
+export interface ScriptResult {
+    /**
+     * Array of command result for each sql command in the script
+     */
+    results: CommandResult[];
+    /**
+     * Command count in the script
+     */
+    totalCommands: number;
+    /**
+     * Total execution time
+     */
+    totalTime: number;
+}

package/typings/interfaces/statement-prepare-options.d.ts

@@ -0,0 +1,13 @@
+import type { DataTypeMap } from '../data-type-map';
+import type { OID } from '../types.js';
+export interface StatementPrepareOptions {
+    /**
+     * Specifies data type for each parameter
+     */
+    paramTypes?: OID[];
+    /**
+     * Data type map instance
+     * @default GlobalTypeMap
+     */
+    typeMap?: DataTypeMap;
+}

package/typings/protocol/backend.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Protocol } from './protocol.js';
+declare type ParseCallback = (code: Protocol.BackendMessageCode, data?: any) => void;
+export declare class Backend {
+    private _buf?;
+    reset(): void;
+    parse(data: Buffer, callback: ParseCallback): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+export declare class BufferReader {
+    buffer: Buffer;
+    offset: number;
+    constructor(buffer: Buffer);
+    get length(): number;
+    readUInt8(): number;
+    readUInt16BE(): number;
+    readInt16BE(): number;
+    readUInt32BE(): number;
+    readInt32BE(): number;
+    readCString(encoding?: BufferEncoding): string;
+    readLString(len: number, encoding?: BufferEncoding): string | null;
+    readBuffer(len?: number): Buffer;
+    moveBy(n: number): this;
+    moveTo(pos: number): this;
+    private _checkReadable;
+}

package/typings/protocol/database-error.d.ts

@@ -0,0 +1,20 @@
+import { Protocol } from './protocol.js';
+export declare class DatabaseError extends Error {
+    severity?: string;
+    code?: string;
+    detail?: string;
+    hint?: string;
+    position?: number;
+    internalPosition?: string;
+    internalQuery?: string;
+    where?: string;
+    schema?: string;
+    table?: string;
+    column?: string;
+    dataType?: string;
+    constraint?: string;
+    lineNr?: number;
+    colNr?: number;
+    line?: string;
+    constructor(msg: Protocol.ErrorResponseMessage);
+}

package/typings/protocol/frontend.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+import { DataTypeMap } from '../data-type-map.js';
+import { QueryOptions } from '../interfaces/query-options.js';
+import { Maybe, OID } from '../types.js';
+import { SASL } from './sasl.js';
+import { SmartBufferConfig } from './smart-buffer.js';
+export interface FrontendOptions {
+    buffer?: SmartBufferConfig;
+}
+export declare namespace Frontend {
+    interface StartupMessageArgs {
+        user: string;
+        database: string;
+        [index: string]: string;
+    }
+    interface BindMessageArgs {
+        typeMap: DataTypeMap;
+        statement?: string;
+        portal?: string;
+        paramTypes?: Maybe<OID>[];
+        params?: any[];
+        queryOptions: QueryOptions;
+    }
+    interface ParseMessageArgs {
+        statement?: string;
+        sql: string;
+        paramTypes?: Maybe<OID>[];
+    }
+    interface DescribeMessageArgs {
+        type: 'P' | 'S';
+        name?: string;
+    }
+    interface ExecuteMessageArgs {
+        portal?: string;
+        fetchCount?: number;
+    }
+    interface CloseMessageArgs {
+        type: 'P' | 'S';
+        name?: string;
+    }
+}
+export declare class Frontend {
+    private _io;
+    constructor(options?: FrontendOptions);
+    getSSLRequestMessage(): Buffer;
+    getStartupMessage(args: Frontend.StartupMessageArgs): Buffer;
+    getPasswordMessage(password: string): Buffer;
+    getSASLMessage(sasl: SASL.Session): Buffer;
+    getSASLFinalMessage(session: SASL.Session): Buffer;
+    getParseMessage(args: Frontend.ParseMessageArgs): Buffer;
+    getBindMessage(args: Frontend.BindMessageArgs): Buffer;
+    getDescribeMessage(args: Frontend.DescribeMessageArgs): Buffer;
+    getExecuteMessage(args: Frontend.ExecuteMessageArgs): Buffer;
+    getCloseMessage(args: Frontend.CloseMessageArgs): Buffer;
+    getQueryMessage(sql: string): Buffer;
+    getFlushMessage(): Buffer;
+    getTerminateMessage(): Buffer;
+    getSyncMessage(): Buffer;
+}

package/typings/protocol/pg-socket.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+import { ConnectionState } from '../constants.js';
+import { ConnectionConfiguration } from '../interfaces/database-connection-params.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { Callback, Maybe } from '../types.js';
+import { Frontend } from './frontend.js';
+import { Protocol } from './protocol.js';
+export type CaptureCallback = (code: Protocol.BackendMessageCode, msg: any, done: (err: Maybe<Error>, result?: any) => void) => void | Promise<void>;
+export interface SocketError extends Error {
+    code: string;
+}
+export declare class PgSocket extends SafeEventEmitter {
+    options: ConnectionConfiguration;
+    private _state;
+    private _socket?;
+    private _backend;
+    private _frontend;
+    private _sessionParameters;
+    private _saslSession?;
+    private _processID?;
+    private _secretKey?;
+    constructor(options: ConnectionConfiguration);
+    get state(): ConnectionState;
+    get processID(): Maybe<number>;
+    get secretKey(): Maybe<number>;
+    get sessionParameters(): Record<string, string>;
+    connect(): void;
+    close(): void;
+    sendParseMessage(args: Frontend.ParseMessageArgs, cb?: Callback): void;
+    sendBindMessage(args: Frontend.BindMessageArgs, cb?: Callback): void;
+    sendDescribeMessage(args: Frontend.DescribeMessageArgs, cb?: Callback): void;
+    sendExecuteMessage(args: Frontend.ExecuteMessageArgs, cb?: Callback): void;
+    sendCloseMessage(args: Frontend.CloseMessageArgs, cb?: Callback): void;
+    sendQueryMessage(sql: string, cb?: Callback): void;
+    sendFlushMessage(cb?: Callback): void;
+    sendTerminateMessage(cb?: Callback): void;
+    sendSyncMessage(): void;
+    capture(callback: CaptureCallback): Promise<any>;
+    protected _removeListeners(): void;
+    protected _reset(): void;
+    protected _handleConnect(): void;
+    protected _handleClose(): void;
+    protected _handleError(err: unknown): void;
+    protected _handleData(data: Buffer): void;
+    protected _resolvePassword(cb: (password: string) => void): void;
+    protected _handleAuthenticationMessage(msg?: any): void;
+    protected _handleParameterStatus(msg: Protocol.ParameterStatusMessage): void;
+    protected _handleBackendKeyData(msg: Protocol.BackendKeyDataMessage): void;
+    protected _handleCommandComplete(msg: any): Protocol.CommandCompleteMessage;
+    protected _send(data: Buffer, cb?: Callback): void;
+}