@zz1996/dbhub-dameng 0.1.0

package/dist/chunk-IPK7BYBL.js

@@ -0,0 +1,35 @@
+// src/utils/identifier-quoter.ts
+function quoteIdentifier(identifier, dbType) {
+  if (/[\0\x08\x09\x1a\n\r]/.test(identifier)) {
+    throw new Error(`Invalid identifier: contains control characters: ${identifier}`);
+  }
+  if (!identifier) {
+    throw new Error("Identifier cannot be empty");
+  }
+  switch (dbType) {
+    case "postgres":
+    case "sqlite":
+    case "dameng":
+      return `"${identifier.replace(/"/g, '""')}"`;
+    case "mysql":
+    case "mariadb":
+      return `\`${identifier.replace(/`/g, "``")}\``;
+    case "sqlserver":
+      return `[${identifier.replace(/]/g, "]]")}]`;
+    default:
+      return `"${identifier.replace(/"/g, '""')}"`;
+  }
+}
+function quoteQualifiedIdentifier(tableName, schemaName, dbType) {
+  const quotedTable = quoteIdentifier(tableName, dbType);
+  if (schemaName) {
+    const quotedSchema = quoteIdentifier(schemaName, dbType);
+    return `${quotedSchema}.${quotedTable}`;
+  }
+  return quotedTable;
+}
+
+export {
+  quoteIdentifier,
+  quoteQualifiedIdentifier
+};

package/dist/chunk-RTB262PR.js

@@ -0,0 +1,60 @@
+// src/utils/multi-statement-result-parser.ts
+function isMetadataObject(element) {
+  if (!element || typeof element !== "object" || Array.isArray(element)) {
+    return false;
+  }
+  return "affectedRows" in element || "insertId" in element || "fieldCount" in element || "warningStatus" in element;
+}
+function isMultiStatementResult(results) {
+  if (!Array.isArray(results) || results.length === 0) {
+    return false;
+  }
+  const firstElement = results[0];
+  return isMetadataObject(firstElement) || Array.isArray(firstElement);
+}
+function extractRowsFromMultiStatement(results) {
+  if (!Array.isArray(results)) {
+    return [];
+  }
+  const allRows = [];
+  for (const result of results) {
+    if (Array.isArray(result)) {
+      allRows.push(...result);
+    }
+  }
+  return allRows;
+}
+function extractAffectedRows(results) {
+  if (isMetadataObject(results)) {
+    return results.affectedRows || 0;
+  }
+  if (!Array.isArray(results)) {
+    return 0;
+  }
+  if (isMultiStatementResult(results)) {
+    let totalAffected = 0;
+    for (const result of results) {
+      if (isMetadataObject(result)) {
+        totalAffected += result.affectedRows || 0;
+      } else if (Array.isArray(result)) {
+        totalAffected += result.length;
+      }
+    }
+    return totalAffected;
+  }
+  return results.length;
+}
+function parseQueryResults(results) {
+  if (!Array.isArray(results)) {
+    return [];
+  }
+  if (isMultiStatementResult(results)) {
+    return extractRowsFromMultiStatement(results);
+  }
+  return results;
+}
+
+export {
+  extractAffectedRows,
+  parseQueryResults
+};

package/dist/chunk-SQA2ISDE.js

@@ -0,0 +1,503 @@
+// src/connectors/interface.ts
+var _ConnectorRegistry = class _ConnectorRegistry {
+  /**
+   * Register a new connector
+   */
+  static register(connector) {
+    _ConnectorRegistry.connectors.set(connector.id, connector);
+  }
+  /**
+   * Get a connector by ID
+   */
+  static getConnector(id) {
+    return _ConnectorRegistry.connectors.get(id) || null;
+  }
+  /**
+   * Get connector for a DSN string
+   * Tries to find a connector that can handle the given DSN format
+   */
+  static getConnectorForDSN(dsn) {
+    for (const connector of _ConnectorRegistry.connectors.values()) {
+      if (connector.dsnParser.isValidDSN(dsn)) {
+        return connector;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get all available connector IDs
+   */
+  static getAvailableConnectors() {
+    return Array.from(_ConnectorRegistry.connectors.keys());
+  }
+  /**
+   * Get sample DSN for a specific connector
+   */
+  static getSampleDSN(connectorType) {
+    const connector = _ConnectorRegistry.getConnector(connectorType);
+    if (!connector) return null;
+    return connector.dsnParser.getSampleDSN();
+  }
+  /**
+   * Get all available sample DSNs
+   */
+  static getAllSampleDSNs() {
+    const samples = {};
+    for (const [id, connector] of _ConnectorRegistry.connectors.entries()) {
+      samples[id] = connector.dsnParser.getSampleDSN();
+    }
+    return samples;
+  }
+};
+_ConnectorRegistry.connectors = /* @__PURE__ */ new Map();
+var ConnectorRegistry = _ConnectorRegistry;
+
+// src/utils/safe-url.ts
+var SafeURL = class {
+  /**
+   * Parse a URL and handle special characters in passwords
+   * This is a safe alternative to the URL constructor
+   * 
+   * @param urlString - The DSN string to parse
+   */
+  constructor(urlString) {
+    this.protocol = "";
+    this.hostname = "";
+    this.port = "";
+    this.pathname = "";
+    this.username = "";
+    this.password = "";
+    this.searchParams = /* @__PURE__ */ new Map();
+    if (!urlString || urlString.trim() === "") {
+      throw new Error("URL string cannot be empty");
+    }
+    try {
+      const protocolSeparator = urlString.indexOf("://");
+      if (protocolSeparator !== -1) {
+        this.protocol = urlString.substring(0, protocolSeparator + 1);
+        urlString = urlString.substring(protocolSeparator + 3);
+      } else {
+        throw new Error('Invalid URL format: missing protocol (e.g., "mysql://")');
+      }
+      const questionMarkIndex = urlString.indexOf("?");
+      let queryParams = "";
+      if (questionMarkIndex !== -1) {
+        queryParams = urlString.substring(questionMarkIndex + 1);
+        urlString = urlString.substring(0, questionMarkIndex);
+        queryParams.split("&").forEach((pair) => {
+          const parts = pair.split("=");
+          if (parts.length === 2 && parts[0] && parts[1]) {
+            this.searchParams.set(parts[0], decodeURIComponent(parts[1]));
+          }
+        });
+      }
+      const atIndex = urlString.indexOf("@");
+      if (atIndex !== -1) {
+        const auth = urlString.substring(0, atIndex);
+        urlString = urlString.substring(atIndex + 1);
+        const colonIndex2 = auth.indexOf(":");
+        if (colonIndex2 !== -1) {
+          this.username = auth.substring(0, colonIndex2);
+          this.password = auth.substring(colonIndex2 + 1);
+          this.username = decodeURIComponent(this.username);
+          this.password = decodeURIComponent(this.password);
+        } else {
+          this.username = auth;
+        }
+      }
+      const pathSeparatorIndex = urlString.indexOf("/");
+      if (pathSeparatorIndex !== -1) {
+        this.pathname = urlString.substring(pathSeparatorIndex);
+        urlString = urlString.substring(0, pathSeparatorIndex);
+      }
+      const colonIndex = urlString.indexOf(":");
+      if (colonIndex !== -1) {
+        this.hostname = urlString.substring(0, colonIndex);
+        this.port = urlString.substring(colonIndex + 1);
+      } else {
+        this.hostname = urlString;
+      }
+      if (this.protocol === "") {
+        throw new Error("Invalid URL: protocol is required");
+      }
+    } catch (error) {
+      throw new Error(`Failed to parse URL: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Helper method to safely get a parameter from query string
+   * 
+   * @param name - The parameter name to retrieve
+   * @returns The parameter value or null if not found
+   */
+  getSearchParam(name) {
+    return this.searchParams.has(name) ? this.searchParams.get(name) : null;
+  }
+  /**
+   * Helper method to iterate over all parameters
+   * 
+   * @param callback - Function to call for each parameter
+   */
+  forEachSearchParam(callback) {
+    this.searchParams.forEach((value, key) => callback(value, key));
+  }
+};
+
+// src/utils/dsn-obfuscate.ts
+function parseConnectionInfoFromDSN(dsn) {
+  if (!dsn) {
+    return null;
+  }
+  try {
+    const type = getDatabaseTypeFromDSN(dsn);
+    if (typeof type === "undefined") {
+      return null;
+    }
+    if (type === "sqlite") {
+      const prefix = "sqlite:///";
+      if (dsn.length > prefix.length) {
+        const rawPath = dsn.substring(prefix.length);
+        const firstChar = rawPath[0];
+        const isWindowsDrive = rawPath.length > 1 && rawPath[1] === ":";
+        const isSpecialPath = firstChar === ":" || firstChar === "." || firstChar === "~" || isWindowsDrive;
+        return {
+          type,
+          database: isSpecialPath ? rawPath : "/" + rawPath
+        };
+      }
+      return { type };
+    }
+    const url = new SafeURL(dsn);
+    const info = { type };
+    if (url.hostname) {
+      info.host = url.hostname;
+    }
+    if (url.port) {
+      info.port = parseInt(url.port, 10);
+    }
+    if (url.pathname && url.pathname.length > 1) {
+      info.database = url.pathname.substring(1);
+    }
+    if (url.username) {
+      info.user = url.username;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+function obfuscateDSNPassword(dsn) {
+  if (!dsn) {
+    return dsn;
+  }
+  try {
+    const type = getDatabaseTypeFromDSN(dsn);
+    if (type === "sqlite") {
+      return dsn;
+    }
+    const url = new SafeURL(dsn);
+    if (!url.password) {
+      return dsn;
+    }
+    const obfuscatedPassword = "*".repeat(Math.min(url.password.length, 8));
+    const protocol = dsn.split(":")[0];
+    let result;
+    if (url.username) {
+      result = `${protocol}://${url.username}:${obfuscatedPassword}@${url.hostname}`;
+    } else {
+      result = `${protocol}://${obfuscatedPassword}@${url.hostname}`;
+    }
+    if (url.port) {
+      result += `:${url.port}`;
+    }
+    result += url.pathname;
+    if (url.searchParams.size > 0) {
+      const params = [];
+      url.forEachSearchParam((value, key) => {
+        params.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+      });
+      result += `?${params.join("&")}`;
+    }
+    return result;
+  } catch {
+    return dsn;
+  }
+}
+function getDatabaseTypeFromDSN(dsn) {
+  if (!dsn) {
+    return void 0;
+  }
+  const protocol = dsn.split(":")[0];
+  return protocolToConnectorType(protocol);
+}
+function protocolToConnectorType(protocol) {
+  const mapping = {
+    "postgres": "postgres",
+    "postgresql": "postgres",
+    "mysql": "mysql",
+    "mariadb": "mariadb",
+    "sqlserver": "sqlserver",
+    "sqlite": "sqlite",
+    "dameng": "dameng",
+    "dm": "dameng"
+  };
+  return mapping[protocol];
+}
+function getDefaultPortForType(type) {
+  const ports = {
+    "postgres": 5432,
+    "mysql": 3306,
+    "mariadb": 3306,
+    "sqlserver": 1433,
+    "sqlite": void 0,
+    "dameng": 5236
+  };
+  return ports[type];
+}
+
+// src/utils/sql-parser.ts
+var TokenType = { Plain: 0, Comment: 1, QuotedBlock: 2 };
+function plainToken(i) {
+  return { type: TokenType.Plain, end: i + 1 };
+}
+function scanSingleLineComment(sql, i) {
+  if (sql[i] !== "-" || sql[i + 1] !== "-") {
+    return null;
+  }
+  let j = i;
+  while (j < sql.length && sql[j] !== "\n") {
+    j++;
+  }
+  return { type: TokenType.Comment, end: j };
+}
+function scanSingleLineCommentMySQL(sql, i) {
+  if (sql[i] !== "-" || sql[i + 1] !== "-") {
+    return null;
+  }
+  const next = sql[i + 2];
+  if (next !== void 0 && next.charCodeAt(0) > 32 && next.charCodeAt(0) !== 127) {
+    return null;
+  }
+  let j = i;
+  while (j < sql.length && sql[j] !== "\n") {
+    j++;
+  }
+  return { type: TokenType.Comment, end: j };
+}
+function scanMultiLineComment(sql, i) {
+  if (sql[i] !== "/" || sql[i + 1] !== "*") {
+    return null;
+  }
+  let j = i + 2;
+  while (j < sql.length && !(sql[j] === "*" && sql[j + 1] === "/")) {
+    j++;
+  }
+  if (j < sql.length) {
+    j += 2;
+  }
+  return { type: TokenType.Comment, end: j };
+}
+function scanMultiLineCommentMySQL(sql, i) {
+  if (sql[i] !== "/" || sql[i + 1] !== "*") {
+    return null;
+  }
+  const next = sql[i + 2];
+  const nextNext = sql[i + 3];
+  if (next === "!" || next === "M" && nextNext === "!") {
+    return null;
+  }
+  return scanMultiLineComment(sql, i);
+}
+function scanNestedMultiLineComment(sql, i) {
+  if (sql[i] !== "/" || sql[i + 1] !== "*") {
+    return null;
+  }
+  let j = i + 2;
+  let depth = 1;
+  while (j < sql.length && depth > 0) {
+    if (sql[j] === "/" && sql[j + 1] === "*") {
+      depth++;
+      j += 2;
+    } else if (sql[j] === "*" && sql[j + 1] === "/") {
+      depth--;
+      j += 2;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.Comment, end: j };
+}
+function scanSingleQuotedString(sql, i) {
+  if (sql[i] !== "'") {
+    return null;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === "'" && sql[j + 1] === "'") {
+      j += 2;
+    } else if (sql[j] === "'") {
+      j++;
+      break;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.QuotedBlock, end: j };
+}
+function scanDoubleQuotedString(sql, i) {
+  if (sql[i] !== '"') {
+    return null;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === '"' && sql[j + 1] === '"') {
+      j += 2;
+    } else if (sql[j] === '"') {
+      j++;
+      break;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.QuotedBlock, end: j };
+}
+var dollarQuoteOpenRegex = /^\$([a-zA-Z_]\w*)?\$/;
+function scanDollarQuotedBlock(sql, i) {
+  if (sql[i] !== "$") {
+    return null;
+  }
+  const next = sql[i + 1];
+  if (next >= "0" && next <= "9") {
+    return null;
+  }
+  const remaining = sql.substring(i);
+  const m = dollarQuoteOpenRegex.exec(remaining);
+  if (!m) {
+    return null;
+  }
+  const tag = m[0];
+  const bodyStart = i + tag.length;
+  const closeIdx = sql.indexOf(tag, bodyStart);
+  const end = closeIdx !== -1 ? closeIdx + tag.length : sql.length;
+  return { type: TokenType.QuotedBlock, end };
+}
+function scanBacktickQuotedIdentifier(sql, i) {
+  if (sql[i] !== "`") {
+    return null;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === "`" && sql[j + 1] === "`") {
+      j += 2;
+    } else if (sql[j] === "`") {
+      j++;
+      break;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.QuotedBlock, end: j };
+}
+function scanBracketQuotedIdentifier(sql, i) {
+  if (sql[i] !== "[") {
+    return null;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === "]" && sql[j + 1] === "]") {
+      j += 2;
+    } else if (sql[j] === "]") {
+      j++;
+      break;
+    } else {
+      j++;
+    }
+  }
+  return { type: TokenType.QuotedBlock, end: j };
+}
+function scanTokenAnsi(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? plainToken(i);
+}
+function scanTokenPostgres(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanNestedMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanDollarQuotedBlock(sql, i) ?? plainToken(i);
+}
+function scanTokenMySQL(sql, i) {
+  return scanSingleLineCommentMySQL(sql, i) ?? scanMultiLineCommentMySQL(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanBacktickQuotedIdentifier(sql, i) ?? plainToken(i);
+}
+function scanTokenSQLite(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanBacktickQuotedIdentifier(sql, i) ?? scanBracketQuotedIdentifier(sql, i) ?? plainToken(i);
+}
+function scanTokenSQLServer(sql, i) {
+  return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanBracketQuotedIdentifier(sql, i) ?? plainToken(i);
+}
+var dialectScanners = {
+  postgres: scanTokenPostgres,
+  mysql: scanTokenMySQL,
+  mariadb: scanTokenMySQL,
+  sqlite: scanTokenSQLite,
+  sqlserver: scanTokenSQLServer,
+  dameng: scanTokenAnsi
+};
+function getScanner(dialect) {
+  return dialect ? dialectScanners[dialect] ?? scanTokenAnsi : scanTokenAnsi;
+}
+function stripCommentsAndStrings(sql, dialect) {
+  const scanToken = getScanner(dialect);
+  const parts = [];
+  let plainStart = -1;
+  let i = 0;
+  while (i < sql.length) {
+    const token = scanToken(sql, i);
+    if (token.type === TokenType.Plain) {
+      if (plainStart === -1) {
+        plainStart = i;
+      }
+    } else {
+      if (plainStart !== -1) {
+        parts.push(sql.substring(plainStart, i));
+        plainStart = -1;
+      }
+      parts.push(" ");
+    }
+    i = token.end;
+  }
+  if (plainStart !== -1) {
+    parts.push(sql.substring(plainStart));
+  }
+  return parts.join("");
+}
+function splitSQLStatements(sql, dialect) {
+  const scanToken = getScanner(dialect);
+  const statements = [];
+  let stmtStart = 0;
+  let i = 0;
+  while (i < sql.length) {
+    if (sql[i] === ";") {
+      const trimmed2 = sql.substring(stmtStart, i).trim();
+      if (trimmed2.length > 0) {
+        statements.push(trimmed2);
+      }
+      stmtStart = i + 1;
+      i++;
+      continue;
+    }
+    const token = scanToken(sql, i);
+    i = token.end;
+  }
+  const trimmed = sql.substring(stmtStart).trim();
+  if (trimmed.length > 0) {
+    statements.push(trimmed);
+  }
+  return statements;
+}
+
+export {
+  ConnectorRegistry,
+  SafeURL,
+  parseConnectionInfoFromDSN,
+  obfuscateDSNPassword,
+  getDatabaseTypeFromDSN,
+  getDefaultPortForType,
+  stripCommentsAndStrings,
+  splitSQLStatements
+};

package/dist/chunk-WVVMH6FJ.js

@@ -0,0 +1,49 @@
+// src/utils/module-loader.ts
+var MISSING_MODULE_RE = /Cannot find (?:package|module) '([^']+)'/;
+function isDriverNotInstalled(err, driver) {
+  if (!(err instanceof Error) || !("code" in err) || err.code !== "ERR_MODULE_NOT_FOUND") {
+    return false;
+  }
+  const match = err.message.match(MISSING_MODULE_RE);
+  if (!match) {
+    return false;
+  }
+  const missingSpecifier = match[1];
+  return missingSpecifier === driver || missingSpecifier.startsWith(`${driver}/`);
+}
+function isModuleNotFound(err) {
+  if (!(err instanceof Error) || !("code" in err)) {
+    return false;
+  }
+  const code = err.code;
+  return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND";
+}
+async function loadConnectors(connectorModules) {
+  await Promise.all(
+    connectorModules.map(async ({ load, name, driver }) => {
+      try {
+        await load();
+      } catch (err) {
+        if (isDriverNotInstalled(err, driver)) {
+          console.error(
+            `Skipping ${name} connector: driver package "${driver}" not installed.`
+          );
+        } else if (isModuleNotFound(err)) {
+          const msg = err instanceof Error ? err.message : String(err);
+          const match = msg.match(MISSING_MODULE_RE);
+          const missing = match ? match[1] : "unknown";
+          console.error(
+            `Skipping ${name} connector: required dependency "${missing}" not installed.`
+          );
+        } else {
+          throw err;
+        }
+      }
+    })
+  );
+}
+
+export {
+  isDriverNotInstalled,
+  loadConnectors
+};