@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/QueryDbGsiTtlTest.res

@@ -0,0 +1,268 @@
+// Phase 5 — GSI fidelity (CREATE INDEX statements) and TTL filtering
+// for QueryDbStorage_Sqlite.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+let openFreshDb = () => SqliteDriver.openDb(~path=":memory:")
+
+let collect = stream =>
+  stream
+  ->Stream.runCollect
+  ->Effect.catchAll(_ => Effect.succeed([]))
+  ->Effect.runPromise
+
+describe("QueryDbStorage_Sqlite — GSI", () => {
+  testPromise("declared indexes produce CREATE INDEX statements", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+
+    let byOwnerIdx: Reventless.ReadModel.indexConfig = {
+      index: "ByOwner",
+      type_: "S",
+      idField: "ownerId",
+      projectionType: ALL,
+    }
+    let byOwnerCreatedIdx: Reventless.ReadModel.indexConfig = {
+      index: "ByOwnerCreated",
+      type_: "S",
+      idField: "ownerId",
+      subIdField: "createdAt",
+      projectionType: KEYS_ONLY,
+    }
+
+    let _ = Storage.make(
+      ~name="orders",
+      ~indexes=[byOwnerIdx, byOwnerCreatedIdx],
+      ~api=(),
+      ~apiRole=(),
+      ~opts,
+    )
+
+    // Verify the indexes were created in sqlite_master.
+    let listIndexes = DbProvider.db->SqliteDriver.prepare(
+      "SELECT name, sql FROM sqlite_master WHERE type='index' AND tbl_name='qdb_orders' ORDER BY name",
+    )
+    let rows = listIndexes->SqliteDriver.all([])
+    let names = rows->Array.map(row =>
+      switch row->Dict.get("name") {
+      | Some(JSON.String(s)) => s
+      | _ => ""
+      }
+    )
+    expect(names->Array.includes("idx_qdb_orders_ByOwner"))->toBe(true)
+    expect(names->Array.includes("idx_qdb_orders_ByOwnerCreated"))->toBe(true)
+
+    // Confirm the index definition references json_extract on the configured field.
+    let firstSql = switch rows->Array.find(row =>
+      switch row->Dict.get("name") {
+      | Some(JSON.String(s)) => s == "idx_qdb_orders_ByOwner"
+      | _ => false
+      }
+    ) {
+    | Some(row) =>
+      switch row->Dict.get("sql") {
+      | Some(JSON.String(s)) => s
+      | _ => ""
+      }
+    | None => ""
+    }
+    expect(firstSql->String.includes("json_extract(item, '$.ownerId')"))->toBe(true)
+  })
+
+  testPromise("composite-key indexes use pk/sk concatenation expressions", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+
+    let compositeIdx: Reventless.ReadModel.indexConfig = {
+      index: "ByTenantOwner",
+      type_: "S",
+      pkFields: ["tenantId", "ownerId"],
+      pkSep: "|",
+      projectionType: ALL,
+    }
+
+    let _ = Storage.make(
+      ~name="composite",
+      ~indexes=[compositeIdx],
+      ~api=(),
+      ~apiRole=(),
+      ~opts,
+    )
+
+    let listSql = DbProvider.db->SqliteDriver.prepare(
+      "SELECT sql FROM sqlite_master WHERE type='index' AND name='idx_qdb_composite_ByTenantOwner'",
+    )
+    let row = listSql->SqliteDriver.get([])->Option.getOrThrow
+    let sql = switch row->Dict.get("sql") {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+    expect(
+      sql->String.includes("json_extract(item, '$.tenantId') || '|' || json_extract(item, '$.ownerId')"),
+    )->toBe(true)
+  })
+
+  testPromise("index name is sanitised — special characters in index name become underscores", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+
+    let weirdIdx: Reventless.ReadModel.indexConfig = {
+      index: "by-thing.v2",
+      type_: "S",
+      idField: "thing",
+      projectionType: ALL,
+    }
+    let _ = Storage.make(
+      ~name="rm",
+      ~indexes=[weirdIdx],
+      ~api=(),
+      ~apiRole=(),
+      ~opts,
+    )
+    let listIndexes = DbProvider.db->SqliteDriver.prepare(
+      "SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='qdb_rm'",
+    )
+    let names =
+      listIndexes
+      ->SqliteDriver.all([])
+      ->Array.map(row =>
+        switch row->Dict.get("name") {
+        | Some(JSON.String(s)) => s
+        | _ => ""
+        }
+      )
+    expect(names->Array.includes("idx_qdb_rm_by_thing_v2"))->toBe(true)
+  })
+})
+
+describe("QueryDbStorage_Sqlite — TTL", () => {
+  testPromise("save with TTL in the future returns the item", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+
+    let s = Storage.make(~name="rt-future", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let oneHourFromNow = Float.toInt(Date.now() /. 1000.0) + 3600
+    let _ = await ops.save(
+      "k",
+      JSON.Encode.string("alive"),
+      ReventlessCore.QueryDb.Any,
+      Some(oneHourFromNow),
+    )
+
+    let items = await ops.loadStream("k")->collect
+    expect(items->Array.length)->toBe(1)
+  })
+
+  testPromise("save with TTL already in the past hides the item from reads", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+
+    let s = Storage.make(~name="rt-past", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let aMinuteAgo = Float.toInt(Date.now() /. 1000.0) - 60
+    let _ = await ops.save(
+      "k",
+      JSON.Encode.string("expired"),
+      ReventlessCore.QueryDb.Any,
+      Some(aMinuteAgo),
+    )
+
+    let items = await ops.loadStream("k")->collect
+    expect(items->Array.length)->toBe(0)
+  })
+
+  testPromise("save without TTL is treated as never expiring", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+
+    let s = Storage.make(~name="rt-none", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let _ = await ops.save("k", JSON.Encode.string("forever"), ReventlessCore.QueryDb.Any, None)
+
+    let items = await ops.loadStream("k")->collect
+    expect(items->Array.length)->toBe(1)
+  })
+
+  testPromise("scanAll skips expired rows", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+
+    let s = Storage.make(~name="scan-ttl", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let _ = await ops.save("alive", JSON.Encode.string("a"), ReventlessCore.QueryDb.Any, None)
+    let aMinuteAgo = Float.toInt(Date.now() /. 1000.0) - 60
+    let _ = await ops.save(
+      "expired",
+      JSON.Encode.string("e"),
+      ReventlessCore.QueryDb.Any,
+      Some(aMinuteAgo),
+    )
+
+    let scan = TestBus.getQueryDbScan("scan-ttl")
+    switch scan {
+    | Some(fn) => expect(fn()->Array.length)->toBe(1)
+    | None => expect("scan registered")->toBe("scan missing")
+    }
+  })
+
+  testPromise("overwriting an expired row with a non-expired one makes it visible again", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+
+    let s = Storage.make(~name="overwrite-ttl", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+
+    let aMinuteAgo = Float.toInt(Date.now() /. 1000.0) - 60
+    let _ = await ops.save(
+      "k",
+      JSON.Encode.string("expired"),
+      ReventlessCore.QueryDb.Any,
+      Some(aMinuteAgo),
+    )
+
+    let items1 = await ops.loadStream("k")->collect
+    expect(items1->Array.length)->toBe(0)
+
+    let _ = await ops.save(
+      "k",
+      JSON.Encode.string("revived"),
+      ReventlessCore.QueryDb.Any,
+      None,
+    )
+    let items2 = await ops.loadStream("k")->collect
+    expect(items2->Array.length)->toBe(1)
+    expect(items2->Array.getUnsafe(0))->toEqual(JSON.Encode.string("revived"))
+  })
+})

package/tests/adapter/QueryDbGsiTtlTest.res.mjs

@@ -0,0 +1,209 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as QueryDbStorage_Sqlite$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+function openFreshDb() {
+  return SqliteDriver$ReventlessLocal.openDb(":memory:");
+}
+
+function collect(stream) {
+  return Effect.runPromise(Effect.catchAll(Stream.runCollect(stream), param => Effect.succeed([])));
+}
+
+globalThis.describe("QueryDbStorage_Sqlite — GSI", () => {
+  globalThis.test("declared indexes produce CREATE INDEX statements", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    Storage.make("orders", [
+      {
+        index: "ByOwner",
+        type_: "S",
+        idField: "ownerId",
+        projectionType: "ALL"
+      },
+      {
+        index: "ByOwnerCreated",
+        type_: "S",
+        idField: "ownerId",
+        subIdField: "createdAt",
+        projectionType: "KEYS_ONLY"
+      }
+    ], undefined, undefined, undefined, undefined, opts);
+    let listIndexes = SqliteDriver$ReventlessLocal.prepare(db, "SELECT name, sql FROM sqlite_master WHERE type='index' AND tbl_name='qdb_orders' ORDER BY name");
+    let rows = SqliteDriver$ReventlessLocal.all(listIndexes, []);
+    let names = rows.map(row => {
+      let match = row["name"];
+      if (typeof match === "string") {
+        return match;
+      } else {
+        return "";
+      }
+    });
+    globalThis.expect(names.includes("idx_qdb_orders_ByOwner")).toBe(true);
+    globalThis.expect(names.includes("idx_qdb_orders_ByOwnerCreated")).toBe(true);
+    let row = rows.find(row => {
+      let match = row["name"];
+      return match === "idx_qdb_orders_ByOwner";
+    });
+    let firstSql;
+    if (row !== undefined) {
+      let match = row["sql"];
+      firstSql = typeof match === "string" ? match : "";
+    } else {
+      firstSql = "";
+    }
+    globalThis.expect(firstSql.includes("json_extract(item, '$.ownerId')")).toBe(true);
+  });
+  globalThis.test("composite-key indexes use pk/sk concatenation expressions", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let compositeIdx_pkFields = [
+      "tenantId",
+      "ownerId"
+    ];
+    let compositeIdx_pkSep = "|";
+    let compositeIdx = {
+      index: "ByTenantOwner",
+      type_: "S",
+      pkFields: compositeIdx_pkFields,
+      pkSep: compositeIdx_pkSep,
+      projectionType: "ALL"
+    };
+    Storage.make("composite", [compositeIdx], undefined, undefined, undefined, undefined, opts);
+    let listSql = SqliteDriver$ReventlessLocal.prepare(db, "SELECT sql FROM sqlite_master WHERE type='index' AND name='idx_qdb_composite_ByTenantOwner'");
+    let row = Stdlib_Option.getOrThrow(SqliteDriver$ReventlessLocal.get(listSql, []), undefined);
+    let match = row["sql"];
+    let sql = typeof match === "string" ? match : "";
+    globalThis.expect(sql.includes("json_extract(item, '$.tenantId') || '|' || json_extract(item, '$.ownerId')")).toBe(true);
+  });
+  globalThis.test("index name is sanitised — special characters in index name become underscores", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    Storage.make("rm", [{
+        index: "by-thing.v2",
+        type_: "S",
+        idField: "thing",
+        projectionType: "ALL"
+      }], undefined, undefined, undefined, undefined, opts);
+    let listIndexes = SqliteDriver$ReventlessLocal.prepare(db, "SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='qdb_rm'");
+    let names = SqliteDriver$ReventlessLocal.all(listIndexes, []).map(row => {
+      let match = row["name"];
+      if (typeof match === "string") {
+        return match;
+      } else {
+        return "";
+      }
+    });
+    globalThis.expect(names.includes("idx_qdb_rm_by_thing_v2")).toBe(true);
+  });
+});
+
+globalThis.describe("QueryDbStorage_Sqlite — TTL", () => {
+  globalThis.test("save with TTL in the future returns the item", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("rt-future", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let oneHourFromNow = (Date.now() / 1000.0 | 0) + 3600 | 0;
+    await ops.save("k", "alive", "Any", oneHourFromNow);
+    let items = await collect(ops.loadStream("k"));
+    globalThis.expect(items.length).toBe(1);
+  });
+  globalThis.test("save with TTL already in the past hides the item from reads", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("rt-past", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let aMinuteAgo = (Date.now() / 1000.0 | 0) - 60 | 0;
+    await ops.save("k", "expired", "Any", aMinuteAgo);
+    let items = await collect(ops.loadStream("k"));
+    globalThis.expect(items.length).toBe(0);
+  });
+  globalThis.test("save without TTL is treated as never expiring", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("rt-none", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.save("k", "forever", "Any", undefined);
+    let items = await collect(ops.loadStream("k"));
+    globalThis.expect(items.length).toBe(1);
+  });
+  globalThis.test("scanAll skips expired rows", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("scan-ttl", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.save("alive", "a", "Any", undefined);
+    let aMinuteAgo = (Date.now() / 1000.0 | 0) - 60 | 0;
+    await ops.save("expired", "e", "Any", aMinuteAgo);
+    let scan = TestBus.getQueryDbScan("scan-ttl");
+    if (scan !== undefined) {
+      globalThis.expect(scan().length).toBe(1);
+    } else {
+      globalThis.expect("scan registered").toBe("scan missing");
+    }
+  });
+  globalThis.test("overwriting an expired row with a non-expired one makes it visible again", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("overwrite-ttl", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let aMinuteAgo = (Date.now() / 1000.0 | 0) - 60 | 0;
+    await ops.save("k", "expired", "Any", aMinuteAgo);
+    let items1 = await collect(ops.loadStream("k"));
+    globalThis.expect(items1.length).toBe(0);
+    await ops.save("k", "revived", "Any", undefined);
+    let items2 = await collect(ops.loadStream("k"));
+    globalThis.expect(items2.length).toBe(1);
+    globalThis.expect(items2[0]).toEqual("revived");
+  });
+});
+
+export {
+  opts,
+  openFreshDb,
+  collect,
+}
+/*  Not a pure module */