@prairielearn/postgres 1.0.0

package/README.md

@@ -0,0 +1,126 @@
+# `@prairielearn/postgres`
+
+Tools for loading and executing Postgres queries.
+
+## Usage
+
+Before making any queries, you must initialize the library with your connection details and an error handler:
+
+```ts
+import sqldb from '@prairielearn/postgres';
+
+function idleErrorHandler(err: any) {
+  console.error(err);
+  process.exit(1);
+}
+
+await sqldb.initAsync(
+  {
+    user: '...',
+    database: '...',
+    host: '...',
+    password: '...',
+    max: 2,
+    idleTimeoutMillis: 30000,
+  },
+  idleErrorHandler
+);
+```
+
+The options argument accepts any values that the [`pg.Pool`](https://node-postgres.com/apis/pool) constructor does.
+
+### Loading queries from files
+
+The recommended way to write queries is to store them in a `.sql` file adjacent to the file from which they'll be used. For instance, if we want to make some queries in an `index.js` file, we can put the following in `index.sql`:
+
+```sql
+-- BLOCK select_user
+SELECT * FROM users WHERE id = $user_id;
+
+-- BLOCK select_course
+SELECT * FROM courses WHERE id = $course_id;
+```
+
+You can then load these queries in your JavaScript file:
+
+```ts
+import sqldb from '@prairielearn/postgres';
+const sql = sqldb.loadSqlEquiv(import.meta.url);
+
+console.log(sql.select_user);
+console.log(sql.select_course);
+
+// Or, if you're working in a CommonJS file:
+const sqldb = require('@prairielearn/postgres');
+const sql = sqldb.loadSqlEquiv(__filename);
+```
+
+### Making queries
+
+Once you've loaded your SQL, you can use them to query the database:
+
+```ts
+import sqldb from '@prairielearn/postgres';
+const sql = sqldb.loadSqlEquiv(import.meta.url);
+
+const result = await sqldb.queryAsync(sql.select_user, { user_id: '1' });
+console.log(result.rows);
+```
+
+The `queryAsync` function returns a [`pg.Result`](https://node-postgres.com/apis/result) object; see linked documentation for a list of additional properties that are available on that object.
+
+There are a variety of utility methods that can make assertions about the results:
+
+- `queryOneRowAsync`: Throws an error if the result doesn't have exactly one row.
+- `queryZeroOrOneRowAsync`: Throws an error if the result has more than one row.
+
+### Stored procedures (sprocs)
+
+There are also functions that make it easy to call a stored procedure with a given set of arguments. Consider a database that has the following sproc defined:
+
+```sql
+CREATE PROCEDURE insert_data(a integer, b integer)
+LANGUAGE SQL
+BEGIN ATOMIC
+  INSERT INTO tbl VALUES (a);
+  INSERT INTO tbl VALUES (b);
+END;
+```
+
+You can call this sproc in your JavaScript code:
+
+```ts
+await sqldb.callAsync('insert_data', [1, 2]);
+```
+
+### Transactions
+
+To use transactions, wrap your queries with the `runInTransaction` function:
+
+```ts
+await sqldb.runInTransaction(async () => {
+  await sqldb.queryAsync(sql.insert_user, { name: 'Kevin Young' });
+  await sqldb.queryAsync(sql.insert_course, { rubric: 'CS 101' });
+});
+```
+
+`runInTransaction` will start a transaction and then execute the provided function. Any nested query will use the same client and thus run inside the transaction. If the function throws an error, the transaction is rolled back; otherwise, it is committed.
+
+### Callback-style functions
+
+For most functions that return promises, there are corresponding versions that work with Node-style callbacks:
+
+```ts
+sqldb.query(sql.select_user, (err, result) => {
+  if (err) {
+    console.error('Error running query', err);
+  } else {
+    console.log(result.rows);
+  }
+});
+```
+
+However, these should be avoided in new code:
+
+- They make it more difficult to correctly handle errors
+- Callback-style code tends to be more verbose and suffer from "callback hell"

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { loadSql, loadSqlEquiv } from './loader';
+export * from './pool';
+export { PoolClient } from 'pg';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSqlEquiv = exports.loadSql = void 0;
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "loadSql", { enumerable: true, get: function () { return loader_1.loadSql; } });
+Object.defineProperty(exports, "loadSqlEquiv", { enumerable: true, get: function () { return loader_1.loadSqlEquiv; } });
+__exportStar(require("./pool"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,mCAAiD;AAAxC,iGAAA,OAAO,OAAA;AAAE,sGAAA,YAAY,OAAA;AAC9B,yCAAuB"}

package/dist/loader.d.ts

@@ -0,0 +1,4 @@
+type SqlFile = Record<string, string>;
+export declare function loadSql(filename: string): SqlFile;
+export declare function loadSqlEquiv(filePathOrUrl: string): SqlFile;
+export {};

package/dist/loader.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSqlEquiv = exports.loadSql = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = __importDefault(require("node:url"));
+function loadSql(filename) {
+    const sql = {};
+    sql.all = node_fs_1.default.readFileSync(filename, 'utf8');
+    const lines = sql.all.split(/\r?\n/);
+    const blockRE = /^ *-- *BLOCK +([^ ]+) *$/;
+    let blockName = null;
+    lines.forEach((line) => {
+        var result = blockRE.exec(line);
+        if (result) {
+            blockName = result[1];
+            if (sql[blockName])
+                throw new Error(`${filename}: duplicate BLOCK name: ${blockName}`);
+            sql[blockName] = line;
+        }
+        else if (blockName) {
+            sql[blockName] += '\n' + line;
+        }
+    });
+    return sql;
+}
+exports.loadSql = loadSql;
+function loadSqlEquiv(filePathOrUrl) {
+    let resolvedPath = filePathOrUrl;
+    // This allows for us to pass `import.meta.url` to this function in ES Modules
+    // environments where `__filename` is not available.
+    if (filePathOrUrl.startsWith('file://')) {
+        resolvedPath = node_url_1.default.fileURLToPath(filePathOrUrl);
+    }
+    const components = node_path_1.default.parse(resolvedPath);
+    components.ext = '.sql';
+    const sqlFilename = node_path_1.default.join(components.dir, components.name) + components.ext;
+    return loadSql(sqlFilename);
+}
+exports.loadSqlEquiv = loadSqlEquiv;
+//# sourceMappingURL=loader.js.map

package/dist/loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.js","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,0DAA6B;AAC7B,wDAA2B;AAI3B,SAAgB,OAAO,CAAC,QAAgB;IACtC,MAAM,GAAG,GAAY,EAAE,CAAC;IACxB,GAAG,CAAC,GAAG,GAAG,iBAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACrC,MAAM,OAAO,GAAG,0BAA0B,CAAC;IAC3C,IAAI,SAAS,GAAkB,IAAI,CAAC;IACpC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QACrB,IAAI,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,MAAM,EAAE;YACV,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,GAAG,CAAC,SAAS,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,2BAA2B,SAAS,EAAE,CAAC,CAAC;YACvF,GAAG,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;SACvB;aAAM,IAAI,SAAS,EAAE;YACpB,GAAG,CAAC,SAAS,CAAC,IAAI,IAAI,GAAG,IAAI,CAAC;SAC/B;IACH,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC;AAjBD,0BAiBC;AAED,SAAgB,YAAY,CAAC,aAAqB;IAChD,IAAI,YAAY,GAAG,aAAa,CAAC;IAEjC,8EAA8E;IAC9E,oDAAoD;IACpD,IAAI,aAAa,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;QACvC,YAAY,GAAG,kBAAG,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;KACjD;IAED,MAAM,UAAU,GAAG,mBAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IAC5C,UAAU,CAAC,GAAG,GAAG,MAAM,CAAC;IACxB,MAAM,WAAW,GAAG,mBAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC;IAChF,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC;AAC9B,CAAC;AAbD,oCAaC"}

package/dist/pool.d.ts

@@ -0,0 +1,256 @@
+/// <reference types="node" />
+import pg, { QueryResult } from 'pg';
+type Params = Record<string, any> | any[];
+export declare class PostgresError extends Error {
+    data: Record<string, any>;
+    constructor(message: string, data: Record<string, any>);
+}
+export declare class PostgresPool {
+    /** The pool from which clients will be acquired. */
+    private pool;
+    /**
+     * 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.
+     */
+    private alsClient;
+    private searchSchema;
+    /**
+     * Creates a new connection pool and attempts to connect to the database.
+     */
+    initAsync(pgConfig: pg.PoolConfig, idleErrorHandler: (error: Error, client: pg.PoolClient) => void): Promise<void>;
+    /**
+     * Creates a new connection pool and attempts to connect to the database.
+     */
+    init: (arg1: pg.PoolConfig, arg2: (error: Error, client: pg.PoolClient) => void, callback: (err: NodeJS.ErrnoException) => void) => void;
+    /**
+     * Closes the connection pool.
+     */
+    closeAsync(): Promise<void>;
+    /**
+     * Closes the connection pool.
+     */
+    close: (callback: (err: NodeJS.ErrnoException) => void) => void;
+    /**
+     * 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.
+     */
+    getClientAsync(): Promise<pg.PoolClient>;
+    /**
+     * Gets a new client from the connection pool.
+     */
+    getClient(callback: (error: Error | null, client?: pg.PoolClient, done?: () => void) => void): void;
+    /**
+     * Performs a query with the given client.
+     */
+    queryWithClientAsync(client: pg.PoolClient, sql: string, params: Params): Promise<pg.QueryResult>;
+    /**
+     * Performs a query with the given client.
+     */
+    queryWithClient: (arg1: pg.PoolClient, arg2: string, arg3: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Performs a query with the given client. Errors if the query returns more
+     * than one row.
+     */
+    queryWithClientOneRowAsync(client: pg.PoolClient, sql: string, params: Params): Promise<pg.QueryResult>;
+    /**
+     * Performs a query with the given client. Errors if the query returns more
+     * than one row.
+     */
+    queryWithClientOneRow: (arg1: pg.PoolClient, arg2: string, arg3: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Performs a query with the given client. Errors if the query returns more
+     * than one row.
+     */
+    queryWithClientZeroOrOneRowAsync(client: pg.PoolClient, sql: string, params: Params): Promise<QueryResult>;
+    /**
+     * Performs a query with the given client. Errors if the query returns more
+     * than one row.
+     */
+    queryWithClientZeroOrOneRow: (arg1: pg.PoolClient, arg2: string, arg3: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Rolls back the current transaction for the given client.
+     */
+    rollbackWithClientAsync(client: pg.PoolClient): Promise<void>;
+    /**
+     * Rolls back the current transaction for the given client.
+     */
+    rollbackWithClient(client: pg.PoolClient, _done: (release?: any) => void, callback: (err: Error | null) => void): void;
+    /**
+     * Begins a new transaction.
+     */
+    beginTransactionAsync(): Promise<pg.PoolClient>;
+    /**
+     * Commits the transaction if err is null, otherwise rollbacks the transaction.
+     * Also releases the client.
+     */
+    endTransactionAsync(client: pg.PoolClient, err: Error | null | undefined): Promise<void>;
+    /**
+     * Commits the transaction if err is null, otherwise rollbacks the transaction.
+     * Also releases the client.
+     */
+    endTransaction(client: pg.PoolClient, _done: (rollback?: any) => void, err: Error | null | undefined, callback: (error: Error | null) => void): void;
+    /**
+     * 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.
+     */
+    runInTransactionAsync(fn: (client: pg.PoolClient) => Promise<void>): Promise<void>;
+    /**
+     * Executes a query with the specified parameters.
+     */
+    queryAsync(sql: string, params: Params): Promise<QueryResult>;
+    /**
+     * Executes a query with the specified parameters.
+     */
+    query: (arg1: string, arg2: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Executes a query with the specified parameters. Errors if the query does
+     * not return exactly one row.
+     */
+    queryOneRowAsync(sql: string, params: Params): Promise<pg.QueryResult>;
+    /**
+     * Executes a query with the specified parameters. Errors if the query does
+     * not return exactly one row.
+     */
+    queryOneRow: (arg1: string, arg2: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Executes a query with the specified parameters. Errors if the query
+     * returns more than one row.
+     */
+    queryZeroOrOneRowAsync(sql: string, params: Params): Promise<pg.QueryResult>;
+    /**
+     * Executes a query with the specified parameters. Errors if the query
+     * returns more than one row.
+     */
+    queryZeroOrOneRow: (arg1: string, arg2: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Calls the given function with the specified parameters.
+     */
+    callAsync(functionName: string, params: any[]): Promise<pg.QueryResult>;
+    /**
+     * Calls the given function with the specified parameters.
+     */
+    call: (arg1: string, arg2: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Calls the given function with the specified parameters. Errors if the
+     * function does not return exactly one row.
+     */
+    callOneRowAsync(functionName: string, params: any[]): Promise<pg.QueryResult>;
+    /**
+     * Calls the given function with the specified parameters. Errors if the
+     * function does not return exactly one row.
+     */
+    callOneRow: (arg1: string, arg2: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Calls the given function with the specified parameters. Errors if the
+     * function returns more than one row.
+     */
+    callZeroOrOneRowAsync(functionName: string, params: any[]): Promise<pg.QueryResult>;
+    /**
+     * Calls the given function with the specified parameters. Errors if the
+     * function returns more than one row.
+     */
+    callZeroOrOneRow: (arg1: string, arg2: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     */
+    callWithClientAsync(client: pg.PoolClient, functionName: string, params: any[]): Promise<pg.QueryResult>;
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     */
+    callWithClient: (arg1: pg.PoolClient, arg2: string, arg3: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     * Errors if the function does not return exactly one row.
+     */
+    callWithClientOneRowAsync(client: pg.PoolClient, functionName: string, params: any[]): Promise<pg.QueryResult>;
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     * Errors if the function does not return exactly one row.
+     */
+    callWithClientOneRow: (arg1: pg.PoolClient, arg2: string, arg3: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     * Errors if the function returns more than one row.
+     */
+    callWithClientZeroOrOneRowAsync(client: pg.PoolClient, functionName: string, params: any[]): Promise<pg.QueryResult>;
+    /**
+     * Calls a function with the specified parameters using a specific client.
+     * Errors if the function returns more than one row.
+     */
+    callWithClientZeroOrOneRow: (arg1: pg.PoolClient, arg2: string, arg3: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+    /**
+     * Set the schema to use for the search path.
+     *
+     * @param schema The schema name to use (can be "null" to unset the search path)
+     */
+    setSearchSchema(schema: string): Promise<void>;
+    /**
+     * Get the schema that is currently used for the search path.
+     *
+     * @return schema in use (may be `null` to indicate no schema)
+     */
+    getSearchSchema(): string | null;
+    /**
+     * 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.
+     */
+    setRandomSearchSchemaAsync(prefix: string): Promise<string>;
+    /**
+     * Generate, set, and return a random schema name.
+     */
+    setRandomSearchSchema: (arg1: string, callback: (err: NodeJS.ErrnoException, result: string) => void) => void;
+}
+export declare const init: (arg1: pg.PoolConfig, arg2: (error: Error, client: pg.PoolClient) => void, callback: (err: NodeJS.ErrnoException) => void) => void;
+export declare const initAsync: (pgConfig: pg.PoolConfig, idleErrorHandler: (error: Error, client: pg.PoolClient) => void) => Promise<void>;
+export declare const close: (callback: (err: NodeJS.ErrnoException) => void) => void;
+export declare const closeAsync: () => Promise<void>;
+export declare const getClientAsync: () => Promise<pg.PoolClient>;
+export declare const getClient: (callback: (error: Error | null, client?: pg.PoolClient, done?: () => void) => void) => void;
+export declare const queryWithClient: (arg1: pg.PoolClient, arg2: string, arg3: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const queryWithClientAsync: (client: pg.PoolClient, sql: string, params: Params) => Promise<pg.QueryResult>;
+export declare const queryWithClientOneRow: (arg1: pg.PoolClient, arg2: string, arg3: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const queryWithClientOneRowAsync: (client: pg.PoolClient, sql: string, params: Params) => Promise<pg.QueryResult>;
+export declare const queryWithClientZeroOrOneRow: (arg1: pg.PoolClient, arg2: string, arg3: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const queryWithClientZeroOrOneRowAsync: (client: pg.PoolClient, sql: string, params: Params) => Promise<QueryResult>;
+export declare const rollbackWithClientAsync: (client: pg.PoolClient) => Promise<void>;
+export declare const rollbackWithClient: (client: pg.PoolClient, _done: (release?: any) => void, callback: (err: Error | null) => void) => void;
+export declare const beginTransactionAsync: () => Promise<pg.PoolClient>;
+export declare const endTransactionAsync: (client: pg.PoolClient, err: Error | null | undefined) => Promise<void>;
+export declare const endTransaction: (client: pg.PoolClient, _done: (rollback?: any) => void, err: Error | null | undefined, callback: (error: Error | null) => void) => void;
+export declare const runInTransactionAsync: (fn: (client: pg.PoolClient) => Promise<void>) => Promise<void>;
+export declare const query: (arg1: string, arg2: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const queryAsync: (sql: string, params: Params) => Promise<QueryResult>;
+export declare const queryOneRow: (arg1: string, arg2: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const queryOneRowAsync: (sql: string, params: Params) => Promise<pg.QueryResult>;
+export declare const queryZeroOrOneRow: (arg1: string, arg2: Params, callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const queryZeroOrOneRowAsync: (sql: string, params: Params) => Promise<pg.QueryResult>;
+export declare const call: (arg1: string, arg2: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const callAsync: (functionName: string, params: any[]) => Promise<pg.QueryResult>;
+export declare const callOneRow: (arg1: string, arg2: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const callOneRowAsync: (functionName: string, params: any[]) => Promise<pg.QueryResult>;
+export declare const callZeroOrOneRow: (arg1: string, arg2: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const callZeroOrOneRowAsync: (functionName: string, params: any[]) => Promise<pg.QueryResult>;
+export declare const callWithClient: (arg1: pg.PoolClient, arg2: string, arg3: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const callWithClientAsync: (client: pg.PoolClient, functionName: string, params: any[]) => Promise<pg.QueryResult>;
+export declare const callWithClientOneRow: (arg1: pg.PoolClient, arg2: string, arg3: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const callWithClientOneRowAsync: (client: pg.PoolClient, functionName: string, params: any[]) => Promise<pg.QueryResult>;
+export declare const callWithClientZeroOrOneRow: (arg1: pg.PoolClient, arg2: string, arg3: any[], callback: (err: NodeJS.ErrnoException | null, result: pg.QueryResult<any>) => void) => void;
+export declare const callWithClientZeroOrOneRowAsync: (client: pg.PoolClient, functionName: string, params: any[]) => Promise<pg.QueryResult>;
+export declare const setSearchSchema: (schema: string) => Promise<void>;
+export declare const getSearchSchema: () => string | null;
+export declare const setRandomSearchSchema: (arg1: string, callback: (err: NodeJS.ErrnoException, result: string) => void) => void;
+export declare const setRandomSearchSchemaAsync: (prefix: string) => Promise<string>;
+export {};