datapeek 0.1.1

package/dist/cli/index.js

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+import {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  testConnection
+} from "./chunk-4IGBRCNN.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// 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(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;
+}
+
+// src/cli/index.ts
+import open from "open";
+var program = new Command();
+program.name("datapeek").description("A local SQL database browser").version("0.1.0").argument("[connectionString]", "SQL Server connection string").option("-p, --port <port>", "Port to run the server on", "4983").option("--no-open", "Do not open browser automatically").action(async (connectionString, options) => {
+  const port = parseInt(options?.port || "4983", 10);
+  try {
+    const server = await startServer(port, connectionString);
+    const url = `http://localhost:${port}`;
+    console.log(`
+\u{1F680} Datapeek server running at ${url}`);
+    if (connectionString) {
+      console.log(`\u{1F4CA} Connection string provided: ${connectionString.substring(0, 20)}...`);
+    }
+    console.log(`
+Press Ctrl+C to stop
+`);
+    if (options?.open !== false) {
+      await open(url);
+    }
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/cli/mssql-2REU4IX7.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  parseConnectionString,
+  testConnection
+} from "./chunk-IPR5JXB5.js";
+export {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  parseConnectionString,
+  testConnection
+};

package/dist/cli/mssql-4KECNFPA.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  parseConnectionString,
+  testConnection
+} from "./chunk-4IGBRCNN.js";
+export {
+  connect,
+  disconnect,
+  executeQuery,
+  getConnection,
+  parseConnectionString,
+  testConnection
+};