postgresai 0.14.0-dev.82 → 0.14.0-dev.83

package/lib/checkup.ts

@@ -1242,272 +1242,6 @@ async function generateF001(client: Client, nodeName: string): Promise<Report> {
   return report;
 }
 
-/**
- * Generate F004 report - Autovacuum: heap bloat estimate
- *
- * Estimates table bloat based on statistical analysis of table pages vs expected pages.
- * Uses pg_stats for column statistics to estimate row sizes.
- */
-async function generateF004(client: Client, nodeName: string): Promise<Report> {
-  const report = createBaseReport("F004", "Autovacuum: heap bloat estimate", nodeName);
-  const postgresVersion = await getPostgresVersion(client);
-
-  interface TableBloatRow {
-    schemaname: string;
-    tblname: string;
-    real_size_bytes: string;
-    real_size_pretty: string;
-    extra_size_bytes: string;
-    extra_size_pretty: string;
-    extra_pct: string;
-    fillfactor: string;
-    bloat_size_bytes: string;
-    bloat_size_pretty: string;
-    bloat_pct: string;
-    is_na: string;
-  }
-
-  let bloatData: TableBloatRow[] = [];
-  let bloatError: string | null = null;
-
-  try {
-    const result = await client.query<TableBloatRow>(`
-      select
-        schemaname,
-        tblname,
-        (bs * tblpages)::bigint as real_size_bytes,
-        pg_size_pretty((bs * tblpages)::bigint) as real_size_pretty,
-        ((tblpages - est_tblpages) * bs)::bigint as extra_size_bytes,
-        pg_size_pretty(((tblpages - est_tblpages) * bs)::bigint) as extra_size_pretty,
-        case when tblpages > 0 and tblpages - est_tblpages > 0
-          then round(100.0 * (tblpages - est_tblpages) / tblpages, 2)
-          else 0
-        end as extra_pct,
-        fillfactor,
-        case when tblpages - est_tblpages_ff > 0
-          then ((tblpages - est_tblpages_ff) * bs)::bigint
-          else 0
-        end as bloat_size_bytes,
-        pg_size_pretty(case when tblpages - est_tblpages_ff > 0
-          then ((tblpages - est_tblpages_ff) * bs)::bigint
-          else 0
-        end) as bloat_size_pretty,
-        case when tblpages > 0 and tblpages - est_tblpages_ff > 0
-          then round(100.0 * (tblpages - est_tblpages_ff) / tblpages, 2)
-          else 0
-        end as bloat_pct,
-        is_na::text
-      from (
-        select
-          ceil(reltuples / ((bs - page_hdr) / tpl_size)) + ceil(toasttuples / 4) as est_tblpages,
-          ceil(reltuples / ((bs - page_hdr) * fillfactor / (tpl_size * 100))) + ceil(toasttuples / 4) as est_tblpages_ff,
-          tblpages, fillfactor, bs, schemaname, tblname, is_na
-        from (
-          select
-            (4 + tpl_hdr_size + tpl_data_size + (2 * ma)
-              - case when tpl_hdr_size % ma = 0 then ma else tpl_hdr_size % ma end
-              - case when ceil(tpl_data_size)::int % ma = 0 then ma else ceil(tpl_data_size)::int % ma end
-            ) as tpl_size,
-            (heappages + toastpages) as tblpages,
-            reltuples, toasttuples, bs, page_hdr, schemaname, tblname, fillfactor, is_na
-          from (
-            select
-              ns.nspname as schemaname,
-              tbl.relname as tblname,
-              tbl.reltuples,
-              tbl.relpages as heappages,
-              coalesce(toast.relpages, 0) as toastpages,
-              coalesce(toast.reltuples, 0) as toasttuples,
-              coalesce(substring(array_to_string(tbl.reloptions, ' ') from 'fillfactor=([0-9]+)')::smallint, 100) as fillfactor,
-              current_setting('block_size')::numeric as bs,
-              case when version() ~ 'mingw32' or version() ~ '64-bit|x86_64|ppc64|ia64|amd64' then 8 else 4 end as ma,
-              24 as page_hdr,
-              23 + case when max(coalesce(s.null_frac, 0)) > 0 then (7 + count(s.attname)) / 8 else 0::int end
-                + case when bool_or(att.attname = 'oid' and att.attnum < 0) then 4 else 0 end as tpl_hdr_size,
-              sum((1 - coalesce(s.null_frac, 0)) * coalesce(s.avg_width, 0)) as tpl_data_size,
-              (bool_or(att.atttypid = 'pg_catalog.name'::regtype)
-                or sum(case when att.attnum > 0 then 1 else 0 end) <> count(s.attname))::int as is_na
-            from pg_attribute as att
-              join pg_class as tbl on att.attrelid = tbl.oid
-              join pg_namespace as ns on ns.oid = tbl.relnamespace
-              left join pg_stats as s on s.schemaname = ns.nspname
-                and s.tablename = tbl.relname and s.attname = att.attname
-              left join pg_class as toast on tbl.reltoastrelid = toast.oid
-            where not att.attisdropped
-              and tbl.relkind in ('r', 'm')
-              and ns.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')
-            group by ns.nspname, tbl.relname, tbl.reltuples, tbl.relpages, toast.relpages, toast.reltuples, tbl.reloptions
-          ) as s
-        ) as s2
-      ) as s3
-      where tblpages > 0 and (bs * tblpages) >= 1024 * 1024  -- exclude tables < 1 MiB
-      order by bloat_size_bytes desc
-      limit 100
-    `);
-    bloatData = result.rows;
-  } catch (err) {
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    console.log(`[F004] Error estimating table bloat: ${errorMsg}`);
-    bloatError = errorMsg;
-  }
-
-  report.results[nodeName] = {
-    data: {
-      tables: bloatData,
-      ...(bloatError && { error: bloatError }),
-    },
-    postgres_version: postgresVersion,
-  };
-
-  return report;
-}
-
-/**
- * Generate F005 report - Autovacuum: index bloat estimate
- *
- * Estimates B-tree index bloat based on statistical analysis of index pages vs expected pages.
- */
-async function generateF005(client: Client, nodeName: string): Promise<Report> {
-  const report = createBaseReport("F005", "Autovacuum: index bloat estimate", nodeName);
-  const postgresVersion = await getPostgresVersion(client);
-
-  interface IndexBloatRow {
-    schemaname: string;
-    tblname: string;
-    idxname: string;
-    real_size_bytes: string;
-    real_size_pretty: string;
-    table_size_bytes: string;
-    table_size_pretty: string;
-    extra_size_bytes: string;
-    extra_size_pretty: string;
-    extra_pct: string;
-    fillfactor: string;
-    bloat_size_bytes: string;
-    bloat_size_pretty: string;
-    bloat_pct: string;
-    is_na: string;
-  }
-
-  let bloatData: IndexBloatRow[] = [];
-  let bloatError: string | null = null;
-
-  try {
-    const result = await client.query<IndexBloatRow>(`
-      select
-        nspname as schemaname,
-        tblname,
-        idxname,
-        (bs * relpages)::bigint as real_size_bytes,
-        pg_size_pretty((bs * relpages)::bigint) as real_size_pretty,
-        pg_relation_size(tbloid)::bigint as table_size_bytes,
-        pg_size_pretty(pg_relation_size(tbloid)) as table_size_pretty,
-        ((relpages - est_pages) * bs)::bigint as extra_size_bytes,
-        pg_size_pretty(((relpages - est_pages) * bs)::bigint) as extra_size_pretty,
-        round(100.0 * (relpages - est_pages) / relpages, 2) as extra_pct,
-        fillfactor,
-        case when relpages > est_pages_ff
-          then ((relpages - est_pages_ff) * bs)::bigint
-          else 0
-        end as bloat_size_bytes,
-        pg_size_pretty(case when relpages > est_pages_ff
-          then ((relpages - est_pages_ff) * bs)::bigint
-          else 0
-        end) as bloat_size_pretty,
-        case when relpages > est_pages_ff
-          then round(100.0 * (relpages - est_pages_ff) / relpages, 2)
-          else 0
-        end as bloat_pct,
-        is_na::text
-      from (
-        select
-          coalesce(1 + ceil(reltuples / floor((bs - pageopqdata - pagehdr) / (4 + nulldatahdrwidth)::float)), 0) as est_pages,
-          coalesce(1 + ceil(reltuples / floor((bs - pageopqdata - pagehdr) * fillfactor / (100 * (4 + nulldatahdrwidth)::float))), 0) as est_pages_ff,
-          bs, nspname, tblname, idxname, relpages, fillfactor, is_na, tbloid
-        from (
-          select
-            maxalign, bs, nspname, tblname, idxname, reltuples, relpages, idxoid, fillfactor, tbloid,
-            (index_tuple_hdr_bm + maxalign
-              - case when index_tuple_hdr_bm % maxalign = 0 then maxalign else index_tuple_hdr_bm % maxalign end
-              + nulldatawidth + maxalign
-              - case when nulldatawidth = 0 then 0
-                     when nulldatawidth::integer % maxalign = 0 then maxalign
-                     else nulldatawidth::integer % maxalign end
-            )::numeric as nulldatahdrwidth,
-            pagehdr, pageopqdata, is_na
-          from (
-            select
-              n.nspname, i.tblname, i.idxname, i.reltuples, i.relpages, i.tbloid, i.idxoid, i.fillfactor,
-              current_setting('block_size')::numeric as bs,
-              case when version() ~ 'mingw32' or version() ~ '64-bit|x86_64|ppc64|ia64|amd64' then 8 else 4 end as maxalign,
-              24 as pagehdr,
-              16 as pageopqdata,
-              case when max(coalesce(s.null_frac, 0)) = 0
-                then 8
-                else 8 + ((32 + 8 - 1) / 8)
-              end as index_tuple_hdr_bm,
-              sum((1 - coalesce(s.null_frac, 0)) * coalesce(s.avg_width, 1024)) as nulldatawidth,
-              (max(case when i.atttypid = 'pg_catalog.name'::regtype then 1 else 0 end) > 0)::int as is_na
-            from (
-              select
-                ct.relname as tblname, ct.relnamespace, ic.idxname, ic.attpos, ic.indkey,
-                ic.indkey[ic.attpos], ic.reltuples, ic.relpages, ic.tbloid, ic.idxoid, ic.fillfactor,
-                coalesce(a1.attnum, a2.attnum) as attnum,
-                coalesce(a1.attname, a2.attname) as attname,
-                coalesce(a1.atttypid, a2.atttypid) as atttypid,
-                case when a1.attnum is null then ic.idxname else ct.relname end as attrelname
-              from (
-                select
-                  idxname, reltuples, relpages, tbloid, idxoid, fillfactor,
-                  indkey, generate_subscripts(indkey, 1) as attpos
-                from (
-                  select
-                    ci.relname as idxname, ci.reltuples, ci.relpages, i.indrelid as tbloid,
-                    i.indexrelid as idxoid,
-                    coalesce(substring(array_to_string(ci.reloptions, ' ') from 'fillfactor=([0-9]+)')::smallint, 90) as fillfactor,
-                    i.indkey
-                  from pg_index as i
-                    join pg_class as ci on ci.oid = i.indexrelid
-                    join pg_namespace as ns on ns.oid = ci.relnamespace
-                    join pg_am as am on am.oid = ci.relam
-                  where am.amname = 'btree'
-                    and ci.relpages > 0
-                    and ns.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')
-                ) as idx_data
-              ) as ic
-                join pg_class as ct on ct.oid = ic.tbloid
-                left join pg_attribute as a1 on a1.attrelid = ic.idxoid and a1.attnum = ic.indkey[ic.attpos]
-                left join pg_attribute as a2 on a2.attrelid = ic.tbloid and a2.attnum = ic.indkey[ic.attpos]
-            ) as i
-              join pg_namespace as n on n.oid = i.relnamespace
-              left join pg_stats as s on s.schemaname = n.nspname
-                and s.tablename = i.attrelname and s.attname = i.attname
-            group by n.nspname, i.tblname, i.idxname, i.reltuples, i.relpages, i.tbloid, i.idxoid, i.fillfactor
-          ) as rows_data_stats
-        ) as rows_hdr_pdg_stats
-      ) as relation_stats
-      where relpages > 0 and (bs * relpages) >= 1024 * 1024  -- exclude indexes < 1 MiB
-      order by bloat_size_bytes desc
-      limit 100
-    `);
-    bloatData = result.rows;
-  } catch (err) {
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    console.log(`[F005] Error estimating index bloat: ${errorMsg}`);
-    bloatError = errorMsg;
-  }
-
-  report.results[nodeName] = {
-    data: {
-      indexes: bloatData,
-      ...(bloatError && { error: bloatError }),
-    },
-    postgres_version: postgresVersion,
-  };
-
-  return report;
-}
-
 /**
  * Generate G001 report - Memory-related settings
  */
@@ -1712,8 +1446,6 @@ export const REPORT_GENERATORS: Record<string, (client: Client, nodeName: string
   D001: generateD001,
   D004: generateD004,
   F001: generateF001,
-  F004: generateF004,
-  F005: generateF005,
   G001: generateG001,
   G003: generateG003,
   H001: generateH001,

package/lib/mcp-server.ts

@@ -447,7 +447,7 @@ export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?:
   });
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  server.setRequestHandler(CallToolRequestSchema, async (req: any) => {
+  server.setRequestHandler(CallToolRequestSchema, async (req: any): Promise<any> => {
     return handleToolCall(req, rootOpts, extra);
   });
 

package/lib/supabase.ts

@@ -337,9 +337,14 @@ export class SupabaseClient {
  * Fetch the database pooler connection string from Supabase Management API.
  * Returns a postgresql:// URL with the specified username but no password.
  *
+ * Note: The username will be automatically suffixed with `.<projectRef>` if not
+ * already present, as required by Supabase pooler connections.
+ *
  * @param config Supabase configuration with projectRef and accessToken
- * @param username Username to include in the URL (e.g., monitoring user)
- * @returns Database URL without password (e.g., "postgresql://user@host:port/postgres")
+ * @param username Username to include in the URL (e.g., monitoring user).
+ *                 Will be transformed to `<username>.<projectRef>` format.
+ * @returns Database URL without password (e.g., "postgresql://user.project@host:port/postgres"),
+ *          or null if the API call fails or returns no pooler config.
  */
 export async function fetchPoolerDatabaseUrl(
   config: SupabaseConfig,
@@ -347,6 +352,14 @@ export async function fetchPoolerDatabaseUrl(
 ): Promise<string | null> {
   const url = `${SUPABASE_API_BASE}/v1/projects/${encodeURIComponent(config.projectRef)}/config/database/pooler`;
 
+  // For Supabase pooler connections, the username must include the project ref:
+  //   <user>.<project_ref>
+  // Example:
+  //   postgresql://postgres_ai_mon.xhaqmsvczjkkvkgdyast@aws-1-eu-west-1.pooler.supabase.com:6543/postgres
+  const suffix = `.${config.projectRef}`;
+  const effectiveUsername = username.endsWith(suffix) ? username : `${username}${suffix}`;
+  // URL-encode the username to handle special characters safely
+  const encodedUsername = encodeURIComponent(effectiveUsername);
   try {
     const response = await fetch(url, {
       method: "GET",
@@ -367,7 +380,7 @@ export async function fetchPoolerDatabaseUrl(
       const pooler = data[0];
       // Build URL from components if available
       if (pooler.db_host && pooler.db_port && pooler.db_name) {
-        return `postgresql://${username}@${pooler.db_host}:${pooler.db_port}/${pooler.db_name}`;
+        return `postgresql://${encodedUsername}@${pooler.db_host}:${pooler.db_port}/${pooler.db_name}`;
       }
       // Fallback: try to extract from connection_string if present
       if (typeof pooler.connection_string === "string") {
@@ -375,7 +388,7 @@ export async function fetchPoolerDatabaseUrl(
           const connUrl = new URL(pooler.connection_string);
           // Use provided username; handle empty port for default ports (e.g., 5432)
           const portPart = connUrl.port ? `:${connUrl.port}` : "";
-          return `postgresql://${username}@${connUrl.hostname}${portPart}${connUrl.pathname}`;
+          return `postgresql://${encodedUsername}@${connUrl.hostname}${portPart}${connUrl.pathname}`;
         } catch {
           return null;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresai",
-  "version": "0.14.0-dev.82",
+  "version": "0.14.0-dev.83",
   "description": "postgres_ai CLI",
   "license": "Apache-2.0",
   "private": false,
@@ -45,12 +45,12 @@
     "pg": "^8.16.3"
   },
   "devDependencies": {
-    "@types/bun": "^1.1.14",
+    "@types/bun": "^1.3.6",
     "@types/js-yaml": "^4.0.9",
     "@types/pg": "^8.15.6",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "typescript": "^5.3.3"
+    "typescript": "^5.9.3"
   },
   "publishConfig": {
     "access": "public"

package/test/checkup.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect } from "bun:test";
 import { resolve } from "path";
+import type { Client } from "pg";
 
 // Import from source directly since we're using Bun
 import * as checkup from "../lib/checkup";
@@ -86,7 +87,7 @@ describe("createBaseReport", () => {
 // Tests for CHECK_INFO
 describe("CHECK_INFO and REPORT_GENERATORS", () => {
   // Express-mode checks that have generators
-  const expressCheckIds = ["A002", "A003", "A004", "A007", "A013", "D001", "D004", "F001", "F004", "F005", "G001", "G003", "H001", "H002", "H004"];
+  const expressCheckIds = ["A002", "A003", "A004", "A007", "A013", "D001", "D004", "F001", "G001", "G003", "H001", "H002", "H004"];
 
   test("CHECK_INFO contains all express-mode checks", () => {
     for (const checkId of expressCheckIds) {
@@ -947,6 +948,66 @@ describe("CLI tests", () => {
     expect(r.stdout).toMatch(/available checks/i);
     expect(r.stdout).toMatch(/A002/);
   });
+
+  test("checkup --help shows --upload and --no-upload options", () => {
+    const r = runCli(["checkup", "--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/--upload/);
+    expect(r.stdout).toMatch(/--no-upload/);
+  });
+
+  test("checkup --no-upload is recognized as valid option", () => {
+    // Should not produce "unknown option" error for --no-upload
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--no-upload"]);
+    // Connection will fail, but option parsing should succeed
+    expect(r.stderr).not.toMatch(/unknown option/i);
+    expect(r.stderr).not.toMatch(/did you mean/i);
+  });
+
+  test("checkup --upload is recognized as valid option", () => {
+    // Should not produce "unknown option" error for --upload
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--upload"]);
+    // Connection will fail, but option parsing should succeed
+    expect(r.stderr).not.toMatch(/unknown option/i);
+    expect(r.stderr).not.toMatch(/did you mean/i);
+  });
+
+  test("checkup --json does not imply --no-upload (decoupled behavior)", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --json alone should NOT disable upload - when --upload is explicitly requested
+    // with --json, it should require API key (proving upload is not disabled)
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--json", "--upload"], env);
+    // Should fail with "API key is required" because upload is enabled
+    expect(r.stderr).toMatch(/API key is required/i);
+    expect(r.stderr).not.toMatch(/unknown option/i);
+  });
+
+  test("checkup --json --no-upload explicitly disables upload", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --json with --no-upload should disable upload (no API key error)
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--json", "--no-upload"], env);
+    // Should NOT show "API key is required" because upload is disabled
+    expect(r.stderr).not.toMatch(/API key is required/i);
+    expect(r.stderr).not.toMatch(/unknown option/i);
+  });
+
+  test("checkup --upload requires API key", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --upload explicitly requests upload, should fail without API key
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--upload"], env);
+    expect(r.stderr).toMatch(/API key is required/i);
+  });
+
+  test("checkup --no-upload does not require API key", () => {
+    // Use empty config dir to ensure no API key is configured
+    const env = { XDG_CONFIG_HOME: "/tmp/postgresai-test-empty-config" };
+    // --no-upload disables upload, should not require API key
+    const r = runCli(["checkup", "postgresql://test:test@localhost:5432/test", "--no-upload"], env);
+    expect(r.stderr).not.toMatch(/API key is required/i);
+  });
 });
 
 // Tests for checkup-api module

package/test/init.test.ts

@@ -68,9 +68,9 @@ describe("init module", () => {
     expect(plan.database).toBe("mydb");
     const roleStep = plan.steps.find((s: { name: string }) => s.name === "01.role");
     expect(roleStep).toBeTruthy();
-    expect(roleStep.sql).toMatch(/do\s+\$\$/i);
-    expect(roleStep.sql).toMatch(/create\s+user/i);
-    expect(roleStep.sql).toMatch(/alter\s+user/i);
+    expect(roleStep!.sql).toMatch(/do\s+\$\$/i);
+    expect(roleStep!.sql).toMatch(/create\s+user/i);
+    expect(roleStep!.sql).toMatch(/alter\s+user/i);
     expect(plan.steps.some((s: { optional?: boolean }) => s.optional)).toBe(false);
   });
 
@@ -86,12 +86,12 @@ describe("init module", () => {
 
     const roleStep = plan.steps.find((s: { name: string }) => s.name === "01.role");
     expect(roleStep).toBeTruthy();
-    expect(roleStep.sql).toMatch(/create\s+user\s+"user ""with"" quotes ✓"/i);
-    expect(roleStep.sql).toMatch(/alter\s+user\s+"user ""with"" quotes ✓"/i);
+    expect(roleStep!.sql).toMatch(/create\s+user\s+"user ""with"" quotes ✓"/i);
+    expect(roleStep!.sql).toMatch(/alter\s+user\s+"user ""with"" quotes ✓"/i);
 
     const permStep = plan.steps.find((s: { name: string }) => s.name === "03.permissions");
     expect(permStep).toBeTruthy();
-    expect(permStep.sql).toMatch(/grant connect on database "db name ""with"" quotes ✓" to "user ""with"" quotes ✓"/i);
+    expect(permStep!.sql).toMatch(/grant connect on database "db name ""with"" quotes ✓" to "user ""with"" quotes ✓"/i);
   });
 
   test("buildInitPlan keeps backslashes in passwords (no unintended escaping)", async () => {
@@ -104,7 +104,7 @@ describe("init module", () => {
     });
     const roleStep = plan.steps.find((s: { name: string }) => s.name === "01.role");
     expect(roleStep).toBeTruthy();
-    expect(roleStep.sql).toContain(`password '${pw}'`);
+    expect(roleStep!.sql).toContain(`password '${pw}'`);
   });
 
   test("buildInitPlan rejects identifiers with null bytes", async () => {
@@ -138,8 +138,8 @@ describe("init module", () => {
     });
     const step = plan.steps.find((s: { name: string }) => s.name === "01.role");
     expect(step).toBeTruthy();
-    expect(step.sql).toMatch(/password 'pa''ss'/);
-    expect(step.params).toBeUndefined();
+    expect(step!.sql).toMatch(/password 'pa''ss'/);
+    expect(step!.params).toBeUndefined();
   });
 
   test("buildInitPlan includes optional steps when enabled", async () => {
@@ -420,7 +420,7 @@ describe("init module", () => {
     });
     const step = plan.steps.find((s: { name: string }) => s.name === "01.role");
     expect(step).toBeTruthy();
-    const redacted = init.redactPasswordsInSql(step.sql);
+    const redacted = init.redactPasswordsInSql(step!.sql);
     expect(redacted).toMatch(/password '<redacted>'/i);
   });
 

package/test/issues.test.ts

@@ -60,7 +60,7 @@ describe("createIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       )
-    );
+    ) as unknown as typeof fetch;
 
     const result = await createIssue({
       apiKey: "test-key",
@@ -93,7 +93,7 @@ describe("createIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       );
-    });
+    }) as unknown as typeof fetch;
 
     const result = await createIssue({
       apiKey: "test-key",
@@ -127,7 +127,7 @@ describe("createIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       )
-    );
+    ) as unknown as typeof fetch;
 
     await expect(
       createIssue({
@@ -194,7 +194,7 @@ describe("updateIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       )
-    );
+    ) as unknown as typeof fetch;
 
     const result = await updateIssue({
       apiKey: "test-key",
@@ -223,7 +223,7 @@ describe("updateIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       )
-    );
+    ) as unknown as typeof fetch;
 
     const result = await updateIssue({
       apiKey: "test-key",
@@ -252,7 +252,7 @@ describe("updateIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       )
-    );
+    ) as unknown as typeof fetch;
 
     const result = await updateIssue({
       apiKey: "test-key",
@@ -281,7 +281,7 @@ describe("updateIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       )
-    );
+    ) as unknown as typeof fetch;
 
     const result = await updateIssue({
       apiKey: "test-key",
@@ -313,7 +313,7 @@ describe("updateIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       );
-    });
+    }) as unknown as typeof fetch;
 
     await updateIssue({
       apiKey: "test-key",
@@ -345,7 +345,7 @@ describe("updateIssue", () => {
           headers: { "Content-Type": "application/json" },
         })
       )
-    );
+    ) as unknown as typeof fetch;
 
     await expect(
       updateIssue({
@@ -414,7 +414,7 @@ describe("updateIssueComment", () => {
           headers: { "Content-Type": "application/json" },
         })
       );
-    });
+    }) as unknown as typeof fetch;
 
     const result = await updateIssueComment({
       apiKey: "test-key",
@@ -442,7 +442,7 @@ describe("updateIssueComment", () => {
           headers: { "Content-Type": "application/json" },
         })
       )
-    );
+    ) as unknown as typeof fetch;
 
     await expect(
       updateIssueComment({