@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/SortKey_FilterTest.res.mjs

@@ -0,0 +1,135 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as SortKey_Filter$ReventlessLocal from "../../src/adapter/QueryDb/SortKey_Filter.res.mjs";
+
+function makeItem(sk) {
+  let d = {};
+  d["_subId"] = sk;
+  return d;
+}
+
+let items = [
+  makeItem("art/2026-01"),
+  makeItem("art/2026-02"),
+  makeItem("math/2026-01"),
+  makeItem("math/2026-02"),
+  makeItem("science/2026-01")
+];
+
+let skField = "_subId";
+
+function getSks(result) {
+  return result.items.map(item => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[skField]), Stdlib_JSON.Decode.string), ""));
+}
+
+globalThis.describe("SortKey_Filter.apply:", () => {
+  globalThis.test("no filters returns all items in order", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    globalThis.expect(r.items.length).toBe(5);
+    globalThis.expect(getSks(r)).toEqual([
+      "art/2026-01",
+      "art/2026-02",
+      "math/2026-01",
+      "math/2026-02",
+      "science/2026-01"
+    ]);
+    globalThis.expect(r.nextToken).toBe(undefined);
+  });
+  globalThis.test("prefix filters to matching sort keys", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, "math", undefined, undefined, undefined, undefined, undefined, undefined);
+    globalThis.expect(getSks(r)).toEqual([
+      "math/2026-01",
+      "math/2026-02"
+    ]);
+    globalThis.expect(r.nextToken).toBe(undefined);
+  });
+  globalThis.test("from filters to sort keys >= from", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, "math/2026-01", undefined, undefined, undefined, undefined, undefined);
+    globalThis.expect(getSks(r)).toEqual([
+      "math/2026-01",
+      "math/2026-02",
+      "science/2026-01"
+    ]);
+  });
+  globalThis.test("to filters to sort keys <= to", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, "art/2026-02", undefined, undefined, undefined, undefined);
+    globalThis.expect(getSks(r)).toEqual([
+      "art/2026-01",
+      "art/2026-02"
+    ]);
+  });
+  globalThis.test("from+to gives BETWEEN range", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, "art/2026-02", "math/2026-01", undefined, undefined, undefined, undefined);
+    globalThis.expect(getSks(r)).toEqual([
+      "art/2026-02",
+      "math/2026-01"
+    ]);
+  });
+  globalThis.test("eq filters to exact match only", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, undefined, "math/2026-02", undefined, undefined, undefined);
+    globalThis.expect(getSks(r)).toEqual(["math/2026-02"]);
+  });
+  globalThis.test("reverse returns items in descending order", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, undefined, undefined, true, undefined, undefined);
+    globalThis.expect(getSks(r)).toEqual([
+      "science/2026-01",
+      "math/2026-02",
+      "math/2026-01",
+      "art/2026-02",
+      "art/2026-01"
+    ]);
+  });
+  globalThis.test("limit returns first N items", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, undefined, undefined, undefined, 2, undefined);
+    globalThis.expect(getSks(r)).toEqual([
+      "art/2026-01",
+      "art/2026-02"
+    ]);
+    globalThis.expect(r.nextToken).toBe("2");
+  });
+  globalThis.test("nextToken resumes from offset", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, undefined, undefined, undefined, 2, 2);
+    globalThis.expect(getSks(r)).toEqual([
+      "math/2026-01",
+      "math/2026-02"
+    ]);
+    globalThis.expect(r.nextToken).toBe("4");
+  });
+  globalThis.test("last page has no nextToken", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, undefined, undefined, undefined, 2, 4);
+    globalThis.expect(getSks(r)).toEqual(["science/2026-01"]);
+    globalThis.expect(r.nextToken).toBe(undefined);
+  });
+  globalThis.test("prefix + limit + nextToken paginates correctly", async () => {
+    let r1 = SortKey_Filter$ReventlessLocal.apply(items, skField, "art", undefined, undefined, undefined, undefined, 1, undefined);
+    globalThis.expect(getSks(r1)).toEqual(["art/2026-01"]);
+    globalThis.expect(r1.nextToken).toBe("1");
+    let r2 = SortKey_Filter$ReventlessLocal.apply(items, skField, "art", undefined, undefined, undefined, undefined, 1, 1);
+    globalThis.expect(getSks(r2)).toEqual(["art/2026-02"]);
+    globalThis.expect(r2.nextToken).toBe(undefined);
+  });
+  globalThis.test("reverse + limit returns last N items", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, undefined, undefined, true, 3, undefined);
+    globalThis.expect(getSks(r)).toEqual([
+      "science/2026-01",
+      "math/2026-02",
+      "math/2026-01"
+    ]);
+    globalThis.expect(r.nextToken).toBe("3");
+  });
+  globalThis.test("eq with no match returns empty", async () => {
+    let r = SortKey_Filter$ReventlessLocal.apply(items, skField, undefined, undefined, undefined, "nonexistent", undefined, undefined, undefined);
+    globalThis.expect(r.items.length).toBe(0);
+    globalThis.expect(r.nextToken).toBe(undefined);
+  });
+});
+
+export {
+  makeItem,
+  items,
+  skField,
+  getSks,
+}
+/* items Not a pure module */

package/tests/adapter/SqliteDriverTest.res

@@ -0,0 +1,86 @@
+// Round-trip test for the SqliteDriver wrapper.
+// Uses an in-memory database (`:memory:`) so no filesystem cleanup is needed.
+
+open JestGlobals
+
+describe("SqliteDriver", () => {
+  testPromise("open / exec / prepare / run / get / all / iterate / close round-trip", async () => {
+    let db = SqliteDriver.openDb(~path=":memory:")
+    db->SqliteDriver.exec("CREATE TABLE t(id INTEGER PRIMARY KEY, v TEXT)")
+
+    let insert = db->SqliteDriver.prepare("INSERT INTO t(id, v) VALUES(?, ?)")
+    insert->SqliteDriver.run([JSON.Encode.int(1), JSON.Encode.string("hello")])
+    insert->SqliteDriver.run([JSON.Encode.int(2), JSON.Encode.string("world")])
+
+    let selectAll = db->SqliteDriver.prepare("SELECT id, v FROM t WHERE id > ? ORDER BY id")
+    let rows = selectAll->SqliteDriver.all([JSON.Encode.int(0)])
+    expect(rows->Array.length)->toBe(2)
+    let firstRow = rows->Array.getUnsafe(0)
+    expect(firstRow->Dict.get("v")->Option.getOr(JSON.Encode.null))->toEqual(
+      JSON.Encode.string("hello"),
+    )
+
+    let getOne = selectAll->SqliteDriver.get([JSON.Encode.int(0)])
+    expect(getOne->Option.isSome)->toBe(true)
+
+    let countViaIterate = ref(0)
+    let iter = selectAll->SqliteDriver.iterate([JSON.Encode.int(0)])
+    let _ = iter->Iterator.forEach(_row => countViaIterate := countViaIterate.contents + 1)
+    expect(countViaIterate.contents)->toBe(2)
+
+    db->SqliteDriver.close
+  })
+
+  testPromise("transaction commits on success, rolls back on exception", async () => {
+    let db = SqliteDriver.openDb(~path=":memory:")
+    db->SqliteDriver.exec("CREATE TABLE t(id INTEGER PRIMARY KEY)")
+    let insert = db->SqliteDriver.prepare("INSERT INTO t(id) VALUES(?)")
+    let countAll = db->SqliteDriver.prepare("SELECT COUNT(*) AS c FROM t")
+
+    db->SqliteDriver.transaction(() => {
+      insert->SqliteDriver.run([JSON.Encode.int(1)])
+      insert->SqliteDriver.run([JSON.Encode.int(2)])
+    })
+
+    let row = countAll->SqliteDriver.get([])->Option.getOrThrow
+    expect(row->Dict.get("c")->Option.getOr(JSON.Encode.null))->toEqual(JSON.Encode.int(2))
+
+    let didThrow = ref(false)
+    try {
+      db->SqliteDriver.transaction(() => {
+        insert->SqliteDriver.run([JSON.Encode.int(3)])
+        throw(Failure("boom"))
+      })
+    } catch {
+    | Failure(_) => didThrow := true
+    }
+    expect(didThrow.contents)->toBe(true)
+
+    let rowAfter = countAll->SqliteDriver.get([])->Option.getOrThrow
+    expect(rowAfter->Dict.get("c")->Option.getOr(JSON.Encode.null))->toEqual(JSON.Encode.int(2))
+
+    db->SqliteDriver.close
+  })
+
+  testPromise("Backend.fromEnv parses sqlite path and reset flag", async () => {
+    let originalEnv =
+      Backend.processEnv->Dict.get("REVENTLESS_LOCAL_BACKEND")
+
+    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db")
+    let parsed = Backend.fromEnv()
+    expect(parsed)->toEqual(Backend.Sqlite({path: "./local.db", resetOnStart: false}))
+
+    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db?reset")
+    let parsedReset = Backend.fromEnv()
+    expect(parsedReset)->toEqual(Backend.Sqlite({path: "./local.db", resetOnStart: true}))
+
+    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "memory")
+    let parsedMem = Backend.fromEnv()
+    expect(parsedMem)->toEqual(Backend.Memory)
+
+    switch originalEnv {
+    | Some(v) => Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", v)
+    | None => Backend.processEnv->Dict.delete("REVENTLESS_LOCAL_BACKEND")
+    }
+  })
+})

package/tests/adapter/SqliteDriverTest.res.mjs

@@ -0,0 +1,101 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Backend$ReventlessLocal from "../../src/adapter/Backend.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+
+globalThis.describe("SqliteDriver", () => {
+  globalThis.test("open / exec / prepare / run / get / all / iterate / close round-trip", async () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE t(id INTEGER PRIMARY KEY, v TEXT)");
+    let insert = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO t(id, v) VALUES(?, ?)");
+    SqliteDriver$ReventlessLocal.run(insert, [
+      1,
+      "hello"
+    ]);
+    SqliteDriver$ReventlessLocal.run(insert, [
+      2,
+      "world"
+    ]);
+    let selectAll = SqliteDriver$ReventlessLocal.prepare(db, "SELECT id, v FROM t WHERE id > ? ORDER BY id");
+    let rows = SqliteDriver$ReventlessLocal.all(selectAll, [0]);
+    globalThis.expect(rows.length).toBe(2);
+    let firstRow = rows[0];
+    globalThis.expect(Stdlib_Option.getOr(firstRow["v"], null)).toEqual("hello");
+    let getOne = SqliteDriver$ReventlessLocal.get(selectAll, [0]);
+    globalThis.expect(Stdlib_Option.isSome(getOne)).toBe(true);
+    let countViaIterate = {
+      contents: 0
+    };
+    let iter = SqliteDriver$ReventlessLocal.iterate(selectAll, [0]);
+    iter.forEach(_row => {
+      countViaIterate.contents = countViaIterate.contents + 1 | 0;
+    });
+    globalThis.expect(countViaIterate.contents).toBe(2);
+    return SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("transaction commits on success, rolls back on exception", async () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE t(id INTEGER PRIMARY KEY)");
+    let insert = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO t(id) VALUES(?)");
+    let countAll = SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM t");
+    SqliteDriver$ReventlessLocal.transaction(db, () => {
+      SqliteDriver$ReventlessLocal.run(insert, [1]);
+      SqliteDriver$ReventlessLocal.run(insert, [2]);
+    });
+    let row = Stdlib_Option.getOrThrow(SqliteDriver$ReventlessLocal.get(countAll, []), undefined);
+    globalThis.expect(Stdlib_Option.getOr(row["c"], null)).toEqual(2);
+    let didThrow = false;
+    try {
+      SqliteDriver$ReventlessLocal.transaction(db, () => {
+        SqliteDriver$ReventlessLocal.run(insert, [3]);
+        throw {
+          RE_EXN_ID: "Failure",
+          _1: "boom",
+          Error: new Error()
+        };
+      });
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (exn.RE_EXN_ID === "Failure") {
+        didThrow = true;
+      } else {
+        throw exn;
+      }
+    }
+    globalThis.expect(didThrow).toBe(true);
+    let rowAfter = Stdlib_Option.getOrThrow(SqliteDriver$ReventlessLocal.get(countAll, []), undefined);
+    globalThis.expect(Stdlib_Option.getOr(rowAfter["c"], null)).toEqual(2);
+    return SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("Backend.fromEnv parses sqlite path and reset flag", async () => {
+    let originalEnv = process.env["REVENTLESS_LOCAL_BACKEND"];
+    process.env["REVENTLESS_LOCAL_BACKEND"] = "sqlite:./local.db";
+    let parsed = Backend$ReventlessLocal.fromEnv();
+    globalThis.expect(parsed).toEqual({
+      TAG: "Sqlite",
+      path: "./local.db",
+      resetOnStart: false
+    });
+    process.env["REVENTLESS_LOCAL_BACKEND"] = "sqlite:./local.db?reset";
+    let parsedReset = Backend$ReventlessLocal.fromEnv();
+    globalThis.expect(parsedReset).toEqual({
+      TAG: "Sqlite",
+      path: "./local.db",
+      resetOnStart: true
+    });
+    process.env["REVENTLESS_LOCAL_BACKEND"] = "memory";
+    let parsedMem = Backend$ReventlessLocal.fromEnv();
+    globalThis.expect(parsedMem).toEqual("Memory");
+    if (originalEnv !== undefined) {
+      process.env["REVENTLESS_LOCAL_BACKEND"] = originalEnv;
+      return;
+    } else {
+      return Stdlib_Dict.$$delete(process.env, "REVENTLESS_LOCAL_BACKEND");
+    }
+  });
+});
+
+/*  Not a pure module */

package/tests/adapter/TaskBucketSqliteTest.res

@@ -0,0 +1,44 @@
+// Round-trip test for TaskBucket_Sqlite put/get helpers.
+
+open JestGlobals
+
+describe("TaskBucket_Sqlite", () => {
+  testPromise("put then get returns the stored body", async () => {
+    let db = SqliteDriver.openDb(~path=":memory:")
+    TaskBucket_Sqlite.put(~db, ~bucket="b1", ~key="k1", ~body="hello world")
+    let got = TaskBucket_Sqlite.get(~db, ~bucket="b1", ~key="k1")
+    expect(got)->toEqual(Some("hello world"))
+    db->SqliteDriver.close
+  })
+
+  testPromise("put overwrites existing body at same (bucket, key)", async () => {
+    let db = SqliteDriver.openDb(~path=":memory:")
+    TaskBucket_Sqlite.put(~db, ~bucket="b1", ~key="k", ~body="one")
+    TaskBucket_Sqlite.put(~db, ~bucket="b1", ~key="k", ~body="two")
+    let got = TaskBucket_Sqlite.get(~db, ~bucket="b1", ~key="k")
+    expect(got)->toEqual(Some("two"))
+    db->SqliteDriver.close
+  })
+
+  testPromise("get returns None for missing key", async () => {
+    let db = SqliteDriver.openDb(~path=":memory:")
+    let got = TaskBucket_Sqlite.get(~db, ~bucket="empty", ~key="nope")
+    expect(got)->toEqual(None)
+    db->SqliteDriver.close
+  })
+
+  testPromise("body persists across a file reopen", async () => {
+    let path = `/tmp/reventless-test-task-${Float.toString(Date.now())}.db`
+
+    {
+      let db = SqliteDriver.openDb(~path)
+      TaskBucket_Sqlite.put(~db, ~bucket="audit", ~key="42", ~body="payload")
+      db->SqliteDriver.close
+    }
+
+    let db2 = SqliteDriver.openDb(~path)
+    let got = TaskBucket_Sqlite.get(~db=db2, ~bucket="audit", ~key="42")
+    expect(got)->toEqual(Some("payload"))
+    db2->SqliteDriver.close
+  })
+})

package/tests/adapter/TaskBucketSqliteTest.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as TaskBucket_Sqlite$ReventlessLocal from "../../src/adapter/Task/TaskBucket_Sqlite.res.mjs";
+
+globalThis.describe("TaskBucket_Sqlite", () => {
+  globalThis.test("put then get returns the stored body", async () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    TaskBucket_Sqlite$ReventlessLocal.put(db, "b1", "k1", "hello world");
+    let got = TaskBucket_Sqlite$ReventlessLocal.get(db, "b1", "k1");
+    globalThis.expect(got).toEqual("hello world");
+    return SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("put overwrites existing body at same (bucket, key)", async () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    TaskBucket_Sqlite$ReventlessLocal.put(db, "b1", "k", "one");
+    TaskBucket_Sqlite$ReventlessLocal.put(db, "b1", "k", "two");
+    let got = TaskBucket_Sqlite$ReventlessLocal.get(db, "b1", "k");
+    globalThis.expect(got).toEqual("two");
+    return SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("get returns None for missing key", async () => {
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let got = TaskBucket_Sqlite$ReventlessLocal.get(db, "empty", "nope");
+    globalThis.expect(got).toEqual(undefined);
+    return SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("body persists across a file reopen", async () => {
+    let path = `/tmp/reventless-test-task-` + Date.now().toString() + `.db`;
+    let db = SqliteDriver$ReventlessLocal.openDb(path);
+    TaskBucket_Sqlite$ReventlessLocal.put(db, "audit", "42", "payload");
+    SqliteDriver$ReventlessLocal.close(db);
+    let db2 = SqliteDriver$ReventlessLocal.openDb(path);
+    let got = TaskBucket_Sqlite$ReventlessLocal.get(db2, "audit", "42");
+    globalThis.expect(got).toEqual("payload");
+    return SqliteDriver$ReventlessLocal.close(db2);
+  });
+});
+
+/*  Not a pure module */

package/tests/adapter/TaskBucketTest.res

@@ -0,0 +1,106 @@
+// Unit tests for LocalTaskBucket.
+// Covers makeHandler (event extraction) and make (dummy resource for Task_Builder compatibility).
+
+open JestGlobals
+
+// No Pulumi mock needed (LocalTaskBucket has no Pulumi.Output usage)
+
+describe("LocalTaskBucket", () => {
+  describe("makeHandler", () => {
+    testPromise("calls callback with eventName and key extracted from JSON object", async () => {
+      let receivedEventName: ref<string> = ref("")
+      let receivedKey: ref<string> = ref("")
+      let callback: ReventlessCore.Task.bucketCallback = async (~eventName, ~key) => {
+        receivedEventName := eventName
+        receivedKey := key
+        []
+      }
+      let handler = LocalTaskBucket.makeHandler(callback)
+      let json = JSON.Encode.object(
+        Dict.fromArray([
+          ("eventName", JSON.Encode.string("ObjectCreated:Put")),
+          ("key", JSON.Encode.string("uploads/file.csv")),
+        ]),
+      )
+      let _ = await handler(json, ())
+      expect(receivedEventName.contents)->toBe("ObjectCreated:Put")
+      expect(receivedKey.contents)->toBe("uploads/file.csv")
+    })
+
+    testPromise("uses 'ObjectCreated' when JSON has no eventName field", async () => {
+      let receivedEventName: ref<string> = ref("")
+      let callback: ReventlessCore.Task.bucketCallback = async (~eventName, ~key as _) => {
+        receivedEventName := eventName
+        []
+      }
+      let handler = LocalTaskBucket.makeHandler(callback)
+      let json = JSON.Encode.object(
+        Dict.fromArray([("key", JSON.Encode.string("some/path"))]),
+      )
+      let _ = await handler(json, ())
+      expect(receivedEventName.contents)->toBe("ObjectCreated")
+    })
+
+    testPromise("uses empty string when JSON has no key field", async () => {
+      let receivedKey: ref<string> = ref("initial")
+      let callback: ReventlessCore.Task.bucketCallback = async (~eventName as _, ~key) => {
+        receivedKey := key
+        []
+      }
+      let handler = LocalTaskBucket.makeHandler(callback)
+      let json = JSON.Encode.object(
+        Dict.fromArray([("eventName", JSON.Encode.string("ObjectRemoved"))]),
+      )
+      let _ = await handler(json, ())
+      expect(receivedKey.contents)->toBe("")
+    })
+
+    testPromise("non-object JSON uses 'ObjectCreated' and empty string for key", async () => {
+      let receivedEventName: ref<string> = ref("")
+      let receivedKey: ref<string> = ref("initial")
+      let callback: ReventlessCore.Task.bucketCallback = async (~eventName, ~key) => {
+        receivedEventName := eventName
+        receivedKey := key
+        []
+      }
+      let handler = LocalTaskBucket.makeHandler(callback)
+      let _ = await handler(JSON.Encode.string("not-an-object"), ())
+      expect(receivedEventName.contents)->toBe("ObjectCreated")
+      expect(receivedKey.contents)->toBe("")
+    })
+
+    testPromise("non-string eventName field falls back to ObjectCreated", async () => {
+      let receivedEventName: ref<string> = ref("")
+      let callback: ReventlessCore.Task.bucketCallback = async (~eventName, ~key as _) => {
+        receivedEventName := eventName
+        []
+      }
+      let handler = LocalTaskBucket.makeHandler(callback)
+      let json = JSON.Encode.object(
+        Dict.fromArray([("eventName", JSON.Encode.int(42))]),
+      )
+      let _ = await handler(json, ())
+      expect(receivedEventName.contents)->toBe("ObjectCreated")
+    })
+
+    testPromise("returns task actions from callback", async () => {
+      let callback: ReventlessCore.Task.bucketCallback = async (~eventName as _, ~key as _) => {
+        [ReventlessCore.Task.DeleteSchedule("my-schedule")]
+      }
+      let handler = LocalTaskBucket.makeHandler(callback)
+      let json = JSON.Encode.object(Dict.fromArray([]))
+      let actions = await handler(json, ())
+      expect(actions->Array.length)->toBe(1)
+    })
+  })
+
+  describe("make", () => {
+    testPromise(
+      "returns one dummy resource so Task_Builder can access resources[0]",
+      async () => {
+        let bucket = LocalTaskBucket.make(~name="my-bucket", ~opts={})
+        expect(bucket.resources->Array.length)->toBe(1)
+      },
+    )
+  })
+})

package/tests/adapter/TaskBucketTest.res.mjs

@@ -0,0 +1,118 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as LocalTaskBucket$ReventlessLocal from "../../src/adapter/Task/LocalTaskBucket.res.mjs";
+
+globalThis.describe("LocalTaskBucket", () => {
+  globalThis.describe("makeHandler", () => {
+    globalThis.test("calls callback with eventName and key extracted from JSON object", async () => {
+      let receivedEventName = {
+        contents: ""
+      };
+      let receivedKey = {
+        contents: ""
+      };
+      let callback = async (eventName, key) => {
+        receivedEventName.contents = eventName;
+        receivedKey.contents = key;
+        return [];
+      };
+      let handler = LocalTaskBucket$ReventlessLocal.makeHandler(callback);
+      let json = Object.fromEntries([
+        [
+          "eventName",
+          "ObjectCreated:Put"
+        ],
+        [
+          "key",
+          "uploads/file.csv"
+        ]
+      ]);
+      await handler(json, undefined);
+      globalThis.expect(receivedEventName.contents).toBe("ObjectCreated:Put");
+      globalThis.expect(receivedKey.contents).toBe("uploads/file.csv");
+    });
+    globalThis.test("uses 'ObjectCreated' when JSON has no eventName field", async () => {
+      let receivedEventName = {
+        contents: ""
+      };
+      let callback = async (eventName, param) => {
+        receivedEventName.contents = eventName;
+        return [];
+      };
+      let handler = LocalTaskBucket$ReventlessLocal.makeHandler(callback);
+      let json = Object.fromEntries([[
+          "key",
+          "some/path"
+        ]]);
+      await handler(json, undefined);
+      globalThis.expect(receivedEventName.contents).toBe("ObjectCreated");
+    });
+    globalThis.test("uses empty string when JSON has no key field", async () => {
+      let receivedKey = {
+        contents: "initial"
+      };
+      let callback = async (param, key) => {
+        receivedKey.contents = key;
+        return [];
+      };
+      let handler = LocalTaskBucket$ReventlessLocal.makeHandler(callback);
+      let json = Object.fromEntries([[
+          "eventName",
+          "ObjectRemoved"
+        ]]);
+      await handler(json, undefined);
+      globalThis.expect(receivedKey.contents).toBe("");
+    });
+    globalThis.test("non-object JSON uses 'ObjectCreated' and empty string for key", async () => {
+      let receivedEventName = {
+        contents: ""
+      };
+      let receivedKey = {
+        contents: "initial"
+      };
+      let callback = async (eventName, key) => {
+        receivedEventName.contents = eventName;
+        receivedKey.contents = key;
+        return [];
+      };
+      let handler = LocalTaskBucket$ReventlessLocal.makeHandler(callback);
+      await handler("not-an-object", undefined);
+      globalThis.expect(receivedEventName.contents).toBe("ObjectCreated");
+      globalThis.expect(receivedKey.contents).toBe("");
+    });
+    globalThis.test("non-string eventName field falls back to ObjectCreated", async () => {
+      let receivedEventName = {
+        contents: ""
+      };
+      let callback = async (eventName, param) => {
+        receivedEventName.contents = eventName;
+        return [];
+      };
+      let handler = LocalTaskBucket$ReventlessLocal.makeHandler(callback);
+      let json = Object.fromEntries([[
+          "eventName",
+          42
+        ]]);
+      await handler(json, undefined);
+      globalThis.expect(receivedEventName.contents).toBe("ObjectCreated");
+    });
+    globalThis.test("returns task actions from callback", async () => {
+      let callback = async (param, param$1) => [{
+          TAG: "DeleteSchedule",
+          _0: "my-schedule"
+        }];
+      let handler = LocalTaskBucket$ReventlessLocal.makeHandler(callback);
+      let json = Object.fromEntries([]);
+      let actions = await handler(json, undefined);
+      globalThis.expect(actions.length).toBe(1);
+    });
+  });
+  globalThis.describe("make", () => {
+    globalThis.test("returns one dummy resource so Task_Builder can access resources[0]", async () => {
+      let bucket = LocalTaskBucket$ReventlessLocal.make("my-bucket", {});
+      globalThis.expect(bucket.resources.length).toBe(1);
+    });
+  });
+});
+
+/*  Not a pure module */