datapeek 0.1.11 → 0.1.13

package/dist/cli/chunk-6K3WSEIM.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+
+import {
+  connect,
+  disconnect,
+  executeQuery,
+  executeQueryMultiple,
+  getConnection,
+  parseConnectionString,
+  testConnection
+} from "./chunk-3XB4P3G3.js";
+
+// src/server/db/postgres.ts
+import { Pool } from "pg";
+var pool = 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;
+  pool = 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 pool.connect();
+    await client.release();
+  } catch (error) {
+    await pool.end().catch(() => {
+    });
+    pool = null;
+    throw error;
+  }
+}
+async function disconnect2() {
+  if (pool) {
+    try {
+      await pool.end();
+    } catch (error) {
+    }
+    pool = null;
+  }
+}
+function getConnection2() {
+  return pool;
+}
+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 (!pool) {
+    throw new Error("Not connected to database");
+  }
+  try {
+    const { query: convertedQuery, values } = convertNamedParamsToPositional(query, parameters || []);
+    const result = await pool.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 (!pool) {
+    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 pool.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 `$${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
+};