@juit/pgproxy-client 1.2.1 → 1.3.1

package/src/provider.ts

@@ -6,7 +6,7 @@ import { assert } from './assert'
  * ========================================================================== */
 
 /** Describes the result of a query from a {@link PGProvider} */
-export interface PGConnectionResult {
+export interface PGProviderResult {
   /** The SQL command that generated this result (`SELECT`, `INSERT`, ...) */
   command: string
   /** Number of rows affected by this query (e.g. added rows in `INSERT`) */
@@ -17,15 +17,18 @@ export interface PGConnectionResult {
   rows: (string | null)[][]
 }
 
-export interface PGConnection {
-  query(text: string, params?: (string | null)[]): Promise<PGConnectionResult>
+export interface PGProviderConnection {
+  query(text: string, params?: (string | null)[]): Promise<PGProviderResult>
 }
 
-export interface PGProviderConstructor<Connection extends PGConnection> {
+export interface PGProviderConstructor<Connection extends PGProviderConnection = PGProviderConnection> {
   new (url: URL): PGProvider<Connection>
 }
 
-export interface PGProvider<Connection extends PGConnection> extends PGConnection {
+export interface PGProvider<Connection extends PGProviderConnection = PGProviderConnection> extends PGProviderConnection {
+  /** The URL used to create this provider, devoid of any credentials */
+  readonly url: Readonly<URL>
+
   acquire(): Promise<Connection>
   release(connection: Connection): Promise<void>
   destroy(): Promise<void>
@@ -35,12 +38,28 @@ export interface PGProvider<Connection extends PGConnection> extends PGConnectio
  * ABSTRACT PROVIDER IMPLEMENTATION                                           *
  * ========================================================================== */
 
-export abstract class AbstractPGProvider<Connection extends PGConnection>
+/** Hide away URLs, without `#private` fields modifying our signatures */
+const providerUrls = new WeakMap<AbstractPGProvider, URL>()
+
+export abstract class AbstractPGProvider<Connection extends PGProviderConnection = PGProviderConnection>
 implements PGProvider<Connection> {
+  constructor(url: URL | string) {
+    providerUrls.set(this, new URL(url)) // Defensive copy
+  }
+
+  get url(): Readonly<URL> {
+    const url = providerUrls.get(this)
+    assert(url, 'Internal error: missing provider URL')
+    const sanitizedUrl = new URL(url)
+    sanitizedUrl.username = ''
+    sanitizedUrl.password = ''
+    return sanitizedUrl
+  }
+
   abstract acquire(): Promise<Connection>
-  abstract release(connection: PGConnection): Promise<void>
+  abstract release(connection: PGProviderConnection): Promise<void>
 
-  async query(text: string, params: (string | null)[] = []): Promise<PGConnectionResult> {
+  async query(text: string, params: (string | null)[] = []): Promise<PGProviderResult> {
     const connection = await this.acquire()
     try {
       return await connection.query(text, params)
@@ -54,17 +73,18 @@ implements PGProvider<Connection> {
   }
 }
 
+
 /* ========================================================================== *
  * PROVIDERS REGISTRATION                                                     *
  * ========================================================================== */
 
 /** All known providers, mapped by protocol */
-const providers = new Map<string, PGProviderConstructor<PGConnection>>()
+const providers = new Map<string, PGProviderConstructor>()
 
 /** Register a provider, associating it with the specified protocol */
 export function registerProvider(
     protocol: string,
-    constructor: PGProviderConstructor<PGConnection>,
+    constructor: PGProviderConstructor,
 ): void {
   protocol = `${protocol}:` // URL always has protocol with _colon_
   assert(! providers.has(protocol), `Connection provider for "${protocol}..." already registered`)
@@ -73,7 +93,7 @@ export function registerProvider(
 }
 
 /** Create a new {@link PGProvider} instance for the specified URL */
-export function createProvider(url: URL): PGProvider<PGConnection> {
+export function createProvider(url: URL): PGProvider {
   const Provider = providers.get(url.protocol)
   assert(Provider, `No connection provider registered for "${url.protocol}..."`)
   return new Provider(url)

package/src/result.ts

@@ -1,5 +1,5 @@
 import type { Registry } from '@juit/pgproxy-types'
-import type { PGConnectionResult } from './provider'
+import type { PGProviderResult } from './provider'
 
 /* ========================================================================== *
  * EXPORTED TYPES                                                             *
@@ -33,7 +33,7 @@ export interface PGResultConstructor {
   new <
     Row extends Record<string, any> = Record<string, any>,
     Tuple extends readonly any[] = readonly any [],
-  >(result: PGConnectionResult, registry: Registry): PGResult<Row, Tuple>
+  >(result: PGProviderResult, registry: Registry): PGResult<Row, Tuple>
 }
 
 /* ========================================================================== *
@@ -51,7 +51,7 @@ export const PGResult: PGResultConstructor = class PGResultImpl<
   rows: Row[]
   tuples: Tuple[]
 
-  constructor(result: PGConnectionResult, registry: Registry) {
+  constructor(result: PGProviderResult, registry: Registry) {
     this.rowCount = result.rowCount
     this.command = result.command
     this.fields = result.fields.map(([ name, oid ]) => ({ name, oid }))

package/src/sql.ts

@@ -110,3 +110,8 @@ function makeSQL(
 export function SQL(strings: readonly string[], ...args: readonly any[]): SQL {
   return makeSQL(strings, args)
 }
+
+/** Escape a PostgreSQL identifier (table, column, ... names) */
+export function escape(str: string): string {
+  return `"${str.replaceAll('"', '""').trim()}"`
+}

package/src/websocket.ts

@@ -1,7 +1,8 @@
 import { assert } from './assert'
+import { AbstractPGProvider } from './provider'
 
 import type { Request, Response } from '@juit/pgproxy-server'
-import type { PGConnection, PGConnectionResult, PGProvider } from './provider'
+import type { PGProvider, PGProviderConnection, PGProviderResult } from './provider'
 
 /* ========================================================================== *
  * WEBSOCKET TYPES: in order to work with both WHATWG WebSockets and NodeJS's *
@@ -54,10 +55,10 @@ function msg(message: string | null | undefined, defaultMessage: string): string
   return message || defaultMessage
 }
 
-/** A request, simply an unwrapped {@link PGConnectionResult} promise */
+/** A request, simply an unwrapped {@link PGProviderResult} promise */
 class WebSocketRequest {
-  readonly promise: Promise<PGConnectionResult>
-  readonly resolve!: (result: PGConnectionResult) => void
+  readonly promise: Promise<PGProviderResult>
+  readonly resolve!: (result: PGProviderResult) => void
   readonly reject!: (reason: any) => void
 
   constructor(public id: string) {
@@ -148,7 +149,7 @@ class WebSocketConnectionImpl implements WebSocketConnection {
     this._socket.close(1000, 'Normal termination')
   }
 
-  query(query: string, params: (string | null)[] = []): Promise<PGConnectionResult> {
+  query(query: string, params: (string | null)[] = []): Promise<PGProviderResult> {
     /* The error is set also when the websocket is closed, soooooo... */
     if (this._error) return Promise.reject(this._error)
 
@@ -177,16 +178,16 @@ class WebSocketConnectionImpl implements WebSocketConnection {
  * ========================================================================== */
 
 /** A connection to the database backed by a `WebSocket` */
-export interface WebSocketConnection extends PGConnection {
+export interface WebSocketConnection extends PGProviderConnection {
   /** Close this connection and the underlying `WebSocket` */
   close(): void
 }
 
 /** An abstract provider implementing `connect(...)` via WHATWG WebSockets */
-export abstract class WebSocketProvider implements PGProvider<WebSocketConnection> {
+export abstract class WebSocketProvider extends AbstractPGProvider implements PGProvider<WebSocketConnection> {
   private readonly _connections = new Set<WebSocketConnection>()
 
-  abstract query(text: string, params?: (string | null)[]): Promise<PGConnectionResult>
+  abstract query(text: string, params?: (string | null)[]): Promise<PGProviderResult>
 
   /** Return a unique request identifier to correlate responses */
   protected abstract _getUniqueRequestId(): string