Class ConnectorPostgres

Abstract class for creating connections to different backend providers. All implementations should extend this class and implement the following steps:

Add the provider to ./providers/.ts
Update ./factory.ts to reference the provider
Register the tag with the Provider type in ./types/provider.ts.
Create the specific provider type file at ./types/.ts
Update ./modules/utils.ts (identifyProvider) with logic to resolve the provider by inspecting the class/import

Hierarchy (view full)

AbstractConnection<PostgresClassType, PostgresClientOptions>
- ConnectorPostgres

Constructors

constructor

new ConnectorPostgres(): ConnectorPostgres
Returns ConnectorPostgres
Inherited from AbstractConnection.constructor

Properties

`Protected`connection

connection: any = null

defaultOptions

defaultOptions: PostgresClientOptions = ...

`Protected`id

id: string = null

poolClientInstance

poolClientInstance: PostgresPoolClientType

`Protected` `Static`connectionInstances

connectionInstances: Set<PostgresClientType> = ...

`Static`disconnecting

disconnecting: boolean = false

`Protected` `Static`instances

instances: Map<string, AbstractConnection<ProviderClass, ProviderOptions>> = ...

`Static`logger

logger: ILogger = ...

`Protected` `Static`poolClientInstances

poolClientInstances: Set<PostgresPoolClientType> = ...

`Protected` `Static`taskQueueConnections

taskQueueConnections: Map<string, ConnectorPostgres> = ...

Methods

closeConnection

closeConnection(connection): Promise<void>
Parameters
- connection: PostgresClientType
Returns Promise<void>
Overrides AbstractConnection.closeConnection
- Defined in services/connector/providers/postgres.ts:199

createConnection

createConnection(clientConstructor, options, config?): Promise<PostgresClientType>
Parameters
- clientConstructor: any
- options: PostgresClientOptions
- config: {
  connect?: boolean;
  provider?: string;
  } = {}
  - Optionalconnect?: boolean
  - Optionalprovider?: string
Returns Promise<PostgresClientType>
Overrides AbstractConnection.createConnection
- Defined in services/connector/providers/postgres.ts:116

disconnect

disconnect(): Promise<void>
Returns Promise<void>
Inherited from AbstractConnection.disconnect
- Defined in services/connector/index.ts:40

getClient

getClient(): PostgresClientType
Returns PostgresClientType
Overrides AbstractConnection.getClient
- Defined in services/connector/providers/postgres.ts:159

getConnectionId

getConnectionId(): string
Get the connection ID for monitoring purposes

Returns string
- Defined in services/connector/providers/postgres.ts:169

`Static`connect

connect<T>(this, id, client, options?, config?): Promise<T>
Type Parameters
- T extends AbstractConnection<ProviderClass, ProviderOptions, T>
Parameters
- this: (new () => T)
  - - new (): T
    - Returns T
- id: string
- client: ProviderClass
- Optionaloptions: ProviderOptions
- Optionalconfig: StringAnyType
Returns Promise<T>
Inherited from AbstractConnection.connect
- Defined in services/connector/index.ts:52

`Static`disconnectAll

disconnectAll(): Promise<void>
Returns Promise<void>
Overrides AbstractConnection.disconnectAll
- Defined in services/connector/providers/postgres.ts:173

`Static`disconnectConnections

disconnectConnections(): Promise<void>
Returns Promise<void>
- Defined in services/connector/providers/postgres.ts:192

`Static`disconnectPoolClients

disconnectPoolClients(): Promise<void>
Returns Promise<void>
- Defined in services/connector/providers/postgres.ts:185

`Static`getConnectionStats

getConnectionStats(): {
    taskQueueConnections: number;
    taskQueueDetails: {
        connectionId: string;
        key: string;
        reusedCount: number;
    }[];
    totalConnections: number;
    totalPoolClients: number;
}
Get comprehensive connection statistics for monitoring taskQueue pooling effectiveness

Returns {
    taskQueueConnections: number;
    taskQueueDetails: {
        connectionId: string;
        key: string;
        reusedCount: number;
    }[];
    totalConnections: number;
    totalPoolClients: number;
}
- taskQueueConnections: number
- taskQueueDetails: {
      connectionId: string;
      key: string;
      reusedCount: number;
  }[]
- totalConnections: number
- totalPoolClients: number
- Defined in services/connector/providers/postgres.ts:37

`Static`getOrCreateTaskQueueConnection

getOrCreateTaskQueueConnection(id, taskQueue, clientConstructor, options, config?): Promise<ConnectorPostgres>
Gets or creates a PostgreSQL connection based on taskQueue and database configuration. If a connection already exists for the same taskQueue + config, it will be reused. This optimization reduces connection overhead for PostgreSQL providers.
Parameters
- id: string
- taskQueue: string
- clientConstructor: PostgresClassType
- options: PostgresClientOptions
- config: {
  connect?: boolean;
  provider?: string;
  } = {}
  - Optionalconnect?: boolean
  - Optionalprovider?: string
Returns Promise<ConnectorPostgres>
- Defined in services/connector/providers/postgres.ts:227

`Static`getPoolingEffectiveness

getPoolingEffectiveness(): {
    averageReusesPerPool: number;
    poolingEfficiency: number;
    taskQueuePools: number;
    totalConnections: number;
    totalReuses: number;
}
Check taskQueue pooling effectiveness - returns metrics about connection reuse

Returns {
    averageReusesPerPool: number;
    poolingEfficiency: number;
    taskQueuePools: number;
    totalConnections: number;
    totalReuses: number;
}
- averageReusesPerPool: number
- poolingEfficiency: number
- taskQueuePools: number
- totalConnections: number
- totalReuses: number
- Defined in services/connector/providers/postgres.ts:83

`Static`getTransactionClient

getTransactionClient(transactionClient): Promise<["client" | "poolclient", PostgresClientType]>
Parameters
- transactionClient: any
Returns Promise<["client" | "poolclient", PostgresClientType]>
- Defined in services/connector/providers/postgres.ts:285

`Static`isPoolClient

isPoolClient(client): client is PostgresPoolClientType
Parameters
- client: any
Returns client is PostgresPoolClientType
- Defined in services/connector/providers/postgres.ts:203

`Static`logConnectionStats

logConnectionStats(logger?): void
Log current connection statistics - useful for debugging connection pooling
Parameters
- Optionallogger: any
Returns void
- Defined in services/connector/providers/postgres.ts:66

Class ConnectorPostgres

Hierarchy (view full)

Index

Constructors

Properties

Methods

Constructors

constructor

Returns ConnectorPostgres

Properties

Protectedconnection

defaultOptions

Protectedid

poolClientInstance

Protected StaticconnectionInstances

Staticdisconnecting

Protected Staticinstances

Staticlogger

Protected StaticpoolClientInstances

Protected StatictaskQueueConnections

Methods

closeConnection

Parameters

Returns Promise<void>

createConnection

Parameters

Optionalconnect?: boolean

Optionalprovider?: string

Returns Promise<PostgresClientType>

disconnect

Returns Promise<void>

getClient

Returns PostgresClientType

getConnectionId

Returns string

Staticconnect

Type Parameters

Parameters

Returns T

Returns Promise<T>

StaticdisconnectAll

Returns Promise<void>

StaticdisconnectConnections

Returns Promise<void>

StaticdisconnectPoolClients

Returns Promise<void>

StaticgetConnectionStats

Returns { taskQueueConnections: number; taskQueueDetails: { connectionId: string; key: string; reusedCount: number; }[]; totalConnections: number; totalPoolClients: number; }

taskQueueConnections: number

taskQueueDetails: { connectionId: string; key: string; reusedCount: number; }[]

totalConnections: number

totalPoolClients: number

StaticgetOrCreateTaskQueueConnection

Parameters

Optionalconnect?: boolean

Optionalprovider?: string

Returns Promise<ConnectorPostgres>

StaticgetPoolingEffectiveness

Returns { averageReusesPerPool: number; poolingEfficiency: number; taskQueuePools: number; totalConnections: number; totalReuses: number; }

averageReusesPerPool: number

poolingEfficiency: number

taskQueuePools: number

totalConnections: number

totalReuses: number

StaticgetTransactionClient

Parameters

Returns Promise<["client" | "poolclient", PostgresClientType]>

StaticisPoolClient

Parameters

Returns client is PostgresPoolClientType

StaticlogConnectionStats

Parameters

Returns void

Settings

On This Page

`Protected`connection

`Protected`id

`Protected` `Static`connectionInstances

`Static`disconnecting

`Protected` `Static`instances

`Static`logger

`Protected` `Static`poolClientInstances

`Protected` `Static`taskQueueConnections

`Optional`connect?: boolean

`Optional`provider?: string

`Static`connect

`Static`disconnectAll

`Static`disconnectConnections

`Static`disconnectPoolClients

`Static`getConnectionStats

Returns {
taskQueueConnections: number;
taskQueueDetails: {
connectionId: string;
key: string;
reusedCount: number;
}[];
totalConnections: number;
totalPoolClients: number;
}

taskQueueDetails: {
connectionId: string;
key: string;
reusedCount: number;
}[]

`Static`getOrCreateTaskQueueConnection

`Optional`connect?: boolean

`Optional`provider?: string

`Static`getPoolingEffectiveness

Returns {
averageReusesPerPool: number;
poolingEfficiency: number;
taskQueuePools: number;
totalConnections: number;
totalReuses: number;
}

`Static`getTransactionClient

`Static`isPoolClient

`Static`logConnectionStats