pg#PoolConfig TypeScript Examples

export function createPostgresPool(
    configOrDatabaseUrl: PluginsServerConfig | string,
    onError?: (error: Error) => any
): Pool {
    if (typeof configOrDatabaseUrl !== 'string') {
        if (!configOrDatabaseUrl.DATABASE_URL && !configOrDatabaseUrl.POSTHOG_DB_NAME) {
            throw new Error('Invalid configuration for Postgres: either DATABASE_URL or POSTHOG_DB_NAME required')
        }
    }
    const credentials: Partial<PoolConfig> =
        typeof configOrDatabaseUrl === 'string'
            ? {
                  connectionString: configOrDatabaseUrl,
              }
            : configOrDatabaseUrl.DATABASE_URL
            ? {
                  connectionString: configOrDatabaseUrl.DATABASE_URL,
              }
            : {
                  database: configOrDatabaseUrl.POSTHOG_DB_NAME ?? undefined,
                  user: configOrDatabaseUrl.POSTHOG_DB_USER,
                  password: configOrDatabaseUrl.POSTHOG_DB_PASSWORD,
                  host: configOrDatabaseUrl.POSTHOG_POSTGRES_HOST,
                  port: configOrDatabaseUrl.POSTHOG_POSTGRES_PORT,
              }

    const pgPool = new Pool({
        ...credentials,
        idleTimeoutMillis: 500,
        max: 10,
        ssl: process.env.DYNO // Means we are on Heroku
            ? {
                  rejectUnauthorized: false,
              }
            : undefined,
    })

    const handleError =
        onError ||
        ((error) => {
            Sentry.captureException(error)
            status.error('?', 'PostgreSQL error encountered!\n', error)
        })

    pgPool.on('error', handleError)

    return pgPool
}

async function pg(): Promise<Pool> {
  if (!pgPool) {
    let poolConfig: PoolConfig = {
      user: process.env.POSTGRES_USER || 'postgres',
      database: process.env.POSTGRES_DB || 'cloud_pricing',
      password: process.env.POSTGRES_PASSWORD || '',
      port: Number(process.env.POSTGRES_PORT) || 5432,
      host: process.env.POSTGRES_HOST || 'localhost',
      max: Number(process.env.POSTGRES_MAX_CLIENTS) || 10,
    };

    if (process.env.POSTGRES_URI) {
      poolConfig = {
        connectionString:
          process.env.POSTGRES_URI ||
          'postgresql://postgres:@localhost:5432/cloud_pricing',
      };
    }

    pgPool = new Pool(poolConfig);
  }
  return pgPool;
}

private getPostgresPoolConfig(): PoolConfig {
    return {
      connectionString: this.config.get<string>('DATABASE_URL'),
      ssl:
        this.config.get<string>('NODE_ENV') !== 'development'
          ? { rejectUnauthorized: false }
          : undefined,
    };
  }

private getPostgresPoolConfig(): PoolConfig {
    return {
      connectionString: this.config.get<string>('DATABASE_URL'),
      ssl:
        this.config.get<string>('NODE_ENV') !== 'development'
          ? { rejectUnauthorized: false }
          : undefined,
    };
  }

export function createPoolConfig(): PoolConfig {
    return {
        host: process.env.DB_HOST || 'localhost',
        port: process.env.DB_PORT ? parseInt(process.env.DB_PORT) : 5432,
        database: process.env.DB_NAME || 'postgres',
        user: process.env.DB_USER || 'postgres',
        password: process.env.DB_PASS || 'postgres'
    }
}

constructor(config: PoolConfig) {
    const { query, end } = init(config)
    this.query = query
    this.end = end
    this.columns = new PostgresMetaColumns(this.query)
    this.config = new PostgresMetaConfig(this.query)
    this.extensions = new PostgresMetaExtensions(this.query)
    this.functions = new PostgresMetaFunctions(this.query)
    this.policies = new PostgresMetaPolicies(this.query)
    this.publications = new PostgresMetaPublications(this.query)
    this.roles = new PostgresMetaRoles(this.query)
    this.schemas = new PostgresMetaSchemas(this.query)
    this.tables = new PostgresMetaTables(this.query)
    this.triggers = new PostgresMetaTriggers(this.query)
    this.types = new PostgresMetaTypes(this.query)
    this.version = new PostgresMetaVersion(this.query)
    this.views = new PostgresMetaViews(this.query)
  }

init: (config: PoolConfig) => {
  query: (sql: string) => Promise<PostgresMetaResult<any>>
  end: () => Promise<void>
} = (config) => {
  // NOTE: Race condition could happen here: one async task may be doing
  // `pool.end()` which invalidates the pool and subsequently all existing
  // handles to `query`. Normally you might only deal with one DB so you don't
  // need to call `pool.end()`, but since the server needs this, we make a
  // compromise: if we run `query` after `pool.end()` is called (i.e. pool is
  // `null`), we temporarily create a pool and close it right after.
  let pool: Pool | null = new Pool(config)
  return {
    async query(sql) {
      try {
        if (!pool) {
          const pool = new Pool(config)
          const { rows } = await pool.query(sql)
          await pool.end()
          return { data: rows, error: null }
        }

        const { rows } = await pool.query(sql)
        return { data: rows, error: null }
      } catch (e: any) {
        return { data: null, error: { message: e.message } }
      }
    },

    async end() {
      const _pool = pool
      pool = null
      // Gracefully wait for active connections to be idle, then close all
      // connections in the pool.
      if (_pool) await _pool.end()
    },
  }
}

private readonly args: PoolConfig;