@fedify/sqlite 1.8.1-pr.318.1225

package/kv.ts

@@ -0,0 +1,278 @@
+import { type PlatformDatabase, SqliteDatabase } from "#sqlite";
+import type { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
+import { Temporal } from "@js-temporal/polyfill";
+import { getLogger } from "@logtape/logtape";
+import { isEqual } from "es-toolkit";
+import type { SqliteDatabaseAdapter } from "./adapter.ts";
+
+const logger = getLogger(["fedify", "sqlite", "kv"]);
+
+/**
+ * Options for the SQLite key–value store.
+ */
+export interface SqliteKvStoreOptions {
+  /**
+   * The table name to use for the key–value store.
+   * Only letters, digits, and underscores are allowed.
+   * `"fedify_kv"` by default.
+   * @default `"fedify_kv"`
+   */
+  tableName?: string;
+
+  /**
+   * Whether the table has been initialized.  `false` by default.
+   * @default `false`
+   */
+  initialized?: boolean;
+}
+
+/**
+ * A key–value store that uses SQLite as the underlying storage.
+ *
+ * @example
+ * ```ts
+ * import { createFederation } from "@fedify/fedify";
+ * import { SqliteKvStore } from "@fedify/sqlite";
+ * import { DatabaseSync } from "node:sqlite";
+ *
+ * const db = new DatabaseSync(":memory:");
+ * const federation = createFederation({
+ *   // ...
+ *   kv: new SqliteKvStore(db),
+ * });
+ * ```
+ */
+export class SqliteKvStore implements KvStore {
+  static readonly #defaultTableName = "fedify_kv";
+  static readonly #tableNameRegex = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+  readonly #db: SqliteDatabaseAdapter;
+  readonly #tableName: string;
+  #initialized: boolean;
+
+  constructor(
+    readonly db: PlatformDatabase,
+    readonly options: SqliteKvStoreOptions = {},
+  ) {
+    this.#db = new SqliteDatabase(db);
+    this.#initialized = options.initialized ?? false;
+    this.#tableName = options.tableName ?? SqliteKvStore.#defaultTableName;
+
+    if (!SqliteKvStore.#tableNameRegex.test(this.#tableName)) {
+      throw new Error(
+        `Invalid table name for the key–value store: ${this.#tableName}`,
+      );
+    }
+  }
+
+  /**
+   * {@inheritDoc KvStore.get}
+   */
+  // deno-lint-ignore require-await
+  async get<T = unknown>(key: KvKey): Promise<T | undefined> {
+    this.initialize();
+
+    const encodedKey = this.#encodeKey(key);
+    const now = Temporal.Now.instant().epochMilliseconds;
+
+    const result = this.#db
+      .prepare(`
+      SELECT value 
+      FROM "${this.#tableName}" 
+      WHERE key = ? AND (expires IS NULL OR expires > ?)
+    `)
+      .get(encodedKey, now);
+
+    if (!result) {
+      return undefined;
+    }
+    return this.#decodeValue((result as { value: string }).value) as T;
+  }
+
+  /**
+   * {@inheritDoc KvStore.set}
+   */
+  // deno-lint-ignore require-await
+  async set(
+    key: KvKey,
+    value: unknown,
+    options?: KvStoreSetOptions,
+  ): Promise<void> {
+    this.initialize();
+
+    if (value === undefined) {
+      return;
+    }
+
+    const encodedKey = this.#encodeKey(key);
+    const encodedValue = this.#encodeValue(value);
+    const now = Temporal.Now.instant().epochMilliseconds;
+    const expiresAt = options?.ttl !== undefined
+      ? now + options.ttl.total({ unit: "milliseconds" })
+      : null;
+
+    this.#db
+      .prepare(
+        `INSERT INTO "${this.#tableName}" (key, value, created, expires)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          expires = excluded.expires`,
+      )
+      .run(encodedKey, encodedValue, now, expiresAt);
+
+    this.#expire();
+    return;
+  }
+
+  /**
+   * {@inheritDoc KvStore.delete}
+   */
+  // deno-lint-ignore require-await
+  async delete(key: KvKey): Promise<void> {
+    this.initialize();
+
+    const encodedKey = this.#encodeKey(key);
+
+    this.#db
+      .prepare(`
+      DELETE FROM "${this.#tableName}" WHERE key = ?
+    `)
+      .run(encodedKey);
+    this.#expire();
+    return Promise.resolve();
+  }
+
+  /**
+   * {@inheritDoc KvStore.cas}
+   */
+  // deno-lint-ignore require-await
+  async cas(
+    key: KvKey,
+    expectedValue: unknown,
+    newValue: unknown,
+    options?: KvStoreSetOptions,
+  ): Promise<boolean> {
+    this.initialize();
+
+    const encodedKey = this.#encodeKey(key);
+    const now = Temporal.Now.instant().epochMilliseconds;
+    const expiresAt = options?.ttl !== undefined
+      ? now + options.ttl.total({ unit: "milliseconds" })
+      : null;
+
+    try {
+      this.#db.exec("BEGIN IMMEDIATE");
+
+      const currentResult = this.#db
+        .prepare(`
+          SELECT value 
+          FROM "${this.#tableName}" 
+          WHERE key = ? AND (expires IS NULL OR expires > ?)
+        `)
+        .get(encodedKey, now) as { value: string } | undefined;
+      const currentValue = currentResult === undefined
+        ? undefined
+        : this.#decodeValue(currentResult.value);
+
+      if (!isEqual(currentValue, expectedValue)) {
+        this.#db.exec("ROLLBACK");
+        return false;
+      }
+
+      if (newValue === undefined) {
+        this.#db
+          .prepare(`
+            DELETE FROM "${this.#tableName}" WHERE key = ?
+          `)
+          .run(encodedKey);
+      } else {
+        const newValueJson = this.#encodeValue(newValue);
+
+        this.#db
+          .prepare(`
+          INSERT INTO "${this.#tableName}" (key, value, created, expires)
+          VALUES (?, ?, ?, ?)
+          ON CONFLICT(key) DO UPDATE SET
+            value = excluded.value,
+            expires = excluded.expires
+          `)
+          .run(encodedKey, newValueJson, now, expiresAt);
+      }
+
+      this.#db.exec("COMMIT");
+      this.#expire();
+      return true;
+    } catch (error) {
+      this.#db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+
+  /**
+   * Creates the table used by the key–value store if it does not already exist.
+   * Does nothing if the table already exists.
+   */
+  initialize() {
+    if (this.#initialized) {
+      return;
+    }
+
+    logger.debug("Initializing the key–value store table {tableName}...", {
+      tableName: this.#tableName,
+    });
+
+    this.#db.exec(`
+      CREATE TABLE IF NOT EXISTS "${this.#tableName}" (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        created INTEGER NOT NULL,
+        expires INTEGER
+      )
+    `);
+
+    this.#db.exec(`
+      CREATE INDEX IF NOT EXISTS "idx_${this.#tableName}_expires" 
+      ON "${this.#tableName}" (expires)
+    `);
+
+    this.#initialized = true;
+    logger.debug("Initialized the key–value store table {tableName}.", {
+      tableName: this.#tableName,
+    });
+  }
+
+  #expire() {
+    const now = Temporal.Now.instant().epochMilliseconds;
+    this.#db
+      .prepare(`
+      DELETE FROM "${this.#tableName}"
+      WHERE expires IS NOT NULL AND expires <= ?
+    `)
+      .run(now);
+  }
+
+  /**
+   * Drops the table used by the key–value store.  Does nothing if the table
+   * does not exist.
+   */
+  drop() {
+    this.#db.exec(`DROP TABLE IF EXISTS "${this.#tableName}"`);
+    this.#initialized = false;
+  }
+
+  #encodeKey(key: KvKey): string {
+    return JSON.stringify(key);
+  }
+
+  #decodeKey(key: string): KvKey {
+    return JSON.parse(key);
+  }
+
+  #encodeValue(value: unknown): string {
+    return JSON.stringify(value);
+  }
+
+  #decodeValue(value: string): unknown {
+    return JSON.parse(value);
+  }
+}

package/mod.ts

@@ -0,0 +1,5 @@
+/**
+ * SQLite drivers for Fedify.
+ * @module
+ */
+export { SqliteKvStore } from "./kv.ts";

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@fedify/sqlite",
+  "version": "1.8.1-pr.318.1225+27a86736",
+  "description": "SQLite drivers for Fedify",
+  "keywords": [
+    "fedify",
+    "sqlite"
+  ],
+  "license": "MIT",
+  "author": "An Nyeong <me@annyeong.me>",
+  "homepage": "https://fedify.dev/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fedify-dev/fedify.git",
+    "directory": "sqlite"
+  },
+  "bugs": {
+    "url": "https://github.com/fedify-dev/fedify/issues"
+  },
+  "funding": [
+    "https://opencollective.com/fedify",
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "main": "./dist/mod.js",
+  "module": "./dist/mod.js",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "import": "./dist/mod.js",
+      "default": "./dist/mod.js"
+    },
+    "./kv": {
+      "types": "./dist/kv.d.ts",
+      "import": "./dist/kv.js",
+      "default": "./dist/kv.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "imports": {
+    "#sqlite": {
+      "bun": "./dist/sqlite.bun.js",
+      "deno": "./dist/sqlite.node.js",
+      "import": "./dist/sqlite.node.js",
+      "require": "./dist/sqlite.node.cjs"
+    }
+  },
+  "dependencies": {
+    "@logtape/logtape": "^1.0.0",
+    "es-toolkit": "^1.31.0"
+  },
+  "peerDependencies": {
+    "@fedify/fedify": "1.8.1-pr.318.1225+27a86736"
+  },
+  "devDependencies": {
+    "@js-temporal/polyfill": "^0.5.1",
+    "@std/async": "npm:@jsr/std__async@^1.0.13",
+    "tsdown": "^0.12.9",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test kv.test.ts",
+    "test:bun": "tsdown && bun test --timeout=10000 kv.test.ts",
+    "test:deno": "tsdown && deno test kv.test.ts"
+  }
+}

package/sqlite.bun.ts

@@ -0,0 +1,45 @@
+import { Database, type Statement } from "bun:sqlite";
+import type {
+  SqliteDatabaseAdapter,
+  SqliteStatementAdapter,
+} from "./adapter.ts";
+
+export { Database as PlatformDatabase };
+export type { Statement as PlatformStatement };
+
+export class SqliteDatabase implements SqliteDatabaseAdapter {
+  constructor(private readonly db: Database) {}
+
+  prepare(sql: string): SqliteStatementAdapter {
+    return new SqliteStatement(this.db.query(sql));
+  }
+
+  exec(sql: string): void {
+    this.db.exec(sql);
+  }
+
+  close(): void {
+    this.db.close(false);
+  }
+}
+
+export class SqliteStatement implements SqliteStatementAdapter {
+  constructor(private readonly stmt: Statement) {}
+
+  run(...params: unknown[]): { changes: number; lastInsertRowid: number } {
+    return this.stmt.run(...params);
+  }
+
+  get(...params: unknown[]): unknown | undefined {
+    const result = this.stmt.get(...params);
+    // to make the return type compatible with the node version
+    if (result === null) {
+      return undefined;
+    }
+    return result;
+  }
+
+  all(...params: unknown[]): unknown[] {
+    return this.stmt.all(...params);
+  }
+}

package/sqlite.node.ts

@@ -0,0 +1,48 @@
+import {
+  DatabaseSync,
+  type SQLInputValue,
+  type StatementSync,
+} from "node:sqlite";
+import type {
+  SqliteDatabaseAdapter,
+  SqliteStatementAdapter,
+} from "./adapter.ts";
+
+export { DatabaseSync as PlatformDatabase };
+export type { StatementSync as PlatformStatement };
+
+export class SqliteDatabase implements SqliteDatabaseAdapter {
+  constructor(private readonly db: DatabaseSync) {}
+
+  prepare(sql: string): SqliteStatementAdapter {
+    return new SqliteStatement(this.db.prepare(sql));
+  }
+
+  exec(sql: string): void {
+    this.db.exec(sql);
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}
+
+export class SqliteStatement implements SqliteStatementAdapter {
+  constructor(private readonly stmt: StatementSync) {}
+
+  run(...params: unknown[]): { changes: number; lastInsertRowid: number } {
+    const result = this.stmt.run(...params as SQLInputValue[]);
+    return {
+      changes: Number(result.changes),
+      lastInsertRowid: Number(result.lastInsertRowid),
+    };
+  }
+
+  get(...params: unknown[]): unknown | undefined {
+    return this.stmt.get(...params as SQLInputValue[]);
+  }
+
+  all(...params: unknown[]): unknown[] {
+    return this.stmt.all(...params as SQLInputValue[]);
+  }
+}

package/tsdown.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["mod.ts", "kv.ts", "sqlite.node.ts", "sqlite.bun.ts"],
+  dts: true,
+  unbundle: true,
+  platform: "node",
+  outputOptions: {
+    intro: `
+import { Temporal } from "@js-temporal/polyfill";
+    `,
+  },
+});