patch pg to handle non-UTC timestamps automatically.

- this helps a lot when the server is running on a non-UTC timezone

Author: williamstein

src/packages/database/pool/cached.ts

@@ -24,8 +24,7 @@ of multiple projects.
 
 import { reuseInFlight } from "@cocalc/util/reuse-in-flight";
 import LRU from "lru-cache";
-import { Pool } from "pg";
-
+import { type Pool } from "pg";
 import getLogger from "@cocalc/backend/logger";
 import getPool from "./pool";
 

src/packages/database/pool/pg-utc-normalize.ts

@@ -0,0 +1,69 @@
+// see https://chatgpt.com/share/68c2df30-1f30-800e-94de-38fbbcdc88bd
+// Basically this ensures input Date objects are formated as iso strings,
+// so they are interpreted as UTC time properly. The root cause is that
+// our database schema uses "timestamp without timezone" everywhere, and
+// it would be painful to migrate everything.   ANY query using
+// pool.query('...', params)
+// that potentially has Date's in params should pass the params through normalizeParams.
+// This is taken care of automatically in getPool and the db class.
+
+import type { Pool, QueryConfig } from "pg";
+
+function normalizeValue(v: any): any {
+  if (v instanceof Date) return v.toISOString();
+  if (Array.isArray(v)) return v.map(normalizeValue);
+  return v;
+}
+
+export function normalizeValues(values?: any[]): any[] | undefined {
+  return Array.isArray(values) ? values.map(normalizeValue) : values;
+}
+
+function normalizeQueryArgs(args: any[]): any[] {
+  // Forms:
+  // 1) query(text)
+  // 2) query(text, values)
+  // 3) query(text, values, callback)
+  // 4) query(config)
+  // 5) query(config, callback)
+  if (typeof args[0] === "string") {
+    if (Array.isArray(args[1])) {
+      const v = normalizeValues(args[1]);
+      if (args.length === 2) return [args[0], v];
+      // callback in position 2
+      return [args[0], v, args[2]];
+    }
+    // only text (or text, callback)
+    return args;
+  } else {
+    // config object path
+    const cfg: QueryConfig = { ...args[0] };
+    if ("values" in cfg && Array.isArray(cfg.values)) {
+      cfg.values = normalizeValues(cfg.values)!;
+    }
+    if (args.length === 1) return [cfg];
+    return [cfg, args[1]]; // callback passthrough
+  }
+}
+
+export function patchPoolForUtc(pool: Pool): Pool {
+  if ((pool as any).__utcNormalized) return pool;
+
+  // Patch pool.query
+  const origPoolQuery = pool.query.bind(pool);
+  (pool as any).query = function (...args: any[]) {
+    return origPoolQuery(...normalizeQueryArgs(args));
+  } as typeof pool.query;
+
+  pool.on("connect", (client) => {
+    if ((client as any).__utcNormalized) return;
+    const origQuery = client.query.bind(client);
+    client.query = function (...args: any[]) {
+      return origQuery(...normalizeQueryArgs(args));
+    } as typeof client.query;
+    (client as any).__utcNormalized = true;
+  });
+
+  (pool as any).__utcNormalized = true;
+  return pool;
+}

src/packages/database/pool/pool.ts

@@ -17,11 +17,10 @@ import getCachedPool, { CacheTime } from "./cached";
 import dbPassword from "./password";
 import { types } from "pg";
 export * from "./util";
-
+import { patchPoolForUtc } from "./pg-utc-normalize";
 
 const L = getLogger("db:pool");
 
-
 let pool: Pool | undefined = undefined;
 
 // This makes it so when we read dates out, if they are in a "timestamp with no timezone" field in the
@@ -48,6 +47,9 @@ export default function getPool(cacheTime?: CacheTime): Pool {
       options: "-c timezone=UTC", // ← make the session time zone UTC
     });
 
+    // make Dates always UTC ISO going in
+    patchPoolForUtc(pool);
+
     pool.on("error", (err: Error) => {
       L.debug("WARNING: Unexpected error on idle client in PG pool", {
         err: err.message,
@@ -114,6 +116,8 @@ export async function initEphemeralDatabase({
     ssl,
     options: "-c timezone=UTC", // ← make the session time zone UTC
   });
+  patchPoolForUtc(db);
+
   db.on("error", (err: Error) => {
     L.debug("WARNING: Unexpected error on idle client in PG pool", {
       err: err.message,

src/packages/database/postgres-base.coffee

@@ -41,6 +41,8 @@ winston      = require('@cocalc/backend/logger').getLogger('postgres')
 { quoteField } = require('./postgres/schema/util')
 { primaryKey, primaryKeys } = require('./postgres/schema/table')
 
+{ normalizeValues } = require('./pool/pg-utc-normalize')
+
 misc_node = require('@cocalc/backend/misc_node')
 { sslConfigToPsqlEnv, pghost, pgdatabase, pguser, pgssl } = require("@cocalc/backend/data")
 
@@ -818,7 +820,7 @@ class exports.PostgreSQL extends EventEmitter    # emits a 'connect' event whene
                 dbg("run query with specific postgres parameters in a transaction")
                 do_query_with_pg_params(client: client, query: opts.query, params: opts.params, pg_params:opts.pg_params, cb: query_cb)
             else
-                client.query(opts.query, opts.params, query_cb)
+                client.query(opts.query, normalizeValues(opts.params), query_cb)
 
         catch e
             # this should never ever happen

src/packages/database/postgres/set-pg-params.ts

@@ -8,6 +8,7 @@
 
 import { Client } from "pg";
 import { getLogger } from "@cocalc/backend/logger";
+import { normalizeValues } from "../pool/pg-utc-normalize";
 
 const L = getLogger("db:set-pg-params").debug;
 
@@ -33,7 +34,7 @@ export async function do_query_with_pg_params(opts: Opts): Promise<void> {
       L(`Setting query param: ${k}=${v}`);
       await client.query(q);
     }
-    const res = await client.query(query, params);
+    const res = await client.query(query, normalizeValues(params));
     await client.query("COMMIT");
     cb(undefined, res);
   } catch (err) {