datapeek 0.1.7 → 0.1.9

package/dist/cli/{chunk-5X2YZYYM.js → chunk-G7KSYREO.js}

@@ -71,7 +71,23 @@ async function testConnection(config) {
 async function connect(config) {
   await disconnect();
   const connectionConfig = typeof config === "string" ? parseConnectionString(config) : config;
-  pool = new sql.ConnectionPool(connectionConfig);
+  const poolConfig = {
+    ...connectionConfig,
+    connectionTimeout: 3e4,
+    // 30 seconds for connection
+    pool: {
+      max: 10,
+      min: 0,
+      idleTimeoutMillis: 3e4,
+      acquireTimeoutMillis: 3e4
+    },
+    options: {
+      ...connectionConfig.options,
+      requestTimeout: 12e4
+      // 2 minutes for queries (increased for complex queries with JOINs)
+    }
+  };
+  pool = new sql.ConnectionPool(poolConfig);
   try {
     await pool.connect();
   } catch (error) {
@@ -96,6 +112,7 @@ async function executeQuery(query, parameters) {
     throw new Error("Not connected to database");
   }
   const request = pool.request();
+  request.timeout = 12e4;
   if (parameters) {
     for (const param of parameters) {
       if (param.type) {
@@ -105,14 +122,25 @@ async function executeQuery(query, parameters) {
       }
     }
   }
-  const result = await request.query(query);
-  return result.recordset || [];
+  try {
+    const result = await request.query(query);
+    return result.recordset || [];
+  } catch (error) {
+    if (error.code === "ETIMEOUT" || error.code === "ESOCKET" || error.message?.includes("timeout") || error.message?.includes("ETIMEDOUT")) {
+      const timeoutError = new Error("Query execution timeout. The query took too long to execute. Try disabling foreign key displays or reducing the page size.");
+      timeoutError.code = "ETIMEOUT";
+      timeoutError.originalError = error;
+      throw timeoutError;
+    }
+    throw error;
+  }
 }
 async function executeQueryMultiple(query, parameters) {
   if (!pool || !pool.connected) {
     throw new Error("Not connected to database");
   }
   const request = pool.request();
+  request.timeout = 12e4;
   if (parameters) {
     for (const param of parameters) {
       if (param.type) {
@@ -122,8 +150,18 @@ async function executeQueryMultiple(query, parameters) {
       }
     }
   }
-  const result = await request.query(query);
-  return result.recordsets || [];
+  try {
+    const result = await request.query(query);
+    return result.recordsets || [];
+  } catch (error) {
+    if (error.code === "ETIMEOUT" || error.code === "ESOCKET" || error.message?.includes("timeout") || error.message?.includes("ETIMEDOUT")) {
+      const timeoutError = new Error("Query execution timeout. The query took too long to execute. Try simplifying your query or reducing the result set size.");
+      timeoutError.code = "ETIMEOUT";
+      timeoutError.originalError = error;
+      throw timeoutError;
+    }
+    throw error;
+  }
 }
 
 export {

package/dist/cli/dev.js

@@ -7,7 +7,7 @@ import {
   executeQueryMultiple,
   getConnection,
   testConnection
-} from "./chunk-5X2YZYYM.js";
+} from "./chunk-G7KSYREO.js";
 
 // src/server/index.ts
 import express from "express";
@@ -88,7 +88,7 @@ connectionRoutes.delete("/", async (req, res) => {
 });
 connectionRoutes.get("/status", async (req, res) => {
   try {
-    const { getConnection: getConnection2, executeQuery: executeQuery3 } = await import("./mssql-D7NDIUG7.js");
+    const { getConnection: getConnection2, executeQuery: executeQuery3 } = await import("./mssql-HI3S4B7E.js");
     const pool = getConnection2();
     if (pool && pool.connected) {
       try {
@@ -98,7 +98,7 @@ connectionRoutes.get("/status", async (req, res) => {
       } catch (error) {
         const errorMessage = error.message || "";
         if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-          const { disconnect: disconnect2 } = await import("./mssql-D7NDIUG7.js");
+          const { disconnect: disconnect2 } = await import("./mssql-HI3S4B7E.js");
           await disconnect2();
         }
         res.json({ connected: false });
@@ -134,7 +134,7 @@ tableRoutes.get("/", async (req, res) => {
   } catch (error) {
     const errorMessage = error.message || "";
     if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-D7NDIUG7.js");
+      const { disconnect: disconnect2 } = await import("./mssql-HI3S4B7E.js");
       await disconnect2();
     }
     res.status(500).json({ error: error.message || "Failed to fetch tables" });
@@ -154,7 +154,10 @@ tableRoutes.get("/:schema/:table", async (req, res) => {
         c.CHARACTER_MAXIMUM_LENGTH as maxLength,
         c.IS_NULLABLE as isNullable,
         c.COLUMN_DEFAULT as defaultValue,
-        CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END as isPrimaryKey
+        CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END as isPrimaryKey,
+        fk.REFERENCED_TABLE_SCHEMA as referencedSchema,
+        fk.REFERENCED_TABLE_NAME as referencedTable,
+        fk.REFERENCED_COLUMN_NAME as referencedColumn
       FROM INFORMATION_SCHEMA.COLUMNS c
       LEFT JOIN (
         SELECT ku.TABLE_SCHEMA, ku.TABLE_NAME, ku.COLUMN_NAME
@@ -165,6 +168,27 @@ tableRoutes.get("/:schema/:table", async (req, res) => {
       ) pk ON c.TABLE_SCHEMA = pk.TABLE_SCHEMA
         AND c.TABLE_NAME = pk.TABLE_NAME
         AND c.COLUMN_NAME = pk.COLUMN_NAME
+      LEFT JOIN (
+        SELECT 
+          kcu1.TABLE_SCHEMA,
+          kcu1.TABLE_NAME,
+          kcu1.COLUMN_NAME,
+          kcu2.TABLE_SCHEMA as REFERENCED_TABLE_SCHEMA,
+          kcu2.TABLE_NAME as REFERENCED_TABLE_NAME,
+          kcu2.COLUMN_NAME as REFERENCED_COLUMN_NAME
+        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
+      ) 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
       ORDER BY c.ORDINAL_POSITION
@@ -177,7 +201,7 @@ tableRoutes.get("/:schema/:table", async (req, res) => {
   } catch (error) {
     const errorMessage = error.message || "";
     if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-D7NDIUG7.js");
+      const { disconnect: disconnect2 } = await import("./mssql-HI3S4B7E.js");
       await disconnect2();
     }
     res.status(500).json({ error: error.message || "Failed to fetch table structure" });
@@ -190,13 +214,65 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     const pageSize = Math.min(parseInt(req.query.pageSize) || 100, 1e3);
     const sortColumn = req.query.sortColumn;
     const sortDirection = req.query.sortDirection || "asc";
+    const fkDisplayMode = req.query.fkDisplayMode || "key-only";
     const offset = (page - 1) * pageSize;
+    const filters = {};
+    Object.keys(req.query).forEach((key) => {
+      const match = key.match(/^filter\[(.+)\]$/);
+      if (match && req.query[key] && String(req.query[key]).trim()) {
+        filters[match[1]] = String(req.query[key]).trim();
+      }
+    });
+    console.log("Received filters from query:", filters);
+    console.log("All query params:", req.query);
     const pool = getConnection();
     if (!pool || !pool.connected) {
       return res.status(400).json({ error: "Not connected to database" });
     }
-    const countQuery = `SELECT COUNT(*) as total FROM [${schema}].[${table}]`;
-    const countResult = await executeQuery(countQuery);
+    const filterColumns = [];
+    if (Object.keys(filters).length > 0) {
+      try {
+        const columnNames = Object.keys(filters);
+        const placeholders = columnNames.map((_, i) => `@col${i}`).join(", ");
+        const validateQuery = `
+          SELECT COLUMN_NAME 
+          FROM INFORMATION_SCHEMA.COLUMNS 
+          WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table AND COLUMN_NAME IN (${placeholders})
+        `;
+        const validateParams = [
+          { name: "schema", value: schema, type: sql.NVarChar },
+          { name: "table", value: table, type: sql.NVarChar },
+          ...columnNames.map((col, i) => ({ name: `col${i}`, value: col, type: sql.NVarChar }))
+        ];
+        const validateResult = await executeQuery(validateQuery, validateParams);
+        filterColumns.push(...validateResult.map((r) => r.COLUMN_NAME));
+        console.log("Validated filter columns:", filterColumns, "from filters:", filters);
+      } catch (e) {
+        console.error("Error validating filter columns:", e);
+        console.error("Filters that failed validation:", filters);
+      }
+    }
+    let whereClause = "";
+    const filterParams = [];
+    if (filterColumns.length > 0) {
+      const validFilters = filterColumns.filter((col) => {
+        const filterValue = filters[col];
+        return filterValue && filterValue.trim() !== "";
+      });
+      if (validFilters.length > 0) {
+        const whereConditions = validFilters.map((col, index) => {
+          const filterValue = filters[col];
+          filterParams.push({ name: `filter${index}`, value: `%${filterValue.trim()}%`, type: sql.NVarChar });
+          return `[${col}] LIKE @filter${index}`;
+        });
+        whereClause = `WHERE ${whereConditions.join(" AND ")}`;
+        console.log("Applying WHERE clause:", whereClause);
+        console.log("Filter params:", filterParams);
+        console.log("Valid filters:", validFilters);
+      }
+    }
+    const countQuery = `SELECT COUNT(*) as total FROM [${schema}].[${table}]${whereClause ? " " + whereClause : ""}`;
+    const countResult = await executeQuery(countQuery, filterParams.length > 0 ? filterParams : []);
     const total = countResult[0]?.total || 0;
     let orderByColumn = sortColumn || "";
     let orderByDirection = sortDirection?.toUpperCase() === "DESC" ? "DESC" : "ASC";
@@ -237,47 +313,204 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
       } catch (e) {
       }
     }
+    const fkJoins = [];
+    const fkSelects = [];
+    const fkDisplayColumns = {};
+    if (fkDisplayMode === "key-display" || fkDisplayMode === "display-only") {
+      const fkQuery = `
+        SELECT 
+          kcu1.COLUMN_NAME as fkColumnName,
+          kcu2.TABLE_SCHEMA as referencedSchema,
+          kcu2.TABLE_NAME as referencedTable,
+          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 kcu1.TABLE_SCHEMA = @schema
+          AND kcu1.TABLE_NAME = @table
+      `;
+      console.log("Fetching foreign keys with query:", fkQuery);
+      const foreignKeys = await executeQuery(fkQuery, [
+        { name: "schema", value: schema, type: sql.NVarChar },
+        { name: "table", value: table, type: sql.NVarChar }
+      ]);
+      console.log(`Found ${foreignKeys.length} foreign key(s)`);
+      if (foreignKeys.length > 0) {
+        const uniqueRefTables = Array.from(
+          new Set(foreignKeys.map((fk) => `${fk.referencedSchema}.${fk.referencedTable}`))
+        );
+        const tableConditions = uniqueRefTables.map((tableRef, idx) => {
+          const [refSchema, refTable] = tableRef.split(".");
+          return `(TABLE_SCHEMA = @refSchema${idx} AND TABLE_NAME = @refTable${idx})`;
+        }).join(" OR ");
+        const batchColumnsQuery = `
+        SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, ORDINAL_POSITION
+        FROM INFORMATION_SCHEMA.COLUMNS
+        WHERE ${tableConditions}
+        ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+      `;
+        const batchParams = uniqueRefTables.flatMap((tableRef, idx) => {
+          const [refSchema, refTable] = tableRef.split(".");
+          return [
+            { name: `refSchema${idx}`, value: refSchema, type: sql.NVarChar },
+            { name: `refTable${idx}`, value: refTable, type: sql.NVarChar }
+          ];
+        });
+        console.log("Fetching referenced table columns with query:", batchColumnsQuery);
+        console.log("Batch parameters:", batchParams.map((p) => ({ name: p.name, value: p.value })));
+        const allRefColumns = await executeQuery(batchColumnsQuery, batchParams);
+        console.log(`Found columns for ${uniqueRefTables.length} referenced table(s)`);
+        const columnsByTable = {};
+        allRefColumns.forEach((col) => {
+          const key = `${col.TABLE_SCHEMA}.${col.TABLE_NAME}`;
+          if (!columnsByTable[key]) {
+            columnsByTable[key] = [];
+          }
+          columnsByTable[key].push(col);
+        });
+        for (const fk of foreignKeys) {
+          const fkColumn = fk.fkColumnName;
+          const refSchema = fk.referencedSchema;
+          const refTable = fk.referencedTable;
+          const refColumn = fk.referencedColumn;
+          const tableKey = `${refSchema}.${refTable}`;
+          const refColumns = columnsByTable[tableKey] || [];
+          const preferredNames = ["name", "title", "description", "code"];
+          let displayColumn = null;
+          for (const preferredName of preferredNames) {
+            const found = refColumns.find(
+              (col) => col.COLUMN_NAME.toLowerCase() === preferredName.toLowerCase()
+            );
+            if (found) {
+              displayColumn = found.COLUMN_NAME;
+              break;
+            }
+          }
+          if (!displayColumn) {
+            const stringTypes = ["varchar", "nvarchar", "char", "nchar", "text", "ntext"];
+            const found = refColumns.find(
+              (col) => stringTypes.some((type) => col.DATA_TYPE.toLowerCase().includes(type))
+            );
+            if (found) {
+              displayColumn = found.COLUMN_NAME;
+            }
+          }
+          if (displayColumn) {
+            const alias = `fk_${fkColumn}`;
+            fkJoins.push({
+              alias,
+              refSchema,
+              refTable,
+              fkColumn,
+              refColumn,
+              displayColumn
+            });
+            fkSelects.push(`${alias}.[${displayColumn}] as [${fkColumn}_display]`);
+            fkDisplayColumns[fkColumn] = displayColumn;
+          }
+        }
+      }
+    }
+    const baseTableAlias = "t";
+    let baseSelects = `[${baseTableAlias}].*`;
+    if (fkDisplayMode === "display-only") {
+      const fkColumnNames = fkJoins.map((fk) => fk.fkColumn);
+      if (fkColumnNames.length > 0) {
+        baseSelects = `[${baseTableAlias}].*`;
+      }
+    }
+    const allSelects = `${baseSelects}${fkSelects.length > 0 ? ", " + fkSelects.join(", ") : ""}`;
+    const buildJoinClauses = (tableAlias) => {
+      return fkJoins.map(
+        (fk) => `LEFT JOIN [${fk.refSchema}].[${fk.refTable}] ${fk.alias} ON [${tableAlias}].[${fk.fkColumn}] = ${fk.alias}.[${fk.refColumn}]`
+      ).join("\n        ");
+    };
     let data;
     let generatedQuery = "";
     if (orderByColumn) {
-      generatedQuery = `SELECT * FROM [${schema}].[${table}]
-ORDER BY [${orderByColumn}] ${orderByDirection}
-OFFSET ${offset} ROWS
-FETCH NEXT ${pageSize} ROWS ONLY`;
       const dataQuery = `
-        SELECT * FROM [${schema}].[${table}]
-        ORDER BY [${orderByColumn}] ${orderByDirection}
+        SELECT ${allSelects}
+        FROM [${schema}].[${table}] ${baseTableAlias}
+        ${buildJoinClauses(baseTableAlias)}
+        ${whereClause}
+        ORDER BY ${baseTableAlias}.[${orderByColumn}] ${orderByDirection}
         OFFSET @offset ROWS
         FETCH NEXT @pageSize ROWS ONLY
       `;
+      generatedQuery = `SELECT ${allSelects}
+FROM [${schema}].[${table}] ${baseTableAlias}${fkJoins.length > 0 ? "\n" + buildJoinClauses(baseTableAlias) : ""}${whereClause ? "\n" + whereClause : ""}
+ORDER BY ${baseTableAlias}.[${orderByColumn}] ${orderByDirection}
+OFFSET ${offset} ROWS
+FETCH NEXT ${pageSize} ROWS ONLY`;
+      console.log("Executing SQL query:", dataQuery);
+      console.log("Query parameters:", {
+        offset,
+        pageSize,
+        filterParams: filterParams.map((p) => ({ name: p.name, value: p.value }))
+      });
       data = await executeQuery(dataQuery, [
         { name: "offset", value: offset, type: sql.Int },
-        { name: "pageSize", value: pageSize, type: sql.Int }
+        { name: "pageSize", value: pageSize, type: sql.Int },
+        ...filterParams
       ]);
     } else {
-      generatedQuery = `SELECT * FROM (
-  SELECT *, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) as rn
-  FROM [${schema}].[${table}]
-) t
-WHERE rn > ${offset} AND rn <= ${offset + pageSize}
-ORDER BY rn`;
+      const innerQuery = `
+        SELECT *, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) as rn
+        FROM [${schema}].[${table}]
+        ${whereClause}
+      `;
       const dataQuery = `
-        SELECT * FROM (
-          SELECT *, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) as rn
-          FROM [${schema}].[${table}]
-        ) t
-        WHERE rn > @offset AND rn <= @offset + @pageSize
-        ORDER BY rn
+        SELECT ${allSelects}
+        FROM (${innerQuery}) ${baseTableAlias}
+        ${buildJoinClauses(baseTableAlias)}
+        WHERE ${baseTableAlias}.rn > @offset AND ${baseTableAlias}.rn <= @offset + @pageSize
+        ORDER BY ${baseTableAlias}.rn
       `;
+      generatedQuery = `SELECT ${allSelects}
+FROM (
+  SELECT *, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) as rn
+  FROM [${schema}].[${table}]${whereClause ? "\n  " + whereClause : ""}
+) ${baseTableAlias}${fkJoins.length > 0 ? "\n" + buildJoinClauses(baseTableAlias) : ""}
+WHERE ${baseTableAlias}.rn > ${offset} AND ${baseTableAlias}.rn <= ${offset + pageSize}
+ORDER BY ${baseTableAlias}.rn`;
+      console.log("Executing SQL query:", dataQuery);
+      console.log("Query parameters:", {
+        offset,
+        pageSize,
+        filterParams: filterParams.map((p) => ({ name: p.name, value: p.value }))
+      });
       data = await executeQuery(dataQuery, [
         { name: "offset", value: offset, type: sql.Int },
-        { name: "pageSize", value: pageSize, type: sql.Int }
+        { name: "pageSize", value: pageSize, type: sql.Int },
+        ...filterParams
       ]);
       data = data.map((row) => {
         const { rn, ...rest } = row;
         return rest;
       });
     }
+    if (fkDisplayMode === "display-only") {
+      const fkColumnNames = fkJoins.map((fk) => fk.fkColumn);
+      data = data.map((row) => {
+        const filteredRow = { ...row };
+        fkColumnNames.forEach((fkCol) => {
+          delete filteredRow[fkCol];
+          const displayColName = `${fkCol}_display`;
+          if (displayColName in filteredRow) {
+            filteredRow[fkCol] = filteredRow[displayColName];
+            delete filteredRow[displayColName];
+          }
+        });
+        return filteredRow;
+      });
+    }
     res.json({
       data,
       query: generatedQuery,
@@ -286,20 +519,124 @@ ORDER BY rn`;
         pageSize,
         total,
         totalPages: Math.ceil(total / pageSize)
-      }
+      },
+      foreignKeyDisplays: fkDisplayColumns,
+      fkDisplayMode
     });
   } catch (error) {
     console.error("Error fetching table data:", error);
     const errorMessage = error.message || "";
     if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-D7NDIUG7.js");
+      const { disconnect: disconnect2 } = await import("./mssql-HI3S4B7E.js");
       await disconnect2();
     }
+    const isTimeout = error.code === "ETIMEOUT" || error.code === "ESOCKET" || error.message?.includes("timeout") || error.message?.includes("ETIMEDOUT") || error.originalError?.code === "ETIMEOUT" || error.originalError?.code === "ESOCKET";
     const errorDetails = error.originalError?.message || error.originalError?.info?.message || "";
-    res.status(500).json({
-      error: errorMessage,
-      details: errorDetails
+    if (isTimeout) {
+      res.status(408).json({
+        error: errorMessage || "Query execution timeout",
+        details: errorDetails || "The query took too long to execute. Try disabling foreign key displays or reducing the page size.",
+        timeout: true
+      });
+    } else {
+      res.status(500).json({
+        error: errorMessage,
+        details: errorDetails
+      });
+    }
+  }
+});
+tableRoutes.post("/:schema/:table/related-data", async (req, res) => {
+  try {
+    const { schema, table } = req.params;
+    const { foreignKeyColumn, referencedSchema, referencedTable, referencedColumn, ids } = req.body;
+    if (!foreignKeyColumn || !referencedSchema || !referencedTable || !referencedColumn || !ids || !Array.isArray(ids) || ids.length === 0) {
+      return res.status(400).json({ error: "Missing required parameters" });
+    }
+    const pool = getConnection();
+    if (!pool || !pool.connected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const columnsQuery = `
+      SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = @refSchema
+        AND TABLE_NAME = @refTable
+      ORDER BY ORDINAL_POSITION
+    `;
+    const columns = await executeQuery(columnsQuery, [
+      { name: "refSchema", value: referencedSchema, type: sql.NVarChar },
+      { name: "refTable", value: referencedTable, type: sql.NVarChar }
+    ]);
+    const referencedColInfo = columns.find(
+      (col) => col.COLUMN_NAME === referencedColumn
+    );
+    if (!referencedColInfo) {
+      return res.status(400).json({ error: `Referenced column '${referencedColumn}' not found` });
+    }
+    const getSqlType = (dataType) => {
+      const dt = dataType.toLowerCase();
+      if (dt === "int" || dt === "integer") return sql.Int;
+      if (dt === "bigint") return sql.BigInt;
+      if (dt === "smallint") return sql.SmallInt;
+      if (dt === "tinyint") return sql.TinyInt;
+      if (dt === "bit") return sql.Bit;
+      if (dt === "float" || dt === "real" || dt === "double precision") return sql.Float;
+      if (dt === "decimal" || dt === "numeric" || dt === "money" || dt === "smallmoney") return sql.Decimal(18, 0);
+      if (dt === "datetime" || dt === "datetime2" || dt === "smalldatetime") return sql.DateTime;
+      if (dt === "date") return sql.Date;
+      if (dt === "time") return sql.Time;
+      if (dt === "uniqueidentifier") return sql.UniqueIdentifier;
+      return sql.NVarChar;
+    };
+    const referencedColumnType = getSqlType(referencedColInfo.DATA_TYPE);
+    const preferredNames = ["name", "title", "description", "code"];
+    let displayColumn = null;
+    for (const preferredName of preferredNames) {
+      const found = columns.find(
+        (col) => col.COLUMN_NAME.toLowerCase() === preferredName.toLowerCase()
+      );
+      if (found) {
+        displayColumn = found.COLUMN_NAME;
+        break;
+      }
+    }
+    if (!displayColumn) {
+      const stringTypes = ["varchar", "nvarchar", "char", "nchar", "text", "ntext"];
+      const found = columns.find(
+        (col) => stringTypes.some((type) => col.DATA_TYPE.toLowerCase().includes(type))
+      );
+      if (found) {
+        displayColumn = found.COLUMN_NAME;
+      }
+    }
+    const placeholders = ids.map((_, i) => `@id${i}`).join(", ");
+    const selectColumns = displayColumn ? `[${referencedColumn}], [${displayColumn}]` : `[${referencedColumn}]`;
+    const dataQuery = `
+      SELECT ${selectColumns}
+      FROM [${referencedSchema}].[${referencedTable}]
+      WHERE [${referencedColumn}] IN (${placeholders})
+    `;
+    const params = ids.map((id, i) => ({
+      name: `id${i}`,
+      value: id,
+      type: referencedColumnType
+    }));
+    const result = await executeQuery(dataQuery, params);
+    const dataMap = {};
+    result.forEach((row) => {
+      const key = String(row[referencedColumn]);
+      dataMap[key] = displayColumn ? row[displayColumn] : null;
     });
+    res.json({ dataMap, displayColumn });
+  } catch (error) {
+    console.error("Error fetching related data:", error);
+    const errorMessage = error.message || "";
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
+      const { disconnect: disconnect2 } = await import("./mssql-HI3S4B7E.js");
+      await disconnect2();
+    }
+    res.status(500).json({ error: error.message || "Failed to fetch related data" });
   }
 });
 
@@ -312,22 +649,6 @@ queryRoutes.post("/", async (req, res) => {
     if (!sqlQuery || typeof sqlQuery !== "string") {
       return res.status(400).json({ error: "Query is required" });
     }
-    const trimmedQuery = sqlQuery.trim().toUpperCase();
-    if (!trimmedQuery.startsWith("SELECT")) {
-      return res.status(400).json({
-        error: "Only SELECT queries are allowed (read-only mode)"
-      });
-    }
-    const dangerousKeywords = ["DROP", "DELETE", "INSERT", "UPDATE", "ALTER", "CREATE", "TRUNCATE", "EXEC", "EXECUTE"];
-    const hasDangerousKeyword = dangerousKeywords.some((keyword) => {
-      const regex = new RegExp(`\\b${keyword}\\b`, "i");
-      return regex.test(sqlQuery);
-    });
-    if (hasDangerousKeyword) {
-      return res.status(400).json({
-        error: "Query contains prohibited keywords. Only SELECT queries are allowed."
-      });
-    }
     const startTime = Date.now();
     const resultSets = await executeQueryMultiple(sqlQuery);
     const executionTime = Date.now() - startTime;
@@ -339,7 +660,7 @@ queryRoutes.post("/", async (req, res) => {
   } catch (error) {
     const errorMessage = error.message || "";
     if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-D7NDIUG7.js");
+      const { disconnect: disconnect2 } = await import("./mssql-HI3S4B7E.js");
       await disconnect2();
     }
     res.status(500).json({