datapeek 0.1.11 → 0.1.12

package/dist/cli/chunk-2I4MNNVK.js

@@ -0,0 +1,628 @@
+#!/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;
+  const poolConfig = {
+    ...connectionConfig,
+    connectionTimeout: 3e4,
+    // 30 seconds for connection
+    pool: {
+      max: 10,
+      min: 0,
+      idleTimeoutMillis: 3e4,
+      acquireTimeoutMillis: 3e4
+    },
+    options: {
+      ...connectionConfig.options,
+      requestTimeout: 18e5
+      // 30 minutes for queries
+    }
+  };
+  pool = new sql.ConnectionPool(poolConfig);
+  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, queryId) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  request.timeout = 18e5;
+  if (queryId) {
+    const { registerQuery, unregisterQuery } = await import("./queryCancellation-4CMKYTFU.js");
+    registerQuery(queryId, () => {
+      try {
+        request.cancel();
+      } catch (e) {
+      }
+    });
+  }
+  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);
+      }
+    }
+  }
+  try {
+    const result = await request.query(query);
+    if (queryId) {
+      const { unregisterQuery } = await import("./queryCancellation-4CMKYTFU.js");
+      unregisterQuery(queryId);
+    }
+    return result.recordset || [];
+  } catch (error) {
+    if (queryId) {
+      const { unregisterQuery } = await import("./queryCancellation-4CMKYTFU.js");
+      unregisterQuery(queryId);
+    }
+    if (error.code === "ECANCEL" || error.message?.includes("cancel")) {
+      const cancelError = new Error("Query was cancelled by user");
+      cancelError.code = "ECANCEL";
+      cancelError.cancelled = true;
+      throw cancelError;
+    }
+    if (error.code === "ETIMEOUT" || error.code === "ESOCKET" || error.message?.includes("timeout") || error.message?.includes("ETIMEDOUT")) {
+      const timeoutError = new Error("Query execution timeout. The query took too long to execute. Try disabling foreign key displays or reducing the page size.");
+      timeoutError.code = "ETIMEOUT";
+      timeoutError.originalError = error;
+      throw timeoutError;
+    }
+    throw error;
+  }
+}
+async function executeQueryMultiple(query, parameters, queryId) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  request.timeout = 18e5;
+  if (queryId) {
+    const { registerQuery, unregisterQuery } = await import("./queryCancellation-4CMKYTFU.js");
+    registerQuery(queryId, () => {
+      try {
+        request.cancel();
+      } catch (e) {
+      }
+    });
+  }
+  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);
+      }
+    }
+  }
+  try {
+    const result = await request.query(query);
+    const recordsets = result.recordsets || [];
+    const columnMetadata = [];
+    if (recordsets.length > 0) {
+      for (let index = 0; index < recordsets.length; index++) {
+        const recordset = recordsets[index];
+        if (recordset.length === 0) {
+          let columns = [];
+          const resultSet = index === 0 ? result.recordset : result.recordsets?.[index] || null;
+          if (resultSet) {
+            try {
+              const recordsetObj = resultSet;
+              if (recordsetObj.columns && typeof recordsetObj.columns === "object") {
+                columns = Object.keys(recordsetObj.columns);
+              } else if (recordsetObj.recordset && recordsetObj.recordset.columns) {
+                columns = Object.keys(recordsetObj.recordset.columns);
+              }
+              if (columns.length === 0 && result.recordset) {
+                if (index === 0 && result.recordset.columns) {
+                  columns = Object.keys(result.recordset.columns);
+                }
+              }
+            } catch (e) {
+            }
+          }
+          if (columns.length === 0) {
+            try {
+              const trimmedQuery = query.trim().toUpperCase();
+              if (trimmedQuery.startsWith("SELECT")) {
+                const metadataRequest = pool.request();
+                metadataRequest.timeout = 18e5;
+                let metadataQuery = query;
+                if (!trimmedQuery.match(/\bTOP\s+\d+/i)) {
+                  metadataQuery = query.replace(/^(\s*SELECT\s+)(.*)$/i, "$1TOP 0 $2");
+                } else {
+                  metadataQuery = query.replace(/\bTOP\s+\d+/i, "TOP 0");
+                }
+                const metadataResult = await metadataRequest.query(metadataQuery);
+                if (metadataResult.recordset) {
+                  const metadataRecordset = metadataResult.recordset;
+                  if (metadataRecordset.columns) {
+                    columns = Object.keys(metadataRecordset.columns);
+                  }
+                }
+              }
+            } catch (metadataError) {
+            }
+          }
+          if (columns.length > 0) {
+            columnMetadata.push({ resultSetIndex: index, columns });
+          }
+        }
+      }
+    }
+    if (queryId) {
+      const { unregisterQuery } = await import("./queryCancellation-4CMKYTFU.js");
+      unregisterQuery(queryId);
+    }
+    return { recordsets, columnMetadata: columnMetadata.length > 0 ? columnMetadata : void 0 };
+  } catch (error) {
+    if (queryId) {
+      const { unregisterQuery } = await import("./queryCancellation-4CMKYTFU.js");
+      unregisterQuery(queryId);
+    }
+    if (error.code === "ECANCEL" || error.message?.includes("cancel")) {
+      const cancelError = new Error("Query was cancelled by user");
+      cancelError.code = "ECANCEL";
+      cancelError.cancelled = true;
+      throw cancelError;
+    }
+    if (error.code === "ETIMEOUT" || error.code === "ESOCKET" || error.message?.includes("timeout") || error.message?.includes("ETIMEDOUT")) {
+      const timeoutError = new Error("Query execution timeout. The query took too long to execute. Try simplifying your query or reducing the result set size.");
+      timeoutError.code = "ETIMEOUT";
+      timeoutError.originalError = error;
+      throw timeoutError;
+    }
+    throw error;
+  }
+}
+
+// src/server/db/postgres.ts
+import { Pool } from "pg";
+var pool2 = null;
+function parseConnectionString2(connectionString) {
+  const config = {
+    server: "",
+    database: "",
+    options: {
+      ssl: false
+    }
+  };
+  if (connectionString.startsWith("postgresql://") || connectionString.startsWith("postgres://")) {
+    try {
+      const url = new URL(connectionString);
+      config.server = url.hostname;
+      config.database = url.pathname.slice(1);
+      config.user = url.username || void 0;
+      config.password = url.password || void 0;
+      config.port = url.port ? parseInt(url.port, 10) : 5432;
+      const sslMode = url.searchParams.get("sslmode");
+      if (sslMode === "require" || sslMode === "prefer") {
+        config.options.ssl = true;
+      } else if (sslMode === "disable") {
+        config.options.ssl = false;
+      }
+      return config;
+    } catch (error) {
+      throw new Error(`Invalid PostgreSQL connection string: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  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 "host":
+      case "server":
+      case "data source":
+        config.server = value;
+        break;
+      case "database":
+      case "dbname":
+        config.database = value;
+        break;
+      case "user id":
+      case "userid":
+      case "uid":
+      case "user":
+        config.user = value;
+        break;
+      case "password":
+      case "pwd":
+        config.password = value;
+        break;
+      case "port":
+        config.port = parseInt(value, 10);
+        break;
+      case "sslmode":
+      case "ssl mode":
+        if (value.toLowerCase() === "require" || value.toLowerCase() === "prefer") {
+          config.options.ssl = true;
+        } else if (value.toLowerCase() === "disable") {
+          config.options.ssl = false;
+        }
+        break;
+    }
+  }
+  return config;
+}
+async function testConnection2(config) {
+  const connectionConfig = typeof config === "string" ? parseConnectionString2(config) : config;
+  const testPool = new Pool({
+    host: connectionConfig.server,
+    port: connectionConfig.port || 5432,
+    database: connectionConfig.database,
+    user: connectionConfig.user,
+    password: connectionConfig.password,
+    ssl: connectionConfig.options?.ssl,
+    connectionTimeoutMillis: 1e4
+  });
+  try {
+    const client = await testPool.connect();
+    await client.release();
+    await testPool.end();
+  } catch (error) {
+    await testPool.end().catch(() => {
+    });
+    throw error;
+  }
+}
+async function connect2(config) {
+  await disconnect2();
+  const connectionConfig = typeof config === "string" ? parseConnectionString2(config) : config;
+  pool2 = new Pool({
+    host: connectionConfig.server,
+    port: connectionConfig.port || 5432,
+    database: connectionConfig.database,
+    user: connectionConfig.user,
+    password: connectionConfig.password,
+    ssl: connectionConfig.options?.ssl,
+    max: 10,
+    idleTimeoutMillis: 3e4,
+    connectionTimeoutMillis: 3e4,
+    statement_timeout: 12e4
+    // 2 minutes for queries
+  });
+  try {
+    const client = await pool2.connect();
+    await client.release();
+  } catch (error) {
+    await pool2.end().catch(() => {
+    });
+    pool2 = null;
+    throw error;
+  }
+}
+async function disconnect2() {
+  if (pool2) {
+    try {
+      await pool2.end();
+    } catch (error) {
+    }
+    pool2 = null;
+  }
+}
+function getConnection2() {
+  return pool2;
+}
+function convertNamedParamsToPositional(query, parameters) {
+  if (!parameters || parameters.length === 0) {
+    return { query, values: [] };
+  }
+  const paramMap = /* @__PURE__ */ new Map();
+  parameters.forEach((param, index) => {
+    paramMap.set(param.name, { value: param.value, index: index + 1 });
+  });
+  const values = [];
+  let paramIndex = 1;
+  const convertedQuery = query.replace(/@(\w+)/g, (match, paramName) => {
+    const param = paramMap.get(paramName);
+    if (param) {
+      if (values[param.index - 1] === void 0) {
+        values[param.index - 1] = param.value;
+      }
+      return `$${param.index}`;
+    }
+    const newIndex = paramIndex++;
+    values[newIndex - 1] = void 0;
+    return `$${newIndex}`;
+  });
+  for (let i = 0; i < values.length; i++) {
+    if (values[i] === void 0) {
+      const param = parameters[i];
+      if (param) {
+        values[i] = param.value;
+      }
+    }
+  }
+  return { query: convertedQuery, values };
+}
+async function executeQuery2(query, parameters) {
+  if (!pool2) {
+    throw new Error("Not connected to database");
+  }
+  try {
+    const { query: convertedQuery, values } = convertNamedParamsToPositional(query, parameters || []);
+    const result = await pool2.query(convertedQuery, values);
+    return result.rows || [];
+  } catch (error) {
+    if (error.code === "ETIMEOUT" || error.code === "57014" || error.message?.includes("timeout") || error.message?.includes("canceling statement")) {
+      const timeoutError = new Error("Query execution timeout. The query took too long to execute. Try disabling foreign key displays or reducing the page size.");
+      timeoutError.code = "ETIMEOUT";
+      timeoutError.originalError = error;
+      throw timeoutError;
+    }
+    throw error;
+  }
+}
+async function executeQueryMultiple2(query, parameters) {
+  if (!pool2) {
+    throw new Error("Not connected to database");
+  }
+  try {
+    const queries = query.split(";").map((q) => q.trim()).filter((q) => q.length > 0);
+    if (queries.length === 0) {
+      return { recordsets: [], columnMetadata: void 0 };
+    }
+    const { query: convertedQuery, values } = convertNamedParamsToPositional(queries[0], parameters || []);
+    const result = await pool2.query(convertedQuery, values);
+    const recordsets = [result.rows || []];
+    const columnMetadata = [];
+    if (result.rows.length === 0 && result.fields) {
+      const columns = result.fields.map((field) => field.name);
+      if (columns.length > 0) {
+        columnMetadata.push({ resultSetIndex: 0, columns });
+      }
+    }
+    return {
+      recordsets,
+      columnMetadata: columnMetadata.length > 0 ? columnMetadata : void 0
+    };
+  } catch (error) {
+    if (error.code === "ETIMEOUT" || error.code === "57014" || error.message?.includes("timeout") || error.message?.includes("canceling statement")) {
+      const timeoutError = new Error("Query execution timeout. The query took too long to execute. Try simplifying your query or reducing the result set size.");
+      timeoutError.code = "ETIMEOUT";
+      timeoutError.originalError = error;
+      throw timeoutError;
+    }
+    throw error;
+  }
+}
+
+// src/server/db/index.ts
+var currentDbType = "mssql";
+function detectDbType(connectionString) {
+  if (!connectionString) {
+    return "mssql";
+  }
+  const trimmed = connectionString.trim();
+  if (trimmed.startsWith("postgresql://") || trimmed.startsWith("postgres://")) {
+    return "postgres";
+  }
+  return "mssql";
+}
+function getDbType() {
+  return currentDbType;
+}
+function setDbType(type) {
+  currentDbType = type;
+}
+var mssqlDialect = {
+  quoteId(name) {
+    return `[${name}]`;
+  },
+  param(index) {
+    return `@p${index}`;
+  },
+  limitOffset(offset, limit) {
+    return `OFFSET ${offset} ROWS FETCH NEXT ${limit} ROWS ONLY`;
+  },
+  topN(n) {
+    return `TOP ${n}`;
+  },
+  currentDbQuery() {
+    return `SELECT DB_NAME() as databaseName`;
+  },
+  castToDate(expr) {
+    return `CAST(${expr} AS DATE)`;
+  },
+  tryCastToNVarChar(expr) {
+    return `TRY_CAST(${expr} AS NVARCHAR(4000))`;
+  }
+};
+var postgresDialect = {
+  quoteId(name) {
+    return `"${name}"`;
+  },
+  param(index) {
+    return `@p${index}`;
+  },
+  limitOffset(offset, limit) {
+    return `LIMIT ${limit} OFFSET ${offset}`;
+  },
+  topN(n) {
+    return "";
+  },
+  currentDbQuery() {
+    return `SELECT current_database() as "databaseName"`;
+  },
+  castToDate(expr) {
+    return `CAST(${expr} AS DATE)`;
+  },
+  tryCastToNVarChar(expr) {
+    return `CAST(${expr} AS TEXT)`;
+  }
+};
+function getDialect() {
+  return currentDbType === "postgres" ? postgresDialect : mssqlDialect;
+}
+async function testConnection3(config) {
+  if (typeof config === "string") {
+    const dbType = detectDbType(config);
+    if (dbType === "postgres") {
+      return testConnection2(config);
+    } else {
+      return testConnection(config);
+    }
+  } else {
+    if (currentDbType === "postgres") {
+      return testConnection2(config);
+    } else {
+      return testConnection(config);
+    }
+  }
+}
+async function connect3(config) {
+  if (typeof config === "string") {
+    const dbType = detectDbType(config);
+    setDbType(dbType);
+    if (dbType === "postgres") {
+      return connect2(config);
+    } else {
+      return connect(config);
+    }
+  } else {
+    if (currentDbType === "postgres") {
+      return connect2(config);
+    } else {
+      return connect(config);
+    }
+  }
+}
+async function disconnect3() {
+  if (currentDbType === "postgres") {
+    return disconnect2();
+  } else {
+    return disconnect();
+  }
+}
+function getConnection3() {
+  if (currentDbType === "postgres") {
+    return getConnection2();
+  } else {
+    return getConnection();
+  }
+}
+async function executeQuery3(query, parameters) {
+  if (currentDbType === "postgres") {
+    return executeQuery2(query, parameters);
+  } else {
+    return executeQuery(query, parameters);
+  }
+}
+async function executeQueryMultiple3(query, parameters) {
+  if (currentDbType === "postgres") {
+    return executeQueryMultiple2(query, parameters);
+  } else {
+    return executeQueryMultiple(query, parameters);
+  }
+}
+function parseConnectionString3(connectionString) {
+  const dbType = detectDbType(connectionString);
+  if (dbType === "postgres") {
+    return parseConnectionString2(connectionString);
+  } else {
+    return parseConnectionString(connectionString);
+  }
+}
+
+export {
+  detectDbType,
+  getDbType,
+  setDbType,
+  getDialect,
+  testConnection3 as testConnection,
+  connect3 as connect,
+  disconnect3 as disconnect,
+  getConnection3 as getConnection,
+  executeQuery3 as executeQuery,
+  executeQueryMultiple3 as executeQueryMultiple,
+  parseConnectionString3 as parseConnectionString
+};