@fedify/postgres 2.0.0-pr.412.1559 → 2.0.0-pr.412.1794

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,33 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/kv.cjs

@@ -0,0 +1,116 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_utils = require('./utils.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/kv.ts
+const logger = (0, __logtape_logtape.getLogger)([
+	"fedify",
+	"postgres",
+	"kv"
+]);
+/**
+* A key–value store that uses PostgreSQL as the underlying storage.
+*
+* @example
+* ```ts
+* import { createFederation } from "@fedify/fedify";
+* import { PostgresKvStore } from "@fedify/postgres";
+* import postgres from "postgres";
+*
+* const federation = createFederation({
+*   // ...
+*   kv: new PostgresKvStore(postgres("postgres://user:pass@localhost/db")),
+* });
+* ```
+*/
+var PostgresKvStore = class {
+	#sql;
+	#tableName;
+	#initialized;
+	#driverSerializesJson = false;
+	/**
+	* Creates a new PostgreSQL key–value store.
+	* @param sql The PostgreSQL client to use.
+	* @param options The options for the key–value store.
+	*/
+	constructor(sql, options = {}) {
+		this.#sql = sql;
+		this.#tableName = options.tableName ?? "fedify_kv_v2";
+		this.#initialized = options.initialized ?? false;
+	}
+	async #expire() {
+		await this.#sql`
+      DELETE FROM ${this.#sql(this.#tableName)}
+      WHERE ttl IS NOT NULL AND created + ttl < CURRENT_TIMESTAMP;
+    `;
+	}
+	async get(key) {
+		await this.initialize();
+		const result = await this.#sql`
+      SELECT value
+      FROM ${this.#sql(this.#tableName)}
+      WHERE key = ${key} AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP);
+    `;
+		if (result.length < 1) return void 0;
+		return result[0].value;
+	}
+	async set(key, value, options) {
+		await this.initialize();
+		const ttl = options?.ttl == null ? null : options.ttl.toString();
+		await this.#sql`
+      INSERT INTO ${this.#sql(this.#tableName)} (key, value, ttl)
+      VALUES (
+        ${key},
+        ${this.#json(value)},
+        ${ttl}
+      )
+      ON CONFLICT (key)
+        DO UPDATE SET value = EXCLUDED.value, ttl = EXCLUDED.ttl;
+    `;
+		await this.#expire();
+	}
+	async delete(key) {
+		await this.initialize();
+		await this.#sql`
+      DELETE FROM ${this.#sql(this.#tableName)}
+      WHERE key = ${key};
+    `;
+		await this.#expire();
+	}
+	/**
+	* Creates the table used by the key–value store if it does not already exist.
+	* Does nothing if the table already exists.
+	*/
+	async initialize() {
+		if (this.#initialized) return;
+		logger.debug("Initializing the key–value store table {tableName}...", { tableName: this.#tableName });
+		await this.#sql`
+      CREATE UNLOGGED TABLE IF NOT EXISTS ${this.#sql(this.#tableName)} (
+        key text[] PRIMARY KEY,
+        value jsonb NOT NULL,
+        created timestamp with time zone DEFAULT CURRENT_TIMESTAMP,
+        ttl interval
+      );
+    `;
+		this.#driverSerializesJson = await require_utils.driverSerializesJson(this.#sql);
+		this.#initialized = true;
+		logger.debug("Initialized the key–value store table {tableName}.", { tableName: this.#tableName });
+	}
+	/**
+	* Drops the table used by the key–value store.  Does nothing if the table
+	* does not exist.
+	*/
+	async drop() {
+		await this.#sql`DROP TABLE IF EXISTS ${this.#sql(this.#tableName)};`;
+	}
+	#json(value) {
+		if (this.#driverSerializesJson) return this.#sql.json(value);
+		return this.#sql.json(JSON.stringify(value));
+	}
+};
+
+//#endregion
+exports.PostgresKvStore = PostgresKvStore;

package/dist/kv.d.cts

@@ -0,0 +1,59 @@
+import { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
+import { Sql } from "postgres";
+
+//#region src/kv.d.ts
+/**
+ * Options for the PostgreSQL key–value store.
+ */
+interface PostgresKvStoreOptions {
+  /**
+   * The table name to use for the key–value store.
+   * `"fedify_kv_v2"` by default.
+   * @default `"fedify_kv_v2"`
+   */
+  tableName?: string;
+  /**
+   * Whether the table has been initialized.  `false` by default.
+   * @default `false`
+   */
+  initialized?: boolean;
+}
+/**
+ * A key–value store that uses PostgreSQL as the underlying storage.
+ *
+ * @example
+ * ```ts
+ * import { createFederation } from "@fedify/fedify";
+ * import { PostgresKvStore } from "@fedify/postgres";
+ * import postgres from "postgres";
+ *
+ * const federation = createFederation({
+ *   // ...
+ *   kv: new PostgresKvStore(postgres("postgres://user:pass@localhost/db")),
+ * });
+ * ```
+ */
+declare class PostgresKvStore implements KvStore {
+  #private;
+  /**
+   * Creates a new PostgreSQL key–value store.
+   * @param sql The PostgreSQL client to use.
+   * @param options The options for the key–value store.
+   */
+  constructor(sql: Sql<{}>, options?: PostgresKvStoreOptions);
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions | undefined): Promise<void>;
+  delete(key: KvKey): Promise<void>;
+  /**
+   * Creates the table used by the key–value store if it does not already exist.
+   * Does nothing if the table already exists.
+   */
+  initialize(): Promise<void>;
+  /**
+   * Drops the table used by the key–value store.  Does nothing if the table
+   * does not exist.
+   */
+  drop(): Promise<void>;
+}
+//#endregion
+export { PostgresKvStore, PostgresKvStoreOptions };

package/dist/kv.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { driverSerializesJson } from "./utils.js";
 import { getLogger } from "@logtape/logtape";
 

package/dist/mod.cjs

@@ -0,0 +1,8 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_kv = require('./kv.cjs');
+const require_mq = require('./mq.cjs');
+
+exports.PostgresKvStore = require_kv.PostgresKvStore;
+exports.PostgresMessageQueue = require_mq.PostgresMessageQueue;

package/dist/mod.d.cts

@@ -0,0 +1,3 @@
+import { PostgresKvStore, PostgresKvStoreOptions } from "./kv.cjs";
+import { PostgresMessageQueue, PostgresMessageQueueOptions } from "./mq.cjs";
+export { PostgresKvStore, PostgresKvStoreOptions, PostgresMessageQueue, PostgresMessageQueueOptions };

package/dist/mod.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { PostgresKvStore } from "./kv.js";
 import { PostgresMessageQueue } from "./mq.js";
 

package/dist/mq.cjs

@@ -0,0 +1,186 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_utils = require('./utils.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+const postgres = require_rolldown_runtime.__toESM(require("postgres"));
+
+//#region src/mq.ts
+const logger = (0, __logtape_logtape.getLogger)([
+	"fedify",
+	"postgres",
+	"mq"
+]);
+/**
+* A message queue that uses PostgreSQL as the underlying storage.
+*
+* @example
+* ```ts
+* import { createFederation } from "@fedify/fedify";
+* import { PostgresKvStore, PostgresMessageQueue } from "@fedify/postgres";
+* import postgres from "postgres";
+*
+* const sql = postgres("postgres://user:pass@localhost/db");
+*
+* const federation = createFederation({
+*   kv: new PostgresKvStore(sql),
+*   queue: new PostgresMessageQueue(sql),
+* });
+* ```
+*/
+var PostgresMessageQueue = class {
+	#sql;
+	#tableName;
+	#channelName;
+	#pollIntervalMs;
+	#initialized;
+	#driverSerializesJson = false;
+	constructor(sql, options = {}) {
+		this.#sql = sql;
+		this.#tableName = options?.tableName ?? "fedify_message_v2";
+		this.#channelName = options?.channelName ?? "fedify_channel";
+		this.#pollIntervalMs = Temporal.Duration.from(options?.pollInterval ?? { seconds: 5 }).total("millisecond");
+		this.#initialized = options?.initialized ?? false;
+	}
+	async enqueue(message, options) {
+		await this.initialize();
+		const delay = options?.delay ?? Temporal.Duration.from({ seconds: 0 });
+		if (options?.delay) logger.debug("Enqueuing a message with a delay of {delay}...", {
+			delay,
+			message
+		});
+		else logger.debug("Enqueuing a message...", { message });
+		await this.#sql`
+      INSERT INTO ${this.#sql(this.#tableName)} (message, delay)
+      VALUES (
+        ${this.#json(message)},
+        ${delay.toString()}
+      );
+    `;
+		logger.debug("Enqueued a message.", { message });
+		await this.#sql.notify(this.#channelName, delay.toString());
+		logger.debug("Notified the message queue channel {channelName}.", {
+			channelName: this.#channelName,
+			message
+		});
+	}
+	async enqueueMany(messages, options) {
+		if (messages.length === 0) return;
+		await this.initialize();
+		const delay = options?.delay ?? Temporal.Duration.from({ seconds: 0 });
+		if (options?.delay) logger.debug("Enqueuing messages with a delay of {delay}...", {
+			delay,
+			messages
+		});
+		else logger.debug("Enqueuing messages...", { messages });
+		for (const message of messages) await this.#sql`
+        INSERT INTO ${this.#sql(this.#tableName)} (message, delay)
+        VALUES (
+          ${this.#json(message)},
+          ${delay.toString()}
+        );
+      `;
+		logger.debug("Enqueued messages.", { messages });
+		await this.#sql.notify(this.#channelName, delay.toString());
+		logger.debug("Notified the message queue channel {channelName}.", {
+			channelName: this.#channelName,
+			messages
+		});
+	}
+	async listen(handler, options = {}) {
+		await this.initialize();
+		const { signal } = options;
+		const poll = async () => {
+			while (!signal?.aborted) {
+				const query = this.#sql`
+          DELETE FROM ${this.#sql(this.#tableName)}
+          WHERE id = (
+            SELECT id
+            FROM ${this.#sql(this.#tableName)}
+            WHERE created + delay < CURRENT_TIMESTAMP
+            ORDER BY created
+            LIMIT 1
+          )
+          RETURNING message;
+        `.execute();
+				const cancel = query.cancel.bind(query);
+				signal?.addEventListener("abort", cancel);
+				let i = 0;
+				for (const message of await query) {
+					if (signal?.aborted) return;
+					await handler(message.message);
+					i++;
+				}
+				signal?.removeEventListener("abort", cancel);
+				if (i < 1) break;
+			}
+		};
+		const timeouts = /* @__PURE__ */ new Set();
+		const listen = await this.#sql.listen(this.#channelName, async (delay) => {
+			const duration = Temporal.Duration.from(delay);
+			const durationMs = duration.total("millisecond");
+			if (durationMs < 1) await poll();
+			else timeouts.add(setTimeout(poll, durationMs));
+		}, poll);
+		signal?.addEventListener("abort", () => {
+			listen.unlisten();
+			for (const timeout of timeouts) clearTimeout(timeout);
+		});
+		while (!signal?.aborted) {
+			let timeout;
+			await new Promise((resolve) => {
+				signal?.addEventListener("abort", resolve);
+				timeout = setTimeout(() => {
+					signal?.removeEventListener("abort", resolve);
+					resolve(0);
+				}, this.#pollIntervalMs);
+				timeouts.add(timeout);
+			});
+			if (timeout != null) timeouts.delete(timeout);
+			await poll();
+		}
+		await new Promise((resolve) => {
+			signal?.addEventListener("abort", () => resolve());
+			if (signal?.aborted) return resolve();
+		});
+	}
+	/**
+	* Initializes the message queue table if it does not already exist.
+	*/
+	async initialize() {
+		if (this.#initialized) return;
+		logger.debug("Initializing the message queue table {tableName}...", { tableName: this.#tableName });
+		try {
+			await this.#sql`
+      CREATE TABLE IF NOT EXISTS ${this.#sql(this.#tableName)} (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        message jsonb NOT NULL,
+        delay interval DEFAULT '0 seconds',
+        created timestamp with time zone DEFAULT CURRENT_TIMESTAMP
+      );
+    `;
+		} catch (error) {
+			if (!(error instanceof postgres.default.PostgresError && error.constraint_name === "pg_type_typname_nsp_index")) {
+				logger.error("Failed to initialize the message queue table: {error}", { error });
+				throw error;
+			}
+		}
+		this.#driverSerializesJson = await require_utils.driverSerializesJson(this.#sql);
+		this.#initialized = true;
+		logger.debug("Initialized the message queue table {tableName}.", { tableName: this.#tableName });
+	}
+	/**
+	* Drops the message queue table if it exists.
+	*/
+	async drop() {
+		await this.#sql`DROP TABLE IF EXISTS ${this.#sql(this.#tableName)};`;
+	}
+	#json(value) {
+		if (this.#driverSerializesJson) return this.#sql.json(value);
+		return this.#sql.json(JSON.stringify(value));
+	}
+};
+
+//#endregion
+exports.PostgresMessageQueue = PostgresMessageQueue;

package/dist/mq.d.cts

@@ -0,0 +1,65 @@
+import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
+import { Sql } from "postgres";
+
+//#region src/mq.d.ts
+/**
+ * Options for the PostgreSQL message queue.
+ */
+interface PostgresMessageQueueOptions {
+  /**
+   * The table name to use for the message queue.
+   * `"fedify_message_v2"` by default.
+   * @default `"fedify_message_v2"`
+   */
+  tableName?: string;
+  /**
+   * The channel name to use for the message queue.
+   * `"fedify_channel"` by default.
+   * @default `"fedify_channel"`
+   */
+  channelName?: string;
+  /**
+   * Whether the table has been initialized.  `false` by default.
+   * @default `false`
+   */
+  initialized?: boolean;
+  /**
+   * The poll interval for the message queue.  5 seconds by default.
+   * @default `{ seconds: 5 }`
+   */
+  pollInterval?: Temporal.Duration | Temporal.DurationLike;
+}
+/**
+ * A message queue that uses PostgreSQL as the underlying storage.
+ *
+ * @example
+ * ```ts
+ * import { createFederation } from "@fedify/fedify";
+ * import { PostgresKvStore, PostgresMessageQueue } from "@fedify/postgres";
+ * import postgres from "postgres";
+ *
+ * const sql = postgres("postgres://user:pass@localhost/db");
+ *
+ * const federation = createFederation({
+ *   kv: new PostgresKvStore(sql),
+ *   queue: new PostgresMessageQueue(sql),
+ * });
+ * ```
+ */
+declare class PostgresMessageQueue implements MessageQueue {
+  #private;
+  constructor(sql: Sql<{}>, options?: PostgresMessageQueueOptions);
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
+  /**
+   * Initializes the message queue table if it does not already exist.
+   */
+  initialize(): Promise<void>;
+  /**
+   * Drops the message queue table if it exists.
+   */
+  drop(): Promise<void>;
+}
+//#endregion
+export { PostgresMessageQueue, PostgresMessageQueueOptions };

package/dist/mq.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { driverSerializesJson } from "./utils.js";
 import { getLogger } from "@logtape/logtape";
 import postgres from "postgres";

package/dist/utils.cjs

@@ -0,0 +1,12 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+
+//#region src/utils.ts
+async function driverSerializesJson(sql) {
+	const result = await sql`SELECT ${sql.json("{\"foo\":1}")}::jsonb AS test;`;
+	return result[0].test === "{\"foo\":1}";
+}
+
+//#endregion
+exports.driverSerializesJson = driverSerializesJson;

package/dist/utils.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 //#region src/utils.ts
 async function driverSerializesJson(sql) {
 	const result = await sql`SELECT ${sql.json("{\"foo\":1}")}::jsonb AS test;`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/postgres",
-  "version": "2.0.0-pr.412.1559+4a4b1861",
+  "version": "2.0.0-pr.412.1794+5c393341",
   "description": "PostgreSQL drivers for Fedify",
   "keywords": [
     "fedify",
@@ -27,23 +27,38 @@
     "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"
     },
     "./mq": {
-      "types": "./dist/mq.d.ts",
+      "types": {
+        "import": "./dist/mq.d.ts",
+        "require": "./dist/mq.d.cts",
+        "default": "./dist/mq.d.ts"
+      },
       "import": "./dist/mq.js",
+      "require": "./dist/mq.cjs",
       "default": "./dist/mq.js"
     },
     "./package.json": "./package.json"
@@ -55,11 +70,11 @@
   ],
   "dependencies": {
     "@js-temporal/polyfill": "^0.5.1",
-    "@logtape/logtape": "^1.0.0"
+    "@logtape/logtape": "^1.1.1"
   },
   "peerDependencies": {
     "postgres": "^3.4.7",
-    "@fedify/fedify": "2.0.0-pr.412.1559+4a4b1861"
+    "@fedify/fedify": "^2.0.0-pr.412.1794+5c393341"
   },
   "devDependencies": {
     "@std/async": "npm:@jsr/std__async@^1.0.13",