postgresai 0.14.0-beta.2 → 0.14.0-beta.4

package/test/init.test.ts

@@ -0,0 +1,345 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { resolve } from "path";
+
+// Import from source directly since we're using Bun
+import * as init from "../lib/init";
+const DEFAULT_MONITORING_USER = init.DEFAULT_MONITORING_USER;
+
+function runCli(args: string[], env: Record<string, string> = {}) {
+  const cliPath = resolve(import.meta.dir, "..", "bin", "postgres-ai.ts");
+  const bunBin = typeof process.execPath === "string" && process.execPath.length > 0 ? process.execPath : "bun";
+  const result = Bun.spawnSync([bunBin, cliPath, ...args], {
+    env: { ...process.env, ...env },
+  });
+  return {
+    status: result.exitCode,
+    stdout: new TextDecoder().decode(result.stdout),
+    stderr: new TextDecoder().decode(result.stderr),
+  };
+}
+
+function runPgai(args: string[], env: Record<string, string> = {}) {
+  // For testing, run the CLI directly since pgai is just a thin wrapper
+  // In production, pgai wrapper will properly resolve and spawn the postgresai CLI
+  const cliPath = resolve(import.meta.dir, "..", "bin", "postgres-ai.ts");
+  const bunBin = typeof process.execPath === "string" && process.execPath.length > 0 ? process.execPath : "bun";
+  const result = Bun.spawnSync([bunBin, cliPath, ...args], {
+    env: { ...process.env, ...env },
+  });
+  return {
+    status: result.exitCode,
+    stdout: new TextDecoder().decode(result.stdout),
+    stderr: new TextDecoder().decode(result.stderr),
+  };
+}
+
+describe("init module", () => {
+  test("maskConnectionString hides password when present", () => {
+    const masked = init.maskConnectionString("postgresql://user:secret@localhost:5432/mydb");
+    expect(masked).toMatch(/postgresql:\/\/user:\*{5}@localhost:5432\/mydb/);
+    expect(masked).not.toMatch(/secret/);
+  });
+
+  test("parseLibpqConninfo parses basic host/dbname/user/port/password", () => {
+    const cfg = init.parseLibpqConninfo("dbname=mydb host=localhost user=alice port=5432 password=secret");
+    expect(cfg.database).toBe("mydb");
+    expect(cfg.host).toBe("localhost");
+    expect(cfg.user).toBe("alice");
+    expect(cfg.port).toBe(5432);
+    expect(cfg.password).toBe("secret");
+  });
+
+  test("parseLibpqConninfo supports quoted values", () => {
+    const cfg = init.parseLibpqConninfo("dbname='my db' host='local host'");
+    expect(cfg.database).toBe("my db");
+    expect(cfg.host).toBe("local host");
+  });
+
+  test("buildInitPlan includes a race-safe role DO block", async () => {
+    const plan = await init.buildInitPlan({
+      database: "mydb",
+      monitoringUser: DEFAULT_MONITORING_USER,
+      monitoringPassword: "pw",
+      includeOptionalPermissions: false,
+    });
+
+    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(plan.steps.some((s: { optional?: boolean }) => s.optional)).toBe(false);
+  });
+
+  test("buildInitPlan handles special characters in monitoring user and database identifiers", async () => {
+    const monitoringUser = 'user "with" quotes ✓';
+    const database = 'db name "with" quotes ✓';
+    const plan = await init.buildInitPlan({
+      database,
+      monitoringUser,
+      monitoringPassword: "pw",
+      includeOptionalPermissions: false,
+    });
+
+    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);
+
+    const permStep = plan.steps.find((s: { name: string }) => s.name === "02.permissions");
+    expect(permStep).toBeTruthy();
+    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 () => {
+    const pw = String.raw`pw\with\backslash`;
+    const plan = await init.buildInitPlan({
+      database: "mydb",
+      monitoringUser: DEFAULT_MONITORING_USER,
+      monitoringPassword: pw,
+      includeOptionalPermissions: false,
+    });
+    const roleStep = plan.steps.find((s: { name: string }) => s.name === "01.role");
+    expect(roleStep).toBeTruthy();
+    expect(roleStep.sql).toContain(`password '${pw}'`);
+  });
+
+  test("buildInitPlan rejects identifiers with null bytes", async () => {
+    await expect(
+      init.buildInitPlan({
+        database: "mydb",
+        monitoringUser: "bad\0user",
+        monitoringPassword: "pw",
+        includeOptionalPermissions: false,
+      })
+    ).rejects.toThrow(/Identifier cannot contain null bytes/);
+  });
+
+  test("buildInitPlan rejects literals with null bytes", async () => {
+    await expect(
+      init.buildInitPlan({
+        database: "mydb",
+        monitoringUser: DEFAULT_MONITORING_USER,
+        monitoringPassword: "pw\0bad",
+        includeOptionalPermissions: false,
+      })
+    ).rejects.toThrow(/Literal cannot contain null bytes/);
+  });
+
+  test("buildInitPlan inlines password safely for CREATE/ALTER ROLE grammar", async () => {
+    const plan = await init.buildInitPlan({
+      database: "mydb",
+      monitoringUser: DEFAULT_MONITORING_USER,
+      monitoringPassword: "pa'ss",
+      includeOptionalPermissions: false,
+    });
+    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();
+  });
+
+  test("buildInitPlan includes optional steps when enabled", async () => {
+    const plan = await init.buildInitPlan({
+      database: "mydb",
+      monitoringUser: DEFAULT_MONITORING_USER,
+      monitoringPassword: "pw",
+      includeOptionalPermissions: true,
+    });
+    expect(plan.steps.some((s: { optional?: boolean }) => s.optional)).toBe(true);
+  });
+
+  test("resolveAdminConnection accepts positional URI", () => {
+    const r = init.resolveAdminConnection({ conn: "postgresql://u:p@h:5432/d" });
+    expect(r.clientConfig.connectionString).toBeTruthy();
+    expect(r.display).not.toMatch(/:p@/);
+  });
+
+  test("resolveAdminConnection accepts positional conninfo", () => {
+    const r = init.resolveAdminConnection({ conn: "dbname=mydb host=localhost user=alice" });
+    expect(r.clientConfig.database).toBe("mydb");
+    expect(r.clientConfig.host).toBe("localhost");
+    expect(r.clientConfig.user).toBe("alice");
+  });
+
+  test("resolveAdminConnection rejects invalid psql-like port", () => {
+    expect(() => init.resolveAdminConnection({ host: "localhost", port: "abc", username: "u", dbname: "d" }))
+      .toThrow(/Invalid port value/);
+  });
+
+  test("resolveAdminConnection rejects when only PGPASSWORD is provided (no connection details)", () => {
+    expect(() => init.resolveAdminConnection({ envPassword: "pw" })).toThrow(/Connection is required/);
+  });
+
+  test("resolveAdminConnection rejects when connection is missing", () => {
+    expect(() => init.resolveAdminConnection({})).toThrow(/Connection is required/);
+  });
+
+  test("resolveMonitoringPassword auto-generates a strong, URL-safe password by default", async () => {
+    const r = await init.resolveMonitoringPassword({ monitoringUser: DEFAULT_MONITORING_USER });
+    expect(r.generated).toBe(true);
+    expect(typeof r.password).toBe("string");
+    expect(r.password.length).toBeGreaterThanOrEqual(30);
+    expect(r.password).toMatch(/^[A-Za-z0-9_-]+$/);
+  });
+
+  test("applyInitPlan preserves Postgres error fields on step failures", async () => {
+    const plan = {
+      monitoringUser: DEFAULT_MONITORING_USER,
+      database: "mydb",
+      steps: [{ name: "01.role", sql: "select 1" }],
+    };
+
+    const pgErr = Object.assign(new Error("permission denied to create role"), {
+      code: "42501",
+      detail: "some detail",
+      hint: "some hint",
+      schema: "pg_catalog",
+      table: "pg_roles",
+      constraint: "some_constraint",
+      routine: "aclcheck_error",
+    });
+
+    const calls: string[] = [];
+    const client = {
+      query: async (sql: string) => {
+        calls.push(sql);
+        if (sql === "begin;") return { rowCount: 1 };
+        if (sql === "rollback;") return { rowCount: 1 };
+        if (sql === "select 1") throw pgErr;
+        throw new Error(`unexpected sql: ${sql}`);
+      },
+    };
+
+    try {
+      await init.applyInitPlan({ client: client as any, plan: plan as any });
+      expect(true).toBe(false); // Should not reach here
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(Error);
+      expect(e.message).toMatch(/Failed at step "01\.role":/);
+      expect(e.code).toBe("42501");
+      expect(e.detail).toBe("some detail");
+      expect(e.hint).toBe("some hint");
+      expect(e.schema).toBe("pg_catalog");
+      expect(e.table).toBe("pg_roles");
+      expect(e.constraint).toBe("some_constraint");
+      expect(e.routine).toBe("aclcheck_error");
+    }
+
+    expect(calls).toEqual(["begin;", "select 1", "rollback;"]);
+  });
+
+  test("verifyInitSetup runs inside a repeatable read snapshot and rolls back", async () => {
+    const calls: string[] = [];
+    const client = {
+      query: async (sql: string, params?: any) => {
+        calls.push(String(sql));
+
+        if (String(sql).toLowerCase().startsWith("begin isolation level repeatable read")) {
+          return { rowCount: 1, rows: [] };
+        }
+        if (String(sql).toLowerCase() === "rollback;") {
+          return { rowCount: 1, rows: [] };
+        }
+        if (String(sql).includes("select rolconfig")) {
+          return { rowCount: 1, rows: [{ rolconfig: ['search_path=postgres_ai, "$user", public, pg_catalog'] }] };
+        }
+        if (String(sql).includes("from pg_catalog.pg_roles")) {
+          return { rowCount: 1, rows: [] };
+        }
+        if (String(sql).includes("has_database_privilege")) {
+          return { rowCount: 1, rows: [{ ok: true }] };
+        }
+        if (String(sql).includes("pg_has_role")) {
+          return { rowCount: 1, rows: [{ ok: true }] };
+        }
+        if (String(sql).includes("has_table_privilege") && String(sql).includes("pg_catalog.pg_index")) {
+          return { rowCount: 1, rows: [{ ok: true }] };
+        }
+        if (String(sql).includes("to_regclass('postgres_ai.pg_statistic')")) {
+          return { rowCount: 1, rows: [{ ok: true }] };
+        }
+        if (String(sql).includes("has_table_privilege") && String(sql).includes("postgres_ai.pg_statistic")) {
+          return { rowCount: 1, rows: [{ ok: true }] };
+        }
+        if (String(sql).includes("has_function_privilege")) {
+          return { rowCount: 1, rows: [{ ok: true }] };
+        }
+        if (String(sql).includes("has_schema_privilege")) {
+          return { rowCount: 1, rows: [{ ok: true }] };
+        }
+
+        throw new Error(`unexpected sql: ${sql} params=${JSON.stringify(params)}`);
+      },
+    };
+
+    const r = await init.verifyInitSetup({
+      client: client as any,
+      database: "mydb",
+      monitoringUser: DEFAULT_MONITORING_USER,
+      includeOptionalPermissions: false,
+    });
+    expect(r.ok).toBe(true);
+    expect(r.missingRequired.length).toBe(0);
+
+    expect(calls.length).toBeGreaterThan(2);
+    expect(calls[0].toLowerCase()).toMatch(/^begin isolation level repeatable read/);
+    expect(calls[calls.length - 1].toLowerCase()).toBe("rollback;");
+  });
+
+  test("redactPasswordsInSql redacts password literals with embedded quotes", async () => {
+    const plan = await init.buildInitPlan({
+      database: "mydb",
+      monitoringUser: DEFAULT_MONITORING_USER,
+      monitoringPassword: "pa'ss",
+      includeOptionalPermissions: false,
+    });
+    const step = plan.steps.find((s: { name: string }) => s.name === "01.role");
+    expect(step).toBeTruthy();
+    const redacted = init.redactPasswordsInSql(step.sql);
+    expect(redacted).toMatch(/password '<redacted>'/i);
+  });
+});
+
+describe("CLI commands", () => {
+  test("cli: prepare-db with missing connection prints help/options", () => {
+    const r = runCli(["prepare-db"]);
+    expect(r.status).not.toBe(0);
+    expect(r.stderr).toMatch(/--print-sql/);
+    expect(r.stderr).toMatch(/--monitoring-user/);
+  });
+
+  test("cli: prepare-db --print-sql works without connection (offline mode)", () => {
+    const r = runCli(["prepare-db", "--print-sql", "-d", "mydb", "--password", "monpw"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/SQL plan \(offline; not connected\)/);
+    expect(r.stdout).toMatch(new RegExp(`grant connect on database "mydb" to "${DEFAULT_MONITORING_USER}"`, "i"));
+  });
+
+  test("pgai wrapper forwards to postgresai CLI", () => {
+    const r = runPgai(["--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/postgresai|PostgresAI/i);
+  });
+
+  test("cli: prepare-db command exists and shows help", () => {
+    const r = runCli(["prepare-db", "--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/monitoring user/i);
+    expect(r.stdout).toMatch(/--print-sql/);
+  });
+
+  test("cli: mon local-install command exists and shows help", () => {
+    const r = runCli(["mon", "local-install", "--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/--demo/);
+    expect(r.stdout).toMatch(/--api-key/);
+  });
+
+  test("cli: auth login --help shows --set-key option", () => {
+    const r = runCli(["auth", "login", "--help"]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/--set-key/);
+  });
+});

package/test/schema-validation.test.ts

@@ -0,0 +1,81 @@
+/**
+ * JSON Schema validation tests for express checkup reports.
+ * Validates that generated reports match schemas in reporter/schemas/.
+ */
+import { describe, test, expect } from "bun:test";
+import { resolve } from "path";
+import { readFileSync } from "fs";
+import Ajv2020 from "ajv/dist/2020";
+
+import * as checkup from "../lib/checkup";
+import { createMockClient } from "./test-utils";
+
+const ajv = new Ajv2020({ allErrors: true, strict: false });
+const schemasDir = resolve(import.meta.dir, "../../reporter/schemas");
+
+function validateAgainstSchema(report: any, checkId: string): void {
+  const schemaPath = resolve(schemasDir, `${checkId}.schema.json`);
+  const schema = JSON.parse(readFileSync(schemaPath, "utf8"));
+  const validate = ajv.compile(schema);
+  const valid = validate(report);
+  if (!valid) {
+    const errors = validate.errors?.map(e => `${e.instancePath}: ${e.message}`).join(", ");
+    throw new Error(`${checkId} schema validation failed: ${errors}`);
+  }
+}
+
+// Test data for index reports
+const indexTestData = {
+  H001: {
+    emptyRows: { invalidIndexesRows: [] },
+    dataRows: {
+      invalidIndexesRows: [
+        { schema_name: "public", table_name: "users", index_name: "users_email_idx", relation_name: "users", index_size_bytes: "1048576", supports_fk: false },
+      ],
+    },
+  },
+  H002: {
+    emptyRows: { unusedIndexesRows: [] },
+    dataRows: {
+      unusedIndexesRows: [
+        { schema_name: "public", table_name: "logs", index_name: "logs_created_idx", index_definition: "CREATE INDEX logs_created_idx ON public.logs USING btree (created_at)", reason: "Never Used Indexes", idx_scan: "0", index_size_bytes: "8388608", idx_is_btree: true, supports_fk: false },
+      ],
+    },
+  },
+  H004: {
+    emptyRows: { redundantIndexesRows: [] },
+    dataRows: {
+      redundantIndexesRows: [
+        { schema_name: "public", table_name: "orders", index_name: "orders_user_id_idx", relation_name: "orders", access_method: "btree", reason: "public.orders_user_id_created_idx", index_size_bytes: "2097152", table_size_bytes: "16777216", index_usage: "0", supports_fk: false, index_definition: "CREATE INDEX orders_user_id_idx ON public.orders USING btree (user_id)", redundant_to_json: JSON.stringify([{ index_name: "public.orders_user_id_created_idx", index_definition: "CREATE INDEX ...", index_size_bytes: 1048576 }]) },
+      ],
+    },
+  },
+};
+
+describe("Schema validation", () => {
+  // Index health checks (H001, H002, H004) - test empty and with data
+  for (const [checkId, testData] of Object.entries(indexTestData)) {
+    const generator = checkup.REPORT_GENERATORS[checkId];
+
+    test(`${checkId} validates with empty data`, async () => {
+      const mockClient = createMockClient(testData.emptyRows);
+      const report = await generator(mockClient as any, "node-01");
+      validateAgainstSchema(report, checkId);
+    });
+
+    test(`${checkId} validates with sample data`, async () => {
+      const mockClient = createMockClient(testData.dataRows);
+      const report = await generator(mockClient as any, "node-01");
+      validateAgainstSchema(report, checkId);
+    });
+  }
+
+  // Settings reports (D004, F001, G001) - single test each
+  for (const checkId of ["D004", "F001", "G001"]) {
+    test(`${checkId} validates against schema`, async () => {
+      const mockClient = createMockClient();
+      const report = await checkup.REPORT_GENERATORS[checkId](mockClient as any, "node-01");
+      validateAgainstSchema(report, checkId);
+    });
+  }
+});

package/test/test-utils.ts

@@ -0,0 +1,122 @@
+/**
+ * Shared test utilities for CLI tests.
+ */
+
+export interface MockClientOptions {
+  /** Database name returned by current_database() queries (default: "testdb") */
+  databaseName?: string;
+  /** Version rows for pg_settings version query (default: PG 16.3) */
+  versionRows?: any[];
+  settingsRows?: any[];
+  databaseSizesRows?: any[];
+  dbStatsRows?: any[];
+  connectionStatesRows?: any[];
+  uptimeRows?: any[];
+  invalidIndexesRows?: any[];
+  unusedIndexesRows?: any[];
+  redundantIndexesRows?: any[];
+}
+
+const DEFAULT_VERSION_ROWS = [
+  { name: "server_version", setting: "16.3" },
+  { name: "server_version_num", setting: "160003" },
+];
+
+const defaultSettingsRows = [
+  { tag_setting_name: "shared_buffers", tag_setting_value: "128MB", tag_unit: "", tag_category: "Resource Usage / Memory", tag_vartype: "string", is_default: 1, setting_normalized: null, unit_normalized: null },
+  { tag_setting_name: "work_mem", tag_setting_value: "4MB", tag_unit: "", tag_category: "Resource Usage / Memory", tag_vartype: "string", is_default: 1, setting_normalized: null, unit_normalized: null },
+  { tag_setting_name: "autovacuum", tag_setting_value: "on", tag_unit: "", tag_category: "Autovacuum", tag_vartype: "bool", is_default: 1, setting_normalized: null, unit_normalized: null },
+  { tag_setting_name: "pg_stat_statements.max", tag_setting_value: "5000", tag_unit: "", tag_category: "Custom", tag_vartype: "integer", is_default: 0, setting_normalized: null, unit_normalized: null },
+];
+
+/**
+ * Create a mock PostgreSQL client for testing report generators.
+ * Routes SQL queries to appropriate mock data based on query patterns.
+ */
+export function createMockClient(options: MockClientOptions = {}) {
+  const {
+    databaseName = "testdb",
+    versionRows = DEFAULT_VERSION_ROWS,
+    settingsRows = defaultSettingsRows,
+    databaseSizesRows = [],
+    dbStatsRows = [],
+    connectionStatesRows = [],
+    uptimeRows = [],
+    invalidIndexesRows = [],
+    unusedIndexesRows = [],
+    redundantIndexesRows = [],
+  } = options;
+
+  return {
+    query: async (sql: string) => {
+      // Version query (simple inline - used by getPostgresVersion)
+      if (sql.includes("server_version") && sql.includes("server_version_num") && sql.includes("pg_settings") && !sql.includes("tag_setting_name")) {
+        return { rows: versionRows };
+      }
+      // Settings metric query (from metrics.yml - has tag_setting_name, tag_setting_value)
+      if (sql.includes("tag_setting_name") && sql.includes("tag_setting_value") && sql.includes("pg_settings")) {
+        return { rows: settingsRows };
+      }
+      // Database sizes (simple inline - lists all databases)
+      if (sql.includes("pg_database") && sql.includes("pg_database_size") && sql.includes("datistemplate")) {
+        return { rows: databaseSizesRows };
+      }
+      // db_size metric (current database size from metrics.yml)
+      if (sql.includes("pg_database_size(current_database())") && sql.includes("size_b")) {
+        return { rows: [{ tag_datname: databaseName, size_b: "1073741824" }] };
+      }
+      // db_stats metric (from metrics.yml)
+      if (sql.includes("pg_stat_database") && sql.includes("xact_commit") && sql.includes("pg_control_system")) {
+        return { rows: dbStatsRows };
+      }
+      // Stats reset metric (from metrics.yml)
+      if (sql.includes("stats_reset") && sql.includes("pg_stat_database") && sql.includes("seconds_since_reset")) {
+        return { rows: [{ tag_database_name: databaseName, stats_reset_epoch: "1704067200", seconds_since_reset: "2592000" }] };
+      }
+      // Postmaster startup time (simple inline - used by getStatsReset)
+      if (sql.includes("pg_postmaster_start_time") && sql.includes("postmaster_startup_epoch")) {
+        return { rows: [{ postmaster_startup_epoch: "1704067200", postmaster_startup_time: "2024-01-01 00:00:00+00" }] };
+      }
+      // Connection states (simple inline)
+      if (sql.includes("pg_stat_activity") && sql.includes("state") && sql.includes("group by")) {
+        return { rows: connectionStatesRows };
+      }
+      // Uptime info (simple inline)
+      if (sql.includes("pg_postmaster_start_time()") && sql.includes("uptime") && !sql.includes("postmaster_startup_epoch")) {
+        return { rows: uptimeRows };
+      }
+      // Invalid indexes (H001) - from metrics.yml
+      if (sql.includes("indisvalid = false") && sql.includes("fk_indexes")) {
+        return { rows: invalidIndexesRows };
+      }
+      // Unused indexes (H002) - from metrics.yml
+      if (sql.includes("Never Used Indexes") && sql.includes("idx_scan = 0")) {
+        return { rows: unusedIndexesRows };
+      }
+      // Redundant indexes (H004) - from metrics.yml
+      if (sql.includes("redundant_indexes_grouped") && sql.includes("columns like")) {
+        return { rows: redundantIndexesRows };
+      }
+      // D004: pg_stat_statements extension check
+      if (sql.includes("pg_extension") && sql.includes("pg_stat_statements")) {
+        return { rows: [] };
+      }
+      // D004: pg_stat_kcache extension check
+      if (sql.includes("pg_extension") && sql.includes("pg_stat_kcache")) {
+        return { rows: [] };
+      }
+      // G001: Memory settings query
+      if (sql.includes("pg_size_bytes") && sql.includes("shared_buffers") && sql.includes("work_mem")) {
+        return { rows: [{
+          shared_buffers_bytes: "134217728",
+          wal_buffers_bytes: "4194304",
+          work_mem_bytes: "4194304",
+          maintenance_work_mem_bytes: "67108864",
+          effective_cache_size_bytes: "4294967296",
+          max_connections: 100,
+        }] };
+      }
+      throw new Error(`Unexpected query: ${sql}`);
+    },
+  };
+}

package/tsconfig.json

@@ -1,28 +1,20 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "node16",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./",
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "types": ["bun-types"],
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
     "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "moduleResolution": "node16",
-    "types": ["node"]
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": false,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true
   },
-  "include": [
-    "bin/**/*",
-    "lib/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
+  "include": ["bin/**/*", "lib/**/*", "test/**/*"],
+  "exclude": ["node_modules", "dist"]
 }
-

package/dist/bin/postgres-ai.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=postgres-ai.d.ts.map

package/dist/bin/postgres-ai.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-ai.d.ts","sourceRoot":"","sources":["../../bin/postgres-ai.ts"],"names":[],"mappings":""}