npm - datapeek - Versions diffs - 0.1.10 → 0.1.11 - Mend

datapeek 0.1.10 → 0.1.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/cli/dev.js +440 -89
package/dist/cli/index.js +440 -89
package/dist/client/assets/index-CPoX5Biw.css +1 -0
package/dist/client/assets/index-KtK9Gzwi.js +375 -0
package/dist/client/index.html +2 -2
package/dist/server/dev.js +440 -89
package/dist/server/index.js +440 -89
package/package.json +1 -1
package/dist/client/assets/index-BhZ7NrhL.css +0 -1
package/dist/client/assets/index-D-mash8_.js +0 -370

package/dist/client/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/png" href="/favicon.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Datapeek - SQL Database Browser</title>
-    <script type="module" crossorigin src="/assets/index-D-mash8_.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BhZ7NrhL.css">
+    <script type="module" crossorigin src="/assets/index-KtK9Gzwi.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CPoX5Biw.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/dev.js CHANGED Viewed

@@ -214,26 +214,64 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     const sortDirection = req.query.sortDirection || "asc";
     const fkDisplayMode = req.query.fkDisplayMode || "key-only";
     const offset = (page - 1) * pageSize;
-    const filters = {};
+    const parsedFilters = [];
+    const seenFilterColumns = /* @__PURE__ */ new Set();
+    const parseFilterEntry = (columnName, rawValue) => {
+      if (!columnName || rawValue === null || rawValue === void 0 || seenFilterColumns.has(columnName)) {
+        return;
+      }
+      const filterValue = String(rawValue).trim();
+      if (!filterValue) return;
+      try {
+        const parsed = JSON.parse(filterValue);
+        if (parsed && typeof parsed === "object" && parsed.operator) {
+          parsedFilters.push({
+            column: columnName,
+            operator: parsed.operator,
+            value: parsed.value,
+            dataType: parsed.dataType
+          });
+        } else {
+          parsedFilters.push({
+            column: columnName,
+            operator: "contains",
+            value: filterValue
+          });
+        }
+      } catch {
+        parsedFilters.push({
+          column: columnName,
+          operator: "contains",
+          value: filterValue
+        });
+      }
+      seenFilterColumns.add(columnName);
+    };
     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();
+      if (match) {
+        const columnName = match[1];
+        parseFilterEntry(columnName, req.query[key]);
       }
     });
-    console.log("Received filters from query:", filters);
-    console.log("All query params:", req.query);
+    const nestedFilters = req.query.filter;
+    if (nestedFilters && typeof nestedFilters === "object" && !Array.isArray(nestedFilters)) {
+      Object.entries(nestedFilters).forEach(([columnName, rawValue]) => {
+        parseFilterEntry(columnName, rawValue);
+      });
+    }
+    console.log("Parsed filters:", parsedFilters);
     const pool = getConnection();
     if (!pool || !pool.connected) {
       return res.status(400).json({ error: "Not connected to database" });
     }
-    const filterColumns = [];
-    if (Object.keys(filters).length > 0) {
+    const columnMetadata = {};
+    if (parsedFilters.length > 0) {
       try {
-        const columnNames = Object.keys(filters);
+        const columnNames = [...new Set(parsedFilters.map((f) => f.column))];
         const placeholders = columnNames.map((_, i) => `@col${i}`).join(", ");
         const validateQuery = `
-          SELECT COLUMN_NAME
+          SELECT COLUMN_NAME, DATA_TYPE
           FROM INFORMATION_SCHEMA.COLUMNS
           WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table AND COLUMN_NAME IN (${placeholders})
         `;
@@ -243,32 +281,167 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
           ...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);
+        validateResult.forEach((r) => {
+          columnMetadata[r.COLUMN_NAME] = {
+            dataType: r.DATA_TYPE,
+            exists: true
+          };
+        });
+        console.log("Column metadata:", columnMetadata);
       } catch (e) {
         console.error("Error validating filter columns:", e);
-        console.error("Filters that failed validation:", filters);
       }
     }
+    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, 2);
+      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;
+    };
     let whereClause = "";
     const filterParams = [];
-    if (filterColumns.length > 0) {
-      const validFilters = filterColumns.filter((col) => {
-        const filterValue = filters[col];
-        return filterValue && filterValue.trim() !== "";
+    let paramIndex = 0;
+    if (parsedFilters.length > 0) {
+      const whereConditions = [];
+      parsedFilters.forEach((filter) => {
+        const columnName = filter.column;
+        const metadata = columnMetadata[columnName];
+        if (!metadata || !metadata.exists) {
+          console.warn(`Filter column ${columnName} not found, skipping`);
+          return;
+        }
+        const dataType = filter.dataType || metadata.dataType;
+        const operator = filter.operator;
+        const value = filter.value;
+        if (value === null || value === void 0 || value === "") {
+          return;
+        }
+        const sqlType = getSqlType(dataType);
+        const paramName = `filter${paramIndex}`;
+        try {
+          let condition = "";
+          switch (operator) {
+            // Text operators
+            case "contains":
+              filterParams.push({ name: paramName, value: `%${String(value)}%`, type: sql.NVarChar });
+              condition = `[${columnName}] LIKE @${paramName}`;
+              break;
+            case "equals":
+              filterParams.push({ name: paramName, value: String(value), type: sqlType });
+              condition = `[${columnName}] = @${paramName}`;
+              break;
+            case "startsWith":
+              filterParams.push({ name: paramName, value: `${String(value)}%`, type: sql.NVarChar });
+              condition = `[${columnName}] LIKE @${paramName}`;
+              break;
+            case "endsWith":
+              filterParams.push({ name: paramName, value: `%${String(value)}`, type: sql.NVarChar });
+              condition = `[${columnName}] LIKE @${paramName}`;
+              break;
+            case "notContains":
+              filterParams.push({ name: paramName, value: `%${String(value)}%`, type: sql.NVarChar });
+              condition = `[${columnName}] NOT LIKE @${paramName}`;
+              break;
+            // Number operators
+            case "eq":
+              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
+              condition = `[${columnName}] = @${paramName}`;
+              break;
+            case "gt":
+              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
+              condition = `[${columnName}] > @${paramName}`;
+              break;
+            case "gte":
+              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
+              condition = `[${columnName}] >= @${paramName}`;
+              break;
+            case "lt":
+              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
+              condition = `[${columnName}] < @${paramName}`;
+              break;
+            case "lte":
+              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
+              condition = `[${columnName}] <= @${paramName}`;
+              break;
+            case "between":
+              if (typeof value === "object" && "from" in value && "to" in value) {
+                const fromParam = `filter${paramIndex}`;
+                const toParam = `filter${paramIndex + 1}`;
+                filterParams.push({ name: fromParam, value: Number(value.from), type: sqlType });
+                filterParams.push({ name: toParam, value: Number(value.to), type: sqlType });
+                condition = `[${columnName}] BETWEEN @${fromParam} AND @${toParam}`;
+                paramIndex++;
+              }
+              break;
+            // Date operators
+            case "dateEq":
+              filterParams.push({ name: paramName, value: String(value), type: sqlType });
+              condition = `CAST([${columnName}] AS DATE) = CAST(@${paramName} AS DATE)`;
+              break;
+            case "dateAfter":
+              filterParams.push({ name: paramName, value: String(value), type: sqlType });
+              condition = `CAST([${columnName}] AS DATE) > CAST(@${paramName} AS DATE)`;
+              break;
+            case "dateBefore":
+              filterParams.push({ name: paramName, value: String(value), type: sqlType });
+              condition = `CAST([${columnName}] AS DATE) < CAST(@${paramName} AS DATE)`;
+              break;
+            case "dateBetween":
+              if (typeof value === "object" && "from" in value && "to" in value) {
+                const fromParam = `filter${paramIndex}`;
+                const toParam = `filter${paramIndex + 1}`;
+                filterParams.push({ name: fromParam, value: String(value.from), type: sqlType });
+                filterParams.push({ name: toParam, value: String(value.to), type: sqlType });
+                condition = `CAST([${columnName}] AS DATE) BETWEEN CAST(@${fromParam} AS DATE) AND CAST(@${toParam} AS DATE)`;
+                paramIndex++;
+              }
+              break;
+            // Multiple select operators
+            case "in":
+            case "notIn":
+              if (Array.isArray(value) && value.length > 0) {
+                const placeholders = value.map((_, i) => `@${paramName}_${i}`).join(", ");
+                value.forEach((val, i) => {
+                  filterParams.push({ name: `${paramName}_${i}`, value: val, type: sqlType });
+                });
+                const inOperator = operator === "in" ? "IN" : "NOT IN";
+                condition = `[${columnName}] ${inOperator} (${placeholders})`;
+                paramIndex += value.length - 1;
+              }
+              break;
+            default:
+              console.warn(`Unknown filter operator: ${operator}, falling back to contains`);
+              filterParams.push({ name: paramName, value: `%${String(value)}%`, type: sql.NVarChar });
+              condition = `[${columnName}] LIKE @${paramName}`;
+          }
+          if (condition) {
+            whereConditions.push(condition);
+            paramIndex++;
+          }
+        } catch (error) {
+          console.error(`Error building filter condition for ${columnName}:`, error);
+        }
       });
-      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}`;
-        });
+      if (whereConditions.length > 0) {
         whereClause = `WHERE ${whereConditions.join(" AND ")}`;
         console.log("Applying WHERE clause:", whereClause);
-        console.log("Filter params:", filterParams);
-        console.log("Valid filters:", validFilters);
+        console.log("Filter params:", filterParams.map((p) => ({ name: p.name, value: p.value })));
       }
     }
+    const qualifiedDataWhereClause = parsedFilters.reduce((clause, filter) => {
+      const escapedColumn = filter.column.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const pattern = new RegExp(`\\[${escapedColumn}\\]`, "g");
+      return clause.replace(pattern, `[t].[${filter.column}]`);
+    }, whereClause);
     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;
@@ -314,8 +487,7 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     const fkJoins = [];
     const fkSelects = [];
     const fkDisplayColumns = {};
-    if (fkDisplayMode === "key-display" || fkDisplayMode === "display-only") {
-      const fkQuery = `
+    const fkQuery = `
         SELECT
           kcu1.COLUMN_NAME as fkColumnName,
           kcu2.TABLE_SCHEMA as referencedSchema,
@@ -334,73 +506,74 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
         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 = `
+    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;
-            }
+      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 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) {
+        }
+        if (displayColumn) {
+          if (fkDisplayMode === "key-display" || fkDisplayMode === "display-only") {
             const alias = `fk_${fkColumn}`;
             fkJoins.push({
               alias,
@@ -411,8 +584,8 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
               displayColumn
             });
             fkSelects.push(`${alias}.[${displayColumn}] as [${fkColumn}_display]`);
-            fkDisplayColumns[fkColumn] = displayColumn;
           }
+          fkDisplayColumns[fkColumn] = displayColumn;
         }
       }
     }
@@ -437,13 +610,13 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
         SELECT ${allSelects}
         FROM [${schema}].[${table}] ${baseTableAlias}
         ${buildJoinClauses(baseTableAlias)}
-        ${whereClause}
+        ${qualifiedDataWhereClause}
         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 : ""}
+FROM [${schema}].[${table}] ${baseTableAlias}${fkJoins.length > 0 ? "\n" + buildJoinClauses(baseTableAlias) : ""}${qualifiedDataWhereClause ? "\n" + qualifiedDataWhereClause : ""}
 ORDER BY ${baseTableAlias}.[${orderByColumn}] ${orderByDirection}
 OFFSET ${offset} ROWS
 FETCH NEXT ${pageSize} ROWS ONLY`;
@@ -509,6 +682,22 @@ ORDER BY ${baseTableAlias}.rn`;
         return filteredRow;
       });
     }
+    if (generatedQuery && filterParams.length > 0) {
+      const formatSqlLiteral = (value) => {
+        if (value === null || value === void 0) return "NULL";
+        if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
+        if (typeof value === "boolean") return value ? "1" : "0";
+        if (value instanceof Date) return `'${value.toISOString().replace("T", " ").slice(0, 19)}'`;
+        return `'${String(value).replace(/'/g, "''")}'`;
+      };
+      const paramValues = new Map(
+        filterParams.map((p) => [p.name, p.value])
+      );
+      generatedQuery = generatedQuery.replace(/@([A-Za-z0-9_]+)/g, (full, name) => {
+        if (!paramValues.has(name)) return full;
+        return formatSqlLiteral(paramValues.get(name));
+      });
+    }
     res.json({
       data,
       query: generatedQuery,
@@ -637,6 +826,168 @@ tableRoutes.post("/:schema/:table/related-data", async (req, res) => {
     res.status(500).json({ error: error.message || "Failed to fetch related data" });
   }
 });
+tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
+  try {
+    const { schema, table, column } = req.params;
+    const searchQuery = req.query.search;
+    const columnsParam = req.query.columns;
+    const pool = getConnection();
+    if (!pool || !pool.connected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const columnQuery = `
+      SELECT
+        c.COLUMN_NAME,
+        c.DATA_TYPE,
+        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
+          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 AND c.COLUMN_NAME = @column
+    `;
+    const columnResult = await executeQuery(columnQuery, [
+      { name: "schema", value: schema, type: sql.NVarChar },
+      { name: "table", value: table, type: sql.NVarChar },
+      { name: "column", value: column, type: sql.NVarChar }
+    ]);
+    if (columnResult.length === 0) {
+      return res.status(400).json({ error: "Column not found" });
+    }
+    const columnInfo = columnResult[0];
+    const isForeignKey = !!columnInfo.referencedSchema && !!columnInfo.referencedTable;
+    let query = "";
+    const params = [];
+    let displayColumn = null;
+    if (isForeignKey) {
+      const refSchema = columnInfo.referencedSchema;
+      const refTable = columnInfo.referencedTable;
+      const refColumn = columnInfo.referencedColumn;
+      let columnsToSelect = [];
+      if (columnsParam) {
+        columnsToSelect = columnsParam.split(",").map((c) => c.trim()).filter((c) => c);
+      }
+      if (columnsToSelect.length > 0) {
+        const selectCols = columnsToSelect.map((col) => `[${col}]`).join(", ");
+        query = `SELECT DISTINCT ${selectCols} FROM [${refSchema}].[${refTable}]`;
+        if (searchQuery && searchQuery.trim()) {
+          const searchCols = columnsToSelect.map((col) => `[${col}] LIKE @search`).join(" OR ");
+          query += ` WHERE (${searchCols}) AND [${refColumn}] IS NOT NULL`;
+          params.push({ name: "search", value: `%${searchQuery.trim()}%`, type: sql.NVarChar });
+        } else {
+          query += ` WHERE [${refColumn}] IS NOT NULL`;
+        }
+        const orderByCol = columnsToSelect.length > 1 ? columnsToSelect[1] : columnsToSelect[0];
+        query += ` ORDER BY [${orderByCol}] OFFSET 0 ROWS FETCH NEXT 1000 ROWS ONLY`;
+      } else {
+        const refColumnsQuery = `
+          SELECT COLUMN_NAME, DATA_TYPE
+          FROM INFORMATION_SCHEMA.COLUMNS
+          WHERE TABLE_SCHEMA = @refSchema AND TABLE_NAME = @refTable
+          ORDER BY ORDINAL_POSITION
+        `;
+        const refColumns = await executeQuery(refColumnsQuery, [
+          { name: "refSchema", value: refSchema, type: sql.NVarChar },
+          { name: "refTable", value: refTable, type: sql.NVarChar }
+        ]);
+        const preferredNames = ["name", "title", "description", "code"];
+        for (const preferredName of preferredNames) {
+          const found = refColumns.find(
+            (col) => col.COLUMN_NAME.toLowerCase() === preferredName.toLowerCase() && col.COLUMN_NAME.toLowerCase() !== refColumn.toLowerCase()
+          );
+          if (found) {
+            displayColumn = found.COLUMN_NAME;
+            break;
+          }
+        }
+        if (!displayColumn) {
+          const stringTypes = ["varchar", "nvarchar", "char", "nchar", "text", "ntext"];
+          const found = refColumns.find(
+            (col) => col.COLUMN_NAME.toLowerCase() !== refColumn.toLowerCase() && stringTypes.some((type) => col.DATA_TYPE.toLowerCase().includes(type))
+          );
+          if (found) {
+            displayColumn = found.COLUMN_NAME;
+          }
+        }
+        const selectCols = displayColumn ? `[${refColumn}], [${displayColumn}]` : `[${refColumn}]`;
+        query = `SELECT DISTINCT ${selectCols} FROM [${refSchema}].[${refTable}]`;
+        if (searchQuery && searchQuery.trim()) {
+          if (displayColumn) {
+            query += ` WHERE [${displayColumn}] LIKE @search OR [${refColumn}] LIKE @search`;
+          } else {
+            query += ` WHERE [${refColumn}] LIKE @search`;
+          }
+          params.push({ name: "search", value: `%${searchQuery.trim()}%`, type: sql.NVarChar });
+          query += ` AND [${refColumn}] IS NOT NULL`;
+        } else {
+          query += ` WHERE [${refColumn}] IS NOT NULL`;
+        }
+        query += ` ORDER BY ${displayColumn ? `[${displayColumn}]` : `[${refColumn}]`} OFFSET 0 ROWS FETCH NEXT 1000 ROWS ONLY`;
+      }
+    } else {
+      const dataType = columnInfo.DATA_TYPE.toLowerCase();
+      const columnsToSelect = columnsParam ? columnsParam.split(",").map((c) => c.trim()).filter((c) => c) : [];
+      if (columnsToSelect.length > 0) {
+        const escapedColumns = columnsToSelect.map((col) => col.replace(/]/g, "]]"));
+        const keyColumn = escapedColumns[0];
+        const orderByColumn = escapedColumns.length > 1 ? escapedColumns[1] : keyColumn;
+        query = `SELECT DISTINCT ${escapedColumns.map((col) => `[${col}]`).join(", ")} FROM [${schema}].[${table}]`;
+        if (searchQuery && searchQuery.trim()) {
+          const searchCols = escapedColumns.map((col) => `TRY_CAST([${col}] AS NVARCHAR(4000)) LIKE @search`).join(" OR ");
+          query += ` WHERE (${searchCols}) AND [${keyColumn}] IS NOT NULL`;
+          params.push({ name: "search", value: `%${searchQuery.trim()}%`, type: sql.NVarChar });
+        } else {
+          query += ` WHERE [${keyColumn}] IS NOT NULL`;
+        }
+        query += ` ORDER BY [${orderByColumn}] OFFSET 0 ROWS FETCH NEXT 1000 ROWS ONLY`;
+      } else {
+        query = `SELECT DISTINCT [${column}] FROM [${schema}].[${table}]`;
+        if (searchQuery && searchQuery.trim()) {
+          if (["varchar", "nvarchar", "char", "nchar", "text", "ntext"].some((t) => dataType.includes(t))) {
+            query += ` WHERE [${column}] LIKE @search`;
+            params.push({ name: "search", value: `%${searchQuery.trim()}%`, type: sql.NVarChar });
+            query += ` AND [${column}] IS NOT NULL`;
+          } else {
+            query += ` WHERE [${column}] IS NOT NULL`;
+          }
+        } else {
+          query += ` WHERE [${column}] IS NOT NULL`;
+        }
+        query += ` ORDER BY [${column}] OFFSET 0 ROWS FETCH NEXT 1000 ROWS ONLY`;
+      }
+    }
+    const result = await executeQuery(query, params);
+    res.json(result);
+  } catch (error) {
+    console.error("Error fetching distinct values:", error);
+    const errorMessage = error.message || "";
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
+      const { disconnect: disconnect2 } = await import("./mssql-UZUN227W.js");
+      await disconnect2();
+    }
+    res.status(500).json({ error: error.message || "Failed to fetch distinct values" });
+  }
+});
 // src/server/routes/query.ts
 import { Router as Router3 } from "express";