@fedify/sqlite 1.8.1-pr.318.1225

package/dist/sqlite.bun.d.ts

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { SqliteDatabaseAdapter, SqliteStatementAdapter } from "./adapter.js";
+import { Database, Statement } from "bun:sqlite";
+
+//#region sqlite.bun.d.ts
+declare class SqliteDatabase implements SqliteDatabaseAdapter {
+  private readonly db;
+  constructor(db: Database);
+  prepare(sql: string): SqliteStatementAdapter;
+  exec(sql: string): void;
+  close(): void;
+}
+declare class SqliteStatement implements SqliteStatementAdapter {
+  private readonly stmt;
+  constructor(stmt: Statement);
+  run(...params: unknown[]): {
+    changes: number;
+    lastInsertRowid: number;
+  };
+  get(...params: unknown[]): unknown | undefined;
+  all(...params: unknown[]): unknown[];
+}
+//#endregion
+export { Database as PlatformDatabase, Statement as PlatformStatement, SqliteDatabase, SqliteStatement };

package/dist/sqlite.bun.js

@@ -0,0 +1,39 @@
+
+import { Temporal } from "@js-temporal/polyfill";
+    
+import { Database } from "bun:sqlite";
+
+//#region sqlite.bun.ts
+var SqliteDatabase = class {
+	constructor(db) {
+		this.db = db;
+	}
+	prepare(sql) {
+		return new SqliteStatement(this.db.query(sql));
+	}
+	exec(sql) {
+		this.db.exec(sql);
+	}
+	close() {
+		this.db.close(false);
+	}
+};
+var SqliteStatement = class {
+	constructor(stmt) {
+		this.stmt = stmt;
+	}
+	run(...params) {
+		return this.stmt.run(...params);
+	}
+	get(...params) {
+		const result = this.stmt.get(...params);
+		if (result === null) return void 0;
+		return result;
+	}
+	all(...params) {
+		return this.stmt.all(...params);
+	}
+};
+
+//#endregion
+export { Database as PlatformDatabase, SqliteDatabase, SqliteStatement };

package/dist/sqlite.node.d.ts

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { SqliteDatabaseAdapter, SqliteStatementAdapter } from "./adapter.js";
+import { DatabaseSync, StatementSync } from "node:sqlite";
+
+//#region sqlite.node.d.ts
+declare class SqliteDatabase implements SqliteDatabaseAdapter {
+  private readonly db;
+  constructor(db: DatabaseSync);
+  prepare(sql: string): SqliteStatementAdapter;
+  exec(sql: string): void;
+  close(): void;
+}
+declare class SqliteStatement implements SqliteStatementAdapter {
+  private readonly stmt;
+  constructor(stmt: StatementSync);
+  run(...params: unknown[]): {
+    changes: number;
+    lastInsertRowid: number;
+  };
+  get(...params: unknown[]): unknown | undefined;
+  all(...params: unknown[]): unknown[];
+}
+//#endregion
+export { DatabaseSync as PlatformDatabase, StatementSync as PlatformStatement, SqliteDatabase, SqliteStatement };

package/dist/sqlite.node.js

@@ -0,0 +1,41 @@
+
+import { Temporal } from "@js-temporal/polyfill";
+    
+import { DatabaseSync } from "node:sqlite";
+
+//#region sqlite.node.ts
+var SqliteDatabase = class {
+	constructor(db) {
+		this.db = db;
+	}
+	prepare(sql) {
+		return new SqliteStatement(this.db.prepare(sql));
+	}
+	exec(sql) {
+		this.db.exec(sql);
+	}
+	close() {
+		this.db.close();
+	}
+};
+var SqliteStatement = class {
+	constructor(stmt) {
+		this.stmt = stmt;
+	}
+	run(...params) {
+		const result = this.stmt.run(...params);
+		return {
+			changes: Number(result.changes),
+			lastInsertRowid: Number(result.lastInsertRowid)
+		};
+	}
+	get(...params) {
+		return this.stmt.get(...params);
+	}
+	all(...params) {
+		return this.stmt.all(...params);
+	}
+};
+
+//#endregion
+export { DatabaseSync as PlatformDatabase, SqliteDatabase, SqliteStatement };

package/kv.test.ts

@@ -0,0 +1,312 @@
+import { PlatformDatabase } from "#sqlite";
+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 "./kv.ts";
+
+let Temporal: typeof temporal.Temporal;
+if ("Temporal" in globalThis) {
+  Temporal = globalThis.Temporal;
+} else {
+  Temporal = temporal.Temporal;
+}
+
+function getStore(): {
+  db: PlatformDatabase;
+  tableName: string;
+  store: SqliteKvStore;
+} {
+  const db = new PlatformDatabase(":memory:");
+  const tableName = `fedify_kv_test_${Math.random().toString(36).slice(5)}`;
+  return {
+    db,
+    tableName,
+    store: new SqliteKvStore(db, { tableName }),
+  };
+}
+
+test("SqliteKvStore.initialize()", async () => {
+  const { db, tableName, store } = getStore();
+  try {
+    await store.initialize();
+    const result = await db.prepare(`
+      SELECT name FROM sqlite_master 
+      WHERE type='table' AND name=?
+    `).get(tableName);
+    assert(result !== undefined);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.get()", async () => {
+  const { db, tableName, store } = getStore();
+  try {
+    await store.initialize();
+    const now = Temporal.Now.instant().epochMilliseconds;
+    db.prepare(`
+      INSERT INTO ${tableName} (key, value, created)
+      VALUES (?, ?, ?)
+    `).run(JSON.stringify(["foo", "bar"]), JSON.stringify(["foobar"]), now);
+    assert.deepStrictEqual(await store.get(["foo", "bar"]), ["foobar"]);
+
+    db.prepare(`
+      INSERT INTO ${tableName} (key, value, expires, created)
+      VALUES (?, ?, ?, ?)
+    `).run(
+      JSON.stringify(["foo", "bar", "ttl"]),
+      JSON.stringify(["foobar"]),
+      now + 500,
+      Temporal.Now.instant().epochMilliseconds,
+    );
+    await delay(500);
+    assert.strictEqual(await store.get(["foo", "bar", "ttl"]), undefined);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.set()", async () => {
+  const { db, tableName, store } = getStore();
+  try {
+    await store.set(["foo", "baz"], "baz");
+
+    const result = db.prepare(`
+      SELECT * FROM ${tableName}
+      WHERE key = ?
+    `).all(JSON.stringify(["foo", "baz"])) as {
+      key: string;
+      value: string;
+      created: number;
+      expires: number | null;
+    }[];
+
+    assert.strictEqual(result.length, 1);
+    assert.deepStrictEqual(JSON.parse(result[0].key), ["foo", "baz"]);
+    assert.strictEqual(JSON.parse(result[0].value), "baz");
+    assert.strictEqual(result[0].expires, null);
+
+    await store.set(["foo", "qux"], "qux", {
+      ttl: Temporal.Duration.from({ days: 1 }),
+    });
+    const result2 = db.prepare(`
+      SELECT * FROM ${tableName}
+      WHERE key = ?
+    `).all(JSON.stringify(["foo", "qux"])) as {
+      key: string;
+      value: string;
+      created: number;
+      expires: number | null;
+    }[];
+    assert.strictEqual(result2.length, 1);
+    assert.deepStrictEqual(JSON.parse(result2[0].key), ["foo", "qux"]);
+    assert.strictEqual(JSON.parse(result2[0].value), "qux");
+    assert(
+      result2[0].expires && result2[0].expires >= result2[0].created + 86400000,
+    );
+
+    await store.set(["foo", "quux"], true);
+    const result3 = db.prepare(`
+      SELECT * FROM ${tableName}
+      WHERE key = ?
+    `).all(JSON.stringify(["foo", "quux"])) as {
+      key: string;
+      value: string;
+      created: number;
+      expires: number | null;
+    }[];
+    assert.strictEqual(result3.length, 1);
+    assert.deepStrictEqual(JSON.parse(result3[0].key), ["foo", "quux"]);
+    assert.strictEqual(JSON.parse(result3[0].value), true);
+    assert.strictEqual(result3[0].expires, null);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.set() - upsert functionality", async () => {
+  const { db, tableName, store } = getStore();
+  try {
+    await store.set(["upsert"], "initial");
+    assert.strictEqual(await store.get(["upsert"]), "initial");
+    await store.set(["upsert"], "updated");
+    assert.strictEqual(await store.get(["upsert"]), "updated");
+    const result = db.prepare(`
+      SELECT COUNT(*) as count FROM ${tableName} WHERE key = ?
+    `).get(JSON.stringify(["upsert"]));
+    assert.strictEqual((result as { count: number }).count, 1);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.delete()", async () => {
+  const { db, tableName, store } = getStore();
+  try {
+    await store.delete(["foo", "qux"]);
+    const result = db.prepare(`
+      SELECT * FROM ${tableName}
+      WHERE key = ?
+    `).all(JSON.stringify(["foo", "qux"]));
+    assert.strictEqual(result.length, 0);
+
+    db.prepare(`
+      INSERT INTO ${tableName} (key, value, created)
+      VALUES (?, ?, ?)
+    `).run(
+      JSON.stringify(["foo", "qux"]),
+      JSON.stringify(["qux"]),
+      Temporal.Now.instant().epochMilliseconds,
+    );
+    await store.delete(["foo", "qux"]);
+    const result2 = db.prepare(`
+      SELECT * FROM ${tableName}
+      WHERE key = ?
+    `).all(JSON.stringify(["foo", "qux"]));
+    assert.strictEqual(result2.length, 0);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.drop()", async () => {
+  const { db, tableName, store } = getStore();
+  try {
+    await store.drop();
+    const result = await db.prepare(`
+      SELECT name FROM sqlite_master 
+      WHERE type='table' AND name=?
+    `).get(tableName);
+    // Bun returns null, Node returns undefined
+    assert(result === undefined || result === null);
+  } finally {
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.cas()", async () => {
+  const { db, store } = getStore();
+  try {
+    await store.set(["foo", "bar"], "foobar");
+    assert.strictEqual(await store.cas(["foo", "bar"], "bar", "baz"), false);
+    assert.strictEqual(await store.get(["foo", "bar"]), "foobar");
+    assert.strictEqual(await store.cas(["foo", "bar"], "foobar", "baz"), true);
+    assert.strictEqual(await store.get(["foo", "bar"]), "baz");
+    await store.delete(["foo", "bar"]);
+    assert.strictEqual(await store.cas(["foo", "bar"], "foobar", "baz"), false);
+    assert.strictEqual(await store.get(["foo", "bar"]), undefined);
+    assert.strictEqual(await store.cas(["foo", "bar"], undefined, "baz"), true);
+    assert.strictEqual(await store.get(["foo", "bar"]), "baz");
+    assert.strictEqual(await store.cas(["foo", "bar"], "baz", undefined), true);
+    assert.strictEqual(await store.get(["foo", "bar"]), undefined);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore - complex values", async () => {
+  const { db, store } = getStore();
+  try {
+    await store.set(["complex"], {
+      nested: {
+        value: "test",
+      },
+    });
+    assert.deepStrictEqual(await store.get(["complex"]), {
+      nested: {
+        value: "test",
+      },
+    });
+
+    await store.set(["undefined"], undefined);
+    assert.strictEqual(await store.get(["undefined"]), undefined);
+    assert.strictEqual(await store.cas(["undefined"], undefined, "baz"), true);
+    assert.strictEqual(await store.get(["undefined"]), "baz");
+
+    await store.set(["null"], null);
+    assert.strictEqual(await store.get(["null"]), null);
+    assert.strictEqual(await store.cas(["null"], null, "baz"), true);
+    assert.strictEqual(await store.get(["null"]), "baz");
+
+    await store.set(["empty string"], "");
+    assert.strictEqual(await store.get(["empty string"]), "");
+    assert.strictEqual(await store.cas(["empty string"], "", "baz"), true);
+    assert.strictEqual(await store.get(["empty string"]), "baz");
+
+    await store.set(["array"], [1, 2, 3]);
+    assert.deepStrictEqual(await store.get(["array"]), [1, 2, 3]);
+    assert.strictEqual(
+      await store.cas(["array"], [1, 2, 3], [1, 2, 3, 4]),
+      true,
+    );
+    assert.deepStrictEqual(await store.get(["array"]), [1, 2, 3, 4]);
+
+    await store.set(["object"], { a: 1, b: 2 });
+    assert.deepStrictEqual(await store.get(["object"]), { b: 2, a: 1 });
+    assert.strictEqual(
+      await store.cas(["object"], { a: 1, b: 2 }, { a: 1, b: 2, c: 3 }),
+      true,
+    );
+    assert.deepStrictEqual(await store.get(["object"]), { a: 1, b: 2, c: 3 });
+
+    await store.set(["falsy", "false"], false);
+    assert.strictEqual(await store.get(["falsy", "false"]), false);
+    assert.strictEqual(await store.cas(["falsy", "false"], false, true), true);
+    assert.strictEqual(await store.get(["falsy", "false"]), true);
+
+    await store.set(["falsy", "0"], 0);
+    assert.strictEqual(await store.get(["falsy", "0"]), 0);
+    assert.strictEqual(await store.cas(["falsy", "0"], 0, 1), true);
+    assert.strictEqual(await store.get(["falsy", "0"]), 1);
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});
+
+test("SqliteKvStore.set() - preserves created timestamp on update", async () => {
+  const { db, tableName, store } = getStore();
+  try {
+    await store.set(["timestamp-test"], "initial");
+    const initialResult = db.prepare(`
+      SELECT created, expires FROM ${tableName}
+      WHERE key = ?
+    `).get(JSON.stringify(["timestamp-test"]));
+
+    const initialCreated = (initialResult as { created: number }).created;
+    assert(
+      initialCreated !== undefined,
+      "Initial created timestamp should be set",
+    );
+    assert.strictEqual(
+      (initialResult as { expires: number | null }).expires,
+      null,
+    );
+
+    await delay(100);
+
+    const ttl = Temporal.Duration.from({ seconds: 30 });
+    await store.set(["timestamp-test"], "updated", { ttl });
+
+    const updatedResult = db.prepare(`
+      SELECT created, expires FROM ${tableName}
+      WHERE key = ?
+    `).get(JSON.stringify(["timestamp-test"]));
+
+    assert.strictEqual(
+      (updatedResult as { created: number }).created,
+      initialCreated,
+      "Created timestamp should remain unchanged after update",
+    );
+  } finally {
+    await store.drop();
+    await db.close();
+  }
+});