@absurd-sqlite/bun-worker 0.2.2-alpha.2 → 0.3.0-alpha.1

package/test/setup.ts

@@ -6,9 +6,10 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   Absurd,
+  Temporal,
   type AbsurdHooks,
   type JsonValue,
-} from "absurd-sdk";
+} from "@absurd-sqlite/sdk";
 
 import { BunSqliteConnection } from "../src/sqlite";
 
@@ -23,8 +24,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"
@@ -35,7 +36,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 {
@@ -50,16 +51,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 {
@@ -263,10 +264,7 @@ export async function createTestAbsurd(
   queueName: string = "default"
 ): Promise<TestContext> {
   const fixture = createFixture();
-  const absurd = new Absurd({
-    db: fixture.conn,
-    queueName,
-  });
+  const absurd = new Absurd(fixture.conn, { queueName });
 
   await absurd.createQueue(queueName);
 
@@ -335,8 +333,7 @@ export async function createTestAbsurd(
     expectCancelledError: (promise: Promise<unknown>) =>
       expectCancelledError(promise),
     createClient: (options) => {
-      const client = new Absurd({
-        db: fixture.conn,
+      const client = new Absurd(fixture.conn, {
         queueName: options?.queueName ?? queueName,
         hooks: options?.hooks,
       });

package/test/sqlite.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { BunSqliteConnection } from "../src/sqlite";
+import { Temporal } from "@absurd-sqlite/sdk";
 
 describe("BunSqliteConnection", () => {
   it("rewrites postgres-style params and absurd schema names", async () => {
@@ -26,12 +27,14 @@ describe("BunSqliteConnection", () => {
     db.close();
   });
 
-  it("returns empty rows for non-reader statements", async () => {
+  it("throws when query is used for non-reader statements", async () => {
     const db = new Database(":memory:");
     const conn = new BunSqliteConnection(db);
 
-    const { rows } = await conn.query("CREATE TABLE t (id)");
-    expect(rows).toEqual([]);
+    await expect(conn.query("CREATE TABLE t (id)")).rejects.toThrow(
+      "only statements that return data"
+    );
+    await conn.exec("CREATE TABLE t (id)");
 
     await conn.exec("INSERT INTO t (id) VALUES ($1)", [1]);
     const { rows: inserted } = await conn.query<{ id: number }>(
@@ -73,7 +76,7 @@ describe("BunSqliteConnection", () => {
     db.close();
   });
 
-  it("decodes datetime columns into Date objects", async () => {
+  it("decodes datetime columns into Temporal.Instant objects", async () => {
     const db = new Database(":memory:");
     const conn = new BunSqliteConnection(db);
     const now = Date.now();
@@ -81,12 +84,12 @@ describe("BunSqliteConnection", () => {
     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();
   });
 
@@ -146,14 +149,14 @@ describe("BunSqliteConnection", () => {
       }),
     };
 
-    const querySpy = jest.fn().mockReturnValue(statement as any);
-    const db = { query: querySpy } as unknown as Database;
+    const prepareSpy = jest.fn().mockReturnValue(statement as any);
+    const db = { prepare: prepareSpy } as unknown as Database;
     const conn = new BunSqliteConnection(db);
 
     await expect(
       conn.exec("UPDATE locked_table SET value = $1 WHERE id = $2", [1, 1])
     ).resolves.toBeUndefined();
     expect(statement.run).toHaveBeenCalledTimes(2);
-    expect(querySpy).toHaveBeenCalledTimes(1);
+    expect(prepareSpy).toHaveBeenCalledTimes(1);
   });
 });

package/test/step.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, beforeAll, afterEach, jest } from "bun:test";
-import type { Absurd } from "absurd-sdk";
+import { Temporal, type Absurd } from "@absurd-sqlite/sdk";
 import { createTestAbsurd, randomName, type TestContext } from "./setup";
 
 describe("Step functionality", () => {
@@ -193,7 +193,10 @@ describe("Step functionality", () => {
 
     const durationSeconds = 60;
     absurd.registerTask({ name: "sleep-for" }, async (_params, ctx) => {
-      await ctx.sleepFor("wait-for", durationSeconds);
+      await ctx.sleepFor(
+        "wait-for",
+        Temporal.Duration.from({ seconds: durationSeconds }),
+      );
       return { resumed: true };
     });
 
@@ -205,7 +208,9 @@ 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);
     jest.setSystemTime(resumeTime);
@@ -225,11 +230,14 @@ describe("Step functionality", () => {
     await ctx.setFakeNow(base);
 
     const wakeTime = new Date(base.getTime() + 5 * 60 * 1000);
+    const wakeInstant = Temporal.Instant.fromEpochMilliseconds(
+      wakeTime.getTime(),
+    );
     let executions = 0;
 
     absurd.registerTask({ name: "sleep-until" }, async (_params, ctx) => {
       executions++;
-      await ctx.sleepUntil("sleep-step", wakeTime);
+      await ctx.sleepUntil("sleep-step", wakeInstant);
       return { executions };
     });
 
@@ -240,7 +248,7 @@ describe("Step functionality", () => {
     expect(checkpointRow).toMatchObject({
       checkpoint_name: "sleep-step",
       owner_run_id: runID,
-      state: wakeTime.toISOString(),
+      state: wakeInstant.toString(),
     });
 
     const sleepingRun = await ctx.getRun(runID);

package/test/worker.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeAll, afterEach, jest } from "bun:test";
 import { EventEmitter, once } from "events";
 import type { TestContext } from "./setup";
 import { createTestAbsurd, randomName } from "./setup";
-import type { Absurd } from "absurd-sdk";
+import type { Absurd } from "@absurd-sqlite/sdk";
 import { waitFor } from "./wait-for";
 
 describe("Worker", () => {