@fedify/sqlite 2.0.0-pr.490.2 → 2.0.0-pr.559.5

package/src/kv.test.ts

@@ -1,9 +1,9 @@
 import { PlatformDatabase } from "#sqlite";
+import { SqliteKvStore } from "@fedify/sqlite/kv";
 import * as temporal from "@js-temporal/polyfill";
 import { delay } from "@std/async/delay";
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { SqliteKvStore } from "@fedify/sqlite/kv";
 
 let Temporal: typeof temporal.Temporal;
 if ("Temporal" in globalThis) {
@@ -310,3 +310,96 @@ test("SqliteKvStore.set() - preserves created timestamp on update", async () =>
     await db.close();
   }
 });
+
+test("SqliteKvStore.list()", async () => {
+  const { db, store } = getStore();
+  try {
+    await store.set(["prefix", "a"], "value-a");
+    await store.set(["prefix", "b"], "value-b");
+    await store.set(["prefix", "nested", "c"], "value-c");
+    await store.set(["other", "x"], "value-x");
+
+    const entries: { key: readonly string[]; value: unknown }[] = [];
+    for await (const entry of store.list(["prefix"])) {
+      entries.push({ key: entry.key, value: entry.value });
+    }
+
+    assert.strictEqual(entries.length, 3);
+    assert(
+      entries.some((e) => e.key[1] === "a" && e.value === "value-a"),
+    );
+    assert(entries.some((e) => e.key[1] === "b"));
+    assert(entries.some((e) => e.key[1] === "nested"));
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.list() - excludes expired", async () => {
+  const { db, tableName, store } = getStore();
+  try {
+    await store.initialize();
+    const now = Temporal.Now.instant().epochMilliseconds;
+
+    // Insert expired entry directly
+    db.prepare(`
+      INSERT INTO "${tableName}" (key, value, created, expires)
+      VALUES (?, ?, ?, ?)
+    `).run(
+      JSON.stringify(["list-test", "expired"]),
+      JSON.stringify("expired-value"),
+      now - 1000,
+      now - 500,
+    );
+    await store.set(["list-test", "valid"], "valid-value");
+
+    const entries: { key: readonly string[]; value: unknown }[] = [];
+    for await (const entry of store.list(["list-test"])) {
+      entries.push({ key: entry.key, value: entry.value });
+    }
+
+    assert.strictEqual(entries.length, 1);
+    assert.deepStrictEqual(entries[0].key, ["list-test", "valid"]);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.list() - single element key", async () => {
+  const { db, store } = getStore();
+  try {
+    await store.set(["a"], "value-a");
+    await store.set(["b"], "value-b");
+
+    const entries: { key: readonly string[]; value: unknown }[] = [];
+    for await (const entry of store.list(["a"])) {
+      entries.push({ key: entry.key, value: entry.value });
+    }
+
+    assert.strictEqual(entries.length, 1);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.list() - empty prefix", async () => {
+  const { db, store } = getStore();
+  try {
+    await store.set(["a"], "value-a");
+    await store.set(["b", "c"], "value-bc");
+    await store.set(["d", "e", "f"], "value-def");
+
+    const entries: { key: readonly string[]; value: unknown }[] = [];
+    for await (const entry of store.list()) {
+      entries.push({ key: entry.key, value: entry.value });
+    }
+
+    assert.strictEqual(entries.length, 3);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});

package/src/kv.ts

@@ -1,5 +1,10 @@
 import { type PlatformDatabase, SqliteDatabase } from "#sqlite";
-import type { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
+import type {
+  KvKey,
+  KvStore,
+  KvStoreListEntry,
+  KvStoreSetOptions,
+} from "@fedify/fedify";
 import { getLogger } from "@logtape/logtape";
 import { isEqual } from "es-toolkit";
 import type { SqliteDatabaseAdapter } from "./adapter.ts";
@@ -16,13 +21,13 @@ export interface SqliteKvStoreOptions {
    * `"fedify_kv"` by default.
    * @default `"fedify_kv"`
    */
-  tableName?: string;
+  readonly tableName?: string;
 
   /**
    * Whether the table has been initialized.  `false` by default.
    * @default `false`
    */
-  initialized?: boolean;
+  readonly initialized?: boolean;
 }
 
 /**
@@ -212,6 +217,51 @@ export class SqliteKvStore implements KvStore {
     }
   }
 
+  /**
+   * {@inheritDoc KvStore.list}
+   * @since 1.10.0
+   */
+  async *list(prefix?: KvKey): AsyncIterable<KvStoreListEntry> {
+    this.initialize();
+
+    const now = Temporal.Now.instant().epochMilliseconds;
+
+    let results: { key: string; value: string }[];
+
+    if (prefix == null || prefix.length === 0) {
+      // Empty prefix: return all entries
+      results = this.#db
+        .prepare(`
+          SELECT key, value
+          FROM "${this.#tableName}"
+          WHERE expires IS NULL OR expires > ?
+          ORDER BY key
+        `)
+        .all(now) as { key: string; value: string }[];
+    } else {
+      // JSON pattern: '["prefix","' matches keys starting with prefix
+      const pattern = JSON.stringify(prefix).slice(0, -1) + ",%";
+      const exactKey = JSON.stringify(prefix);
+
+      results = this.#db
+        .prepare(`
+          SELECT key, value
+          FROM "${this.#tableName}"
+          WHERE (key LIKE ? ESCAPE '\\' OR key = ?)
+            AND (expires IS NULL OR expires > ?)
+          ORDER BY key
+        `)
+        .all(pattern, exactKey, now) as { key: string; value: string }[];
+    }
+
+    for (const row of results) {
+      yield {
+        key: this.#decodeKey(row.key),
+        value: this.#decodeValue(row.value),
+      };
+    }
+  }
+
   /**
    * Creates the table used by the key–value store if it does not already exist.
    * Does nothing if the table already exists.

package/src/mod.ts

@@ -3,3 +3,4 @@
  * @module
  */
 export { SqliteKvStore } from "./kv.ts";
+export { SqliteMessageQueue } from "./mq.ts";

package/src/mq.test.ts

@@ -0,0 +1,24 @@
+import { PlatformDatabase } from "#sqlite";
+import { test } from "@fedify/fixture";
+import { SqliteMessageQueue } from "@fedify/sqlite/mq";
+import { getRandomKey, testMessageQueue } from "@fedify/testing";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dbDir = await mkdtemp(join(tmpdir(), "fedify-sqlite-"));
+const dbPath = join(dbDir, `${getRandomKey("sqlite")}.db`);
+const db = new PlatformDatabase(dbPath);
+const tableName = getRandomKey("message").replaceAll("-", "_");
+
+test("SqliteMessageQueue", () =>
+  testMessageQueue(
+    () => new SqliteMessageQueue(db, { tableName }),
+    ({ mq1, mq2, controller }) => {
+      controller.abort();
+      mq1.drop();
+      mq1[Symbol.dispose]();
+      mq2[Symbol.dispose]();
+    },
+    { testOrderingKey: true },
+  ));