datapeek 0.1.10 → 0.1.11

package/dist/server/index.js

@@ -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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datapeek",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "A local SQL database browser CLI tool",
   "type": "module",
   "bin": {