@saptools/cf-hana 0.1.1 → 0.1.3

package/dist/index.js

@@ -243,6 +243,7 @@ async function listColumns(connection, schema, table) {
 }
 
 // src/config.ts
+var CLI_VERSION = "0.1.3";
 var ENV_PREFIX = "CF_HANA";
 var DEFAULT_QUERY_TIMEOUT_MS = 3e4;
 var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
@@ -493,7 +494,7 @@ var HdbConnection = class {
       const raw = await this.executeStatement(statement, params);
       return toExecResult(statement, raw);
     } finally {
-      statement.drop();
+      dropStatementQuietly(statement);
     }
   }
   setAutoCommit(enabled) {
@@ -560,6 +561,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 +602,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 +637,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() {
@@ -639,14 +665,178 @@ function createDriver(name) {
   }
 }
 
+// src/history.ts
+import { appendFile, mkdir, readdir, rm } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var SAPTOOLS_DIR_NAME = ".saptools";
+var CF_HANA_DIR_NAME = "cf-hana";
+var HISTORIES_DIR_NAME = "histories";
+var HISTORY_RETENTION_DAYS = 5;
+var HISTORY_FILE_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+function defaultSaptoolsRoot() {
+  return join(homedir(), SAPTOOLS_DIR_NAME);
+}
+function padDatePart(value) {
+  return value.toString().padStart(2, "0");
+}
+function dateKey(date) {
+  return [
+    date.getFullYear().toString(),
+    padDatePart(date.getMonth() + 1),
+    padDatePart(date.getDate())
+  ].join("-");
+}
+function retentionCutoffKey(now) {
+  const cutoff = new Date(now);
+  cutoff.setHours(0, 0, 0, 0);
+  cutoff.setDate(cutoff.getDate() - HISTORY_RETENTION_DAYS);
+  return dateKey(cutoff);
+}
+function resolveSaptoolsRoot(root) {
+  return root ?? defaultSaptoolsRoot();
+}
+function cfHanaHistoryDirectory(saptoolsRoot) {
+  return join(resolveSaptoolsRoot(saptoolsRoot), CF_HANA_DIR_NAME, HISTORIES_DIR_NAME);
+}
+function sqlHistoryFilePath(now = /* @__PURE__ */ new Date(), saptoolsRoot) {
+  return join(cfHanaHistoryDirectory(saptoolsRoot), `${dateKey(now)}.jsonl`);
+}
+async function pruneSqlHistory(now, saptoolsRoot) {
+  const historyDir = cfHanaHistoryDirectory(saptoolsRoot);
+  let files;
+  try {
+    files = await readdir(historyDir);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  const cutoffKey = retentionCutoffKey(now);
+  await Promise.all(
+    files.filter((file) => HISTORY_FILE_PATTERN.test(file)).filter((file) => file.slice(0, 10) < cutoffKey).map(async (file) => {
+      await rm(join(historyDir, file), { force: true });
+    })
+  );
+}
+async function appendSqlHistory(input, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const historyDir = cfHanaHistoryDirectory(options.saptoolsRoot);
+  const entry = {
+    at: now.toISOString(),
+    ...input
+  };
+  await mkdir(historyDir, { recursive: true, mode: 448 });
+  await appendFile(sqlHistoryFilePath(now, options.saptoolsRoot), `${JSON.stringify(entry)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  try {
+    await pruneSqlHistory(now, options.saptoolsRoot);
+  } catch {
+  }
+  return entry;
+}
+
 // 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 +854,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 +881,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 +934,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 +955,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 +988,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 +1145,7 @@ var ConnectionPool = class {
         (error) => {
           this.created -= 1;
           waiter.reject(error);
+          this.servePendingWaiters();
         }
       );
     }
@@ -990,6 +1192,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;
@@ -1031,41 +1238,43 @@ var HanaClient = class _HanaClient {
   }
   /** Run a SELECT (or any read) statement and return typed rows. */
   async query(sql, params, options) {
-    return await this.pool.withConnection(
-      (connection) => connection.query(sql, params, options)
-    );
+    const resolvedParams = params ?? [];
+    const result = await this.runQuery(sql, resolvedParams, options);
+    await this.recordSqlHistory("query", sql, resolvedParams, result);
+    return result;
   }
   /** Run a DML/DDL statement and return its affected-row count. */
   async execute(sql, params, options) {
-    return await this.pool.withConnection(
-      (connection) => connection.execute(sql, params, options)
-    );
+    const resolvedParams = params ?? [];
+    const result = await this.runExecute(sql, resolvedParams, options);
+    await this.recordSqlHistory("execute", sql, resolvedParams, result);
+    return result;
   }
   /** Run a typed `SELECT` built from a spec. */
   async selectFrom(spec) {
     const built = buildSelect(spec);
-    return await this.query(built.sql, built.params);
+    return await this.runQuery(built.sql, built.params);
   }
   /** Count rows in a table, optionally filtered. */
   async count(spec) {
     const built = buildCount(spec);
-    const result = await this.query(built.sql, built.params);
+    const result = await this.runQuery(built.sql, built.params);
     return result.rows[0]?.COUNT ?? 0;
   }
   /** Insert a single row. */
   async insertInto(schema, table, values) {
     const built = buildInsert(schema, table, values);
-    return await this.execute(built.sql, built.params);
+    return await this.runExecute(built.sql, built.params);
   }
   /** Update rows matching a non-empty `where` filter. */
   async update(schema, table, values, where) {
     const built = buildUpdate(schema, table, values, where);
-    return await this.execute(built.sql, built.params);
+    return await this.runExecute(built.sql, built.params);
   }
   /** Delete rows matching a non-empty `where` filter. */
   async deleteFrom(schema, table, where) {
     const built = buildDelete(schema, table, where);
-    return await this.execute(built.sql, built.params);
+    return await this.runExecute(built.sql, built.params);
   }
   /** Run `work` inside a transaction, auto-committing on success. */
   async transaction(work) {
@@ -1108,21 +1317,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;
       }
     });
   }
@@ -1130,6 +1353,35 @@ var HanaClient = class _HanaClient {
   async close() {
     await this.pool.drain();
   }
+  async runQuery(sql, params, options) {
+    return await this.pool.withConnection(
+      (connection) => connection.query(sql, params, options)
+    );
+  }
+  async runExecute(sql, params, options) {
+    return await this.pool.withConnection(
+      (connection) => connection.execute(sql, params, options)
+    );
+  }
+  async recordSqlHistory(operation, sql, params, result) {
+    try {
+      await appendSqlHistory({
+        version: CLI_VERSION,
+        operation,
+        selector: this.info.selector,
+        appName: this.info.appName,
+        schema: this.info.schema,
+        role: this.info.role,
+        statement: result.statement,
+        sql,
+        paramCount: params.length,
+        rowCount: result.rowCount,
+        truncated: result.truncated,
+        elapsedMs: result.elapsedMs
+      });
+    } catch {
+    }
+  }
 };
 
 // src/api.ts