datapeek 0.1.1

package/dist/server/index.js

@@ -0,0 +1,361 @@
+import {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  testConnection
+} from "./chunk-7G2KHS5I.js";
+
+// src/server/index.ts
+import express from "express";
+import cors from "cors";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// src/server/routes/connection.ts
+import { Router } from "express";
+var connectionRoutes = Router();
+connectionRoutes.post("/test", async (req, res) => {
+  const timeout = setTimeout(() => {
+    if (!res.headersSent) {
+      res.status(408).json({
+        success: false,
+        message: "Connection test timeout"
+      });
+    }
+  }, 1e4);
+  try {
+    const config = req.body;
+    await testConnection(config);
+    clearTimeout(timeout);
+    if (!res.headersSent) {
+      res.json({ success: true, message: "Connection successful" });
+    }
+  } catch (error) {
+    clearTimeout(timeout);
+    if (!res.headersSent) {
+      res.status(400).json({
+        success: false,
+        message: error.message || "Connection failed"
+      });
+    }
+  }
+});
+connectionRoutes.get("/provided", (req, res) => {
+  const connString = getProvidedConnectionString();
+  res.json({ connectionString: connString || null });
+});
+connectionRoutes.post("/", async (req, res) => {
+  const timeout = setTimeout(() => {
+    if (!res.headersSent) {
+      res.status(408).json({
+        success: false,
+        message: "Connection timeout"
+      });
+    }
+  }, 15e3);
+  try {
+    const config = req.body;
+    await connect(config);
+    clearTimeout(timeout);
+    if (!res.headersSent) {
+      res.json({ success: true, message: "Connected" });
+    }
+  } catch (error) {
+    clearTimeout(timeout);
+    if (!res.headersSent) {
+      res.status(400).json({
+        success: false,
+        message: error.message || "Connection failed"
+      });
+    }
+  }
+});
+connectionRoutes.delete("/", async (req, res) => {
+  try {
+    await disconnect();
+    res.json({ success: true, message: "Disconnected" });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: error.message || "Disconnect failed"
+    });
+  }
+});
+connectionRoutes.get("/status", async (req, res) => {
+  try {
+    const { getConnection: getConnection2, executeQuery: executeQuery2 } = await import("./mssql-7KV6MCZK.js");
+    const pool = getConnection2();
+    if (pool && pool.connected) {
+      try {
+        const result = await executeQuery2("SELECT DB_NAME() as databaseName");
+        const databaseName = result[0]?.databaseName || null;
+        res.json({ connected: true, databaseName });
+      } catch {
+        res.json({ connected: true, databaseName: null });
+      }
+    } else {
+      res.json({ connected: false });
+    }
+  } catch {
+    res.json({ connected: false });
+  }
+});
+
+// src/server/routes/tables.ts
+import { Router as Router2 } from "express";
+import sql from "mssql";
+var tableRoutes = Router2();
+tableRoutes.get("/", async (req, res) => {
+  try {
+    const pool = getConnection();
+    if (!pool || !pool.connected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const query = `
+      SELECT 
+        TABLE_SCHEMA as schemaName,
+        TABLE_NAME as tableName
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_TYPE = 'BASE TABLE'
+      ORDER BY TABLE_SCHEMA, TABLE_NAME
+    `;
+    const result = await executeQuery(query);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Failed to fetch tables" });
+  }
+});
+tableRoutes.get("/:schema/:table", async (req, res) => {
+  try {
+    const { schema, table } = req.params;
+    const pool = getConnection();
+    if (!pool || !pool.connected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const query = `
+      SELECT 
+        c.COLUMN_NAME as columnName,
+        c.DATA_TYPE as dataType,
+        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
+      FROM INFORMATION_SCHEMA.COLUMNS c
+      LEFT JOIN (
+        SELECT ku.TABLE_SCHEMA, ku.TABLE_NAME, ku.COLUMN_NAME
+        FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+        INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku
+          ON tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+          AND tc.CONSTRAINT_NAME = ku.CONSTRAINT_NAME
+      ) pk ON c.TABLE_SCHEMA = pk.TABLE_SCHEMA
+        AND c.TABLE_NAME = pk.TABLE_NAME
+        AND c.COLUMN_NAME = pk.COLUMN_NAME
+      WHERE c.TABLE_SCHEMA = @schema
+        AND c.TABLE_NAME = @table
+      ORDER BY c.ORDINAL_POSITION
+    `;
+    const result = await executeQuery(query, [
+      { name: "schema", value: schema, type: sql.NVarChar },
+      { name: "table", value: table, type: sql.NVarChar }
+    ]);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Failed to fetch table structure" });
+  }
+});
+tableRoutes.get("/:schema/:table/data", async (req, res) => {
+  try {
+    const { schema, table } = req.params;
+    const page = parseInt(req.query.page) || 1;
+    const pageSize = Math.min(parseInt(req.query.pageSize) || 100, 1e3);
+    const sortColumn = req.query.sortColumn;
+    const sortDirection = req.query.sortDirection || "asc";
+    const offset = (page - 1) * pageSize;
+    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 total = countResult[0]?.total || 0;
+    let orderByColumn = sortColumn || "";
+    let orderByDirection = sortDirection?.toUpperCase() === "DESC" ? "DESC" : "ASC";
+    if (orderByColumn) {
+      try {
+        const validateQuery = `
+          SELECT COLUMN_NAME 
+          FROM INFORMATION_SCHEMA.COLUMNS 
+          WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table AND COLUMN_NAME = @column
+        `;
+        const validateResult = await executeQuery(validateQuery, [
+          { name: "schema", value: schema, type: sql.NVarChar },
+          { name: "table", value: table, type: sql.NVarChar },
+          { name: "column", value: orderByColumn, type: sql.NVarChar }
+        ]);
+        if (validateResult.length === 0) {
+          orderByColumn = "";
+        }
+      } catch (e) {
+        orderByColumn = "";
+      }
+    }
+    if (!orderByColumn) {
+      try {
+        const structureQuery = `
+          SELECT TOP 1 COLUMN_NAME 
+          FROM INFORMATION_SCHEMA.COLUMNS 
+          WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table
+          ORDER BY ORDINAL_POSITION
+        `;
+        const structureResult = await executeQuery(structureQuery, [
+          { name: "schema", value: schema, type: sql.NVarChar },
+          { name: "table", value: table, type: sql.NVarChar }
+        ]);
+        if (structureResult.length > 0) {
+          orderByColumn = structureResult[0].COLUMN_NAME;
+        }
+      } catch (e) {
+      }
+    }
+    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}
+        OFFSET @offset ROWS
+        FETCH NEXT @pageSize ROWS ONLY
+      `;
+      data = await executeQuery(dataQuery, [
+        { name: "offset", value: offset, type: sql.Int },
+        { name: "pageSize", value: pageSize, type: sql.Int }
+      ]);
+    } 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 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
+      `;
+      data = await executeQuery(dataQuery, [
+        { name: "offset", value: offset, type: sql.Int },
+        { name: "pageSize", value: pageSize, type: sql.Int }
+      ]);
+      data = data.map((row) => {
+        const { rn, ...rest } = row;
+        return rest;
+      });
+    }
+    res.json({
+      data,
+      query: generatedQuery,
+      pagination: {
+        page,
+        pageSize,
+        total,
+        totalPages: Math.ceil(total / pageSize)
+      }
+    });
+  } catch (error) {
+    console.error("Error fetching table data:", error);
+    const errorMessage = error.message || "Failed to fetch table data";
+    const errorDetails = error.originalError?.message || error.originalError?.info?.message || "";
+    res.status(500).json({
+      error: errorMessage,
+      details: errorDetails
+    });
+  }
+});
+
+// src/server/routes/query.ts
+import { Router as Router3 } from "express";
+var queryRoutes = Router3();
+queryRoutes.post("/", async (req, res) => {
+  try {
+    const { query: sqlQuery } = req.body;
+    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) => trimmedQuery.includes(keyword)
+    );
+    if (hasDangerousKeyword) {
+      return res.status(400).json({
+        error: "Query contains prohibited keywords. Only SELECT queries are allowed."
+      });
+    }
+    const result = await executeQuery(sqlQuery);
+    res.json({ data: result });
+  } catch (error) {
+    res.status(500).json({
+      error: error.message || "Query execution failed",
+      details: error.originalError?.message
+    });
+  }
+});
+
+// src/server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var providedConnectionString;
+async function startServer(port, connectionString) {
+  providedConnectionString = connectionString;
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+  app.use("/api/connect", connectionRoutes);
+  app.use("/api/tables", tableRoutes);
+  app.use("/api/query", queryRoutes);
+  if (process.env.NODE_ENV === "production") {
+    const clientDist = path.join(__dirname, "../client");
+    app.use(express.static(clientDist));
+    app.get("*", (req, res) => {
+      if (req.path.startsWith("/api")) {
+        return res.status(404).json({ error: "Not found" });
+      }
+      res.sendFile(path.join(clientDist, "index.html"));
+    });
+  }
+  app.get("/api/health", (req, res) => {
+    res.json({ status: "ok", hasConnectionString: !!providedConnectionString });
+  });
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port, () => {
+      resolve(app);
+    });
+    server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use`));
+      } else {
+        reject(error);
+      }
+    });
+  });
+}
+function getProvidedConnectionString() {
+  return providedConnectionString;
+}
+export {
+  getProvidedConnectionString,
+  startServer
+};

package/dist/server/mssql-7KV6MCZK.js

@@ -0,0 +1,16 @@
+import {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  parseConnectionString,
+  testConnection
+} from "./chunk-7G2KHS5I.js";
+export {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  parseConnectionString,
+  testConnection
+};

package/dist/server/mssql-XRYTOVSF.js

@@ -0,0 +1,16 @@
+import {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  parseConnectionString,
+  testConnection
+} from "./chunk-XMPF5YCJ.js";
+export {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  parseConnectionString,
+  testConnection
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "datapeek",
+  "version": "0.1.1",
+  "description": "A local SQL database browser CLI tool",
+  "type": "module",
+  "bin": {
+    "datapeek": "./dist/cli/index.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "./dist/server/index.js",
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "concurrently -n server,client -c blue,green \"npm run dev:server\" \"npm run dev:client\"",
+    "dev:server": "tsup src/server/dev.ts && concurrently --kill-others \"tsup src/server/dev.ts --watch\" \"nodemon dist/server/dev.js\"",
+    "dev:client": "vite --open",
+    "build": "npm run build:client && npm run build:server",
+    "build:client": "vite build",
+    "build:server": "tsup",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "sql",
+    "database",
+    "browser",
+    "cli",
+    "mssql"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "cors": "^2.8.5",
+    "express": "^4.21.2",
+    "mssql": "^11.0.1",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@monaco-editor/react": "^4.6.0",
+    "@tanstack/react-query": "^5.62.11",
+    "@tanstack/react-table": "^8.20.5",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.10.5",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.5",
+    "@vitejs/plugin-react": "^4.3.4",
+    "autoprefixer": "^10.4.20",
+    "clsx": "^2.1.1",
+    "concurrently": "^9.1.2",
+    "nodemon": "^3.1.9",
+    "lucide-react": "^0.468.0",
+    "postcss": "^8.4.49",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tailwindcss": "^3.4.17",
+    "tailwindcss-animate": "^1.0.7",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.5"
+  }
+}