datapeek 0.1.13 → 0.1.15

package/README.md

@@ -4,16 +4,6 @@
 
 Datapeek provides an intuitive web-based interface to browse, query, and explore your SQL Server and PostgreSQL databases directly from your terminal.
 
-## Screenshots
-
-### Light Mode
-![Datapeek Light Mode](https://raw.githubusercontent.com/bishoymly/datapeek/main/public/screenshots/light1.png)
-![Datapeek Light Mode](https://raw.githubusercontent.com/bishoymly/datapeek/main/public/screenshots/light2.png)
-
-### Dark Mode
-![Datapeek Dark Mode](https://raw.githubusercontent.com/bishoymly/datapeek/main/public/screenshots/dark1.png)
-![Datapeek Dark Mode](https://raw.githubusercontent.com/bishoymly/datapeek/main/public/screenshots/dark2.png)
-
 ## Quick Start
 
 ### Option 1: With Connection String (Recommended)
@@ -42,6 +32,16 @@ npx datapeek
 
 A connection dialog will open in your browser where you can enter your database connection details.
 
+## Screenshots
+
+### Light Mode
+![Datapeek Light Mode](https://raw.githubusercontent.com/bishoymly/datapeek/main/public/screenshots/light1.png)
+![Datapeek Light Mode](https://raw.githubusercontent.com/bishoymly/datapeek/main/public/screenshots/light2.png)
+
+### Dark Mode
+![Datapeek Dark Mode](https://raw.githubusercontent.com/bishoymly/datapeek/main/public/screenshots/dark1.png)
+![Datapeek Dark Mode](https://raw.githubusercontent.com/bishoymly/datapeek/main/public/screenshots/dark2.png)
+
 ## Features
 
 - 🗄️ **Multi-Database Support** - Works with both SQL Server and PostgreSQL

package/dist/cli/dev.js

@@ -56,8 +56,15 @@ connectionRoutes.post("/test", async (req, res) => {
   }
 });
 connectionRoutes.get("/provided", (req, res) => {
-  const connString = getProvidedConnectionString();
-  res.json({ connectionString: connString || null });
+  try {
+    const connString = getProvidedConnectionString();
+    res.json({ connectionString: connString || null });
+  } catch (error) {
+    res.status(500).json({
+      connectionString: null,
+      error: error.message || "Failed to get connection string"
+    });
+  }
 });
 connectionRoutes.post("/", async (req, res) => {
   const timeout = setTimeout(() => {
@@ -160,12 +167,17 @@ tableRoutes.get("/", async (req, res) => {
     const result = await executeQuery(query);
     res.json(result);
   } catch (error) {
+    console.error("Error fetching tables:", error);
     const errorMessage = error.message || "";
     if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
       const { disconnect: disconnect2 } = await import("./db-OIJ2PJK6.js");
       await disconnect2();
     }
-    res.status(500).json({ error: error.message || "Failed to fetch tables" });
+    const errorDetails = error.originalError?.message || error.originalError?.info?.message || error.message || "Failed to fetch tables";
+    res.status(500).json({
+      error: error.message || "Failed to fetch tables",
+      details: errorDetails
+    });
   }
 });
 tableRoutes.get("/:schema/:table", async (req, res) => {
@@ -222,13 +234,13 @@ tableRoutes.get("/:schema/:table", async (req, res) => {
       ) fk ON c.table_schema = fk.table_schema
         AND c.table_name = fk.table_name
         AND c.column_name = fk.column_name
-      WHERE c.table_schema = @schema
-        AND c.table_name = @table
+      WHERE c.table_schema = ${dialect.param(1)}
+        AND c.table_name = ${dialect.param(2)}
       ORDER BY c.ordinal_position
     `;
     const result = await executeQuery(query, [
-      { name: "schema", value: schema },
-      { name: "table", value: table }
+      { name: "p1", value: schema },
+      { name: "p2", value: table }
     ]);
     res.json(result);
   } catch (error) {
@@ -316,9 +328,9 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
           WHERE table_schema = ${dialect.param(1)} AND table_name = ${dialect.param(2)} AND column_name IN (${placeholders})
         `;
         const validateParams = [
-          { name: "schema", value: schema },
-          { name: "table", value: table },
-          ...columnNames.map((col) => ({ name: "col", value: col }))
+          { name: "p1", value: schema },
+          { name: "p2", value: table },
+          ...columnNames.map((col, idx) => ({ name: `p${idx + 3}`, value: col }))
         ];
         const validateResult = await executeQuery(validateQuery, validateParams);
         validateResult.forEach((r) => {
@@ -358,75 +370,111 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
           switch (operator) {
             // Text operators
             case "contains":
-              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              filterParams.push({ name: `p${paramIndex}`, value: `%${String(value)}%` });
               condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
               break;
             case "equals":
-              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              filterParams.push({ name: `p${paramIndex}`, value: String(value) });
               condition = `${quotedColumn} = ${dialect.param(paramIndex)}`;
               break;
             case "startsWith":
-              filterParams.push({ name: `filter${paramIndex}`, value: `${String(value)}%` });
+              filterParams.push({ name: `p${paramIndex}`, value: `${String(value)}%` });
               condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
               break;
             case "endsWith":
-              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}` });
+              filterParams.push({ name: `p${paramIndex}`, value: `%${String(value)}` });
               condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
               break;
             case "notContains":
-              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              filterParams.push({ name: `p${paramIndex}`, value: `%${String(value)}%` });
               condition = `${quotedColumn} NOT LIKE ${dialect.param(paramIndex)}`;
               break;
             // Number operators
             case "eq":
-              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              const isNumericType = dataType && ["int", "bigint", "decimal", "numeric", "float", "double", "real", "smallint", "tinyint", "money", "smallmoney"].some((t) => dataType.toLowerCase().includes(t));
+              if (isNumericType) {
+                const numValue = Number(value);
+                if (isNaN(numValue)) {
+                  console.warn(`Cannot convert filter value to number for ${columnName}, skipping`);
+                  break;
+                }
+                filterParams.push({ name: `p${paramIndex}`, value: numValue });
+              } else {
+                filterParams.push({ name: `p${paramIndex}`, value: String(value) });
+              }
               condition = `${quotedColumn} = ${dialect.param(paramIndex)}`;
               break;
             case "gt":
-              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              const gtValue = Number(value);
+              if (isNaN(gtValue)) {
+                console.warn(`Cannot convert filter value to number for ${columnName} (gt), skipping`);
+                break;
+              }
+              filterParams.push({ name: `p${paramIndex}`, value: gtValue });
               condition = `${quotedColumn} > ${dialect.param(paramIndex)}`;
               break;
             case "gte":
-              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              const gteValue = Number(value);
+              if (isNaN(gteValue)) {
+                console.warn(`Cannot convert filter value to number for ${columnName} (gte), skipping`);
+                break;
+              }
+              filterParams.push({ name: `p${paramIndex}`, value: gteValue });
               condition = `${quotedColumn} >= ${dialect.param(paramIndex)}`;
               break;
             case "lt":
-              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              const ltValue = Number(value);
+              if (isNaN(ltValue)) {
+                console.warn(`Cannot convert filter value to number for ${columnName} (lt), skipping`);
+                break;
+              }
+              filterParams.push({ name: `p${paramIndex}`, value: ltValue });
               condition = `${quotedColumn} < ${dialect.param(paramIndex)}`;
               break;
             case "lte":
-              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              const lteValue = Number(value);
+              if (isNaN(lteValue)) {
+                console.warn(`Cannot convert filter value to number for ${columnName} (lte), skipping`);
+                break;
+              }
+              filterParams.push({ name: `p${paramIndex}`, value: lteValue });
               condition = `${quotedColumn} <= ${dialect.param(paramIndex)}`;
               break;
             case "between":
               if (typeof value === "object" && "from" in value && "to" in value) {
                 const fromParamIndex = paramIndex;
                 const toParamIndex = paramIndex + 1;
-                filterParams.push({ name: `filter${fromParamIndex}`, value: Number(value.from) });
-                filterParams.push({ name: `filter${toParamIndex}`, value: Number(value.to) });
+                const fromValue = Number(value.from);
+                const toValue = Number(value.to);
+                if (isNaN(fromValue) || isNaN(toValue)) {
+                  console.warn(`Cannot convert filter values to numbers for ${columnName} (between), skipping`);
+                  break;
+                }
+                filterParams.push({ name: `p${fromParamIndex}`, value: fromValue });
+                filterParams.push({ name: `p${toParamIndex}`, value: toValue });
                 condition = `${quotedColumn} BETWEEN ${dialect.param(fromParamIndex)} AND ${dialect.param(toParamIndex)}`;
                 paramIndex++;
               }
               break;
             // Date operators
             case "dateEq":
-              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              filterParams.push({ name: `p${paramIndex}`, value: String(value) });
               condition = `${dialect.castToDate(quotedColumn)} = ${dialect.castToDate(dialect.param(paramIndex))}`;
               break;
             case "dateAfter":
-              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              filterParams.push({ name: `p${paramIndex}`, value: String(value) });
               condition = `${dialect.castToDate(quotedColumn)} > ${dialect.castToDate(dialect.param(paramIndex))}`;
               break;
             case "dateBefore":
-              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              filterParams.push({ name: `p${paramIndex}`, value: String(value) });
               condition = `${dialect.castToDate(quotedColumn)} < ${dialect.castToDate(dialect.param(paramIndex))}`;
               break;
             case "dateBetween":
               if (typeof value === "object" && "from" in value && "to" in value) {
                 const fromParamIndex = paramIndex;
                 const toParamIndex = paramIndex + 1;
-                filterParams.push({ name: `filter${fromParamIndex}`, value: String(value.from) });
-                filterParams.push({ name: `filter${toParamIndex}`, value: String(value.to) });
+                filterParams.push({ name: `p${fromParamIndex}`, value: String(value.from) });
+                filterParams.push({ name: `p${toParamIndex}`, value: String(value.to) });
                 condition = `${dialect.castToDate(quotedColumn)} BETWEEN ${dialect.castToDate(dialect.param(fromParamIndex))} AND ${dialect.castToDate(dialect.param(toParamIndex))}`;
                 paramIndex++;
               }
@@ -438,7 +486,7 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
                 const placeholders = [];
                 value.forEach((val, i) => {
                   const currentIndex = paramIndex + i;
-                  filterParams.push({ name: `filter${currentIndex}`, value: val });
+                  filterParams.push({ name: `p${currentIndex}`, value: val });
                   placeholders.push(dialect.param(currentIndex));
                 });
                 const inOperator = operator === "in" ? "IN" : "NOT IN";
@@ -448,7 +496,7 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
               break;
             default:
               console.warn(`Unknown filter operator: ${operator}, falling back to contains`);
-              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              filterParams.push({ name: `p${paramIndex}`, value: `%${String(value)}%` });
               condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
           }
           if (condition) {
@@ -485,9 +533,9 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
           WHERE table_schema = ${dialect.param(1)} AND table_name = ${dialect.param(2)} AND column_name = ${dialect.param(3)}
         `;
         const validateResult = await executeQuery(validateQuery, [
-          { name: "schema", value: schema },
-          { name: "table", value: table },
-          { name: "column", value: orderByColumn }
+          { name: "p1", value: schema },
+          { name: "p2", value: table },
+          { name: "p3", value: orderByColumn }
         ]);
         if (validateResult.length === 0) {
           orderByColumn = "";
@@ -509,8 +557,8 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
           ${!topClause ? dialect.limitOffset(0, 1) : ""}
         `;
         const structureResult = await executeQuery(structureQuery, [
-          { name: "schema", value: schema },
-          { name: "table", value: table }
+          { name: "p1", value: schema },
+          { name: "p2", value: table }
         ]);
         if (structureResult.length > 0) {
           orderByColumn = structureResult[0].column_name || structureResult[0].COLUMN_NAME;
@@ -542,8 +590,8 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
       `;
     console.log("Fetching foreign keys with query:", fkQuery);
     const foreignKeys = await executeQuery(fkQuery, [
-      { name: "schema", value: schema },
-      { name: "table", value: table }
+      { name: "p1", value: schema },
+      { name: "p2", value: table }
     ]);
     console.log(`Found ${foreignKeys.length} foreign key(s)`);
     if (foreignKeys.length > 0) {
@@ -560,11 +608,11 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
         WHERE ${tableConditions}
         ORDER BY table_schema, table_name, ordinal_position
       `;
-      const batchParams = uniqueRefTables.flatMap((tableRef) => {
+      const batchParams = uniqueRefTables.flatMap((tableRef, idx) => {
         const [refSchema, refTable] = tableRef.split(".");
         return [
-          { name: "refSchema", value: refSchema },
-          { name: "refTable", value: refTable }
+          { name: `p${idx * 2 + 1}`, value: refSchema },
+          { name: `p${idx * 2 + 2}`, value: refTable }
         ];
       });
       console.log("Fetching referenced table columns with query:", batchColumnsQuery);
@@ -797,8 +845,8 @@ tableRoutes.post("/:schema/:table/related-data", async (req, res) => {
       ORDER BY ordinal_position
     `;
     const columns = await executeQuery(columnsQuery, [
-      { name: "refSchema", value: referencedSchema },
-      { name: "refTable", value: referencedTable }
+      { name: "p1", value: referencedSchema },
+      { name: "p2", value: referencedTable }
     ]);
     const referencedColInfo = columns.find((col) => {
       const colName = col.column_name || col.COLUMN_NAME;
@@ -840,8 +888,8 @@ tableRoutes.post("/:schema/:table/related-data", async (req, res) => {
       FROM ${quotedRefSchema}.${quotedRefTable}
       WHERE ${quotedRefColumn} IN (${placeholders})
     `;
-    const params = ids.map((id) => ({
-      name: "id",
+    const params = ids.map((id, idx) => ({
+      name: `p${idx + 1}`,
       value: id
     }));
     const result = await executeQuery(dataQuery, params);
@@ -907,9 +955,9 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
       WHERE c.table_schema = ${dialect.param(1)} AND c.table_name = ${dialect.param(2)} AND c.column_name = ${dialect.param(3)}
     `;
     const columnResult = await executeQuery(columnQuery, [
-      { name: "schema", value: schema },
-      { name: "table", value: table },
-      { name: "column", value: column }
+      { name: "p1", value: schema },
+      { name: "p2", value: table },
+      { name: "p3", value: column }
     ]);
     if (columnResult.length === 0) {
       return res.status(400).json({ error: "Column not found" });
@@ -936,7 +984,7 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
         if (searchQuery && searchQuery.trim()) {
           const searchCols = columnsToSelect.map((col) => `${dialect.quoteId(col)} LIKE ${dialect.param(1)}`).join(" OR ");
           query += ` WHERE (${searchCols}) AND ${quotedRefColumn} IS NOT NULL`;
-          params.push({ name: "search", value: `%${searchQuery.trim()}%` });
+          params.push({ name: "p1", value: `%${searchQuery.trim()}%` });
         } else {
           query += ` WHERE ${quotedRefColumn} IS NOT NULL`;
         }
@@ -950,8 +998,8 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
           ORDER BY ordinal_position
         `;
         const refColumns = await executeQuery(refColumnsQuery, [
-          { name: "refSchema", value: refSchema },
-          { name: "refTable", value: refTable }
+          { name: "p1", value: refSchema },
+          { name: "p2", value: refTable }
         ]);
         const preferredNames = ["name", "title", "description", "code"];
         for (const preferredName of preferredNames) {
@@ -984,7 +1032,7 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
           } else {
             query += ` WHERE ${quotedRefColumn} LIKE ${dialect.param(1)}`;
           }
-          params.push({ name: "search", value: `%${searchQuery.trim()}%` });
+          params.push({ name: "p1", value: `%${searchQuery.trim()}%` });
           query += ` AND ${quotedRefColumn} IS NOT NULL`;
         } else {
           query += ` WHERE ${quotedRefColumn} IS NOT NULL`;
@@ -1005,7 +1053,7 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
         if (searchQuery && searchQuery.trim()) {
           const searchCols = quotedColumns.map((col) => `${dialect.tryCastToNVarChar(col)} LIKE ${dialect.param(1)}`).join(" OR ");
           query += ` WHERE (${searchCols}) AND ${keyColumn} IS NOT NULL`;
-          params.push({ name: "search", value: `%${searchQuery.trim()}%` });
+          params.push({ name: "p1", value: `%${searchQuery.trim()}%` });
         } else {
           query += ` WHERE ${keyColumn} IS NOT NULL`;
         }
@@ -1015,7 +1063,7 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
         if (searchQuery && searchQuery.trim()) {
           if (["varchar", "nvarchar", "char", "nchar", "text", "ntext"].some((t) => dataType.includes(t))) {
             query += ` WHERE ${quotedColumn} LIKE ${dialect.param(1)}`;
-            params.push({ name: "search", value: `%${searchQuery.trim()}%` });
+            params.push({ name: "p1", value: `%${searchQuery.trim()}%` });
             query += ` AND ${quotedColumn} IS NOT NULL`;
           } else {
             query += ` WHERE ${quotedColumn} IS NOT NULL`;
@@ -1038,6 +1086,131 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
     res.status(500).json({ error: error.message || "Failed to fetch distinct values" });
   }
 });
+tableRoutes.get("/:schema/:table/reverse-foreign-keys", async (req, res) => {
+  try {
+    const { schema, table } = req.params;
+    const pool = getConnection();
+    if (!pool) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const isConnected = "connected" in pool ? pool.connected === true : !pool.ended;
+    if (!isConnected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const dialect = getDialect();
+    const query = `
+      SELECT 
+        kcu1.table_schema as "referencingSchema",
+        kcu1.table_name as "referencingTable",
+        kcu1.column_name as "fkColumnName",
+        kcu2.column_name as "referencedColumn"
+      FROM information_schema.referential_constraints rc
+      INNER JOIN information_schema.key_column_usage kcu1
+        ON rc.constraint_catalog = kcu1.constraint_catalog
+        AND rc.constraint_schema = kcu1.constraint_schema
+        AND rc.constraint_name = kcu1.constraint_name
+      INNER JOIN information_schema.key_column_usage kcu2
+        ON rc.unique_constraint_catalog = kcu2.constraint_catalog
+        AND rc.unique_constraint_schema = kcu2.constraint_schema
+        AND rc.unique_constraint_name = kcu2.constraint_name
+        AND kcu1.ordinal_position = kcu2.ordinal_position
+      WHERE kcu2.table_schema = ${dialect.param(1)}
+        AND kcu2.table_name = ${dialect.param(2)}
+      ORDER BY kcu1.table_schema, kcu1.table_name, kcu1.ordinal_position
+    `;
+    const result = await executeQuery(query, [
+      { name: "p1", value: schema },
+      { name: "p2", value: table }
+    ]);
+    const grouped = {};
+    result.forEach((row) => {
+      const referencingSchema = row.referencingSchema || row.referencing_schema;
+      const referencingTable = row.referencingTable || row.referencing_table;
+      const fkColumnName = row.fkColumnName || row.fk_column_name;
+      const referencedColumn = row.referencedColumn || row.referenced_column;
+      const key = `${referencingSchema}.${referencingTable}`;
+      if (!grouped[key]) {
+        grouped[key] = {
+          referencingSchema,
+          referencingTable,
+          fkColumns: [],
+          referencedColumns: []
+        };
+      }
+      grouped[key].fkColumns.push(fkColumnName);
+      grouped[key].referencedColumns.push(referencedColumn);
+    });
+    const reverseFks = Object.values(grouped);
+    res.json(reverseFks);
+  } catch (error) {
+    console.error("Error fetching reverse foreign keys:", error);
+    const errorMessage = error.message || "";
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+      const { disconnect: disconnect2 } = await import("./db-OIJ2PJK6.js");
+      await disconnect2();
+    }
+    res.status(500).json({ error: error.message || "Failed to fetch reverse foreign keys" });
+  }
+});
+tableRoutes.post("/:schema/:table/count-related", async (req, res) => {
+  try {
+    const { schema, table } = req.params;
+    const { referencingSchema, referencingTable, fkColumns, referencedColumns, primaryKeyValues } = req.body;
+    if (!referencingSchema || !referencingTable || !fkColumns || !Array.isArray(fkColumns) || !referencedColumns || !Array.isArray(referencedColumns) || !primaryKeyValues || !Array.isArray(primaryKeyValues)) {
+      return res.status(400).json({ error: "Missing required parameters" });
+    }
+    if (fkColumns.length !== referencedColumns.length || fkColumns.length !== primaryKeyValues.length) {
+      return res.status(400).json({ error: "FK columns, referenced columns, and primary key values arrays must have the same length" });
+    }
+    const pool = getConnection();
+    if (!pool) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const isConnected = "connected" in pool ? pool.connected === true : !pool.ended;
+    if (!isConnected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const dialect = getDialect();
+    const quotedSchema = dialect.quoteId(referencingSchema);
+    const quotedTable = dialect.quoteId(referencingTable);
+    const whereConditions = [];
+    let paramIndex = 1;
+    const params = [];
+    fkColumns.forEach((fkCol, idx) => {
+      const quotedCol = dialect.quoteId(fkCol);
+      let pkValue = primaryKeyValues[idx];
+      if (typeof pkValue === "number" && isNaN(pkValue)) {
+        pkValue = null;
+      }
+      if (pkValue === "NaN" || pkValue === "nan") {
+        pkValue = null;
+      }
+      if (pkValue === null || pkValue === void 0) {
+        whereConditions.push(`${quotedCol} IS NULL`);
+      } else {
+        whereConditions.push(`${quotedCol} = ${dialect.param(paramIndex)}`);
+        params.push({ name: `p${paramIndex}`, value: pkValue });
+        paramIndex++;
+      }
+    });
+    const query = `
+      SELECT COUNT(*) as "count"
+      FROM ${quotedSchema}.${quotedTable}
+      WHERE ${whereConditions.join(" AND ")}
+    `;
+    const result = await executeQuery(query, params);
+    const count = result[0]?.count || result[0]?.COUNT || 0;
+    res.json({ count: Number(count) });
+  } catch (error) {
+    console.error("Error counting related rows:", error);
+    const errorMessage = error.message || "";
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+      const { disconnect: disconnect2 } = await import("./db-OIJ2PJK6.js");
+      await disconnect2();
+    }
+    res.status(500).json({ error: error.message || "Failed to count related rows" });
+  }
+});
 
 // src/server/routes/query.ts
 import { Router as Router3 } from "express";