Update test files to use Temporal types

Co-authored-by: bcho <1975118+bcho@users.noreply.github.com>

Author: Copilot

sdks/typescript/src/sqlite-connection.ts

@@ -229,12 +229,17 @@ function decodeColumnValue<V = any>(args: {
   }
 
   if (columnTypeName === "datetime") {
-    if (typeof value !== "number") {
-      throw new Error(
-        `Expected datetime column ${columnName} to be a number, got ${typeof value}`
-      );
+    if (typeof value === "string") {
+      // Handle ISO string format
+      return Temporal.Instant.from(value) as V;
+    }
+    if (typeof value === "number") {
+      // Handle epoch milliseconds format
+      return Temporal.Instant.fromEpochMilliseconds(value) as V;
     }
-    return Temporal.Instant.fromEpochMilliseconds(value) as V;
+    throw new Error(
+      `Expected datetime column ${columnName} to be a string or number, got ${typeof value}`
+    );
   }
 
   // For other types, return as is

sdks/typescript/test/basic.test.ts

@@ -8,7 +8,7 @@ import {
   vi,
 } from "vitest";
 import { createTestAbsurd, randomName, type TestContext } from "./setup.js";
-import type { Absurd } from "../src/index.js";
+import { Temporal, type Absurd } from "../src/index.js";
 import { EventEmitter, once } from "events";
 
 describe("Basic SDK Operations", () => {
@@ -170,7 +170,7 @@ describe("Basic SDK Operations", () => {
       const scheduledRun = await ctx.getRun(runID);
       expect(scheduledRun).toMatchObject({
         state: "sleeping",
-        available_at: wakeAt,
+        available_at: Temporal.Instant.fromEpochMilliseconds(wakeAt.getTime()),
         wake_event: null,
       });
 
@@ -188,7 +188,7 @@ describe("Basic SDK Operations", () => {
       const resumedRun = await ctx.getRun(runID);
       expect(resumedRun).toMatchObject({
         state: "running",
-        started_at: wakeAt,
+        started_at: Temporal.Instant.fromEpochMilliseconds(wakeAt.getTime()),
       });
     });
 
@@ -215,7 +215,7 @@ describe("Basic SDK Operations", () => {
       expect(running).toMatchObject({
         state: "running",
         claimed_by: "worker-a",
-        claim_expires_at: new Date(baseTime.getTime() + 30 * 1000),
+        claim_expires_at: Temporal.Instant.fromEpochMilliseconds(baseTime.getTime() + 30 * 1000),
       });
 
       await ctx.setFakeNow(new Date(baseTime.getTime() + 5 * 60 * 1000));
@@ -274,7 +274,7 @@ describe("Basic SDK Operations", () => {
       const runRow = await ctx.getRun(runID);
       expect(runRow).toMatchObject({
         claimed_by: "worker-clean",
-        claim_expires_at: new Date(base.getTime() + 60 * 1000),
+        claim_expires_at: Temporal.Instant.fromEpochMilliseconds(base.getTime() + 60 * 1000),
       });
 
       const beforeTTL = new Date(finishTime.getTime() + 30 * 60 * 1000);
@@ -481,7 +481,7 @@ describe("Basic SDK Operations", () => {
 
       const getExpiresAt = async (runID: string) => {
         const run = await ctx.getRun(runID);
-        return run?.claim_expires_at ? run.claim_expires_at.getTime() : 0;
+        return run?.claim_expires_at ? run.claim_expires_at.epochMilliseconds : 0;
       };
 
       absurd.workBatch("test-worker", claimTimeout);

sdks/typescript/test/events.test.ts

@@ -109,7 +109,7 @@ describe("Event system", () => {
       wake_event: eventName,
     });
     const expectedWake = new Date(baseTime.getTime() + timeoutSeconds * 1000);
-    expect(sleepingRun?.available_at?.getTime()).toBe(expectedWake.getTime());
+    expect(sleepingRun?.available_at?.epochMilliseconds).toBe(expectedWake.getTime());
 
     await ctx.setFakeNow(new Date(expectedWake.getTime() + 1000));
     await absurd.workBatch("worker1", 120, 1);

sdks/typescript/test/retry.test.ts

@@ -312,8 +312,8 @@ describe("Retry and cancellation", () => {
 
     await absurd.cancelTask(taskID);
     const second = await ctx.getTask(taskID);
-    expect(second?.cancelled_at?.getTime()).toBe(
-      first?.cancelled_at?.getTime(),
+    expect(second?.cancelled_at?.epochMilliseconds).toBe(
+      first?.cancelled_at?.epochMilliseconds,
     );
   });
 

sdks/typescript/test/setup.ts

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   Absurd,
+  Temporal,
   type AbsurdHooks,
   type JsonValue,
   type SQLiteDatabase,
@@ -22,8 +23,8 @@ export interface TaskRow {
   retry_strategy: JsonValue | null;
   max_attempts: number | null;
   cancellation: JsonValue | null;
-  enqueue_at: Date;
-  first_started_at: Date | null;
+  enqueue_at: Temporal.Instant;
+  first_started_at: Temporal.Instant | null;
   state:
     | "pending"
     | "running"
@@ -34,7 +35,7 @@ export interface TaskRow {
   attempts: number;
   last_attempt_run: string | null;
   completed_payload: JsonValue | null;
-  cancelled_at: Date | null;
+  cancelled_at: Temporal.Instant | null;
 }
 
 export interface RunRow {
@@ -49,16 +50,16 @@ export interface RunRow {
     | "failed"
     | "cancelled";
   claimed_by: string | null;
-  claim_expires_at: Date | null;
-  available_at: Date;
+  claim_expires_at: Temporal.Instant | null;
+  available_at: Temporal.Instant;
   wake_event: string | null;
   event_payload: JsonValue | null;
-  started_at: Date | null;
-  completed_at: Date | null;
-  failed_at: Date | null;
+  started_at: Temporal.Instant | null;
+  completed_at: Temporal.Instant | null;
+  failed_at: Temporal.Instant | null;
   result: JsonValue | null;
   failure_reason: JsonValue | null;
-  created_at: Date;
+  created_at: Temporal.Instant;
 }
 
 interface SqliteFixture {

sdks/typescript/test/sqlite.test.ts

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 
 import { SQLiteConnection } from "../src/sqlite-connection";
 import type { SQLiteDatabase } from "../src/sqlite-types";
+import { Temporal } from "../src/index";
 
 describe("SQLiteConnection", () => {
   it("rewrites postgres-style params and absurd schema names", async () => {
@@ -69,20 +70,20 @@ describe("SQLiteConnection", () => {
     db.close();
   });
 
-  it("decodes datetime columns into Date objects", async () => {
+  it("decodes datetime columns into Temporal.Instant objects", async () => {
     const db = new sqlite(":memory:") as SQLiteDatabase;
     const conn = new SQLiteConnection(db);
     const now = Date.now();
 
     await conn.exec("CREATE TABLE t_date (created_at DATETIME)");
     await conn.exec("INSERT INTO t_date (created_at) VALUES ($1)", [now]);
 
-    const { rows } = await conn.query<{ created_at: Date }>(
+    const { rows } = await conn.query<{ created_at: Temporal.Instant }>(
       "SELECT created_at FROM t_date"
     );
 
-    expect(rows[0]?.created_at).toBeInstanceOf(Date);
-    expect(rows[0]?.created_at.getTime()).toBe(now);
+    expect(rows[0]?.created_at).toBeInstanceOf(Temporal.Instant);
+    expect(rows[0]?.created_at.epochMilliseconds).toBe(now);
     db.close();
   });
 

sdks/typescript/test/step.test.ts

@@ -205,7 +205,7 @@ describe("Step functionality", () => {
       state: "sleeping",
     });
     const wakeTime = new Date(base.getTime() + durationSeconds * 1000);
-    expect(sleepingRun?.available_at?.getTime()).toBe(wakeTime.getTime());
+    expect(sleepingRun?.available_at?.epochMilliseconds).toBe(wakeTime.getTime());
 
     const resumeTime = new Date(wakeTime.getTime() + 5 * 1000);
     vi.setSystemTime(resumeTime);