fix(driver-sql): Field.date NOW() default reads the UTC calendar day on PG/MySQL (#4022) (#4026)

Two follow-ups from the #3994 line:

1. Field.date + defaultValue NOW() emitted a bare CURRENT_TIMESTAMP default,
   which resolves the calendar day in the SERVER's timezone on Postgres —
   measured: a UTC-12 server recorded yesterday's date; an Asia/Shanghai
   server records tomorrow for every default after 16:00 UTC. MySQL 8.0
   additionally rejects the bare default on a DATE column outright (MariaDB
   is merely permissive, and the driver's UTC-pinned session masked the
   semantic half there). nowColumnDefault now emits a UTC expression default
   on both dialects — timezone('utc', now())::date on Postgres,
   (cast(utc_timestamp() as date)) on MySQL — the #3994 D-C3 construction
   one type over. Defaults only govern newly created columns (D-B3 policy).
   Live tests pin the expression and a defaulted-insert round-trip.

2. marketplace-install-local-seed-lookup.test.ts: 30s → 120s timeout. The
   test cold-imports the real @objectstack/runtime on purpose; under a fully
   parallel turbo run that import stalls on core contention and the 30s cap
   produced recurring false reds (observed 3x, passes standalone). A genuine
   hang still fails, just later.

Closes #4022


Claude-Session: https://claude.ai/code/session_01TPxNwPnjcn599ujXpU3ibJ

Co-authored-by: Claude <noreply@anthropic.com>

Author: os-zhuang

.changeset/date-now-default-utc.md

@@ -0,0 +1,15 @@
+---
+"@objectstack/driver-sql": patch
+---
+
+fix(driver-sql): `Field.date` + `defaultValue: 'NOW()'` records the UTC calendar day on Postgres/MySQL (#4022)
+
+The bare `CURRENT_TIMESTAMP` default resolved the calendar day in the SERVER's
+timezone on Postgres — measured: a UTC-12 server recorded yesterday; an
+Asia/Shanghai server records tomorrow for every default after 16:00 UTC — and
+MySQL 8.0 rejects it on a DATE column outright (MariaDB is merely permissive,
+and the driver's UTC-pinned session masked the semantic half there).
+`nowColumnDefault` now emits a UTC expression default on both dialects, the
+#3994 D-C3 construction one type over. Defaults only govern newly created
+columns; existing columns keep their legacy default, per the standing D-B3
+policy.

docs/adr/0053-date-and-datetime-semantics.md

@@ -643,6 +643,15 @@ canonical `.000` trim on SQLite, `timezone('utc', now())::time(3)` on Postgres,
 `(cast(utc_timestamp(3) as time(3)))` on MySQL (8.0.13+/MariaDB 10.2+ for the
 expression-default syntax) — all reading the UTC clock.
 
+The same construction closes the `Field.date` half of the gap (#4022):
+`nowColumnDefault('date')` emits `timezone('utc', now())::date` on Postgres and
+`(cast(utc_timestamp() as date))` on MySQL. Measured: the bare
+`CURRENT_TIMESTAMP` default recorded YESTERDAY's calendar day on a UTC-12
+Postgres server, and MySQL 8.0 rejects it on a DATE column outright (the
+driver's UTC-pinned session masked the semantic half on MariaDB). Legacy
+columns keep their old default — defaults only govern newly created columns,
+the standing policy since D-B3.
+
 The D-B3 caveat applies unchanged: the backfill converges *shapes*; a wall
 clock the old path never recorded correctly (a pg `Date` bind serialised in the
 host's zone) is not recoverable. Regression cover:

packages/cloud-connection/src/marketplace-install-local-seed-lookup.test.ts

@@ -192,8 +192,11 @@ afterEach(() => { rmSync(dir, { recursive: true, force: true }); vi.restoreAllMo
 describe('marketplace install — seed lookup resolution', () => {
     // Generous timeout: the install handler dynamically imports the real
     // @objectstack/runtime (unmocked on purpose), and that cold import alone
-    // can eat several seconds on a fresh CI runner.
-    it('writes target record ids (never raw externalId strings) for package objects unknown to the metadata service', { timeout: 30_000 }, async () => {
+    // can eat several seconds on a fresh CI runner — and multiples of that
+    // under a fully parallel turbo run, where this test competes with every
+    // other package's suite for cores. 30s was observed flaking exactly that
+    // way (an import stall, not a hang); a genuine hang still fails, just later.
+    it('writes target record ids (never raw externalId strings) for package objects unknown to the metadata service', { timeout: 120_000 }, async () => {
         const { engine, store, registry } = makeEngine();
         const rawApp = makeRawApp();
         const { ctx, fire } = makeCtx(rawApp, {

packages/plugins/driver-sql/src/sql-driver-date-now-default-live.test.ts

@@ -0,0 +1,90 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * #4022 — `Field.date` + `defaultValue: 'NOW()'` on live Postgres and MySQL.
+ *
+ * The bare `CURRENT_TIMESTAMP` default `knex.fn.now()` emits resolves the
+ * calendar day in the SERVER's timezone on Postgres — measured: with the server
+ * at UTC-12, a defaulted insert on UTC's 2026-07-30 stored `2026-07-29`. On an
+ * Asia/Shanghai production server every default after 16:00 UTC records
+ * TOMORROW. MySQL 8.0 rejects the bare default on a DATE column outright
+ * (MariaDB is merely permissive, and the driver's UTC-pinned session masked
+ * the semantic half there).
+ *
+ * The fix is an expression default reading the UTC clock (`nowColumnDefault`),
+ * the #3994 D-C3 construction one type over. The wrong-day scenario cannot be
+ * asserted deterministically in CI (it depends on the time of day relative to
+ * the server's offset), so these tests pin the two things that CAN be:
+ * the DDL builds — which on MySQL 8.0 is itself the compatibility fix — with a
+ * default expression that spells `utc`, and a defaulted insert round-trips a
+ * valid calendar day.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SqlDriver } from '../src/index.js';
+
+const PG_URL = process.env.OS_TEST_POSTGRES_URL;
+const MY_URL = process.env.OS_TEST_MYSQL_URL;
+const TABLE = 'os4022_probe';
+
+const SHAPE = {
+  name: TABLE,
+  fields: {
+    label: { type: 'string' },
+    due_on: { type: 'date', defaultValue: 'NOW()' },
+  },
+} as any;
+
+function suite(dialect: 'pg' | 'mysql', url: string | undefined) {
+  describe.skipIf(!url)(`Field.date NOW() default on live ${dialect} (#4022)`, () => {
+    let driver: SqlDriver;
+
+    beforeEach(async () => {
+      driver = new SqlDriver(
+        dialect === 'pg'
+          ? { client: 'pg', connection: url }
+          : { client: 'mysql2', connection: url },
+      );
+      await driver.execute(`drop table if exists ${TABLE}`).catch(() => {});
+      await driver.initObjects([SHAPE]);
+    });
+
+    afterEach(async () => {
+      await driver.execute(`drop table if exists ${TABLE}`).catch(() => {});
+      await driver.disconnect();
+    });
+
+    it('builds with a UTC expression default, not a bare CURRENT_TIMESTAMP', async () => {
+      // On MySQL 8.0 reaching this line at all is the compatibility half of the
+      // fix — the bare default fails CREATE TABLE there.
+      const res: any = await driver.execute(
+        dialect === 'pg'
+          ? `select column_default as d from information_schema.columns
+             where table_name = '${TABLE}' and column_name = 'due_on'`
+          : `select column_default as d from information_schema.columns
+             where table_schema = database() and table_name = ? and column_name = 'due_on'`,
+        dialect === 'pg' ? [] : [TABLE],
+      );
+      const rows = Array.isArray(res) && Array.isArray(res[0]) ? res[0] : (res?.rows ?? res);
+      const def = String((rows[0] as any).d ?? (rows[0] as any).D ?? '').toLowerCase();
+      expect(def).toContain('utc');
+      expect(def).not.toBe('current_timestamp');
+    });
+
+    it('a defaulted insert round-trips a valid canonical calendar day', async () => {
+      await driver.create(TABLE, { id: 'x', label: 'x' }, { bypassTenantAudit: true });
+      const row: any = await driver.findOne(TABLE, 'x', { bypassTenantAudit: true });
+      expect(String(row.due_on)).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+      // The UTC calendar day only ever differs from this probe's own UTC clock
+      // across a midnight boundary — accept today or the day either side rather
+      // than flake at 00:00, while still catching a ±12h zone leak on any run
+      // that is not within a day-boundary race.
+      const utcToday = Date.parse(new Date().toISOString().slice(0, 10));
+      const stored = Date.parse(String(row.due_on));
+      expect(Math.abs(stored - utcToday)).toBeLessThanOrEqual(24 * 3600 * 1000);
+    });
+  });
+}
+
+suite('pg', PG_URL);
+suite('mysql', MY_URL);

packages/plugins/driver-sql/src/sql-driver.ts

@@ -5109,6 +5109,18 @@ export class SqlDriver implements IDataDriver {
         if (this.isMysql) return this.knex.raw('(cast(utc_timestamp(3) as time(3)))');
         if (this.isPostgres) return this.knex.raw("(timezone('utc', now())::time(3))");
       }
+      // `date` has the same two problems one type over (#4022): a bare
+      // CURRENT_TIMESTAMP default resolves the calendar day in the SERVER's
+      // timezone on Postgres (measured: a UTC-12 server records YESTERDAY),
+      // and MySQL 8.0 rejects it on a DATE column outright (MariaDB is merely
+      // permissive; the driver's UTC-pinned session masked the semantic half
+      // there). Same fix as `time`: an expression default reading the UTC
+      // clock, which is also what `formatInput`'s NOW() safety-net and the
+      // SQLite branch below store.
+      if (type === 'date') {
+        if (this.isMysql) return this.knex.raw('(cast(utc_timestamp() as date))');
+        if (this.isPostgres) return this.knex.raw("(timezone('utc', now())::date)");
+      }
       return this.knex.fn.now();
     }
     switch (type) {