@fedify/postgres 1.8.1-dev.1233 → 1.8.1-dev.1238

package/dist/kv.d.ts

@@ -2,7 +2,7 @@ import { Temporal } from "@js-temporal/polyfill";
 import { Sql } from "postgres";
 import { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
 
-//#region kv.d.ts
+//#region src/kv.d.ts
 /**
  * Options for the PostgreSQL key-value store.
  */

package/dist/kv.js

@@ -4,7 +4,7 @@
 import { driverSerializesJson } from "./utils.js";
 import { getLogger } from "@logtape/logtape";
 
-//#region kv.ts
+//#region src/kv.ts
 const logger = getLogger([
 	"fedify",
 	"postgres",

package/dist/mq.d.ts

@@ -2,7 +2,7 @@ import { Temporal } from "@js-temporal/polyfill";
 import { Sql } from "postgres";
 import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
 
-//#region mq.d.ts
+//#region src/mq.d.ts
 /**
  * Options for the PostgreSQL message queue.
  */

package/dist/mq.js

@@ -5,7 +5,7 @@ import { driverSerializesJson } from "./utils.js";
 import { getLogger } from "@logtape/logtape";
 import postgres from "postgres";
 
-//#region mq.ts
+//#region src/mq.ts
 const logger = getLogger([
 	"fedify",
 	"postgres",

package/dist/utils.js

@@ -1,7 +1,7 @@
 
       import { Temporal } from "@js-temporal/polyfill";
     
-//#region utils.ts
+//#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}";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/postgres",
-  "version": "1.8.1-dev.1233+f748fcc5",
+  "version": "1.8.1-dev.1238+4e631e65",
   "description": "PostgreSQL drivers for Fedify",
   "keywords": [
     "fedify",
@@ -17,7 +17,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fedify-dev/fedify.git",
-    "directory": "postgres"
+    "directory": "packages/postgres"
   },
   "bugs": {
     "url": "https://github.com/fedify-dev/fedify/issues"
@@ -48,13 +48,18 @@
     },
     "./package.json": "./package.json"
   },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
   "dependencies": {
     "@js-temporal/polyfill": "^0.5.1",
     "@logtape/logtape": "^1.0.0"
   },
   "peerDependencies": {
     "postgres": "^3.4.7",
-    "@fedify/fedify": "1.8.1-dev.1233+f748fcc5"
+    "@fedify/fedify": "1.8.1-dev.1238+4e631e65"
   },
   "devDependencies": {
     "@std/async": "npm:@jsr/std__async@^1.0.13",

package/deno.json

@@ -1,22 +0,0 @@
-{
-  "name": "@fedify/postgres",
-  "version": "1.8.1-dev.1233+f748fcc5",
-  "license": "MIT",
-  "exports": {
-    ".": "./mod.ts",
-    "./kv": "./kv.ts",
-    "./mq": "./mq.ts"
-  },
-  "nodeModulesDir": "none",
-  "unstable": [
-    "temporal"
-  ],
-  "exclude": [
-    "dist",
-    "node_modules"
-  ],
-  "tasks": {
-    "check": "deno fmt --check && deno lint && deno check *.ts",
-    "test": "deno test --allow-net --allow-env"
-  }
-}

package/kv.test.ts

@@ -1,142 +0,0 @@
-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 () => {
-  if (dbUrl == null) return; // Bun does not support skip option
-  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 () => {
-  if (dbUrl == null) return; // Bun does not support skip option
-  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 () => {
-  if (dbUrl == null) return; // Bun does not support skip option
-  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 () => {
-  if (dbUrl == null) return; // Bun does not support skip option
-  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 () => {
-  if (dbUrl == null) return; // Bun does not support skip option
-  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/kv.ts

@@ -1,146 +0,0 @@
-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/mod.ts

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

package/mq.test.ts

@@ -1,115 +0,0 @@
-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 () => {
-  if (dbUrl == null) return; // Bun does not support skip option
-  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");
-    }
-  }
-}

package/mq.ts

@@ -1,261 +0,0 @@
-import type {
-  MessageQueue,
-  MessageQueueEnqueueOptions,
-  MessageQueueListenOptions,
-} from "@fedify/fedify";
-import { getLogger } from "@logtape/logtape";
-import type { JSONValue, Parameter, Sql } from "postgres";
-import postgres from "postgres";
-import { driverSerializesJson } from "./utils.ts";
-
-const logger = getLogger(["fedify", "postgres", "mq"]);
-
-/**
- * Options for the PostgreSQL message queue.
- */
-export 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),
- * });
- * ```
- */
-export class PostgresMessageQueue implements MessageQueue {
-  // deno-lint-ignore ban-types
-  readonly #sql: Sql<{}>;
-  readonly #tableName: string;
-  readonly #channelName: string;
-  readonly #pollIntervalMs: number;
-  #initialized: boolean;
-  #driverSerializesJson = false;
-
-  constructor(
-    // deno-lint-ignore ban-types
-    sql: Sql<{}>,
-    options: PostgresMessageQueueOptions = {},
-  ) {
-    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(
-    // deno-lint-ignore no-explicit-any
-    message: any,
-    options?: MessageQueueEnqueueOptions,
-  ): Promise<void> {
-    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(
-    // deno-lint-ignore no-explicit-any
-    messages: any[],
-    options?: MessageQueueEnqueueOptions,
-  ): Promise<void> {
-    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(
-    // deno-lint-ignore no-explicit-any
-    handler: (message: any) => void | Promise<void>,
-    options: MessageQueueListenOptions = {},
-  ): Promise<void> {
-    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 = new Set<ReturnType<typeof setTimeout>>();
-    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: ReturnType<typeof setTimeout> | undefined;
-      await new Promise<unknown>((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<void>((resolve) => {
-      signal?.addEventListener("abort", () => resolve());
-      if (signal?.aborted) return resolve();
-    });
-  }
-
-  /**
-   * Initializes the message queue table if it does not already exist.
-   */
-  async initialize(): Promise<void> {
-    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.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 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(): 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));
-  }
-}
-
-// cSpell: ignore typname

package/tsdown.config.ts

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

package/utils.ts

@@ -1,7 +0,0 @@
-import type { Sql } from "postgres";
-
-// deno-lint-ignore ban-types
-export async function driverSerializesJson(sql: Sql<{}>): Promise<boolean> {
-  const result = await sql`SELECT ${sql.json('{"foo":1}')}::jsonb AS test;`;
-  return result[0].test === '{"foo":1}';
-}