@fedify/postgres 0.3.0-dev.22 → 0.4.0-dev.30

package/mod.ts

@@ -0,0 +1 @@
+export * from "./src/mod.ts";

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@fedify/postgres",
-  "version": "0.3.0-dev.22+7bce50b9",
+  "version": "0.4.0-dev.30",
   "description": "PostgreSQL drivers for Fedify",
   "keywords": [
     "fedify",
     "postgresql",
     "postgres"
   ],
+  "license": "MIT",
   "author": {
     "name": "Hong Minhee",
     "email": "hong@minhee.org",
@@ -17,58 +18,46 @@
     "type": "git",
     "url": "git+https://github.com/fedify-dev/postgres.git"
   },
-  "license": "MIT",
   "bugs": {
     "url": "https://github.com/fedify-dev/postgres/issues"
   },
-  "main": "./script/mod.js",
-  "module": "./esm/mod.js",
-  "types": "./types/mod.d.ts",
+  "funding": [
+    "https://opencollective.com/fedify",
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
   "exports": {
-    ".": {
-      "import": {
-        "types": "./types/mod.d.ts",
-        "default": "./esm/mod.js"
-      },
-      "require": {
-        "types": "./types/mod.d.ts",
-        "default": "./script/mod.js"
-      }
+    "./mod": {
+      "types": "./dist/mod.d.ts",
+      "import": "./dist/mod.js"
     },
     "./kv": {
-      "import": {
-        "types": "./types/src/kv.d.ts",
-        "default": "./esm/src/kv.js"
-      },
-      "require": {
-        "types": "./types/src/kv.d.ts",
-        "default": "./script/src/kv.js"
-      }
+      "types": "./dist/src/kv.d.ts",
+      "import": "./dist/src/kv.js"
     },
     "./mq": {
-      "import": {
-        "types": "./types/src/mq.d.ts",
-        "default": "./esm/src/mq.js"
-      },
-      "require": {
-        "types": "./types/src/mq.d.ts",
-        "default": "./script/src/mq.js"
-      }
-    }
+      "types": "./dist/src/mq.d.ts",
+      "import": "./dist/src/mq.js"
+    },
+    "./package.json": "./package.json"
   },
-  "funding": [
-    "https://opencollective.com/fedify",
-    "https://github.com/sponsors/dahlia"
-  ],
   "dependencies": {
-    "@fedify/fedify": "1.5.0-dev.750",
-    "@logtape/logtape": "^0.9.0",
-    "postgres": "^3.4.5",
-    "@deno/shim-deno": "~0.18.0",
-    "@js-temporal/polyfill": "^0.5.0"
+    "@js-temporal/polyfill": "^0.5.1",
+    "@logtape/logtape": "^1.0.0"
+  },
+  "peerDependencies": {
+    "@fedify/fedify": "^1.7.2",
+    "postgres": "^3.4.7"
   },
   "devDependencies": {
-    "@types/node": "^20.9.0"
+    "@std/async": "npm:@jsr/std__async@^1.0.5",
+    "tsdown": "^0.12.9",
+    "typescript": "^5.8.3"
   },
-  "_generatedBy": "dnt@dev"
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test --timeout=10000"
+  }
 }

package/src/kv.test.ts

@@ -0,0 +1,137 @@
+import { PostgresKvStore } from "@fedify/postgres/kv";
+import * as temporal from "@js-temporal/polyfill";
+import { delay } from "@std/async/delay";
+import assert from "node:assert/strict";
+import process from "node:process";
+import { test } from "node:test";
+import postgres from "postgres";
+
+let Temporal: typeof temporal.Temporal;
+if ("Temporal" in globalThis) {
+  Temporal = globalThis.Temporal;
+} else {
+  Temporal = temporal.Temporal;
+}
+
+const dbUrl = process.env.DATABASE_URL;
+
+function getStore(): {
+  // deno-lint-ignore no-explicit-any
+  sql: postgres.Sql<any>;
+  tableName: string;
+  store: PostgresKvStore;
+} {
+  const sql = postgres(dbUrl!);
+  const tableName = `fedify_kv_test_${Math.random().toString(36).slice(5)}`;
+  return {
+    sql,
+    tableName,
+    store: new PostgresKvStore(sql, { tableName }),
+  };
+}
+
+test("PostgresKvStore.initialize()", { skip: dbUrl == null }, async () => {
+  const { sql, tableName, store } = getStore();
+  try {
+    await store.initialize();
+    const result = await sql`
+      SELECT to_regclass(${tableName}) IS NOT NULL AS exists;
+    `;
+    assert(result[0].exists);
+  } finally {
+    await store.drop();
+    await sql.end();
+  }
+});
+
+test("PostgresKvStore.get()", { skip: dbUrl == null }, async () => {
+  const { sql, tableName, store } = getStore();
+  try {
+    await store.initialize();
+    await sql`
+      INSERT INTO ${sql(tableName)} (key, value)
+      VALUES (${["foo", "bar"]}, ${["foobar"]})
+    `;
+    assert.deepStrictEqual(await store.get(["foo", "bar"]), ["foobar"]);
+
+    await sql`
+      INSERT INTO ${sql(tableName)} (key, value, ttl)
+      VALUES (${["foo", "bar", "ttl"]}, ${["foobar"]}, ${"0 seconds"})
+    `;
+    await delay(500);
+    assert.strictEqual(await store.get(["foo", "bar", "ttl"]), undefined);
+  } finally {
+    await store.drop();
+    await sql.end();
+  }
+});
+
+test("PostgresKvStore.set()", { skip: dbUrl == null }, async () => {
+  const { sql, tableName, store } = getStore();
+  try {
+    await store.set(["foo", "baz"], "baz");
+    const result = await sql`
+      SELECT * FROM ${sql(tableName)}
+      WHERE key = ${["foo", "baz"]}
+    `;
+    assert.strictEqual(result.length, 1);
+    assert.deepStrictEqual(result[0].key, ["foo", "baz"]);
+    assert.strictEqual(result[0].value, "baz");
+    assert.strictEqual(result[0].ttl, null);
+
+    await store.set(["foo", "qux"], "qux", {
+      ttl: Temporal.Duration.from({ days: 1 }),
+    });
+    const result2 = await sql`
+      SELECT * FROM ${sql(tableName)}
+      WHERE key = ${["foo", "qux"]}
+    `;
+    assert.strictEqual(result2.length, 1);
+    assert.deepStrictEqual(result2[0].key, ["foo", "qux"]);
+    assert.strictEqual(result2[0].value, "qux");
+    assert.strictEqual(result2[0].ttl, "1 day");
+
+    await store.set(["foo", "quux"], true);
+    const result3 = await sql`
+      SELECT * FROM ${sql(tableName)}
+      WHERE key = ${["foo", "quux"]}
+    `;
+    assert.strictEqual(result3.length, 1);
+    assert.deepStrictEqual(result3[0].key, ["foo", "quux"]);
+    assert.strictEqual(result3[0].value, true);
+    assert.strictEqual(result3[0].ttl, null);
+  } finally {
+    await store.drop();
+    await sql.end();
+  }
+});
+
+test("PostgresKvStore.delete()", { skip: dbUrl == null }, async () => {
+  const { sql, tableName, store } = getStore();
+  try {
+    await store.delete(["foo", "bar"]);
+    const result = await sql`
+      SELECT * FROM ${sql(tableName)}
+      WHERE key = ${["foo", "bar"]}
+    `;
+    assert.strictEqual(result.length, 0);
+  } finally {
+    await store.drop();
+    await sql.end();
+  }
+});
+
+test("PostgresKvStore.drop()", { skip: dbUrl == null }, async () => {
+  const { sql, tableName, store } = getStore();
+  try {
+    await store.drop();
+    const result2 = await sql`
+      SELECT to_regclass(${tableName}) IS NOT NULL AS exists;
+    `;
+    assert.ok(!result2[0].exists);
+  } finally {
+    await sql.end();
+  }
+});
+
+// cSpell: ignore regclass

package/src/kv.ts

@@ -0,0 +1,146 @@
+import type { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+import type { JSONValue, Parameter, Sql } from "postgres";
+import { driverSerializesJson } from "./utils.ts";
+
+const logger = getLogger(["fedify", "postgres", "kv"]);
+
+/**
+ * Options for the PostgreSQL key-value store.
+ */
+export 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")),
+ * });
+ * ```
+ */
+export class PostgresKvStore implements KvStore {
+  // deno-lint-ignore ban-types
+  readonly #sql: Sql<{}>;
+  readonly #tableName: string;
+  #initialized: boolean;
+  #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(
+    // deno-lint-ignore ban-types
+    sql: Sql<{}>,
+    options: PostgresKvStoreOptions = {},
+  ) {
+    this.#sql = sql;
+    this.#tableName = options.tableName ?? "fedify_kv_v2";
+    this.#initialized = options.initialized ?? false;
+  }
+
+  async #expire(): Promise<void> {
+    await this.#sql`
+      DELETE FROM ${this.#sql(this.#tableName)}
+      WHERE ttl IS NOT NULL AND created + ttl < CURRENT_TIMESTAMP;
+    `;
+  }
+
+  async get<T = unknown>(key: KvKey): Promise<T | undefined> {
+    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 undefined;
+    return result[0].value as T;
+  }
+
+  async set(
+    key: KvKey,
+    value: unknown,
+    options?: KvStoreSetOptions | undefined,
+  ): Promise<void> {
+    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: KvKey): Promise<void> {
+    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(): Promise<void> {
+    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 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(): Promise<void> {
+    await this.#sql`DROP TABLE IF EXISTS ${this.#sql(this.#tableName)};`;
+  }
+
+  #json(value: unknown): Parameter {
+    if (this.#driverSerializesJson) return this.#sql.json(value as JSONValue);
+    return this.#sql.json(JSON.stringify(value));
+  }
+}

package/src/mod.ts

@@ -0,0 +1,2 @@
+export * from "./kv.ts";
+export * from "./mq.ts";

package/src/mq.test.ts

@@ -0,0 +1,114 @@
+import { PostgresMessageQueue } from "@fedify/postgres/mq";
+import * as temporal from "@js-temporal/polyfill";
+import { delay } from "@std/async/delay";
+import process from "node:process";
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import postgres from "postgres";
+
+let Temporal: typeof temporal.Temporal;
+if ("Temporal" in globalThis) {
+  Temporal = globalThis.Temporal;
+} else {
+  Temporal = temporal.Temporal;
+}
+
+const dbUrl = process.env.DATABASE_URL;
+
+test("PostgresMessageQueue", { skip: dbUrl == null }, async () => {
+  const sql = postgres(dbUrl!);
+  const sql2 = postgres(dbUrl!);
+  const tableName = `fedify_message_test_${
+    Math.random().toString(36).slice(5)
+  }`;
+  const channelName = `fedify_channel_test_${
+    Math.random().toString(36).slice(5)
+  }`;
+  const mq = new PostgresMessageQueue(sql, { tableName, channelName });
+  const mq2 = new PostgresMessageQueue(sql2, { tableName, channelName });
+
+  try {
+    const messages: string[] = [];
+    const controller = new AbortController();
+    const listening = mq.listen((message: string) => {
+      messages.push(message);
+    }, { signal: controller.signal });
+    const listening2 = mq2.listen((message: string) => {
+      messages.push(message);
+    }, { signal: controller.signal });
+
+    // enqueue()
+    await mq.enqueue("Hello, world!");
+
+    await waitFor(() => messages.length > 0, 15_000);
+
+    // listen()
+    assert.deepStrictEqual(messages, ["Hello, world!"]);
+
+    // enqueue() with delay
+    let started = 0;
+    started = Date.now();
+    await mq.enqueue(
+      { msg: "Delayed message" },
+      { delay: Temporal.Duration.from({ seconds: 3 }) },
+    );
+
+    await waitFor(() => messages.length > 1, 15_000);
+
+    // listen() with delay
+    assert.deepStrictEqual(messages, ["Hello, world!", {
+      msg: "Delayed message",
+    }]);
+    assert.ok(Date.now() - started > 3_000);
+
+    // enqueueMany()
+    while (messages.length > 0) messages.pop();
+    const batchMessages = [
+      "First batch message",
+      { text: "Second batch message" },
+      { text: "Third batch message", priority: "high" },
+    ];
+    await mq.enqueueMany(batchMessages);
+    await waitFor(() => messages.length === batchMessages.length, 15_000);
+    assert.deepStrictEqual(messages, batchMessages);
+
+    // enqueueMany() with delay
+    while (messages.length > 0) messages.pop();
+    started = Date.now();
+    const delayedBatchMessages = [
+      "Delayed batch 1",
+      "Delayed batch 2",
+    ];
+    await mq.enqueueMany(
+      delayedBatchMessages,
+      { delay: Temporal.Duration.from({ seconds: 2 }) },
+    );
+    await waitFor(
+      () => messages.length === delayedBatchMessages.length,
+      15_000,
+    );
+    assert.deepStrictEqual(messages, delayedBatchMessages);
+    assert.ok(Date.now() - started > 2_000);
+
+    controller.abort();
+    await listening;
+    await listening2;
+  } finally {
+    await mq.drop();
+    await sql.end();
+    await sql2.end();
+  }
+});
+
+async function waitFor(
+  predicate: () => boolean,
+  timeoutMs: number,
+): Promise<void> {
+  const started = Date.now();
+  while (!predicate()) {
+    await delay(500);
+    if (Date.now() - started > timeoutMs) {
+      throw new Error("Timeout");
+    }
+  }
+}