@prairielearn/postgres 1.0.0

package/dist/pool.js

@@ -0,0 +1,712 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRandomSearchSchemaAsync = exports.setRandomSearchSchema = exports.getSearchSchema = exports.setSearchSchema = exports.callWithClientZeroOrOneRowAsync = exports.callWithClientZeroOrOneRow = exports.callWithClientOneRowAsync = exports.callWithClientOneRow = exports.callWithClientAsync = exports.callWithClient = exports.callZeroOrOneRowAsync = exports.callZeroOrOneRow = exports.callOneRowAsync = exports.callOneRow = exports.callAsync = exports.call = exports.queryZeroOrOneRowAsync = exports.queryZeroOrOneRow = exports.queryOneRowAsync = exports.queryOneRow = exports.queryAsync = exports.query = exports.runInTransactionAsync = exports.endTransaction = exports.endTransactionAsync = exports.beginTransactionAsync = exports.rollbackWithClient = exports.rollbackWithClientAsync = exports.queryWithClientZeroOrOneRowAsync = exports.queryWithClientZeroOrOneRow = exports.queryWithClientOneRowAsync = exports.queryWithClientOneRow = exports.queryWithClientAsync = exports.queryWithClient = exports.getClient = exports.getClientAsync = exports.closeAsync = exports.close = exports.initAsync = exports.init = exports.PostgresPool = exports.PostgresError = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const pg_1 = __importDefault(require("pg"));
+const node_path_1 = __importDefault(require("node:path"));
+const debug_1 = __importDefault(require("debug"));
+const node_util_1 = require("node:util");
+const node_async_hooks_1 = require("node:async_hooks");
+const debug = (0, debug_1.default)('prairielib:' + node_path_1.default.basename(__filename, '.js'));
+const lastQueryMap = new WeakMap();
+const searchSchemaMap = new WeakMap();
+function addDataToError(err, data) {
+    err.data = {
+        ...(err.data ?? {}),
+        ...data,
+    };
+    return err;
+}
+class PostgresError extends Error {
+    constructor(message, data) {
+        super(message);
+        this.data = data;
+        this.name = 'PostgresError';
+    }
+}
+exports.PostgresError = PostgresError;
+/**
+ * Formats a string for debugging.
+ */
+function debugString(s) {
+    if (!lodash_1.default.isString(s))
+        return 'NOT A STRING';
+    s = s.replace(/\n/g, '\\n');
+    if (s.length > 78)
+        s = s.substring(0, 75) + '...';
+    s = '"' + s + '"';
+    return s;
+}
+/**
+ * Formats a set of params for debugging.
+ */
+function debugParams(params) {
+    let s;
+    try {
+        s = JSON.stringify(params);
+    }
+    catch (err) {
+        s = 'CANNOT JSON STRINGIFY';
+    }
+    return debugString(s);
+}
+/**
+ * Given an SQL string and params, creates an array of params and an SQL string
+ * with any named dollar-sign placeholders replaced with parameters.
+ */
+function paramsToArray(sql, params) {
+    if (typeof sql !== 'string')
+        throw new Error('SQL must be a string');
+    if (Array.isArray(params)) {
+        return {
+            processedSql: sql,
+            paramsArray: params,
+        };
+    }
+    if (!lodash_1.default.isObjectLike(params))
+        throw new Error('params must be array or object');
+    const re = /\$([-_a-zA-Z0-9]+)/;
+    let result;
+    let processedSql = '';
+    let remainingSql = sql;
+    let nParams = 0;
+    const map = {};
+    let paramsArray = [];
+    while ((result = re.exec(remainingSql)) !== null) {
+        const v = result[1];
+        if (!(0, lodash_1.default)(map).has(v)) {
+            if (!(0, lodash_1.default)(params).has(v))
+                throw new Error(`Missing parameter: ${v}`);
+            if (lodash_1.default.isArray(params[v])) {
+                map[v] =
+                    'ARRAY[' +
+                        lodash_1.default.map(lodash_1.default.range(nParams + 1, nParams + params[v].length + 1), function (n) {
+                            return '$' + n;
+                        }).join(',') +
+                        ']';
+                nParams += params[v].length;
+                paramsArray = paramsArray.concat(params[v]);
+            }
+            else {
+                nParams++;
+                map[v] = '$' + nParams;
+                paramsArray.push(params[v]);
+            }
+        }
+        processedSql += remainingSql.substring(0, result.index) + map[v];
+        remainingSql = remainingSql.substring(result.index + result[0].length);
+    }
+    processedSql += remainingSql;
+    remainingSql = '';
+    return { processedSql, paramsArray };
+}
+/**
+ * Escapes the given identifier for use in an SQL query. Useful for preventing
+ * SQL injection.
+ */
+function escapeIdentifier(identifier) {
+    // Note that as of 2021-06-29 escapeIdentifier() is undocumented. See:
+    // https://github.com/brianc/node-postgres/pull/396
+    // https://github.com/brianc/node-postgres/issues/1978
+    // https://www.postgresql.org/docs/12/sql-syntax-lexical.html
+    return pg_1.default.Client.prototype.escapeIdentifier(identifier);
+}
+class PostgresPool {
+    constructor() {
+        /** The pool from which clients will be acquired. */
+        this.pool = null;
+        /**
+         * We use this to propagate the client associated with the current transaction
+         * to any nested queries. In the past, we had some nasty bugs associated with
+         * the fact that we tried to acquire new clients inside of transactions, which
+         * ultimately lead to a deadlock.
+         */
+        this.alsClient = new node_async_hooks_1.AsyncLocalStorage();
+        this.searchSchema = null;
+        /**
+         * Creates a new connection pool and attempts to connect to the database.
+         */
+        this.init = (0, node_util_1.callbackify)(this.initAsync);
+        /**
+         * Closes the connection pool.
+         */
+        this.close = (0, node_util_1.callbackify)(this.closeAsync);
+        /**
+         * Performs a query with the given client.
+         */
+        this.queryWithClient = (0, node_util_1.callbackify)(this.queryWithClientAsync);
+        /**
+         * Performs a query with the given client. Errors if the query returns more
+         * than one row.
+         */
+        this.queryWithClientOneRow = (0, node_util_1.callbackify)(this.queryWithClientOneRowAsync);
+        /**
+         * Performs a query with the given client. Errors if the query returns more
+         * than one row.
+         */
+        this.queryWithClientZeroOrOneRow = (0, node_util_1.callbackify)(this.queryWithClientZeroOrOneRowAsync);
+        /**
+         * Executes a query with the specified parameters.
+         */
+        this.query = (0, node_util_1.callbackify)(this.queryAsync);
+        /**
+         * Executes a query with the specified parameters. Errors if the query does
+         * not return exactly one row.
+         */
+        this.queryOneRow = (0, node_util_1.callbackify)(this.queryOneRowAsync);
+        /**
+         * Executes a query with the specified parameters. Errors if the query
+         * returns more than one row.
+         */
+        this.queryZeroOrOneRow = (0, node_util_1.callbackify)(this.queryZeroOrOneRowAsync);
+        /**
+         * Calls the given function with the specified parameters.
+         */
+        this.call = (0, node_util_1.callbackify)(this.callAsync);
+        /**
+         * Calls the given function with the specified parameters. Errors if the
+         * function does not return exactly one row.
+         */
+        this.callOneRow = (0, node_util_1.callbackify)(this.callOneRowAsync);
+        /**
+         * Calls the given function with the specified parameters. Errors if the
+         * function returns more than one row.
+         */
+        this.callZeroOrOneRow = (0, node_util_1.callbackify)(this.callZeroOrOneRowAsync);
+        /**
+         * Calls a function with the specified parameters using a specific client.
+         */
+        this.callWithClient = (0, node_util_1.callbackify)(this.callWithClientAsync);
+        /**
+         * Calls a function with the specified parameters using a specific client.
+         * Errors if the function does not return exactly one row.
+         */
+        this.callWithClientOneRow = (0, node_util_1.callbackify)(this.callWithClientOneRowAsync);
+        /**
+         * Calls a function with the specified parameters using a specific client.
+         * Errors if the function returns more than one row.
+         */
+        this.callWithClientZeroOrOneRow = (0, node_util_1.callbackify)(this.callWithClientZeroOrOneRowAsync);
+        /**
+         * Generate, set, and return a random schema name.
+         */
+        this.setRandomSearchSchema = (0, node_util_1.callbackify)(this.setRandomSearchSchemaAsync);
+    }
+    /**
+     * Creates a new connection pool and attempts to connect to the database.
+     */
+    async initAsync(pgConfig, idleErrorHandler) {
+        this.pool = new pg_1.default.Pool(pgConfig);
+        this.pool.on('error', function (err, client) {
+            const lastQuery = lastQueryMap.get(client);
+            idleErrorHandler(addDataToError(err, { lastQuery }), client);
+        });
+        this.pool.on('connect', (client) => {
+            client.on('error', (err) => {
+                const lastQuery = lastQueryMap.get(client);
+                idleErrorHandler(addDataToError(err, { lastQuery }), client);
+            });
+        });
+        this.pool.on('remove', (client) => {
+            // This shouldn't be necessary, as `pg` currently allows clients to be
+            // garbage collected after they're removed. However, if `pg` someday
+            // starts reusing client objects across difference connections, this
+            // will ensure that we re-set the search path when the client reconnects.
+            searchSchemaMap.delete(client);
+        });
+        // Attempt to connect to the database so that we can fail quickly if
+        // something isn't configured correctly.
+        let retryCount = 0;
+        const retryTimeouts = [500, 1000, 2000, 5000, 10000];
+        while (retryCount <= retryTimeouts.length) {
+            try {
+                const client = await this.pool.connect();
+                client.release();
+                return;
+            }
+            catch (err) {
+                if (retryCount === retryTimeouts.length) {
+                    throw new Error(`Could not connect to Postgres after ${retryTimeouts.length} attempts: ${err.message}`);
+                }
+                const timeout = retryTimeouts[retryCount];
+                retryCount++;
+                await new Promise((resolve) => setTimeout(resolve, timeout));
+            }
+        }
+    }
+    /**
+     * Closes the connection pool.
+     */
+    async closeAsync() {
+        if (!this.pool)
+            return;
+        await this.pool.end();
+        this.pool = null;
+    }
+    /**
+     * Gets a new client from the connection pool. If `err` is not null
+     * then `client` and `done` are undefined. If `err` is null then
+     * `client` is valid and can be used. The caller MUST call `done()` to
+     * release the client, whether or not errors occurred while using
+     * `client`. The client can call `done(truthy_value)` to force
+     * destruction of the client, but this should not be used except in
+     * unusual circumstances.
+     */
+    async getClientAsync() {
+        if (!this.pool) {
+            throw new Error('Connection pool is not open');
+        }
+        // If we're inside a transaction, we'll reuse the same client to avoid a
+        // potential deadlock.
+        let client = this.alsClient.getStore() ?? (await this.pool.connect());
+        // If we're configured to use a particular schema, we'll store whether or
+        // not the search path has already been configured for this particular
+        // client. If we acquire a client and it's already had its search path
+        // set, we can avoid setting it again since the search path will persist
+        // for the life of the client.
+        //
+        // We do this check for each call to `getClient` instead of on
+        // `pool.connect` so that we don't have to be really careful about
+        // destroying old clients that were created before `setSearchSchema` was
+        // called. Instead, we'll just check if the search path matches the
+        // currently-desired schema, and if it's a mismatch (or doesn't exist
+        // at all), we re-set it for the current client.
+        //
+        // Note that this accidentally supports changing the search_path on the fly,
+        // although that's not something we currently do (or would be likely to do).
+        // It does NOT support clearing the existing search schema - e.g.,
+        // `setSearchSchema(null)` would not work as you expect. This is fine, as
+        // that's not something we ever do in practice.
+        const clientSearchSchema = searchSchemaMap.get(client);
+        if (this.searchSchema != null && clientSearchSchema !== this.searchSchema) {
+            const setSearchPathSql = `SET search_path TO ${escapeIdentifier(this.searchSchema)},public`;
+            try {
+                await this.queryWithClientAsync(client, setSearchPathSql, {});
+            }
+            catch (err) {
+                client.release();
+                throw err;
+            }
+            searchSchemaMap.set(client, this.searchSchema);
+        }
+        return client;
+    }
+    /**
+     * Gets a new client from the connection pool.
+     */
+    getClient(callback) {
+        this.getClientAsync()
+            .then((client) => callback(null, client, client.release))
+            .catch((err) => callback(err));
+    }
+    /**
+     * Performs a query with the given client.
+     */
+    async queryWithClientAsync(client, sql, params) {
+        debug('queryWithClient()', 'sql:', debugString(sql));
+        debug('queryWithClient()', 'params:', debugParams(params));
+        const { processedSql, paramsArray } = paramsToArray(sql, params);
+        try {
+            lastQueryMap.set(client, processedSql);
+            const result = await client.query(processedSql, paramsArray);
+            debug('queryWithClient() success', 'rowCount:', result.rowCount);
+            return result;
+        }
+        catch (err) {
+            // TODO: why do we do this?
+            const sqlError = JSON.parse(JSON.stringify(err));
+            sqlError.message = err.message;
+            throw addDataToError(err, {
+                sqlError: sqlError,
+                sql: sql,
+                sqlParams: params,
+            });
+        }
+    }
+    /**
+     * Performs a query with the given client. Errors if the query returns more
+     * than one row.
+     */
+    async queryWithClientOneRowAsync(client, sql, params) {
+        debug('queryWithClientOneRow()', 'sql:', debugString(sql));
+        debug('queryWithClientOneRow()', 'params:', debugParams(params));
+        const result = await this.queryWithClientAsync(client, sql, params);
+        if (result.rowCount !== 1) {
+            throw new PostgresError(`Incorrect rowCount: ${result.rowCount}`, {
+                sql,
+                sqlParams: params,
+                result,
+            });
+        }
+        debug('queryWithClientOneRow() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Performs a query with the given client. Errors if the query returns more
+     * than one row.
+     */
+    async queryWithClientZeroOrOneRowAsync(client, sql, params) {
+        debug('queryWithClientZeroOrOneRow()', 'sql:', debugString(sql));
+        debug('queryWithClientZeroOrOneRow()', 'params:', debugParams(params));
+        const result = await this.queryWithClientAsync(client, sql, params);
+        if (result.rowCount > 1) {
+            throw new PostgresError(`Incorrect rowCount: ${result.rowCount}`, {
+                sql,
+                sqlParams: params,
+                result,
+            });
+        }
+        debug('queryWithClientZeroOrOneRow() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Rolls back the current transaction for the given client.
+     */
+    async rollbackWithClientAsync(client) {
+        debug('rollbackWithClient()');
+        // From https://node-postgres.com/features/transactions
+        try {
+            await client.query('ROLLBACK');
+            // Only release the client if we weren't already inside a transaction.
+            if (this.alsClient.getStore() === undefined) {
+                client.release();
+            }
+        }
+        catch (err) {
+            // If there was a problem rolling back the query, something is
+            // seriously messed up. Return the error to the release() function to
+            // close & remove this client from the pool. If you leave a client in
+            // the pool with an unaborted transaction, weird and hard to diagnose
+            // problems might happen.
+            client.release(err);
+        }
+    }
+    /**
+     * Rolls back the current transaction for the given client.
+     */
+    rollbackWithClient(client, _done, callback) {
+        // Note that we can't use `util.callbackify` here because this function
+        // has an additional unused `done` parameter for backwards compatibility.
+        this.rollbackWithClientAsync(client)
+            .then(() => callback(null))
+            .catch((err) => callback(err));
+    }
+    /**
+     * Begins a new transaction.
+     */
+    async beginTransactionAsync() {
+        debug('beginTransaction()');
+        const client = await this.getClientAsync();
+        try {
+            await this.queryWithClientAsync(client, 'START TRANSACTION;', {});
+            return client;
+        }
+        catch (err) {
+            await this.rollbackWithClientAsync(client);
+            throw err;
+        }
+    }
+    /**
+     * Commits the transaction if err is null, otherwise rollbacks the transaction.
+     * Also releases the client.
+     */
+    async endTransactionAsync(client, err) {
+        debug('endTransaction()');
+        if (err) {
+            try {
+                await this.rollbackWithClientAsync(client);
+            }
+            catch (rollbackErr) {
+                throw addDataToError(rollbackErr, { prevErr: err, rollback: 'fail' });
+            }
+            // Even though we successfully rolled back the transaction, there was
+            // still an error in the first place that necessitated a rollback. Re-throw
+            // that error here so that everything downstream of here will know about it.
+            throw addDataToError(err, { rollback: 'success' });
+        }
+        else {
+            try {
+                await this.queryWithClientAsync(client, 'COMMIT', {});
+            }
+            finally {
+                // Only release the client if we aren't nested inside another transaction.
+                if (this.alsClient.getStore() === undefined) {
+                    client.release();
+                }
+            }
+        }
+    }
+    /**
+     * Commits the transaction if err is null, otherwise rollbacks the transaction.
+     * Also releases the client.
+     */
+    endTransaction(client, _done, err, callback) {
+        this.endTransactionAsync(client, err)
+            .then(() => callback(null))
+            .catch((error) => callback(error));
+    }
+    /**
+     * Runs the specified function inside of a transaction. The function will
+     * receive a database client as an argument, but it can also make queries
+     * as usual, and the correct client will be used automatically.
+     *
+     * The transaction will be rolled back if the function throws an error, and
+     * will be committed otherwise.
+     */
+    async runInTransactionAsync(fn) {
+        const client = await this.beginTransactionAsync();
+        try {
+            await this.alsClient.run(client, () => fn(client));
+        }
+        catch (err) {
+            await this.endTransactionAsync(client, err);
+            throw err;
+        }
+        // Note that we don't invoke `endTransactionAsync` inside the `try` block
+        // because we don't want an error thrown by it to trigger *another* call
+        // to `endTransactionAsync` in the `catch` block.
+        await this.endTransactionAsync(client, null);
+    }
+    /**
+     * Executes a query with the specified parameters.
+     */
+    async queryAsync(sql, params) {
+        debug('query()', 'sql:', debugString(sql));
+        debug('query()', 'params:', debugParams(params));
+        const client = await this.getClientAsync();
+        try {
+            return await this.queryWithClientAsync(client, sql, params);
+        }
+        finally {
+            // Only release if we aren't nested in a transaction.
+            if (this.alsClient.getStore() === undefined) {
+                client.release();
+            }
+        }
+    }
+    /**
+     * Executes a query with the specified parameters. Errors if the query does
+     * not return exactly one row.
+     */
+    async queryOneRowAsync(sql, params) {
+        debug('queryOneRow()', 'sql:', debugString(sql));
+        debug('queryOneRow()', 'params:', debugParams(params));
+        const result = await this.queryAsync(sql, params);
+        if (result.rowCount !== 1) {
+            throw new PostgresError(`Incorrect rowCount: ${result.rowCount}`, {
+                sql,
+                sqlParams: params,
+            });
+        }
+        debug('queryOneRow() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Executes a query with the specified parameters. Errors if the query
+     * returns more than one row.
+     */
+    async queryZeroOrOneRowAsync(sql, params) {
+        debug('queryZeroOrOneRow()', 'sql:', debugString(sql));
+        debug('queryZeroOrOneRow()', 'params:', debugParams(params));
+        const result = await this.queryAsync(sql, params);
+        if (result.rowCount > 1) {
+            throw new PostgresError(`Incorrect rowCount: ${result.rowCount}`, {
+                sql,
+                sqlParams: params,
+            });
+        }
+        debug('queryZeroOrOneRow() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Calls the given function with the specified parameters.
+     */
+    async callAsync(functionName, params) {
+        debug('call()', 'function:', functionName);
+        debug('call()', 'params:', debugParams(params));
+        const placeholders = lodash_1.default.map(lodash_1.default.range(1, params.length + 1), (v) => '$' + v).join();
+        const sql = `SELECT * FROM ${escapeIdentifier(functionName)}(${placeholders});`;
+        const result = await this.queryAsync(sql, params);
+        debug('call() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Calls the given function with the specified parameters. Errors if the
+     * function does not return exactly one row.
+     */
+    async callOneRowAsync(functionName, params) {
+        debug('callOneRow()', 'function:', functionName);
+        debug('callOneRow()', 'params:', debugParams(params));
+        const result = await this.callAsync(functionName, params);
+        if (result.rowCount !== 1) {
+            throw new PostgresError('Incorrect rowCount: ' + result.rowCount, {
+                functionName,
+                sqlParams: params,
+            });
+        }
+        debug('callOneRow() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Calls the given function with the specified parameters. Errors if the
+     * function returns more than one row.
+     */
+    async callZeroOrOneRowAsync(functionName, params) {
+        debug('callZeroOrOneRow()', 'function:', functionName);
+        debug('callZeroOrOneRow()', 'params:', debugParams(params));
+        const result = await this.callAsync(functionName, params);
+        if (result.rowCount > 1) {
+            throw new PostgresError('Incorrect rowCount: ' + result.rowCount, {
+                functionName,
+                sqlParams: params,
+            });
+        }
+        debug('callZeroOrOneRow() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     */
+    async callWithClientAsync(client, functionName, params) {
+        debug('callWithClient()', 'function:', functionName);
+        debug('callWithClient()', 'params:', debugParams(params));
+        const placeholders = lodash_1.default.map(lodash_1.default.range(1, params.length + 1), (v) => '$' + v).join();
+        const sql = `SELECT * FROM ${escapeIdentifier(functionName)}(${placeholders})`;
+        const result = await this.queryWithClientAsync(client, sql, params);
+        debug('callWithClient() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     * Errors if the function does not return exactly one row.
+     */
+    async callWithClientOneRowAsync(client, functionName, params) {
+        debug('callWithClientOneRow()', 'function:', functionName);
+        debug('callWithClientOneRow()', 'params:', debugParams(params));
+        const result = await this.callWithClientAsync(client, functionName, params);
+        if (result.rowCount !== 1) {
+            throw new PostgresError('Incorrect rowCount: ' + result.rowCount, {
+                functionName,
+                sqlParams: params,
+            });
+        }
+        debug('callWithClientOneRow() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     * Errors if the function returns more than one row.
+     */
+    async callWithClientZeroOrOneRowAsync(client, functionName, params) {
+        debug('callWithClientZeroOrOneRow()', 'function:', functionName);
+        debug('callWithClientZeroOrOneRow()', 'params:', debugParams(params));
+        const result = await this.callWithClientAsync(client, functionName, params);
+        if (result.rowCount > 1) {
+            throw new PostgresError('Incorrect rowCount: ' + result.rowCount, {
+                functionName,
+                sqlParams: params,
+            });
+        }
+        debug('callWithClientZeroOrOneRow() success', 'rowCount:', result.rowCount);
+        return result;
+    }
+    /**
+     * Set the schema to use for the search path.
+     *
+     * @param schema The schema name to use (can be "null" to unset the search path)
+     */
+    async setSearchSchema(schema) {
+        if (schema == null) {
+            this.searchSchema = schema;
+            return;
+        }
+        await this.queryAsync(`CREATE SCHEMA IF NOT EXISTS ${escapeIdentifier(schema)}`, {});
+        // We only set searchSchema after CREATE to avoid the above query() call using searchSchema.
+        this.searchSchema = schema;
+    }
+    /**
+     * Get the schema that is currently used for the search path.
+     *
+     * @return schema in use (may be `null` to indicate no schema)
+     */
+    getSearchSchema() {
+        return this.searchSchema;
+    }
+    /**
+     * Generate, set, and return a random schema name.
+     *
+     * @param prefix The prefix of the new schema, only the first 28 characters will be used (after lowercasing).
+     * @returns The randomly-generated search schema.
+     */
+    async setRandomSearchSchemaAsync(prefix) {
+        // truncated prefix (max 28 characters)
+        const truncPrefix = prefix.substring(0, 28);
+        // timestamp in format YYYY-MM-DDTHH:MM:SS.SSSZ (guaranteed to not exceed 27 characters in the spec)
+        const timestamp = new Date().toISOString();
+        // random 6-character suffix to avoid clashes (approx 2 billion possible values)
+        const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+        const suffix = lodash_1.default.times(6, function () {
+            return lodash_1.default.sample(chars);
+        }).join('');
+        // Schema is guaranteed to have length at most 63 (= 28 + 1 + 27 + 1 + 6),
+        // which is the default PostgreSQL identifier limit.
+        // Note that this schema name will need quoting because of characters like ':', '-', etc
+        const schema = `${truncPrefix}_${timestamp}_${suffix}`;
+        await this.setSearchSchema(schema);
+        return schema;
+    }
+}
+exports.PostgresPool = PostgresPool;
+const defaultPool = new PostgresPool();
+// We re-expose all functions from the default pool here to account for the
+// default case of a shared global pool of clients. If someone want to create
+// their own pool, we expose the `PostgresPool` class.
+//
+// Note that we explicitly bind all functions to `defaultPool`. This ensures
+// that they'll be invoked with the correct `this` context, specifically when
+// this module is imported as `import * as db from '...'` and that import is
+// subsequently transformed by Babel to `interopRequireWildcard(...)`.
+exports.init = defaultPool.init.bind(defaultPool);
+exports.initAsync = defaultPool.initAsync.bind(defaultPool);
+exports.close = defaultPool.close.bind(defaultPool);
+exports.closeAsync = defaultPool.closeAsync.bind(defaultPool);
+exports.getClientAsync = defaultPool.getClientAsync.bind(defaultPool);
+exports.getClient = defaultPool.getClient.bind(defaultPool);
+exports.queryWithClient = defaultPool.queryWithClient.bind(defaultPool);
+exports.queryWithClientAsync = defaultPool.queryWithClientAsync.bind(defaultPool);
+exports.queryWithClientOneRow = defaultPool.queryWithClientOneRow.bind(defaultPool);
+exports.queryWithClientOneRowAsync = defaultPool.queryWithClientOneRowAsync.bind(defaultPool);
+exports.queryWithClientZeroOrOneRow = defaultPool.queryWithClientZeroOrOneRow.bind(defaultPool);
+exports.queryWithClientZeroOrOneRowAsync = defaultPool.queryWithClientZeroOrOneRowAsync.bind(defaultPool);
+exports.rollbackWithClientAsync = defaultPool.rollbackWithClientAsync.bind(defaultPool);
+exports.rollbackWithClient = defaultPool.rollbackWithClient.bind(defaultPool);
+exports.beginTransactionAsync = defaultPool.beginTransactionAsync.bind(defaultPool);
+exports.endTransactionAsync = defaultPool.endTransactionAsync.bind(defaultPool);
+exports.endTransaction = defaultPool.endTransaction.bind(defaultPool);
+exports.runInTransactionAsync = defaultPool.runInTransactionAsync.bind(defaultPool);
+exports.query = defaultPool.query.bind(defaultPool);
+exports.queryAsync = defaultPool.queryAsync.bind(defaultPool);
+exports.queryOneRow = defaultPool.queryOneRow.bind(defaultPool);
+exports.queryOneRowAsync = defaultPool.queryOneRowAsync.bind(defaultPool);
+exports.queryZeroOrOneRow = defaultPool.queryZeroOrOneRow.bind(defaultPool);
+exports.queryZeroOrOneRowAsync = defaultPool.queryZeroOrOneRowAsync.bind(defaultPool);
+exports.call = defaultPool.call.bind(defaultPool);
+exports.callAsync = defaultPool.callAsync.bind(defaultPool);
+exports.callOneRow = defaultPool.callOneRow.bind(defaultPool);
+exports.callOneRowAsync = defaultPool.callOneRowAsync.bind(defaultPool);
+exports.callZeroOrOneRow = defaultPool.callZeroOrOneRow.bind(defaultPool);
+exports.callZeroOrOneRowAsync = defaultPool.callZeroOrOneRowAsync.bind(defaultPool);
+exports.callWithClient = defaultPool.callWithClient.bind(defaultPool);
+exports.callWithClientAsync = defaultPool.callWithClientAsync.bind(defaultPool);
+exports.callWithClientOneRow = defaultPool.callWithClientOneRow.bind(defaultPool);
+exports.callWithClientOneRowAsync = defaultPool.callWithClientOneRowAsync.bind(defaultPool);
+exports.callWithClientZeroOrOneRow = defaultPool.callWithClientZeroOrOneRow.bind(defaultPool);
+exports.callWithClientZeroOrOneRowAsync = defaultPool.callWithClientZeroOrOneRowAsync.bind(defaultPool);
+exports.setSearchSchema = defaultPool.setSearchSchema.bind(defaultPool);
+exports.getSearchSchema = defaultPool.getSearchSchema.bind(defaultPool);
+exports.setRandomSearchSchema = defaultPool.setRandomSearchSchema.bind(defaultPool);
+exports.setRandomSearchSchemaAsync = defaultPool.setRandomSearchSchemaAsync.bind(defaultPool);
+//# sourceMappingURL=pool.js.map