@fedify/sqlite 2.0.0-pr.433.1603 → 2.0.0-pr.434.1662

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/sqlite",
-  "version": "2.0.0-pr.433.1603+b568af0b",
+  "version": "2.0.0-pr.434.1662+ae9fb437",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/_virtual/{rolldown_runtime.js → rolldown_runtime.cjs}

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        const { Temporal } = require("@js-temporal/polyfill");
+      
 //#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -8,9 +8,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -27,4 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-export { __commonJS, __toESM };
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/adapter.d.cts

@@ -0,0 +1,45 @@
+//#region src/adapter.d.ts
+/**
+ * SQLite database adapter.
+ *
+ * An abstract interface for SQLite database for different runtime environments.
+ */
+interface SqliteDatabaseAdapter {
+  /**
+   * Prepares a SQL statement.
+   * @param sql - The SQL statement to prepare.
+   */
+  prepare(sql: string): SqliteStatementAdapter;
+  /**
+   * Executes a SQL statement.
+   * @param sql - The SQL statement to execute.
+   */
+  exec(sql: string): void;
+  /**
+   * Closes the database connection.
+   */
+  close(): void;
+}
+interface SqliteStatementAdapter {
+  /**
+   * Executes a SQL statement and returns the number of changes made to the database.
+   * @param params - The parameters to bind to the SQL statement.
+   */
+  run(...params: unknown[]): {
+    changes: number;
+    lastInsertRowid: number;
+  };
+  /**
+   * Executes a SQL statement and returns the first row of the result set.
+   * @param params - The parameters to bind to the SQL statement.
+   * @returns The first row of the result set, or `undefined` if the result set is empty.
+   */
+  get(...params: unknown[]): unknown | undefined;
+  /**
+   * Executes a SQL statement and returns all rows of the result set.
+   * @param params - The parameters to bind to the SQL statement.
+   */
+  all(...params: unknown[]): unknown[];
+}
+//#endregion
+export { SqliteDatabaseAdapter, SqliteStatementAdapter };

package/dist/kv.cjs

@@ -0,0 +1,189 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __sqlite = require_rolldown_runtime.__toESM(require("#sqlite"));
+const __js_temporal_polyfill = require_rolldown_runtime.__toESM(require("@js-temporal/polyfill"));
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+const es_toolkit = require_rolldown_runtime.__toESM(require("es-toolkit"));
+
+//#region src/kv.ts
+const logger = (0, __logtape_logtape.getLogger)([
+	"fedify",
+	"sqlite",
+	"kv"
+]);
+/**
+* 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),
+* });
+* ```
+*/
+var SqliteKvStore = class SqliteKvStore {
+	static #defaultTableName = "fedify_kv";
+	static #tableNameRegex = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+	#db;
+	#tableName;
+	#initialized;
+	/**
+	* Creates a new SQLite key–value store.
+	* @param db The SQLite database to use. Supports `node:sqlite` and `bun:sqlite`.
+	* @param options The options for the key–value store.
+	*/
+	constructor(db, options = {}) {
+		this.db = db;
+		this.options = options;
+		this.#db = new __sqlite.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}
+	*/
+	async get(key) {
+		this.initialize();
+		const encodedKey = this.#encodeKey(key);
+		const now = __js_temporal_polyfill.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 void 0;
+		return this.#decodeValue(result.value);
+	}
+	/**
+	* {@inheritDoc KvStore.set}
+	*/
+	async set(key, value, options) {
+		this.initialize();
+		if (value === void 0) return;
+		const encodedKey = this.#encodeKey(key);
+		const encodedValue = this.#encodeValue(value);
+		const now = __js_temporal_polyfill.Temporal.Now.instant().epochMilliseconds;
+		const expiresAt = options?.ttl !== void 0 ? 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}
+	*/
+	async delete(key) {
+		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}
+	*/
+	async cas(key, expectedValue, newValue, options) {
+		this.initialize();
+		const encodedKey = this.#encodeKey(key);
+		const now = __js_temporal_polyfill.Temporal.Now.instant().epochMilliseconds;
+		const expiresAt = options?.ttl !== void 0 ? 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);
+			const currentValue = currentResult === void 0 ? void 0 : this.#decodeValue(currentResult.value);
+			if (!(0, es_toolkit.isEqual)(currentValue, expectedValue)) {
+				this.#db.exec("ROLLBACK");
+				return false;
+			}
+			if (newValue === void 0) 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 = __js_temporal_polyfill.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) {
+		return JSON.stringify(key);
+	}
+	#decodeKey(key) {
+		return JSON.parse(key);
+	}
+	#encodeValue(value) {
+		return JSON.stringify(value);
+	}
+	#decodeValue(value) {
+		return JSON.parse(value);
+	}
+};
+
+//#endregion
+exports.SqliteKvStore = SqliteKvStore;

package/dist/kv.d.cts

@@ -0,0 +1,76 @@
+import { PlatformDatabase } from "#sqlite";
+import { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
+
+//#region src/kv.d.ts
+/**
+ * Options for the SQLite key–value store.
+ */
+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),
+ * });
+ * ```
+ */
+declare class SqliteKvStore implements KvStore {
+  #private;
+  readonly db: PlatformDatabase;
+  readonly options: SqliteKvStoreOptions;
+  /**
+   * Creates a new SQLite key–value store.
+   * @param db The SQLite database to use. Supports `node:sqlite` and `bun:sqlite`.
+   * @param options The options for the key–value store.
+   */
+  constructor(db: PlatformDatabase, options?: SqliteKvStoreOptions);
+  /**
+   * {@inheritDoc KvStore.get}
+   */
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  /**
+   * {@inheritDoc KvStore.set}
+   */
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
+  /**
+   * {@inheritDoc KvStore.delete}
+   */
+  delete(key: KvKey): Promise<void>;
+  /**
+   * {@inheritDoc KvStore.cas}
+   */
+  cas(key: KvKey, expectedValue: unknown, newValue: unknown, options?: KvStoreSetOptions): Promise<boolean>;
+  /**
+   * Creates the table used by the key–value store if it does not already exist.
+   * Does nothing if the table already exists.
+   */
+  initialize(): void;
+  /**
+   * Drops the table used by the key–value store.  Does nothing if the table
+   * does not exist.
+   */
+  drop(): void;
+}
+//#endregion
+export { SqliteKvStore, SqliteKvStoreOptions };

package/dist/kv.js

@@ -1,8 +1,8 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { qi } from "./node_modules/.pnpm/@js-temporal_polyfill@0.5.1/node_modules/@js-temporal/polyfill/dist/index.esm.js";
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { SqliteDatabase } from "#sqlite";
+import { Temporal } from "@js-temporal/polyfill";
 import { getLogger } from "@logtape/logtape";
 import { isEqual } from "es-toolkit";
 
@@ -53,7 +53,7 @@ var SqliteKvStore = class SqliteKvStore {
 	async get(key) {
 		this.initialize();
 		const encodedKey = this.#encodeKey(key);
-		const now = qi.Now.instant().epochMilliseconds;
+		const now = Temporal.Now.instant().epochMilliseconds;
 		const result = this.#db.prepare(`
       SELECT value 
       FROM "${this.#tableName}" 
@@ -70,7 +70,7 @@ var SqliteKvStore = class SqliteKvStore {
 		if (value === void 0) return;
 		const encodedKey = this.#encodeKey(key);
 		const encodedValue = this.#encodeValue(value);
-		const now = qi.Now.instant().epochMilliseconds;
+		const now = Temporal.Now.instant().epochMilliseconds;
 		const expiresAt = options?.ttl !== void 0 ? now + options.ttl.total({ unit: "milliseconds" }) : null;
 		this.#db.prepare(`INSERT INTO "${this.#tableName}" (key, value, created, expires)
         VALUES (?, ?, ?, ?)
@@ -98,7 +98,7 @@ var SqliteKvStore = class SqliteKvStore {
 	async cas(key, expectedValue, newValue, options) {
 		this.initialize();
 		const encodedKey = this.#encodeKey(key);
-		const now = qi.Now.instant().epochMilliseconds;
+		const now = Temporal.Now.instant().epochMilliseconds;
 		const expiresAt = options?.ttl !== void 0 ? now + options.ttl.total({ unit: "milliseconds" }) : null;
 		try {
 			this.#db.exec("BEGIN IMMEDIATE");
@@ -156,7 +156,7 @@ var SqliteKvStore = class SqliteKvStore {
 		logger.debug("Initialized the key–value store table {tableName}.", { tableName: this.#tableName });
 	}
 	#expire() {
-		const now = qi.Now.instant().epochMilliseconds;
+		const now = Temporal.Now.instant().epochMilliseconds;
 		this.#db.prepare(`
       DELETE FROM "${this.#tableName}"
       WHERE expires IS NOT NULL AND expires <= ?

package/dist/mod.cjs

@@ -0,0 +1,6 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_kv = require('./kv.cjs');
+
+exports.SqliteKvStore = require_kv.SqliteKvStore;

package/dist/mod.d.cts

@@ -0,0 +1,2 @@
+import { SqliteKvStore } from "./kv.cjs";
+export { SqliteKvStore };

package/dist/mod.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { SqliteKvStore } from "./kv.js";
 
 export { SqliteKvStore };

package/dist/sqlite.bun.cjs

@@ -0,0 +1,42 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const bun_sqlite = require_rolldown_runtime.__toESM(require("bun:sqlite"));
+
+//#region src/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
+exports.PlatformDatabase = bun_sqlite.Database;
+exports.SqliteDatabase = SqliteDatabase;
+exports.SqliteStatement = SqliteStatement;

package/dist/sqlite.bun.d.cts

@@ -0,0 +1,23 @@
+import { SqliteDatabaseAdapter, SqliteStatementAdapter } from "./adapter.cjs";
+import { Database, Statement } from "bun:sqlite";
+
+//#region src/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

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { Database } from "bun:sqlite";
 
 //#region src/sqlite.bun.ts

package/dist/sqlite.node.cjs

@@ -0,0 +1,44 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const node_sqlite = require_rolldown_runtime.__toESM(require("node:sqlite"));
+
+//#region src/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
+exports.PlatformDatabase = node_sqlite.DatabaseSync;
+exports.SqliteDatabase = SqliteDatabase;
+exports.SqliteStatement = SqliteStatement;

package/dist/sqlite.node.d.cts

@@ -0,0 +1,23 @@
+import { SqliteDatabaseAdapter, SqliteStatementAdapter } from "./adapter.cjs";
+import { DatabaseSync, StatementSync } from "node:sqlite";
+
+//#region src/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

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { DatabaseSync } from "node:sqlite";
 
 //#region src/sqlite.node.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/sqlite",
-  "version": "2.0.0-pr.433.1603+b568af0b",
+  "version": "2.0.0-pr.434.1662+ae9fb437",
   "description": "SQLite drivers for Fedify",
   "keywords": [
     "fedify",
@@ -22,18 +22,28 @@
     "https://github.com/sponsors/dahlia"
   ],
   "type": "module",
-  "main": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
   "module": "./dist/mod.js",
   "types": "./dist/mod.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/mod.d.ts",
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts",
+        "default": "./dist/mod.d.ts"
+      },
       "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs",
       "default": "./dist/mod.js"
     },
     "./kv": {
-      "types": "./dist/kv.d.ts",
+      "types": {
+        "import": "./dist/kv.d.ts",
+        "require": "./dist/kv.d.cts",
+        "default": "./dist/kv.d.ts"
+      },
       "import": "./dist/kv.js",
+      "require": "./dist/kv.cjs",
       "default": "./dist/kv.js"
     },
     "./package.json": "./package.json"
@@ -47,14 +57,14 @@
     }
   },
   "dependencies": {
+    "@js-temporal/polyfill": "^0.5.1",
     "@logtape/logtape": "^1.0.0",
     "es-toolkit": "^1.31.0"
   },
   "peerDependencies": {
-    "@fedify/fedify": "^2.0.0-pr.433.1603+b568af0b"
+    "@fedify/fedify": "^2.0.0-pr.434.1662+ae9fb437"
   },
   "devDependencies": {
-    "@js-temporal/polyfill": "^0.5.1",
     "@std/async": "npm:@jsr/std__async@^1.0.13",
     "tsdown": "^0.12.9",
     "typescript": "^5.9.2"

package/tsdown.config.ts

@@ -4,6 +4,7 @@ export default defineConfig({
   entry: ["src/mod.ts", "src/kv.ts", "src/sqlite.node.ts", "src/sqlite.bun.ts"],
   dts: true,
   unbundle: true,
+  format: ["esm", "cjs"],
   platform: "node",
   inputOptions: {
     onwarn(warning, defaultHandler) {
@@ -16,9 +17,16 @@ export default defineConfig({
       defaultHandler(warning);
     },
   },
-  outputOptions: {
-    intro: `
-      import { Temporal } from "@js-temporal/polyfill";
-    `,
+  outputOptions(outputOptions, format) {
+    if (format === "cjs") {
+      outputOptions.intro = `
+        const { Temporal } = require("@js-temporal/polyfill");
+      `;
+    } else {
+      outputOptions.intro = `
+        import { Temporal } from "@js-temporal/polyfill";
+      `;
+    }
+    return outputOptions;
   },
 });