1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 | import events = require('events');
|
10 | import stream = require('stream');
|
11 | import pgTypes = require('pg-types');
|
12 | import { NoticeMessage } from 'pg-protocol/dist/messages';
|
13 |
|
14 | import { ConnectionOptions } from 'tls';
|
15 |
|
16 | export interface ClientConfig {
|
17 | user?: string | undefined;
|
18 | database?: string | undefined;
|
19 | password?: string | (() => string | Promise<string>) | undefined;
|
20 | port?: number | undefined;
|
21 | host?: string | undefined;
|
22 | connectionString?: string | undefined;
|
23 | keepAlive?: boolean | undefined;
|
24 | stream?: stream.Duplex | undefined;
|
25 | statement_timeout?: false | number | undefined;
|
26 | parseInputDatesAsUTC?: boolean | undefined;
|
27 | ssl?: boolean | ConnectionOptions | undefined;
|
28 | query_timeout?: number | undefined;
|
29 | keepAliveInitialDelayMillis?: number | undefined;
|
30 | idle_in_transaction_session_timeout?: number | undefined;
|
31 | application_name?: string | undefined;
|
32 | connectionTimeoutMillis?: number | undefined;
|
33 | types?: CustomTypesConfig | undefined;
|
34 | options?: string | undefined;
|
35 | }
|
36 |
|
37 | export type ConnectionConfig = ClientConfig;
|
38 |
|
39 | export interface Defaults extends ClientConfig {
|
40 | poolSize?: number | undefined;
|
41 | poolIdleTimeout?: number | undefined;
|
42 | reapIntervalMillis?: number | undefined;
|
43 | binary?: boolean | undefined;
|
44 | parseInt8?: boolean | undefined;
|
45 | }
|
46 |
|
47 | export interface PoolConfig extends ClientConfig {
|
48 | // properties from module 'node-pool'
|
49 | max?: number | undefined;
|
50 | min?: number | undefined;
|
51 | idleTimeoutMillis?: number | undefined;
|
52 | log?: ((...messages: any[]) => void) | undefined;
|
53 | Promise?: PromiseConstructorLike | undefined;
|
54 | allowExitOnIdle?: boolean | undefined;
|
55 | maxUses?: number | undefined;
|
56 | }
|
57 |
|
58 | export interface QueryConfig<I extends any[] = any[]> {
|
59 | name?: string | undefined;
|
60 | text: string;
|
61 | values?: I | undefined;
|
62 | types?: CustomTypesConfig | undefined;
|
63 | }
|
64 |
|
65 | export interface CustomTypesConfig {
|
66 | getTypeParser: typeof pgTypes.getTypeParser;
|
67 | }
|
68 |
|
69 | export interface Submittable {
|
70 | submit: (connection: Connection) => void;
|
71 | }
|
72 |
|
73 | export interface QueryArrayConfig<I extends any[] = any[]> extends QueryConfig<I> {
|
74 | rowMode: 'array';
|
75 | }
|
76 |
|
77 | export interface FieldDef {
|
78 | name: string;
|
79 | tableID: number;
|
80 | columnID: number;
|
81 | dataTypeID: number;
|
82 | dataTypeSize: number;
|
83 | dataTypeModifier: number;
|
84 | format: string;
|
85 | }
|
86 |
|
87 | export interface QueryResultBase {
|
88 | command: string;
|
89 | rowCount: number;
|
90 | oid: number;
|
91 | fields: FieldDef[];
|
92 | }
|
93 |
|
94 | export interface QueryResultRow {
|
95 | [column: string]: any;
|
96 | }
|
97 |
|
98 | export interface QueryResult<R extends QueryResultRow = any> extends QueryResultBase {
|
99 | rows: R[];
|
100 | }
|
101 |
|
102 | export interface QueryArrayResult<R extends any[] = any[]> extends QueryResultBase {
|
103 | rows: R[];
|
104 | }
|
105 |
|
106 | export interface Notification {
|
107 | processId: number;
|
108 | channel: string;
|
109 | payload?: string | undefined;
|
110 | }
|
111 |
|
112 | export interface ResultBuilder<R extends QueryResultRow = any> extends QueryResult<R> {
|
113 | addRow(row: R): void;
|
114 | }
|
115 |
|
116 | export interface QueryParse {
|
117 | name: string;
|
118 | text: string;
|
119 | types: string[];
|
120 | }
|
121 |
|
122 | export interface BindConfig {
|
123 | portal?: string | undefined;
|
124 | statement?: string | undefined;
|
125 | binary?: string | undefined;
|
126 | values?: Array<Buffer | null | undefined | string> | undefined;
|
127 | }
|
128 |
|
129 | export interface ExecuteConfig {
|
130 | portal?: string | undefined;
|
131 | rows?: string | undefined;
|
132 | }
|
133 |
|
134 | export interface MessageConfig {
|
135 | type: string;
|
136 | name?: string | undefined;
|
137 | }
|
138 |
|
139 | export class Connection extends events.EventEmitter {
|
140 | readonly stream: stream.Duplex;
|
141 |
|
142 | constructor(config?: ConnectionConfig);
|
143 |
|
144 | bind(config: BindConfig | null, more: boolean): void;
|
145 | execute(config: ExecuteConfig | null, more: boolean): void;
|
146 | parse(query: QueryParse, more: boolean): void;
|
147 |
|
148 | query(text: string): void;
|
149 |
|
150 | describe(msg: MessageConfig, more: boolean): void;
|
151 | close(msg: MessageConfig, more: boolean): void;
|
152 |
|
153 | flush(): void;
|
154 | sync(): void;
|
155 | end(): void;
|
156 | }
|
157 |
|
158 | /**
|
159 | * {@link https:
|
160 | */
|
161 | export class Pool extends events.EventEmitter {
|
162 | |
163 |
|
164 |
|
165 |
|
166 |
|
167 | constructor(config?: PoolConfig);
|
168 |
|
169 | readonly totalCount: number;
|
170 | readonly idleCount: number;
|
171 | readonly waitingCount: number;
|
172 |
|
173 | connect(): Promise<PoolClient>;
|
174 | connect(callback: (err: Error, client: PoolClient, done: (release?: any) => void) => void): void;
|
175 |
|
176 | end(): Promise<void>;
|
177 | end(callback: () => void): void;
|
178 |
|
179 | query<T extends Submittable>(queryStream: T): T;
|
180 | // tslint:disable:no-unnecessary-generics
|
181 | query<R extends any[] = any[], I extends any[] = any[]>(
|
182 | queryConfig: QueryArrayConfig<I>,
|
183 | values?: I,
|
184 | ): Promise<QueryArrayResult<R>>;
|
185 | query<R extends QueryResultRow = any, I extends any[] = any[]>(
|
186 | queryConfig: QueryConfig<I>,
|
187 | ): Promise<QueryResult<R>>;
|
188 | query<R extends QueryResultRow = any, I extends any[] = any[]>(
|
189 | queryTextOrConfig: string | QueryConfig<I>,
|
190 | values?: I,
|
191 | ): Promise<QueryResult<R>>;
|
192 | query<R extends any[] = any[], I extends any[] = any[]>(
|
193 | queryConfig: QueryArrayConfig<I>,
|
194 | callback: (err: Error, result: QueryArrayResult<R>) => void,
|
195 | ): void;
|
196 | query<R extends QueryResultRow = any, I extends any[] = any[]>(
|
197 | queryTextOrConfig: string | QueryConfig<I>,
|
198 | callback: (err: Error, result: QueryResult<R>) => void,
|
199 | ): void;
|
200 | query<R extends QueryResultRow = any, I extends any[] = any[]>(
|
201 | queryText: string,
|
202 | values: I,
|
203 | callback: (err: Error, result: QueryResult<R>) => void,
|
204 | ): void;
|
205 | // tslint:enable:no-unnecessary-generics
|
206 |
|
207 | on(event: 'error', listener: (err: Error, client: PoolClient) => void): this;
|
208 | on(event: 'connect' | 'acquire' | 'remove', listener: (client: PoolClient) => void): this;
|
209 | }
|
210 |
|
211 | export class ClientBase extends events.EventEmitter {
|
212 | constructor(config?: string | ClientConfig);
|
213 |
|
214 | connect(): Promise<void>;
|
215 | connect(callback: (err: Error) => void): void;
|
216 |
|
217 | query<T extends Submittable>(queryStream: T): T;
|
218 | // tslint:disable:no-unnecessary-generics
|
219 | query<R extends any[] = any[], I extends any[] = any[]>(
|
220 | queryConfig: QueryArrayConfig<I>,
|
221 | values?: I,
|
222 | ): Promise<QueryArrayResult<R>>;
|
223 | query<R extends QueryResultRow = any, I extends any[] = any[]>(
|
224 | queryConfig: QueryConfig<I>,
|
225 | ): Promise<QueryResult<R>>;
|
226 | query<R extends QueryResultRow = any, I extends any[] = any[]>(
|
227 | queryTextOrConfig: string | QueryConfig<I>,
|
228 | values?: I,
|
229 | ): Promise<QueryResult<R>>;
|
230 | query<R extends any[] = any[], I extends any[] = any[]>(
|
231 | queryConfig: QueryArrayConfig<I>,
|
232 | callback: (err: Error, result: QueryArrayResult<R>) => void,
|
233 | ): void;
|
234 | query<R extends QueryResultRow = any, I extends any[] = any[]>(
|
235 | queryTextOrConfig: string | QueryConfig<I>,
|
236 | callback: (err: Error, result: QueryResult<R>) => void,
|
237 | ): void;
|
238 | query<R extends QueryResultRow = any, I extends any[] = any[]>(
|
239 | queryText: string,
|
240 | values: any[],
|
241 | callback: (err: Error, result: QueryResult<R>) => void,
|
242 | ): void;
|
243 | // tslint:enable:no-unnecessary-generics
|
244 |
|
245 | copyFrom(queryText: string): stream.Writable;
|
246 | copyTo(queryText: string): stream.Readable;
|
247 |
|
248 | pauseDrain(): void;
|
249 | resumeDrain(): void;
|
250 |
|
251 | escapeIdentifier(str: string): string;
|
252 | escapeLiteral(str: string): string;
|
253 |
|
254 | on(event: 'drain', listener: () => void): this;
|
255 | on(event: 'error', listener: (err: Error) => void): this;
|
256 | on(event: 'notice', listener: (notice: NoticeMessage) => void): this;
|
257 | on(event: 'notification', listener: (message: Notification) => void): this;
|
258 | // tslint:disable-next-line unified-signatures
|
259 | on(event: 'end', listener: () => void): this;
|
260 | }
|
261 |
|
262 | export class Client extends ClientBase {
|
263 | user?: string | undefined;
|
264 | database?: string | undefined;
|
265 | port: number;
|
266 | host: string;
|
267 | password?: string | undefined;
|
268 | ssl: boolean;
|
269 |
|
270 | constructor(config?: string | ClientConfig);
|
271 |
|
272 | end(): Promise<void>;
|
273 | end(callback: (err: Error) => void): void;
|
274 | }
|
275 |
|
276 | export interface PoolClient extends ClientBase {
|
277 | release(err?: Error | boolean): void;
|
278 | }
|
279 |
|
280 | export class Query<R extends QueryResultRow = any, I extends any[] = any> extends events.EventEmitter
|
281 | implements Submittable {
|
282 | constructor(queryTextOrConfig?: string | QueryConfig<I>, values?: I);
|
283 | submit: (connection: Connection) => void;
|
284 | on(event: 'row', listener: (row: R, result?: ResultBuilder<R>) => void): this;
|
285 | on(event: 'error', listener: (err: Error) => void): this;
|
286 | on(event: 'end', listener: (result: ResultBuilder<R>) => void): this;
|
287 | }
|
288 |
|
289 | export class Events extends events.EventEmitter {
|
290 | on(event: 'error', listener: (err: Error, client: Client) => void): this;
|
291 | }
|
292 |
|
293 | export const types: typeof pgTypes;
|
294 |
|
295 | export const defaults: Defaults & ClientConfig;
|
296 |
|
297 | import * as Pg from '.';
|
298 |
|
299 | export const native: typeof Pg | null;
|
300 |
|
301 | export { DatabaseError } from 'pg-protocol';
|