datapeek 0.1.9 → 0.1.10

package/dist/cli/chunk-3XB4P3G3.js

@@ -0,0 +1,228 @@
+#!/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: 12e4
+      // 2 minutes for queries (increased for complex queries with JOINs)
+    }
+  };
+  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) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  request.timeout = 12e4;
+  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);
+    return result.recordset || [];
+  } catch (error) {
+    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) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  request.timeout = 12e4;
+  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 = 5e3;
+                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 });
+          }
+        }
+      }
+    }
+    return { recordsets, columnMetadata: columnMetadata.length > 0 ? columnMetadata : void 0 };
+  } catch (error) {
+    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;
+  }
+}
+
+export {
+  parseConnectionString,
+  testConnection,
+  connect,
+  disconnect,
+  getConnection,
+  executeQuery,
+  executeQueryMultiple
+};

package/dist/cli/chunk-Y3EHCZQX.js

@@ -0,0 +1,220 @@
+#!/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: 12e4
+      // 2 minutes for queries (increased for complex queries with JOINs)
+    }
+  };
+  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) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  request.timeout = 12e4;
+  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);
+    return result.recordset || [];
+  } catch (error) {
+    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) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  request.timeout = 12e4;
+  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 = [];
+    const emptyResultSetIndices = [];
+    recordsets.forEach((recordset, index) => {
+      if (recordset.length === 0) {
+        emptyResultSetIndices.push(index);
+      }
+    });
+    if (emptyResultSetIndices.length > 0) {
+      try {
+        const trimmedQuery = query.trim().toUpperCase();
+        if (trimmedQuery.startsWith("SELECT")) {
+          const metadataRequest = pool.request();
+          metadataRequest.timeout = 5e3;
+          let metadataQuery = query;
+          if (!trimmedQuery.includes("TOP ")) {
+            metadataQuery = query.replace(/^(\s*SELECT\s+)(.*)$/i, "$1TOP 0 $2");
+          } else {
+            metadataQuery = query.replace(/TOP\s+\d+/i, "TOP 0");
+          }
+          const metadataResult = await metadataRequest.query(metadataQuery);
+          if (metadataResult.recordset) {
+            const metadataRecordset = metadataResult.recordset;
+            if (metadataRecordset.columns && typeof metadataRecordset.columns === "object") {
+              const cols = Object.keys(metadataRecordset.columns);
+              if (cols.length > 0) {
+                emptyResultSetIndices.forEach((index) => {
+                  columnMetadata.push({ resultSetIndex: index, columns: cols });
+                });
+              }
+            }
+            if (columnMetadata.length === 0 && metadataResult.recordset.columns) {
+              const cols = Object.keys(metadataResult.recordset.columns);
+              if (cols.length > 0) {
+                emptyResultSetIndices.forEach((index) => {
+                  columnMetadata.push({ resultSetIndex: index, columns: cols });
+                });
+              }
+            }
+          }
+        }
+      } catch (metadataError) {
+        console.debug("Could not extract column metadata for empty result set:", metadataError);
+      }
+    }
+    return { recordsets, columnMetadata: columnMetadata.length > 0 ? columnMetadata : void 0 };
+  } catch (error) {
+    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;
+  }
+}
+
+export {
+  parseConnectionString,
+  testConnection,
+  connect,
+  disconnect,
+  getConnection,
+  executeQuery,
+  executeQueryMultiple
+};

package/dist/cli/chunk-Z2LV7EWL.js

@@ -0,0 +1,190 @@
+#!/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: 12e4
+      // 2 minutes for queries (increased for complex queries with JOINs)
+    }
+  };
+  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) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  request.timeout = 12e4;
+  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);
+    return result.recordset || [];
+  } catch (error) {
+    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) {
+  if (!pool || !pool.connected) {
+    throw new Error("Not connected to database");
+  }
+  const request = pool.request();
+  request.timeout = 12e4;
+  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 (result.recordset && recordsets.length > 0) {
+      recordsets.forEach((recordset, index) => {
+        if (recordset.length === 0) {
+          const resultSet = index === 0 ? result.recordset : result.recordsets?.[index] || null;
+          if (resultSet && resultSet.columns) {
+            const columns = Object.keys(resultSet.columns);
+            if (columns.length > 0) {
+              columnMetadata.push({ resultSetIndex: index, columns });
+            }
+          }
+        }
+      });
+    }
+    return { recordsets, columnMetadata: columnMetadata.length > 0 ? columnMetadata : void 0 };
+  } catch (error) {
+    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;
+  }
+}
+
+export {
+  parseConnectionString,
+  testConnection,
+  connect,
+  disconnect,
+  getConnection,
+  executeQuery,
+  executeQueryMultiple
+};