litedbmodel 2.2.10 → 2.2.11

package/dist/index.cjs

@@ -3092,11 +3092,27 @@ function mysqlConnection(conn) {
     }
   };
 }
-function mysqlConnectionPool(pool) {
+function mysqlConnectionPool(pool, acquireTimeoutMillis) {
   const handles = /* @__PURE__ */ new WeakMap();
   return {
     async acquire() {
-      const raw = await pool.getConnection();
+      const pending = pool.getConnection();
+      const raw = acquireTimeoutMillis === void 0 ? await pending : await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.then((late) => late.release(), () => void 0);
+          reject(new Error(`timeout exceeded when trying to get a connection (${acquireTimeoutMillis} ms)`));
+        }, acquireTimeoutMillis);
+        pending.then(
+          (c) => {
+            clearTimeout(timer);
+            resolve(c);
+          },
+          (e) => {
+            clearTimeout(timer);
+            reject(e);
+          }
+        );
+      });
       const conn = mysqlConnection(raw);
       handles.set(conn, raw);
       return conn;
@@ -3121,6 +3137,9 @@ function pgPoolFactory(pg) {
       // SIZING (construction knob): the config is the sole source of the cap.
       max: config.maxPool,
       min: config.minPool,
+      // pg-pool bounds BOTH a new connection and the wait for a free one with this one limit.
+      connectionTimeoutMillis: config.connectTimeoutMillis,
+      idleTimeoutMillis: config.idleTimeoutMillis,
       // keepAlive (construction knob): TCP keepalive for serverless/long-idle connections.
       keepAlive: config.keepAlive,
       ...config.keepAlive ? { keepAliveInitialDelayMillis: config.keepAliveInitialDelayMillis } : {}
@@ -3138,12 +3157,15 @@ function mysqlPoolFactory(mysql2) {
       ...config.password !== void 0 ? { password: config.password } : {},
       // SIZING (construction knob): connectionLimit = maxPool (the sole source of the cap).
       connectionLimit: config.maxPool,
+      connectTimeout: config.connectTimeoutMillis,
+      idleTimeout: config.idleTimeoutMillis,
       // keepAlive (construction knob).
       enableKeepAlive: config.keepAlive,
       ...config.keepAlive ? { keepAliveInitialDelay: config.keepAliveInitialDelayMillis } : {},
       ...mysqlDeboxPoolOptions
     });
-    return { pool: mysqlConnectionPool(pool), close: () => pool.end() };
+    const acquireTimeout = config.connectTimeoutMillis > 0 ? config.connectTimeoutMillis : void 0;
+    return { pool: mysqlConnectionPool(pool, acquireTimeout), close: () => pool.end() };
   };
 }
 
@@ -3179,6 +3201,7 @@ function getPool(config) {
       password: config.password,
       max: config.max || 10,
       connectionTimeoutMillis: (config.timeout || 30) * 1e3,
+      idleTimeoutMillis: config.idleTimeoutMillis ?? 1e4,
       query_timeout: (config.queryTimeout || 30) * 1e3,
       keepAlive: config.keepAlive,
       keepAliveInitialDelayMillis: config.keepAliveInitialDelayMillis
@@ -3209,33 +3232,44 @@ function convertPlaceholders(sql2) {
   let index = 0;
   return sql2.replace(/\?/g, () => `$${++index}`);
 }
+var MAX_NAMED_STATEMENTS = 1e3;
+var MAX_UNNAMED_QUERIES = 1e3;
 var preparedStmtCounter = 0;
 var queryCache = /* @__PURE__ */ new Map();
+var unnamedQueries = /* @__PURE__ */ new Map();
 function resolveQuery(sql2) {
   let cached = queryCache.get(sql2);
-  if (!cached) {
-    const convertedSql = convertPlaceholders(sql2);
-    let isMulti = false;
-    let end = convertedSql.length - 1;
-    while (end >= 0 && (convertedSql[end] === " " || convertedSql[end] === "\n" || convertedSql[end] === "	" || convertedSql[end] === "\r")) end--;
-    if (end >= 0 && convertedSql[end] === ";") end--;
-    for (let i = 0; i <= end; i++) {
-      if (convertedSql[i] === ";") {
-        isMulti = true;
-        break;
-      }
-    }
-    cached = {
-      convertedSql,
-      isMulti,
-      name: `ldb_${++preparedStmtCounter}`
-    };
-    queryCache.set(sql2, cached);
+  if (cached) return cached;
+  cached = unnamedQueries.get(sql2);
+  if (cached) {
+    if (preparedStmtCounter < MAX_NAMED_STATEMENTS) {
+      unnamedQueries.delete(sql2);
+      cached.name = `ldb_${++preparedStmtCounter}`;
+      queryCache.set(sql2, cached);
+    }
+    return cached;
   }
+  const convertedSql = convertPlaceholders(sql2);
+  let isMulti = false;
+  let end = convertedSql.length - 1;
+  while (end >= 0 && (convertedSql[end] === " " || convertedSql[end] === "\n" || convertedSql[end] === "	" || convertedSql[end] === "\r")) end--;
+  if (end >= 0 && convertedSql[end] === ";") end--;
+  for (let i = 0; i <= end; i++) {
+    if (convertedSql[i] === ";") {
+      isMulti = true;
+      break;
+    }
+  }
+  cached = { convertedSql, isMulti };
+  if (unnamedQueries.size >= MAX_UNNAMED_QUERIES) {
+    unnamedQueries.delete(unnamedQueries.keys().next().value);
+  }
+  unnamedQueries.set(sql2, cached);
   return cached;
 }
 function clearQueryCache() {
   queryCache.clear();
+  unnamedQueries.clear();
   preparedStmtCounter = 0;
 }
 var PostgresConnection = class {
@@ -3581,6 +3615,7 @@ function getPool2(config) {
       waitForConnections: true,
       connectionLimit: config.max || 10,
       connectTimeout: (config.timeout || 30) * 1e3,
+      idleTimeout: config.idleTimeoutMillis ?? 1e4,
       // Read de-box (issue #9): make BIGINT arrive as an exact string (else mysql2 rounds it to a JS
       // number past 2^53) and the DATE/TIMESTAMP/DATETIME family arrive as its native textual string
       // (else a TZ-shifted JS Date) — the coercible forms `materializeCell` (int64/date) expects. Same
@@ -4277,6 +4312,8 @@ function resolveConnectionConfig(config = {}) {
     keepAliveInitialDelayMillis: config.keepAliveInitialDelayMillis ?? 1e4,
     minPool: config.minPool ?? 0,
     maxPool: config.maxPool ?? 10,
+    connectTimeoutMillis: config.connectTimeoutMillis ?? 3e4,
+    idleTimeoutMillis: config.idleTimeoutMillis ?? 1e4,
     ...config.searchPath !== void 0 ? { searchPath: config.searchPath } : {},
     ...config.charset !== void 0 ? { charset: config.charset } : {}
   };
@@ -4380,14 +4417,15 @@ var writerScopeStore = new import_node_async_hooks2.AsyncLocalStorage();
 function inWriterScope() {
   return writerScopeStore.getStore() === true;
 }
+function latestStamp(cell) {
+  let latest = null;
+  for (let c = cell; c; c = c.prev) {
+    if (c.at !== null && (latest === null || c.at > latest)) latest = c.at;
+  }
+  return latest;
+}
 var WriterStickyClock = class {
-  /**
-   * `null` until the first `mark()` — absence, NOT a value sentinel. The injectable clocks legitimately
-   * return 0 (a monotonic clock right after process start; rust's `SystemClock` does), so encoding
-   * "never marked" as the value 0 would mis-classify a `mark()` at clock t=0 as unmarked and leak the
-   * read-your-writes read to the reader replica. Absence must be distinct from the value 0.
-   */
-  lastWriteAt = null;
+  chain = new import_node_async_hooks2.AsyncLocalStorage();
   enabled;
   stickyDurationMs;
   /** Injectable clock (tests advance it); defaults to `Date.now`. */
@@ -4397,18 +4435,37 @@ var WriterStickyClock = class {
     this.stickyDurationMs = opts.writerStickyDuration ?? 5e3;
     this.now = opts.now ?? Date.now;
   }
-  /** Record that a write/commit just happened (the tx runtime calls this on success). */
+  /**
+   * Start tracking a transaction in the current chain: enters a fresh cell that carries the chain's
+   * latest stamp. Must run synchronously at the start of the transaction, before its first `await`.
+   */
+  begin() {
+    const current = this.chain.getStore();
+    let open = current ?? null;
+    while (open !== null && !open.open) open = open.prev;
+    const cell = { at: latestStamp(current), open: true, prev: open };
+    this.chain.enterWith(cell);
+    return cell;
+  }
+  /** The transaction that began `cell` is over (committed or not). */
+  end(cell) {
+    cell.open = false;
+  }
+  /** Record that the current chain just committed. */
   mark() {
-    if (this.enabled) this.lastWriteAt = this.now();
+    if (!this.enabled) return;
+    let cell = this.chain.getStore();
+    if (cell === void 0) {
+      cell = { at: null, open: false, prev: null };
+      this.chain.enterWith(cell);
+    }
+    cell.at = this.now();
   }
-  /** Is a read currently sticky-to-writer (within `writerStickyDuration` of the last write)? */
+  /** Is a read in the current chain sticky-to-writer (within `writerStickyDuration` of its last commit)? */
   isSticky() {
-    if (!this.enabled || this.lastWriteAt === null) return false;
-    return this.now() - this.lastWriteAt < this.stickyDurationMs;
-  }
-  /** Reset the clock (e.g. between tests / on `closeAllPools`). */
-  reset() {
-    this.lastWriteAt = null;
+    if (!this.enabled) return false;
+    const at = latestStamp(this.chain.getStore());
+    return at !== null && this.now() - at < this.stickyDurationMs;
   }
 };
 function resolvePool(intent, routing) {
@@ -4693,38 +4750,43 @@ async function withTransactionAsync(ctx, fn, opts = {}, dialect = "postgres", is
   const resolved = resolveTxOptions(opts);
   const begins = beginStatements(dialect, resolved.isolation);
   const pool = ctx.connectionPoolFor({ write: true, ...connection !== void 0 ? { db: connection } : {} });
-  let attempt = 0;
-  for (; ; ) {
-    attempt++;
-    const conn = await pool.acquire();
-    const txCtx = ctx.withConnection(conn, true);
-    let poisoned = false;
-    const attemptResult = await runWithPinnedAsyncConnection(conn, connection ?? null, async () => {
-      for (const begin of begins) await runAsync(txCtx, begin, []);
-      try {
-        const r = await runInTransactionScope(() => fn(txCtx));
-        await runAsync(txCtx, resolved.rollbackOnly ? "ROLLBACK" : "COMMIT", []);
-        return { ok: true, value: r };
-      } catch (error2) {
+  const stickyCell = ctx.stickyClock.begin();
+  try {
+    let attempt = 0;
+    for (; ; ) {
+      attempt++;
+      const conn = await pool.acquire();
+      const txCtx = ctx.withConnection(conn, true);
+      let poisoned = false;
+      const attemptResult = await runWithPinnedAsyncConnection(conn, connection ?? null, async () => {
+        for (const begin of begins) await runAsync(txCtx, begin, []);
         try {
-          await runAsync(txCtx, "ROLLBACK", []);
-        } catch {
-          poisoned = true;
+          const r = await runInTransactionScope(() => fn(txCtx));
+          await runAsync(txCtx, resolved.rollbackOnly ? "ROLLBACK" : "COMMIT", []);
+          return { ok: true, value: r };
+        } catch (error2) {
+          try {
+            await runAsync(txCtx, "ROLLBACK", []);
+          } catch {
+            poisoned = true;
+          }
+          return { ok: false, error: error2 };
         }
-        return { ok: false, error: error2 };
+      });
+      await pool.release(conn, poisoned || !attemptResult.ok);
+      if (attemptResult.ok) {
+        if (!resolved.rollbackOnly && resolved.useWriterAfterTransaction) ctx.stickyClock.mark();
+        return attemptResult.value;
       }
-    });
-    await pool.release(conn, poisoned || !attemptResult.ok);
-    if (attemptResult.ok) {
-      if (!resolved.rollbackOnly && resolved.useWriterAfterTransaction) ctx.stickyClock.mark();
-      return attemptResult.value;
-    }
-    const { error } = attemptResult;
-    if (resolved.retryOnError && attempt < resolved.retryLimit && isRetryableTxError(error, isConnectionError2)) {
-      await sleep(resolved.retryDuration * Math.pow(2, attempt - 1));
-      continue;
+      const { error } = attemptResult;
+      if (resolved.retryOnError && attempt < resolved.retryLimit && isRetryableTxError(error, isConnectionError2)) {
+        await sleep(resolved.retryDuration * Math.pow(2, attempt - 1));
+        continue;
+      }
+      throw error;
     }
-    throw error;
+  } finally {
+    ctx.stickyClock.end(stickyCell);
   }
 }
 function transaction(ctx, fn, options = {}, dialect = "postgres", isConnectionError2 = defaultIsConnectionError, connection) {
@@ -4857,11 +4919,13 @@ function compareCore(op, a, b) {
   if (typeof a === "bigint" && typeof b === "bigint")
     c = a < b ? -1 : a > b ? 1 : 0;
   else if (typeof a === "number" && typeof b === "number")
-    c = a < b ? -1 : a > b ? 1 : 0;
+    c = a < b ? -1 : a > b ? 1 : a === b ? 0 : null;
   else if (typeof a === "string" && typeof b === "string")
     c = cmpCodePoints(a, b);
   else
     fail("TYPE_MISMATCH", `${op}: \u540C\u4E00\u578B\u306E int/float/string \u306E\u307F\uFF08got ${typeName(a)}\xD7${typeName(b)}\uFF09`);
+  if (c === null)
+    return false;
   switch (op) {
     case "lt":
       return c < 0;
@@ -7203,6 +7267,8 @@ function toConnectionConfig(config) {
     ...config.user !== void 0 ? { user: config.user } : {},
     ...config.password !== void 0 ? { password: config.password } : {},
     ...config.max !== void 0 ? { maxPool: config.max } : {},
+    ...config.timeout !== void 0 ? { connectTimeoutMillis: config.timeout * 1e3 } : {},
+    ...config.idleTimeoutMillis !== void 0 ? { idleTimeoutMillis: config.idleTimeoutMillis } : {},
     ...config.keepAlive !== void 0 ? { keepAlive: config.keepAlive } : {},
     ...config.keepAliveInitialDelayMillis !== void 0 ? { keepAliveInitialDelayMillis: config.keepAliveInitialDelayMillis } : {}
   };
@@ -7480,52 +7546,46 @@ async function closeAllPools2() {
 
 // src/Middleware.ts
 var import_async_hooks = require("async_hooks");
-var Middleware = class {
-  /** AsyncLocalStorage for per-request instances */
-  static _storage;
-  /** Get or create storage for this class */
-  static getStorage() {
-    if (!this.hasOwnProperty("_storage") || !this._storage) {
-      this._storage = new import_async_hooks.AsyncLocalStorage();
-    }
-    return this._storage;
-  }
+var requestScope = new import_async_hooks.AsyncLocalStorage();
+var Middleware = class _Middleware {
   /**
-   * Get current request's instance.
-   * Creates a new instance on first access within a request.
+   * Get the current request's instance of this middleware. Inside a {@link Middleware.run} scope the
+   * instance is created on first access and shared by the rest of the scope; outside any scope each
+   * call gets a new instance that lives only for that call.
    */
   static getCurrentContext() {
-    const storage = this.getStorage();
-    let instance = storage.getStore();
+    const scope = requestScope.getStore();
+    let instance = scope?.get(this);
     if (!instance) {
       instance = new this();
-      storage.enterWith(instance);
+      instance.init?.();
+      scope?.set(this, instance);
     }
     return instance;
   }
   /**
-   * Run a function with a fresh middleware context.
-   * Useful for explicit context boundaries (e.g., in tests).
+   * Run `fn` as one request: the middleware instances `fn` uses (directly or through DBModel
+   * operations) are created inside the scope and are not shared with any other request. Call it at
+   * the request entry. `Middleware.run` gives every middleware a fresh instance; `X.run` gives `X` a
+   * fresh instance and keeps the enclosing scope's instances of the others.
    */
   static run(fn) {
-    const storage = this.getStorage();
-    const instance = new this();
-    return storage.run(instance, fn);
+    const enclosing = requestScope.getStore();
+    const scope = new Map(this === _Middleware || enclosing === void 0 ? [] : enclosing);
+    scope.delete(this);
+    return requestScope.run(scope, fn);
   }
   /**
-   * Check if currently in a context
+   * Check if the current request scope holds an instance of this middleware
    */
   static hasContext() {
-    return this.getStorage().getStore() !== void 0;
+    return requestScope.getStore()?.has(this) ?? false;
   }
   /**
-   * Clear current context (for testing)
+   * Drop this middleware's instance from the current request scope (for testing)
    */
   static clearContext() {
-    const storage = this.getStorage();
-    if (storage.getStore()) {
-      storage.enterWith(void 0);
-    }
+    requestScope.getStore()?.delete(this);
   }
 };
 function createMiddleware(config) {
@@ -8155,8 +8215,8 @@ var DBModel = class _DBModel {
     useWriterAfterTransaction: true,
     writerStickyDuration: 5e3
   };
-  /** Last transaction completion time (for writer sticky) */
-  static _lastTransactionTime = 0;
+  /** Writer-sticky clock of the v1 execution path (the SCP runtime carries its own in its routing). */
+  static _writerSticky = new WriterStickyClock();
   /**
    * The Phase A-E SCP runtime context (built lazily from `_dbConfig` for the live pg/mysql dialects).
    * `null` when not yet built; `false` when the config is sqlite / uninitialized (⇒ v1 in-proc path,
@@ -8194,6 +8254,8 @@ var DBModel = class _DBModel {
           ...config.user !== void 0 ? { user: config.user } : {},
           ...config.password !== void 0 ? { password: config.password } : {},
           ...config.max !== void 0 ? { max: config.max } : {},
+          ...config.timeout !== void 0 ? { timeout: config.timeout } : {},
+          ...config.idleTimeoutMillis !== void 0 ? { idleTimeoutMillis: config.idleTimeoutMillis } : {},
           ...config.keepAlive !== void 0 ? { keepAlive: config.keepAlive } : {},
           ...config.keepAliveInitialDelayMillis !== void 0 ? { keepAliveInitialDelayMillis: config.keepAliveInitialDelayMillis } : {},
           driver
@@ -8308,6 +8370,10 @@ var DBModel = class _DBModel {
       ...this._configOptions,
       ...options
     };
+    this._writerSticky = new WriterStickyClock({
+      useWriterAfterTransaction: this._configOptions.useWriterAfterTransaction,
+      writerStickyDuration: this._configOptions.writerStickyDuration
+    });
     this._resetScpRuntime();
   }
   /**
@@ -8380,12 +8446,9 @@ var DBModel = class _DBModel {
     }
   }
   /**
-   * Get a DBHandler instance for this model.
-   * Connection priority:
-   * 1. Transaction connection (if in transaction)
-   * 2. Writer context (if in withWriter())
-   * 3. Writer sticky (if within writerStickyDuration after transaction)
-   * 4. Default reader connection
+   * Get a DBHandler instance for this model: the transaction's handler inside a transaction, else the
+   * default handler (whose reads `execute()` sends to the writer inside `withWriter()` or while
+   * writer-sticky).
    */
   static getHandler() {
     const txContext = this._getTransactionContext().getStore();
@@ -8395,24 +8458,14 @@ var DBModel = class _DBModel {
       }
       return txContext.handler;
     }
-    const handler = getDBHandler();
-    if (this._getWriterContext().getStore()) {
-      return handler;
-    }
-    if (this._shouldUseWriterSticky()) {
-      return handler;
-    }
-    return handler;
+    return getDBHandler();
   }
   /**
-   * Check if we should use writer due to sticky after transaction.
+   * Check if this async chain should read from the writer because it committed a transaction within
+   * `writerStickyDuration` (read-your-writes for the request that wrote).
    */
   static _shouldUseWriterSticky() {
-    if (!this._configOptions.useWriterAfterTransaction) {
-      return false;
-    }
-    const stickyDuration = this._configOptions.writerStickyDuration ?? 5e3;
-    return Date.now() - this._lastTransactionTime < stickyDuration;
+    return this._writerSticky.isSticky();
   }
   /**
    * Get transaction context storage.
@@ -8467,8 +8520,11 @@ var DBModel = class _DBModel {
    * 
    * DBModel.use(LoggerMiddleware);
    * 
-   * // After queries
-   * console.log(LoggerMiddleware.getCurrentContext().getLogs());
+   * // One request
+   * await Middleware.run(async () => {
+   *   await handleRequest();
+   *   console.log(LoggerMiddleware.getCurrentContext().getLogs());
+   * });
    * ```
    */
   static use(MiddlewareClass) {
@@ -8517,7 +8573,7 @@ var DBModel = class _DBModel {
    * // Register
    * DBModel.use(TenantMiddleware);
    * 
-   * // Set tenant for current request (type-safe)
+   * // Set tenant for the current request (inside Middleware.run at the request entry, type-safe)
    * TenantMiddleware.getCurrentContext().tenantId = 123;
    * ```
    */
@@ -10318,8 +10374,7 @@ var DBModel = class _DBModel {
     }
     const rt = this._getScpRuntime();
     if (rt !== null && this._scpUsable()) {
-      const useWriterAfterTx = options.useWriterAfterTransaction ?? this._configOptions.useWriterAfterTransaction ?? true;
-      const result = await transaction(
+      return transaction(
         rt.ctx,
         () => {
           const sentinel = {
@@ -10331,8 +10386,6 @@ var DBModel = class _DBModel {
         options,
         rt.dialect
       );
-      if (useWriterAfterTx && !(options.rollbackOnly ?? false)) this._lastTransactionTime = Date.now();
-      return result;
     }
     const handler = this.getHandler();
     const retryOnError = options.retryOnError ?? true;
@@ -10340,38 +10393,41 @@ var DBModel = class _DBModel {
     const retryDuration = options.retryDuration ?? 200;
     const rollbackOnly = options.rollbackOnly ?? false;
     const useWriterAfterTransaction = options.useWriterAfterTransaction ?? this._configOptions.useWriterAfterTransaction ?? true;
-    let attempt = 0;
-    while (true) {
-      attempt++;
-      const connection = await handler.getConnection();
-      let destroyConnection = false;
-      try {
-        await connection.query("BEGIN");
-        const context = { connection };
-        const result = await txContext.run(context, func);
-        if (rollbackOnly) {
-          await connection.query("ROLLBACK");
-        } else {
-          await connection.query("COMMIT");
-          if (useWriterAfterTransaction) {
-            this._lastTransactionTime = Date.now();
-          }
-        }
-        return result;
-      } catch (error) {
-        destroyConnection = true;
+    const stickyCell = this._writerSticky.begin();
+    try {
+      let attempt = 0;
+      while (true) {
+        attempt++;
+        const connection = await handler.getConnection();
+        let destroyConnection = false;
         try {
-          await connection.query("ROLLBACK");
-        } catch {
-        }
-        if (retryOnError && attempt < retryLimit && this.isRetryableError(error)) {
-          await this.sleep(retryDuration * Math.pow(2, attempt - 1));
-          continue;
+          await connection.query("BEGIN");
+          const context = { connection };
+          const result = await txContext.run(context, func);
+          if (rollbackOnly) {
+            await connection.query("ROLLBACK");
+          } else {
+            await connection.query("COMMIT");
+            if (useWriterAfterTransaction) this._writerSticky.mark();
+          }
+          return result;
+        } catch (error) {
+          destroyConnection = true;
+          try {
+            await connection.query("ROLLBACK");
+          } catch {
+          }
+          if (retryOnError && attempt < retryLimit && this.isRetryableError(error)) {
+            await this.sleep(retryDuration * Math.pow(2, attempt - 1));
+            continue;
+          }
+          throw error;
+        } finally {
+          connection.release(destroyConnection || void 0);
         }
-        throw error;
-      } finally {
-        connection.release(destroyConnection || void 0);
       }
+    } finally {
+      this._writerSticky.end(stickyCell);
     }
   }
   /**
@@ -10512,7 +10568,10 @@ var DBModel = class _DBModel {
         writerStickyDuration: options?.writerStickyDuration ?? 5e3,
         ...options
       };
-      static _lastTransactionTime = 0;
+      static _writerSticky = new WriterStickyClock({
+        useWriterAfterTransaction: options?.useWriterAfterTransaction ?? true,
+        writerStickyDuration: options?.writerStickyDuration ?? 5e3
+      });
       // Phase F-2 (#105): this base class gets its OWN SCP runtime slot (built lazily from ITS config),
       // isolated from DBModel's default-config runtime and from other base classes — otherwise a
       // sqlite/mysql base would inherit DBModel's shared pg runtime and route its SQL to the wrong DB.