@snowtop/ent 0.2.6 → 0.2.8

package/action/executor.js

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComplexExecutor = exports.ListBasedExecutor = void 0;
 exports.executeOperations = executeOperations;
-const graph_data_structure_1 = require("graph-data-structure");
 const ent_1 = require("../core/ent");
 const db_1 = __importDefault(require("../core/db"));
 const logger_1 = require("../core/logger");
+const topological_sort_1 = require("./topological_sort");
 const operations_1 = require("./operations");
 // private to ent
 class ListBasedExecutor {
@@ -123,7 +123,7 @@ class ComplexExecutor {
         this.executors = [];
         this.changedOps = new Map();
         this.builder = options?.builder;
-        const graph = new graph_data_structure_1.Graph();
+        const graph = new topological_sort_1.TopologicalGraph();
         const changesetMap = new Map();
         const impl = (c) => {
             changesetMap.set(c.placeholderID.toString(), c);
@@ -131,7 +131,7 @@ class ComplexExecutor {
             if (c.dependencies) {
                 for (let [_, builder] of c.dependencies) {
                     // dependency should go first...
-                    graph.addEdge(builder.placeholderID.toString(), c.placeholderID.toString(), 1);
+                    graph.addEdge(builder.placeholderID.toString(), c.placeholderID.toString());
                 }
             }
             if (c.changesets) {
@@ -156,7 +156,7 @@ class ComplexExecutor {
         // TODO: can this logic be rewritten to not have a set yet avoid duplicates?
         let nodeOps = new Set();
         let remainOps = new Set();
-        const sorted = (0, graph_data_structure_1.topologicalSort)(graph);
+        const sorted = graph.topologicalSort();
         sorted.forEach((node) => {
             let c = changesetMap.get(node);
             if (!c) {

package/action/operations.js

@@ -237,6 +237,9 @@ class EditNodeOperation {
             return `RETURNING ${this.options.loadEntOptions.fields
                 .map((f) => {
                 if (typeof f === "object") {
+                    if ("expression" in f) {
+                        throw new Error("RETURNING does not support computed select expressions");
+                    }
                     return `${f.alias}.${f.column}`;
                 }
                 return f;

package/action/orchestrator.js

@@ -32,9 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntChangeset = exports.Orchestrator = exports.edgeDirection = void 0;
 const ent_1 = require("../core/ent");
@@ -43,8 +40,8 @@ const operations_1 = require("./operations");
 const action_1 = require("../action");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
+const memoize_1 = require("../core/memoize");
 const logger_1 = require("../core/logger");
-const memoizee_1 = __importDefault(require("memoizee"));
 const clause = __importStar(require("../core/clause"));
 const types_1 = require("util/types");
 const operations_2 = require("./operations");
@@ -112,7 +109,7 @@ class Orchestrator {
         this.viewer = options.viewer;
         this.actualOperation = this.options.operation;
         this.existingEnt = this.options.builder.existingEnt;
-        this.memoizedGetFields = (0, memoizee_1.default)(this.getFieldsInfo.bind(this));
+        this.memoizedGetFields = (0, memoize_1.memoizeNoArgs)(this.getFieldsInfo.bind(this));
     }
     // don't type this because we don't care
     __getOptions() {
@@ -639,19 +636,20 @@ class Orchestrator {
                 for (const [k, field] of schemaFields) {
                     const inputKey = this.getInputKey(k);
                     const storageKey = this.getStorageKey(k);
-                    let val = transformed.data[inputKey];
-                    if (val === undefined) {
-                        val = transformed.data[storageKey];
+                    let inputVal = transformed.data[inputKey];
+                    if (inputVal === undefined) {
+                        inputVal = transformed.data[storageKey];
                     }
-                    if (val === undefined) {
+                    if (inputVal === undefined) {
                         continue;
                     }
+                    let dbVal = inputVal;
                     if (field.format) {
-                        val = field.format(transformed.data[k], true);
+                        dbVal = field.format(inputVal, true);
                     }
-                    data[this.getStorageKey(k)] = val;
+                    data[this.getStorageKey(k)] = dbVal;
                     if (!field.immutable) {
-                        this.defaultFieldsByTSName[this.getInputKey(k)] = val;
+                        this.defaultFieldsByTSName[this.getInputKey(k)] = inputVal;
                     }
                     // hmm do we need this?
                     // TODO how to do this for local tests?

package/action/topological_sort.d.ts

@@ -0,0 +1,9 @@
+type NodeID = string;
+export declare class TopologicalGraph {
+    private nodes;
+    private edges;
+    addNode(node: NodeID): void;
+    addEdge(from: NodeID, to: NodeID): void;
+    topologicalSort(): NodeID[];
+}
+export {};

package/action/topological_sort.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologicalGraph = void 0;
+class TopologicalGraph {
+    constructor() {
+        this.nodes = new Set();
+        this.edges = new Map();
+    }
+    addNode(node) {
+        this.nodes.add(node);
+        if (!this.edges.has(node)) {
+            this.edges.set(node, new Set());
+        }
+    }
+    addEdge(from, to) {
+        this.addNode(from);
+        this.addNode(to);
+        this.edges.get(from).add(to);
+    }
+    topologicalSort() {
+        const ordered = [];
+        const seen = new Map();
+        const visit = (node) => {
+            const state = seen.get(node);
+            if (state === 1) {
+                throw new Error("Cycle found");
+            }
+            if (state === 2) {
+                return;
+            }
+            seen.set(node, 1);
+            for (const target of this.edges.get(node) || []) {
+                visit(target);
+            }
+            seen.set(node, 2);
+            ordered.push(node);
+        };
+        for (const node of this.nodes) {
+            if (seen.get(node) !== 2) {
+                visit(node);
+            }
+        }
+        return ordered.reverse();
+    }
+}
+exports.TopologicalGraph = TopologicalGraph;

package/core/async_utils.d.ts

@@ -0,0 +1 @@
+export declare function mapWithConcurrency<T, U>(items: T[], limit: number, mapper: (item: T, index: number) => Promise<U>): Promise<U[]>;

package/core/async_utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapWithConcurrency = mapWithConcurrency;
+async function mapWithConcurrency(items, limit, mapper) {
+    if (!items.length) {
+        return [];
+    }
+    const results = new Array(items.length);
+    const concurrency = limit === Infinity
+        ? items.length
+        : Number.isFinite(limit) && limit > 0
+            ? Math.max(1, Math.floor(limit))
+            : 1;
+    let nextIndex = 0;
+    const workers = new Array(Math.min(concurrency, items.length))
+        .fill(null)
+        .map(async () => {
+        while (true) {
+            const currentIndex = nextIndex;
+            if (currentIndex >= items.length) {
+                return;
+            }
+            nextIndex += 1;
+            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/core/base.d.ts

@@ -1,6 +1,7 @@
 import * as clause from "./clause";
 import { ObjectLoaderFactory } from "./loaders";
 import { OrderBy } from "./query_impl";
+import { QueryExpression } from "./query_expression";
 export interface Loader<K, V> {
     context?: Context;
     load(key: K): Promise<V>;
@@ -26,7 +27,7 @@ export interface PrimableLoader<K, V> extends Loader<K, V> {
     prime(d: V): void;
     primeAll?(d: V): void;
 }
-export type QueryOptions = Required<Pick<LoadRowsOptions, "clause" | "fields" | "tableName">> & Pick<LoadRowsOptions, "orderby" | "join">;
+export type QueryOptions = Required<Pick<LoadRowsOptions, "clause" | "fields" | "tableName">> & Pick<LoadRowsOptions, "distinct" | "alias" | "fieldsAlias" | "disableFieldsAlias" | "disableDefaultOrderByAlias" | "groupby" | "orderby" | "join" | "limit" | "offset">;
 interface cache {
     getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
     getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
@@ -61,16 +62,22 @@ export interface EntConstructor<TEnt extends Ent, TViewer extends Viewer = Viewe
     new (viewer: TViewer, data: Data): TEnt;
 }
 export type ID = string | number;
+export interface SelectColumnField {
+    alias: string;
+    column: string;
+}
+export interface SelectExpressionField {
+    alias: string;
+    expression: QueryExpression;
+}
+export type SelectField = string | SelectColumnField | SelectExpressionField;
 export interface DataOptions {
     tableName: string;
     alias?: string;
     context?: Context;
 }
 export interface SelectBaseDataOptions extends DataOptions {
-    fields: (string | {
-        alias: string;
-        column: string;
-    })[];
+    fields: SelectField[];
     fieldsAlias?: string;
     disableFieldsAlias?: boolean;
     disableDefaultOrderByAlias?: boolean;

package/core/clause.d.ts

@@ -1,10 +1,7 @@
 import { Data, ID, SelectDataOptions } from "./base";
-export interface Clause<T extends Data = Data, K = keyof T> {
-    clause(idx: number, alias?: string): string;
+import { QueryExpression } from "./query_expression";
+export interface Clause<T extends Data = Data, K = keyof T> extends QueryExpression {
     columns(): K[];
-    values(): any[];
-    instanceKey(): string;
-    logValues(): any[];
     compositeOp?: string;
 }
 export interface SensitiveValue {
@@ -180,4 +177,5 @@ export declare function Modulo<T extends Data, K = keyof T>(col: K, value: any,
 export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Pick<SelectDataOptions, "clause">, cls: Clause<V, K>, checkIntersection?: boolean): Clause<V, K>;
 export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Pick<SelectDataOptions, "clause">, cls: Clause<V, K> | undefined, checkIntersection?: boolean): Clause<V, K> | undefined;
 export declare function Expression<T extends Data, K = keyof T>(expression: string): Clause<T, K>;
+export declare function ParameterizedExpression(key: string, expression: (idx: number, alias?: string) => string, values: any[], logValues?: any[]): QueryExpression;
 export {};

package/core/clause.js

@@ -92,6 +92,7 @@ exports.Divide = Divide;
 exports.Modulo = Modulo;
 exports.getCombinedClause = getCombinedClause;
 exports.Expression = Expression;
+exports.ParameterizedExpression = ParameterizedExpression;
 const db_1 = __importStar(require("./db"));
 const query_impl_1 = require("./query_impl");
 function isSensitive(val) {
@@ -256,6 +257,34 @@ class simpleExpression {
         return `${this.expression}`;
     }
 }
+class parameterizedExpression {
+    constructor(key, expression, params, logParams) {
+        this.key = key;
+        this.expression = expression;
+        this.params = params;
+        this.logParams = logParams;
+    }
+    clause(idx, alias) {
+        return this.expression(idx, alias);
+    }
+    values() {
+        return this.params.map((value) => rawValue(value));
+    }
+    logValues() {
+        if (this.logParams) {
+            return this.logParams;
+        }
+        return this.params.map((value) => {
+            if (isSensitive(value)) {
+                return value.logValue();
+            }
+            return value;
+        });
+    }
+    instanceKey() {
+        return this.key;
+    }
+}
 class arraySimpleClause {
     constructor(col, value, op, overrideAlias) {
         this.col = col;
@@ -1107,3 +1136,6 @@ function getCombinedClause(options, cls, checkIntersection = false) {
 function Expression(expression) {
     return new simpleExpression(expression);
 }
+function ParameterizedExpression(key, expression, values, logValues) {
+    return new parameterizedExpression(key, expression, values, logValues);
+}

package/core/config.d.ts

@@ -12,6 +12,14 @@ declare enum fieldPrivacyEvaluated {
     AT_ENT_LOAD = "at_ent_load",
     ON_DEMAND = "on_demand"
 }
+export interface RuntimeDBExtension {
+    name: string;
+    provisionedBy?: "ent" | "external";
+    version?: string;
+    installSchema?: string;
+    runtimeSchemas?: string[];
+    dropCascade?: boolean;
+}
 export interface Config {
     dbConnectionString?: string;
     dbFile?: string;
@@ -20,18 +28,36 @@ export interface Config {
     logQueryWithError?: boolean;
     defaultConnectionLimit?: number;
     loaderMaxBatchSize?: number;
+    clauseLoaderConcurrency?: number;
+    entLoaderPrivacyConcurrencyLimit?: number;
+    devSchema?: RuntimeDevSchemaConfig;
+    extensions?: RuntimeDBExtension[];
 }
-export interface ConfigWithCodegen extends Config {
+export interface ConfigWithCodegen extends Omit<Config, "devSchema"> {
     codegen?: CodegenConfig;
     databaseMigration?: DatabaseMigrationConfig;
     customGraphQLJSONPath?: string;
     dynamicScriptCustomGraphQLJSONPath?: string;
     globalSchemaPath?: string;
+    devSchema?: DevSchemaConfig;
 }
 interface DatabaseMigrationConfig {
     custom_sql_include?: string[];
     custom_sql_exclude?: string[];
 }
+export interface DevSchemaPruneConfig {
+    enabled?: boolean;
+    days?: number;
+}
+export interface RuntimeDevSchemaConfig {
+    enabled?: boolean;
+    schemaName?: string;
+    includePublic?: boolean;
+    ignoreBranches?: string[];
+}
+export interface DevSchemaConfig extends RuntimeDevSchemaConfig {
+    prune?: DevSchemaPruneConfig;
+}
 interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
     defaultActionPolicy?: PrivacyConfig;
@@ -68,5 +94,5 @@ interface importedObject {
     name: string;
     alias?: string;
 }
-export declare function loadConfig(file?: string | Buffer | Config): void;
+export declare function loadConfig(file?: string | Buffer | Config | ConfigWithCodegen): void;
 export {};

package/core/config.js

@@ -43,6 +43,7 @@ const db_1 = __importDefault(require("./db"));
 const path = __importStar(require("path"));
 const logger_1 = require("./logger");
 const ent_1 = require("./ent");
+const object_loader_1 = require("./loaders/object_loader");
 const loader_1 = require("./loaders/loader");
 // ent.config.ts eventually. for now ent.yml
 // or ent.yml?
@@ -65,11 +66,17 @@ function setConfig(cfg) {
     if (cfg.log) {
         (0, logger_1.setLogLevels)(cfg.log);
     }
-    if (cfg.dbConnectionString || cfg.dbFile || cfg.db) {
+    if (cfg.dbConnectionString ||
+        cfg.dbFile ||
+        cfg.db ||
+        cfg.devSchema ||
+        cfg.extensions) {
         db_1.default.initDB({
             connectionString: cfg.dbConnectionString,
             dbFile: cfg.dbFile,
             db: cfg.db,
+            devSchema: cfg.devSchema,
+            extensions: cfg.extensions,
         });
     }
     (0, ent_1.___setLogQueryErrorWithError)(cfg.logQueryWithError);
@@ -79,6 +86,12 @@ function setConfig(cfg) {
     if (cfg.loaderMaxBatchSize !== undefined) {
         (0, loader_1.setLoaderMaxBatchSize)(cfg.loaderMaxBatchSize);
     }
+    if (cfg.clauseLoaderConcurrency !== undefined) {
+        (0, object_loader_1.setClauseLoaderConcurrency)(cfg.clauseLoaderConcurrency);
+    }
+    if (cfg.entLoaderPrivacyConcurrencyLimit !== undefined) {
+        (0, ent_1.setEntLoaderPrivacyConcurrencyLimit)(cfg.entLoaderPrivacyConcurrencyLimit);
+    }
 }
 function isBuffer(b) {
     return b.write !== undefined;

package/core/context.d.ts

@@ -1,12 +1,15 @@
 import { IncomingMessage, ServerResponse } from "http";
 import { Data, Loader, LoaderWithLoadMany, QueryOptions, Viewer } from "./base";
 import { Context } from "./base";
+export declare function getContextCacheMaxDiscardedLoaders(): number;
+export declare function setContextCacheMaxDiscardedLoaders(size?: number | null): void;
 export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
     authViewer(viewer: TViewer): Promise<void>;
     logout(): Promise<void>;
     request: IncomingMessage;
     response: ServerResponse;
 }
+export declare function getContextCacheKey(options: QueryOptions): string;
 export declare class ContextCache {
     loaders: Map<string, Loader<any, any>>;
     loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>>;
@@ -15,7 +18,6 @@ export declare class ContextCache {
     getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
     private itemMap;
     private listMap;
-    private getkey;
     getCachedRows(options: QueryOptions): Data[] | null;
     getCachedRow(options: QueryOptions): Data | null;
     primeCache(options: QueryOptions, rows: Data[]): void;

package/core/context.js

@@ -1,8 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextCache = void 0;
+exports.getContextCacheMaxDiscardedLoaders = getContextCacheMaxDiscardedLoaders;
+exports.setContextCacheMaxDiscardedLoaders = setContextCacheMaxDiscardedLoaders;
+exports.getContextCacheKey = getContextCacheKey;
 const logger_1 = require("./logger");
+const cache_utils_1 = require("./cache_utils");
+const metrics_1 = require("./metrics");
 const query_impl_1 = require("./query_impl");
+const DEFAULT_MAX_DISCARDED_LOADERS = 1000;
+let maxDiscardedLoaders = DEFAULT_MAX_DISCARDED_LOADERS;
+function getContextCacheMaxDiscardedLoaders() {
+    return maxDiscardedLoaders;
+}
+function setContextCacheMaxDiscardedLoaders(size) {
+    if (size === undefined || size === null) {
+        maxDiscardedLoaders = DEFAULT_MAX_DISCARDED_LOADERS;
+        return;
+    }
+    if (!Number.isFinite(size) || size < 0) {
+        throw new Error(`maxDiscardedLoaders must be a non-negative number`);
+    }
+    maxDiscardedLoaders = Math.floor(size);
+}
+function getContextCacheKey(options) {
+    const parts = [
+        `fields:${(0, query_impl_1.getSelectFieldsKey)(options.fields)}`,
+        `clause:${options.clause.instanceKey()}`,
+    ];
+    if (options.distinct !== undefined) {
+        parts.push(`distinct:${options.distinct}`);
+    }
+    if (options.alias !== undefined) {
+        parts.push(`alias:${options.alias}`);
+    }
+    if (options.fieldsAlias !== undefined) {
+        parts.push(`fieldsAlias:${options.fieldsAlias}`);
+    }
+    if (options.disableFieldsAlias !== undefined) {
+        parts.push(`disableFieldsAlias:${options.disableFieldsAlias}`);
+    }
+    if (options.disableDefaultOrderByAlias !== undefined) {
+        parts.push(`disableDefaultOrderByAlias:${options.disableDefaultOrderByAlias}`);
+    }
+    if (options.groupby !== undefined) {
+        parts.push(`groupby:${options.groupby}`);
+    }
+    if (options.orderby) {
+        parts.push(`orderby:${(0, query_impl_1.getOrderByKey)(options.orderby)}`);
+    }
+    if (options.join) {
+        const joinKey = options.join.map((join) => ({
+            type: join.type ?? "inner",
+            tableName: join.tableName,
+            alias: join.alias,
+            clause: join.clause.instanceKey(),
+        }));
+        parts.push(`join:${(0, cache_utils_1.stableStringify)(joinKey)}`);
+    }
+    if (options.limit !== undefined) {
+        parts.push(`limit:${options.limit}`);
+    }
+    if (options.offset !== undefined) {
+        parts.push(`offset:${options.offset}`);
+    }
+    return parts.join(",");
+}
 class ContextCache {
     constructor() {
         this.loaders = new Map();
@@ -37,37 +100,24 @@ class ContextCache {
     }
     // tableName is ignored bcos already indexed on that
     // maybe we just want to store sql queries???
-    getkey(options) {
-        let parts = [
-            options.fields
-                .map((f) => {
-                if (typeof f === "object") {
-                    return `${f.alias}.${f.column}`;
-                }
-                return f;
-            })
-                .join(","),
-            options.clause.instanceKey(),
-        ];
-        if (options.orderby) {
-            parts.push((0, query_impl_1.getOrderByPhrase)(options.orderby));
-        }
-        if (options.join) {
-            parts.push((0, query_impl_1.getJoinInfo)(options.join).phrase);
-        }
-        return parts.join(",");
-    }
     getCachedRows(options) {
         let m = this.listMap.get(options.tableName);
         if (!m) {
             return null;
         }
-        const key = this.getkey(options);
+        const key = getContextCacheKey(options);
         let rows = m.get(key);
         if (rows) {
+            const hook = (0, metrics_1.getOnQueryCacheHit)();
+            if (hook) {
+                hook({
+                    tableName: options.tableName,
+                    key,
+                });
+            }
             (0, logger_1.log)("cache", {
                 "cache-hit": key,
-                "tableName": options.tableName,
+                tableName: options.tableName,
             });
         }
         return rows || null;
@@ -77,12 +127,19 @@ class ContextCache {
         if (!m) {
             return null;
         }
-        const key = this.getkey(options);
+        const key = getContextCacheKey(options);
         let row = m.get(key);
         if (row) {
+            const hook = (0, metrics_1.getOnQueryCacheHit)();
+            if (hook) {
+                hook({
+                    tableName: options.tableName,
+                    key,
+                });
+            }
             (0, logger_1.log)("cache", {
                 "cache-hit": key,
-                "tableName": options.tableName,
+                tableName: options.tableName,
             });
         }
         return row || null;
@@ -90,12 +147,12 @@ class ContextCache {
     primeCache(options, rows) {
         if (Array.isArray(rows)) {
             let m = this.listMap.get(options.tableName) || new Map();
-            m.set(this.getkey(options), rows);
+            m.set(getContextCacheKey(options), rows);
             this.listMap.set(options.tableName, m);
         }
         else {
             let m = this.itemMap.get(options.tableName) || new Map();
-            m.set(this.getkey(options), rows);
+            m.set(getContextCacheKey(options), rows);
             this.itemMap.set(options.tableName, m);
         }
     }
@@ -113,6 +170,13 @@ class ContextCache {
         this.loaderWithLoadMany.clear();
         this.itemMap.clear();
         this.listMap.clear();
+        if (maxDiscardedLoaders === 0) {
+            this.discardedLoaders = [];
+            return;
+        }
+        if (this.discardedLoaders.length > maxDiscardedLoaders) {
+            this.discardedLoaders = this.discardedLoaders.slice(-maxDiscardedLoaders);
+        }
     }
     /**
      * reset clears the cache and resets the discarded loaders

package/core/db.d.ts

@@ -1,4 +1,5 @@
 import { Pool, PoolClient, PoolConfig } from "pg";
+import type { RuntimeDBExtension, RuntimeDevSchemaConfig } from "./config";
 export interface Database extends PoolConfig {
     database?: string;
     user?: string;
@@ -17,12 +18,16 @@ interface DatabaseInfo {
     dialect: Dialect;
     config: PoolConfig;
     filePath?: string;
+    devSchema?: RuntimeDevSchemaConfig;
+    extensions?: RuntimeDBExtension[];
 }
 interface clientConfigArgs {
     connectionString?: string;
     dbFile?: string;
     db?: Database | DBDict;
     cfg?: PoolConfig;
+    devSchema?: RuntimeDevSchemaConfig;
+    extensions?: RuntimeDBExtension[];
 }
 export default class DB {
     db: DatabaseInfo;
@@ -112,7 +117,10 @@ export declare class Sqlite implements Connection, SyncClient {
 }
 export declare class Postgres implements Connection {
     private pool;
-    constructor(pool: Pool);
+    private ready?;
+    private closePromise?;
+    constructor(pool: Pool, ready?: Promise<void> | undefined);
+    private ensureReady;
     self(): this;
     newClient(): Promise<PostgresClient>;
     query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
@@ -122,7 +130,9 @@ export declare class Postgres implements Connection {
 }
 export declare class PostgresClient implements Client {
     private client;
-    constructor(client: PoolClient);
+    private ready?;
+    constructor(client: PoolClient, ready?: Promise<void> | undefined);
+    private ensureReady;
     query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
     queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
     exec(query: string, values?: any[]): Promise<ExecResult>;