datapeek 0.1.1

package/README.md

@@ -0,0 +1,82 @@
+# Datapeek
+
+A local SQL database browser CLI tool, similar to Prisma Studio, for browsing MS SQL Server databases.
+
+## Installation
+
+```bash
+npm install -g datapeek
+```
+
+Or use directly with npx:
+
+```bash
+npx datapeek
+```
+
+## Usage
+
+### With Connection String
+
+```bash
+npx datapeek "Server=localhost;Database=MyDB;User Id=sa;Password=password;"
+```
+
+### Without Connection String
+
+```bash
+npx datapeek
+```
+
+This will open a connection dialog in your browser where you can enter your connection details.
+
+## Development
+
+### Running in Development Mode
+
+```bash
+# Install dependencies
+npm install
+
+# Run development server (opens browser automatically)
+npm run dev
+
+# Run with connection string
+CONNECTION_STRING="Server=localhost;Database=MyDB;User Id=sa;Password=password;" npm run dev
+```
+
+### Building for Production
+
+```bash
+npm run build
+```
+
+## Features
+
+- 🗄️ Browse database tables and schemas
+- 📊 View table data with pagination
+- 🔍 Search and filter tables
+- 📝 SQL query editor with syntax highlighting
+- 💾 Recent connections history
+- 🎨 Modern, Apple-style UI
+- 🌓 Dark mode support
+
+## Example Connection Strings
+
+```bash
+# Local SQL Server with SQL Auth
+Server=localhost;Database=MyDB;User Id=sa;Password=MyPassword;
+
+# Local SQL Server with Windows Auth
+Server=localhost;Database=MyDB;Integrated Security=true;
+
+# SQL Server Express
+Server=localhost\\SQLEXPRESS;Database=MyDB;User Id=sa;Password=MyPassword;
+
+# Remote SQL Server
+Server=myserver.database.windows.net;Database=MyDB;User Id=myuser;Password=MyPassword;Encrypt=true;
+```
+
+## License
+
+MIT

package/dist/cli/chunk-4IGBRCNN.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+// src/server/db/mssql.ts
+import sql from "mssql";
+var pool = null;
+function parseConnectionString(connectionString) {
+  const config = {
+    server: "",
+    database: "",
+    options: {
+      encrypt: true,
+      trustServerCertificate: false,
+      enableArithAbort: true
+    }
+  };
+  const parts = connectionString.split(";");
+  for (const part of parts) {
+    const [key, ...valueParts] = part.split("=");
+    const value = valueParts.join("=").trim();
+    const keyLower = key.trim().toLowerCase();
+    switch (keyLower) {
+      case "server":
+      case "data source":
+        let serverValue = value;
+        if (serverValue.startsWith("tcp:")) {
+          serverValue = serverValue.substring(4);
+        }
+        const [serverHost, serverPort] = serverValue.split(",");
+        config.server = serverHost.trim();
+        if (serverPort) {
+          config.port = parseInt(serverPort.trim(), 10);
+        }
+        break;
+      case "database":
+      case "initial catalog":
+        config.database = value;
+        break;
+      case "user id":
+      case "userid":
+      case "uid":
+        config.user = value;
+        break;
+      case "password":
+      case "pwd":
+        config.password = value;
+        break;
+      case "port":
+        config.port = parseInt(value, 10);
+        break;
+      case "encrypt":
+        config.options.encrypt = value.toLowerCase() === "true";
+        break;
+      case "trustservercertificate":
+      case "trust server certificate":
+        config.options.trustServerCertificate = value.toLowerCase() === "true";
+        break;
+    }
+  }
+  return config;
+}
+async function testConnection(config) {
+  const testPool = typeof config === "string" ? new sql.ConnectionPool(parseConnectionString(config)) : new sql.ConnectionPool(config);
+  try {
+    await testPool.connect();
+    await testPool.close();
+  } catch (error) {
+    throw error;
+  }
+}
+async function connect(config) {
+  await disconnect();
+  const connectionConfig = typeof config === "string" ? parseConnectionString(config) : config;
+  pool = new sql.ConnectionPool(connectionConfig);
+  try {
+    await pool.connect();
+  } catch (error) {
+    pool = null;
+    throw error;
+  }
+}
+async function disconnect() {
+  if (pool) {
+    try {
+      await pool.close();
+    } catch (error) {
+    }
+    pool = null;
+  }
+}
+function getConnection() {
+  return pool;
+}
+async function executeQuery(query, parameters) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  if (parameters) {
+    for (const param of parameters) {
+      if (param.type) {
+        request.input(param.name, param.type, param.value);
+      } else {
+        request.input(param.name, param.value);
+      }
+    }
+  }
+  const result = await request.query(query);
+  return result.recordset || [];
+}
+
+export {
+  parseConnectionString,
+  testConnection,
+  connect,
+  disconnect,
+  getConnection,
+  executeQuery
+};

package/dist/cli/chunk-IPR5JXB5.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+// src/server/db/mssql.ts
+import sql from "mssql";
+var pool = null;
+function parseConnectionString(connectionString) {
+  const config = {
+    server: "",
+    database: "",
+    options: {
+      encrypt: true,
+      trustServerCertificate: false,
+      enableArithAbort: true
+    }
+  };
+  const parts = connectionString.split(";");
+  for (const part of parts) {
+    const [key, ...valueParts] = part.split("=");
+    const value = valueParts.join("=").trim();
+    switch (key.trim().toLowerCase()) {
+      case "server":
+      case "data source":
+        config.server = value;
+        break;
+      case "database":
+      case "initial catalog":
+        config.database = value;
+        break;
+      case "user id":
+      case "uid":
+        config.user = value;
+        break;
+      case "password":
+      case "pwd":
+        config.password = value;
+        break;
+      case "port":
+        config.port = parseInt(value, 10);
+        break;
+      case "encrypt":
+        config.options.encrypt = value.toLowerCase() === "true";
+        break;
+      case "trustservercertificate":
+      case "trust server certificate":
+        config.options.trustServerCertificate = value.toLowerCase() === "true";
+        break;
+    }
+  }
+  return config;
+}
+async function testConnection(config) {
+  const testPool = typeof config === "string" ? new sql.ConnectionPool(parseConnectionString(config)) : new sql.ConnectionPool(config);
+  try {
+    await testPool.connect();
+    await testPool.close();
+  } catch (error) {
+    throw error;
+  }
+}
+async function connect(config) {
+  await disconnect();
+  const connectionConfig = typeof config === "string" ? parseConnectionString(config) : config;
+  pool = new sql.ConnectionPool(connectionConfig);
+  try {
+    await pool.connect();
+  } catch (error) {
+    pool = null;
+    throw error;
+  }
+}
+async function disconnect() {
+  if (pool) {
+    try {
+      await pool.close();
+    } catch (error) {
+    }
+    pool = null;
+  }
+}
+function getConnection() {
+  return pool;
+}
+async function executeQuery(query, parameters) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  if (parameters) {
+    for (const param of parameters) {
+      if (param.type) {
+        request.input(param.name, param.type, param.value);
+      } else {
+        request.input(param.name, param.value);
+      }
+    }
+  }
+  const result = await request.query(query);
+  return result.recordset || [];
+}
+
+export {
+  parseConnectionString,
+  testConnection,
+  connect,
+  disconnect,
+  getConnection,
+  executeQuery
+};

package/dist/cli/dev.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+import {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  testConnection
+} from "./chunk-4IGBRCNN.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-4KECNFPA.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(port2, connectionString2) {
+  providedConnectionString = connectionString2;
+  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(port2, () => {
+      resolve(app);
+    });
+    server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port2} is already in use`));
+      } else {
+        reject(error);
+      }
+    });
+  });
+}
+function getProvidedConnectionString() {
+  return providedConnectionString;
+}
+
+// src/server/dev.ts
+var port = parseInt(process.env.PORT || "4983", 10);
+var connectionString = process.env.CONNECTION_STRING;
+if (connectionString) {
+  console.log(`\u{1F4CA} Connection string detected: ${connectionString.substring(0, 50)}...`);
+}
+startServer(port, connectionString).then(() => {
+  console.log(`
+\u{1F680} Datapeek dev server running at http://localhost:${port}`);
+  console.log(`\u{1F4E1} API endpoints available at http://localhost:${port}/api`);
+  if (connectionString) {
+    console.log(`\u{1F4CA} Connection string provided: ${connectionString.substring(0, 50)}...`);
+  }
+  console.log(`
+Press Ctrl+C to stop
+`);
+}).catch((error) => {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+});