fix(core): normalize scheduledAt to UTC in content.schedule() (#2913)

* fix(core): normalize scheduledAt to UTC in content.schedule()

content.schedule() stored the caller-supplied scheduledAt string
verbatim, even though it already parses it into a Date for validation.
findReadyToPublish() compares scheduled_at against
new Date().toISOString() (always UTC/"Z") using plain string
ordering, so a non-UTC offset (e.g. "+09:00") sorts incorrectly and
the item publishes up to that many hours late (or early, for offsets
ahead of UTC).

Reuses the already-validated scheduledDate and stores
scheduledDate.toISOString() instead of the raw input.

Fixes #2896

* fix(core): normalize scheduledAt in update() and replaceDraftRevisionForUpdate() too

Per review: schedule() normalized scheduledAt to UTC, but the sibling
write paths in update() and replaceDraftRevisionForUpdate() still
stored UpdateContentInput.scheduledAt verbatim, leaving the same
late/early-publish bug reachable through any caller that reaches
those methods with a non-UTC offset.

Extracts a private normalizeScheduledAt() helper (validates and
normalizes, passing null through for unschedule-via-update) and
applies it at both remaining write sites. Also added regression tests
for update() (offset normalization, null clears the field, invalid
string still rejected) and reworded the changeset to describe the
user-facing behavior rather than internal mechanics, per review.

replaceDraftRevisionForUpdate() has no existing unit-test scaffold in
this file (only reachable via updateDraftAware(), which needs a
revisions-enabled collection fixture not currently set up in this
suite) and this environment can't run the test suite to validate a
new one, so no test was added for that path specifically — flagging
this explicitly rather than guessing.

* style: format

* test(core): assert normalized schedule timestamps

* test(core): cover UTC scheduling boundaries

---------

Co-authored-by: emdashbot[bot] <emdashbot[bot]@users.noreply.github.com>
Co-authored-by: Matt Kane <mkane@cloudflare.com>

Author: 3 people

.changeset/schedule-utc-normalization.md

@@ -0,0 +1,5 @@
+---
+"emdash": patch
+---
+
+Fixes `content.schedule()` and content updates so offset dates are stored as canonical UTC ISO 8601 timestamps. Positive and negative offsets now publish at the represented instant instead of several hours late or early.

packages/core/src/database/repositories/content.ts

@@ -847,6 +847,15 @@ export class ContentRepository {
 		return mappedResult;
 	}
 
+	private normalizeScheduledAt(value: string | null): string | null {
+		if (value === null) return null;
+		const scheduledDate = new Date(value);
+		if (isNaN(scheduledDate.getTime())) {
+			throw new EmDashValidationError("Invalid scheduled date");
+		}
+		return scheduledDate.toISOString();
+	}
+
 	/**
 	 * Update content
 	 */
@@ -871,7 +880,7 @@ export class ContentRepository {
 		}
 
 		if (input.scheduledAt !== undefined) {
-			updates.scheduled_at = input.scheduledAt;
+			updates.scheduled_at = this.normalizeScheduledAt(input.scheduledAt);
 		}
 
 		if (input.authorId !== undefined) {
@@ -1030,7 +1039,7 @@ export class ContentRepository {
 			liveMetadataChanged = true;
 		}
 		if (input.scheduledAt !== undefined) {
-			assignments.push(sql`scheduled_at = ${input.scheduledAt}`);
+			assignments.push(sql`scheduled_at = ${this.normalizeScheduledAt(input.scheduledAt)}`);
 			liveMetadataChanged = true;
 		}
 		if (input.authorId !== undefined) {
@@ -1546,10 +1555,11 @@ export class ContentRepository {
 		// transition to 'scheduled' so they aren't visible before the time.
 		const newStatus = existing.status === "published" ? "published" : "scheduled";
 
+		// The due query compares ISO strings, so every stored schedule uses the same UTC form.
 		await sql`
 			UPDATE ${sql.ref(tableName)}
 			SET status = ${newStatus},
-				scheduled_at = ${scheduledAt},
+				scheduled_at = ${scheduledDate.toISOString()},
 				updated_at = ${now}
 			WHERE id = ${id}
 			AND deleted_at IS NULL

packages/core/tests/integration/cli/cli.test.ts

@@ -275,11 +275,11 @@ describe("CLI Integration", () => {
 			);
 
 			// Schedule does not produce JSON output, just a success message
-			await cli("content", "schedule", "posts", item.id, "--at", "2027-06-01T09:00:00Z");
+			await cli("content", "schedule", "posts", item.id, "--at", "2027-06-01T04:00:00-05:00");
 
 			// Verify via get
 			const fetched = await cliJson<{ scheduledAt: string }>("content", "get", "posts", item.id);
-			expect(fetched.scheduledAt).toBe("2027-06-01T09:00:00Z");
+			expect(fetched.scheduledAt).toBe("2027-06-01T09:00:00.000Z");
 
 			// Clean up
 			await cli("content", "delete", "posts", item.id);

packages/core/tests/integration/client/client.test.ts

@@ -322,11 +322,11 @@ describe("EmDashClient Integration", () => {
 		});
 
 		// Schedule for a future date
-		await ctx.client.schedule("posts", item.id, { at: "2027-06-01T09:00:00Z" });
+		await ctx.client.schedule("posts", item.id, { at: "2027-06-01T18:00:00+09:00" });
 
 		// Verify via get
 		const fetched = await ctx.client.get("posts", item.id);
-		expect(fetched.scheduledAt).toBe("2027-06-01T09:00:00Z");
+		expect(fetched.scheduledAt).toBe("2027-06-01T09:00:00.000Z");
 
 		// Trash and restore
 		await ctx.client.delete("posts", item.id);

packages/core/tests/unit/database/repositories/content.test.ts

@@ -1,5 +1,5 @@
 import type { Kysely } from "kysely";
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 
 import { ContentRepository } from "../../../../src/database/repositories/content.js";
 import { RevisionRepository } from "../../../../src/database/repositories/revision.js";
@@ -21,6 +21,7 @@ describe("ContentRepository", () => {
 	});
 
 	afterEach(async () => {
+		vi.useRealTimers();
 		await teardownTestDatabase(db);
 	});
 
@@ -319,6 +320,51 @@ describe("ContentRepository", () => {
 			expect(updated.updatedAt).not.toBe(created.updatedAt);
 		});
 
+		it("should normalize a non-UTC scheduledAt offset", async () => {
+			const input = createPostFixture();
+			const created = await repo.create(input);
+
+			const updated = await repo.update("post", created.id, {
+				scheduledAt: "2099-01-01T21:00:00+09:00",
+			});
+
+			expect(updated.scheduledAt).toBe("2099-01-01T12:00:00.000Z");
+		});
+
+		it("should normalize scheduledAt when staging a draft-aware update", async () => {
+			const created = await repo.create(createPostFixture());
+
+			const updated = await repo.updateDraftAware("post", created.id, {
+				data: { title: "Scheduled revision" },
+				scheduledAt: "2099-01-01T07:00:00-05:00",
+			});
+
+			expect(updated.draftRevisionId).not.toBeNull();
+			expect(updated.scheduledAt).toBe("2099-01-01T12:00:00.000Z");
+		});
+
+		it("should clear scheduledAt when set to null", async () => {
+			const input = createPostFixture();
+			const created = await repo.create(input);
+			const future = new Date(Date.now() + 86_400_000).toISOString();
+			await repo.update("post", created.id, { scheduledAt: future });
+
+			const updated = await repo.update("post", created.id, {
+				scheduledAt: null,
+			});
+
+			expect(updated.scheduledAt).toBeNull();
+		});
+
+		it("should reject an invalid scheduledAt string", async () => {
+			const input = createPostFixture();
+			const created = await repo.create(input);
+
+			await expect(repo.update("post", created.id, { scheduledAt: "not-a-date" })).rejects.toThrow(
+				EmDashValidationError,
+			);
+		});
+
 		it("should throw error for non-existent content", async () => {
 			await expect(repo.update("post", "01J9FAKE0000000000000000", { data: {} })).rejects.toThrow(
 				"Content not found",
@@ -448,6 +494,22 @@ describe("ContentRepository", () => {
 				EmDashValidationError,
 			);
 		});
+
+		it.each([
+			["positive", "2030-01-01T21:00:00+09:00"],
+			["negative", "2030-01-01T07:00:00-05:00"],
+		])("should publish a %s offset at the represented instant", async (_offset, scheduledAt) => {
+			vi.useFakeTimers({ now: new Date("2030-01-01T11:00:00.000Z") });
+			const post = await repo.create(createPostFixture());
+			const updated = await repo.schedule("post", post.id, scheduledAt);
+			expect(updated.scheduledAt).toBe("2030-01-01T12:00:00.000Z");
+
+			vi.setSystemTime(new Date("2030-01-01T11:59:59.999Z"));
+			expect(await repo.findReadyToPublish("post")).toEqual([]);
+
+			vi.setSystemTime(new Date("2030-01-01T12:00:00.000Z"));
+			expect((await repo.findReadyToPublish("post")).map((item) => item.id)).toEqual([post.id]);
+		});
 	});
 
 	describe("unschedule()", () => {