@saptools/cf-hana 0.1.0 → 0.1.2

package/dist/index.js

@@ -493,7 +493,7 @@ var HdbConnection = class {
       const raw = await this.executeStatement(statement, params);
       return toExecResult(statement, raw);
     } finally {
-      statement.drop();
+      dropStatementQuietly(statement);
     }
   }
   setAutoCommit(enabled) {
@@ -560,6 +560,12 @@ var HdbConnection = class {
     });
   }
 };
+function dropStatementQuietly(statement) {
+  try {
+    statement.drop();
+  } catch {
+  }
+}
 function openClient(client, timeoutMs) {
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -595,6 +601,20 @@ function openClient(client, timeoutMs) {
     });
   });
 }
+async function closeClientQuietly(client) {
+  try {
+    await new Promise((resolve) => {
+      client.disconnect(() => {
+        resolve();
+      });
+    });
+  } catch {
+  }
+  try {
+    client.close();
+  } catch {
+  }
+}
 function setCurrentSchema(client, schema) {
   return new Promise((resolve, reject) => {
     client.exec(`SET SCHEMA ${quoteIdentifier(schema)}`, (error) => {
@@ -616,7 +636,12 @@ async function connectHdb(params) {
     useTLS: true
   });
   await openClient(client, params.connectTimeoutMs);
-  await setCurrentSchema(client, params.schema);
+  try {
+    await setCurrentSchema(client, params.schema);
+  } catch (error) {
+    await closeClientQuietly(client);
+    throw error;
+  }
   return new HdbConnection(client);
 }
 function createHdbDriver() {
@@ -642,11 +667,100 @@ function createDriver(name) {
 // src/safety.ts
 var DESTRUCTIVE_DDL_KEYWORDS = /* @__PURE__ */ new Set(["DROP", "TRUNCATE", "ALTER"]);
 var UNSCOPED_WRITE_KEYWORDS = /* @__PURE__ */ new Set(["UPDATE", "DELETE"]);
-function stripStringLiterals(sql) {
-  return sql.replace(/'(?:[^']|'')*'/g, "''");
+function skipQuotedText(sql, start) {
+  const quote = sql[start];
+  let index = start + 1;
+  while (index < sql.length) {
+    if (sql[index] === quote) {
+      if (sql[index + 1] === quote) {
+        index += 2;
+        continue;
+      }
+      index += 1;
+      break;
+    }
+    index += 1;
+  }
+  return index;
+}
+function skipLineComment(sql, start) {
+  let index = start + 2;
+  while (index < sql.length && sql[index] !== "\n") {
+    index += 1;
+  }
+  return index;
+}
+function skipBlockComment(sql, start) {
+  let index = start + 2;
+  while (index < sql.length && !(sql[index] === "*" && sql[index + 1] === "/")) {
+    index += 1;
+  }
+  return Math.min(index + 2, sql.length);
+}
+function maskIgnoredSqlText(sql) {
+  let masked = "";
+  let index = 0;
+  while (index < sql.length) {
+    const char = sql[index];
+    if (char === "'" || char === '"') {
+      const end = skipQuotedText(sql, index);
+      masked += " ".repeat(end - index);
+      index = end;
+      continue;
+    }
+    if (char === "-" && sql[index + 1] === "-") {
+      const end = skipLineComment(sql, index);
+      masked += " ".repeat(end - index);
+      index = end;
+      continue;
+    }
+    if (char === "/" && sql[index + 1] === "*") {
+      const end = skipBlockComment(sql, index);
+      masked += " ".repeat(end - index);
+      index = end;
+      continue;
+    }
+    masked += char ?? "";
+    index += 1;
+  }
+  return masked;
 }
 function hasWhereClause(sql) {
-  return /\bwhere\b/i.test(stripStringLiterals(sql));
+  return /\bwhere\b/i.test(maskIgnoredSqlText(sql));
+}
+function trailingLineCommentIndex(sql) {
+  let index = 0;
+  while (index < sql.length) {
+    const char = sql[index];
+    if (char === "'" || char === '"') {
+      index = skipQuotedText(sql, index);
+      continue;
+    }
+    if (char === "/" && sql[index + 1] === "*") {
+      index = skipBlockComment(sql, index);
+      continue;
+    }
+    if (char === "-" && sql[index + 1] === "-") {
+      const lineEnd = sql.indexOf("\n", index + 2);
+      if (lineEnd === -1 || sql.slice(lineEnd + 1).trim().length === 0) {
+        return index;
+      }
+      index = lineEnd + 1;
+      continue;
+    }
+    index += 1;
+  }
+  return void 0;
+}
+function appendLimit(sql, limit) {
+  const trimmed = sql.replace(/[\s;]+$/, "");
+  const commentIndex = trailingLineCommentIndex(trimmed);
+  if (commentIndex === void 0) {
+    return `${trimmed} LIMIT ${String(limit)}`;
+  }
+  const beforeComment = trimmed.slice(0, commentIndex).replace(/[\s;]+$/, "");
+  const comment = trimmed.slice(commentIndex);
+  return `${beforeComment} LIMIT ${String(limit)} ${comment}`;
 }
 function inspectStatement(sql) {
   const kind = classifyStatement(sql);
@@ -664,12 +778,12 @@ function inspectStatement(sql) {
 }
 function evaluateGuard(sql, config) {
   const inspection = inspectStatement(sql);
-  if (config.readOnly && (inspection.kind === "dml" || inspection.kind === "ddl")) {
+  if (config.readOnly && inspection.kind !== "select") {
     return {
       allowed: false,
       destructive: inspection.destructive,
       violation: "read-only",
-      reason: `read-only mode blocks ${inspection.kind.toUpperCase()} statements`
+      reason: inspection.kind === "unknown" ? "read-only mode only permits SELECT/WITH statements" : `read-only mode blocks ${inspection.kind.toUpperCase()} statements`
     };
   }
   if (inspection.destructive && !config.allowDestructive) {
@@ -691,12 +805,11 @@ function applyAutoLimit(sql, limit) {
   if (limit === false || classifyStatement(sql) !== "select") {
     return { sql, applied: false };
   }
-  const stripped = stripStringLiterals(sql);
+  const stripped = maskIgnoredSqlText(sql);
   if (/\blimit\b/i.test(stripped) || /\btop\s+\d/i.test(stripped)) {
     return { sql, applied: false };
   }
-  const trimmed = sql.replace(/[\s;]+$/, "");
-  return { sql: `${trimmed} LIMIT ${String(limit)}`, applied: true };
+  return { sql: appendLimit(sql, limit), applied: true };
 }
 
 // src/connection.ts
@@ -745,6 +858,12 @@ var Connection = class _Connection {
   async execute(sql, params, options) {
     return await this.run(sql, params ?? [], options ?? {});
   }
+  assertAllowed(sql, options) {
+    this.evaluateSafety(sql, options ?? {});
+  }
+  async executeInternal(sql, params, options) {
+    return await this.run(sql, params ?? [], options ?? {}, { bypassSafety: true });
+  }
   async setAutoCommit(enabled) {
     await this.driverConnection.setAutoCommit(enabled);
   }
@@ -760,21 +879,10 @@ var Connection = class _Connection {
   get isClosed() {
     return this.driverConnection.isClosed();
   }
-  async run(sql, params, options) {
+  async run(sql, params, options, runOptions = {}) {
     assertParamArity(sql, params);
-    const decision = evaluateGuard(sql, {
-      readOnly: this.config.readOnly,
-      allowDestructive: options.allowDestructive ?? this.config.allowDestructive
-    });
-    if (!decision.allowed) {
-      if (decision.violation === "read-only") {
-        throw new ReadOnlyViolationError(
-          decision.reason ?? "read-only mode blocks this statement"
-        );
-      }
-      throw new DestructiveStatementError(
-        decision.reason ?? "destructive statement blocked"
-      );
+    if (runOptions.bypassSafety !== true) {
+      this.evaluateSafety(sql, options);
     }
     const kind = classifyStatement(sql);
     const autoLimit = options.autoLimit ?? this.config.autoLimit;
@@ -804,6 +912,23 @@ var Connection = class _Connection {
     } catch {
     }
   }
+  evaluateSafety(sql, options) {
+    const decision = evaluateGuard(sql, {
+      readOnly: this.config.readOnly,
+      allowDestructive: options.allowDestructive ?? this.config.allowDestructive
+    });
+    if (decision.allowed) {
+      return;
+    }
+    if (decision.violation === "read-only") {
+      throw new ReadOnlyViolationError(
+        decision.reason ?? "read-only mode blocks this statement"
+      );
+    }
+    throw new DestructiveStatementError(
+      decision.reason ?? "destructive statement blocked"
+    );
+  }
 };
 
 // src/pool.ts
@@ -944,6 +1069,7 @@ var ConnectionPool = class {
         (error) => {
           this.created -= 1;
           waiter.reject(error);
+          this.servePendingWaiters();
         }
       );
     }
@@ -990,6 +1116,11 @@ var Transaction = class {
 };
 
 // src/client.ts
+var explainStatementCounter = 0;
+function nextExplainStatementName() {
+  explainStatementCounter = (explainStatementCounter + 1) % Number.MAX_SAFE_INTEGER;
+  return `cf_hana_${String(process.pid)}_${String(Date.now())}_${String(explainStatementCounter)}`;
+}
 var HanaClient = class _HanaClient {
   constructor(pool, info) {
     this.pool = pool;
@@ -1108,21 +1239,35 @@ var HanaClient = class _HanaClient {
   /** Return the HANA execution plan for a statement. */
   async explain(sql, params) {
     return await this.pool.withConnection(async (connection) => {
-      const statementName = `cf_hana_${String(Date.now())}`;
-      await connection.execute(
+      connection.assertAllowed(sql);
+      const statementName = nextExplainStatementName();
+      await connection.executeInternal(
         `EXPLAIN PLAN SET STATEMENT_NAME = '${statementName}' FOR ${sql}`,
         params
       );
-      try {
-        return await connection.query(
-          "SELECT OPERATOR_NAME, TABLE_NAME, TABLE_TYPE, EXECUTION_ENGINE FROM EXPLAIN_PLAN_TABLE WHERE STATEMENT_NAME = ? ORDER BY OPERATOR_ID",
+      const cleanup = async () => {
+        await connection.executeInternal(
+          "DELETE FROM EXPLAIN_PLAN_TABLE WHERE STATEMENT_NAME = ?",
           [statementName]
         );
-      } finally {
-        await connection.execute(
-          "DELETE FROM EXPLAIN_PLAN_TABLE WHERE STATEMENT_NAME = ?",
+      };
+      let queryCompleted = false;
+      try {
+        const result = await connection.query(
+          "SELECT OPERATOR_NAME, TABLE_NAME, TABLE_TYPE, EXECUTION_ENGINE FROM EXPLAIN_PLAN_TABLE WHERE STATEMENT_NAME = ? ORDER BY OPERATOR_ID",
           [statementName]
         );
+        queryCompleted = true;
+        await cleanup();
+        return result;
+      } catch (error) {
+        if (!queryCompleted) {
+          try {
+            await cleanup();
+          } catch {
+          }
+        }
+        throw error;
       }
     });
   }