@compforge/harness-toolbox 0.3.1 → 0.3.2

package/dist/{chunk-s06hs7a8.js → chunk-m91t44jh.js}

@@ -50,9 +50,20 @@ try:
     )
     try:
         with connection.cursor(pymysql.cursors.DictCursor) as cursor:
-            cursor.execute(request["sql"], request["values"])
-            rows = cursor.fetchall()
-        print(json.dumps({"rows": rows}, default=encode, ensure_ascii=False))
+            statements = request.get("statements")
+            if statements is None:
+                cursor.execute(request["sql"], request["values"])
+                rows = cursor.fetchall()
+                print(json.dumps({"rows": rows}, default=encode, ensure_ascii=False))
+            else:
+                # Batch: one process and one connection for independent statements;
+                # the per-statement deadline is re-armed before each execute.
+                results = []
+                for statement in statements:
+                    signal.alarm(math.ceil(request["queryTimeoutMs"] / 1000))
+                    cursor.execute(statement["sql"], statement["values"])
+                    results.append({"rows": cursor.fetchall()})
+                print(json.dumps({"results": results}, default=encode, ensure_ascii=False))
     finally:
         connection.close()
 except Exception as error:
@@ -62,6 +73,9 @@ except Exception as error:
 finally:
     signal.alarm(0)
 `;
+function parsePodResponse(raw) {
+  return JSON.parse(raw, (_key, value) => value?.type === "Buffer" && Array.isArray(value.data) ? Buffer.from(value.data) : value);
+}
 async function queryMysqlViaPod(transport, target, sql, values, options) {
   const raw = await transport.run(POD_QUERY, {
     target,
@@ -69,11 +83,28 @@ async function queryMysqlViaPod(transport, target, sql, values, options) {
     values,
     ...options
   }, options.queryTimeoutMs + 3000);
-  const response = JSON.parse(raw, (_key, value) => value?.type === "Buffer" && Array.isArray(value.data) ? Buffer.from(value.data) : value);
+  const response = parsePodResponse(raw);
   if (response.error || !Array.isArray(response.rows)) {
     throw new Error(`MySQL via Pod failed: ${response.error ?? "invalid response"}${response.code ? ` (${response.code})` : ""}`);
   }
   return response.rows;
 }
+async function queryMysqlViaPodBatch(transport, target, statements, options) {
+  const raw = await transport.run(POD_QUERY, {
+    target,
+    statements: statements.map(({ sql, values }) => ({ sql: preparePodSql(sql, values), values })),
+    ...options
+  }, options.connectTimeoutMs + options.queryTimeoutMs * statements.length + 3000);
+  const response = parsePodResponse(raw);
+  if (response.error || !Array.isArray(response.results)) {
+    throw new Error(`MySQL via Pod batch failed: ${response.error ?? "invalid response"}${response.code ? ` (${response.code})` : ""}`);
+  }
+  return response.results.map((result, index) => {
+    if (!Array.isArray(result.rows)) {
+      throw new Error(`MySQL via Pod batch statement ${index} returned no rows`);
+    }
+    return result.rows;
+  });
+}
 
-export { preparePodSql, queryMysqlViaPod };
+export { preparePodSql, queryMysqlViaPod, queryMysqlViaPodBatch };

package/dist/{chunk-jkpwa8tb.js → chunk-ssdxknsk.js}

@@ -3,8 +3,9 @@ import {
   validateQueryLimits
 } from "./chunk-kbewz29a.js";
 import {
-  queryMysqlViaPod
-} from "./chunk-s06hs7a8.js";
+  queryMysqlViaPod,
+  queryMysqlViaPodBatch
+} from "./chunk-m91t44jh.js";
 import {
   ConcurrencyPool
 } from "./chunk-v3hxvnrc.js";
@@ -28,6 +29,22 @@ class MysqlDatabase {
   query(target, sql, values) {
     return this.#queries.run(() => this.#query(target, sql, values), this.options.signal);
   }
+  queryBatch(target, statements) {
+    return this.#queries.run(async () => {
+      if (!statements.length)
+        return [];
+      return this.#withSession(target, async (session) => {
+        if (session.kind === "python")
+          return queryMysqlViaPodBatch(session.transport, target, statements, this.options);
+        const results = [];
+        for (const { sql, values } of statements) {
+          const [rows] = await session.connection.execute({ sql, values: [...values], timeout: this.options.queryTimeoutMs });
+          results.push(rows);
+        }
+        return results;
+      });
+    }, this.options.signal);
+  }
   queryReadonly(target, sql, values, limits) {
     validateQueryLimits(limits);
     return this.#queries.run(async () => {
@@ -60,7 +77,7 @@ class MysqlDatabase {
     }
     return pending;
   }
-  async#query(target, sql, values) {
+  async#withSession(target, run) {
     this.options.signal?.throwIfAborted();
     const key = [target.host, target.port, target.database, target.user, target.password].join("\x00");
     const pending = this.#session(target);
@@ -68,10 +85,7 @@ class MysqlDatabase {
     try {
       session = await pending;
       this.options.signal?.throwIfAborted();
-      if (session.kind === "python")
-        return await queryMysqlViaPod(session.transport, target, sql, values, this.options);
-      const [rows] = await session.connection.execute({ sql, values: [...values], timeout: this.options.queryTimeoutMs });
-      return rows;
+      return await run(session);
     } catch (error) {
       if (this.#connections.get(key) === pending)
         this.#connections.delete(key);
@@ -80,6 +94,14 @@ class MysqlDatabase {
       throw error;
     }
   }
+  async#query(target, sql, values) {
+    return this.#withSession(target, async (session) => {
+      if (session.kind === "python")
+        return queryMysqlViaPod(session.transport, target, sql, values, this.options);
+      const [rows] = await session.connection.execute({ sql, values: [...values], timeout: this.options.queryTimeoutMs });
+      return rows;
+    });
+  }
   async#open(target) {
     let reason;
     for (let i = 0;i < this.transports.length; i++) {

package/dist/mysql/client.d.ts

@@ -1,6 +1,6 @@
 import type { Client } from "../client";
 import { type Connection, type ConnectionOptions } from "mysql2/promise";
-import type { Database, DatabaseTarget, DatabaseRow, DatabaseQueryLimits, DatabaseQueryResult } from "./types";
+import type { Database, DatabaseTarget, DatabaseRow, DatabaseQueryLimits, DatabaseQueryResult, SqlStatement } from "./types";
 import type { ConnectionSource, ClientLifecycle } from "../datasource";
 import { type Transport } from "../transport";
 export interface MysqlDatabaseOptions extends ClientLifecycle {
@@ -16,6 +16,12 @@ export declare class MysqlDatabase implements Database {
     private readonly connect;
     constructor(transports: readonly Transport[], options: MysqlDatabaseOptions, connect?: ConnectionFactory);
     query(target: DatabaseTarget, sql: string, values: readonly unknown[]): Promise<DatabaseRow[]>;
+    /**
+     * Independent statements in submission order, one session: a Pod transport pays the exec
+     * and connection cost once instead of per statement. Fail-fast like query(); use query()
+     * when a statement depends on an earlier result.
+     */
+    queryBatch(target: DatabaseTarget, statements: readonly SqlStatement[]): Promise<DatabaseRow[][]>;
     /** Bounded, single-statement prepared execution on an isolated READ ONLY session (native only). */
     queryReadonly(target: DatabaseTarget, sql: string, values: readonly unknown[], limits: DatabaseQueryLimits): Promise<DatabaseQueryResult>;
     initialize(target: DatabaseTarget): Promise<void>;

package/dist/mysql/client.js

@@ -2,9 +2,9 @@ import {
   MysqlClient,
   MysqlDatabase,
   openMysql
-} from "../chunk-jkpwa8tb.js";
+} from "../chunk-ssdxknsk.js";
 import"../chunk-kbewz29a.js";
-import"../chunk-s06hs7a8.js";
+import"../chunk-m91t44jh.js";
 import"../chunk-v3hxvnrc.js";
 import"../chunk-xy4g56g4.js";
 export {

package/dist/mysql/index.js

@@ -6,9 +6,9 @@ import {
   MysqlClient,
   MysqlDatabase,
   openMysql
-} from "../chunk-jkpwa8tb.js";
+} from "../chunk-ssdxknsk.js";
 import"../chunk-kbewz29a.js";
-import"../chunk-s06hs7a8.js";
+import"../chunk-m91t44jh.js";
 import"../chunk-v3hxvnrc.js";
 import"../chunk-xy4g56g4.js";
 export {

package/dist/mysql/pod.d.ts

@@ -1,7 +1,16 @@
-import type { DatabaseRow, DatabaseTarget } from "./types";
+import type { DatabaseRow, DatabaseTarget, SqlStatement } from "./types";
 import type { PodPythonTransport } from "../transport";
 export declare function preparePodSql(sql: string, values: readonly unknown[]): string;
 export declare function queryMysqlViaPod(transport: PodPythonTransport, target: DatabaseTarget, sql: string, values: readonly unknown[], options: {
     connectTimeoutMs: number;
     queryTimeoutMs: number;
 }): Promise<DatabaseRow[]>;
+/**
+ * Independent statements over one Pod process and one MySQL connection: the per-exec cost
+ * (kubectl handshake, interpreter start, auth) is paid once. Fail-fast: a statement error
+ * aborts the batch, later statements never execute, and the whole batch throws.
+ */
+export declare function queryMysqlViaPodBatch(transport: PodPythonTransport, target: DatabaseTarget, statements: readonly SqlStatement[], options: {
+    connectTimeoutMs: number;
+    queryTimeoutMs: number;
+}): Promise<DatabaseRow[][]>;

package/dist/mysql/pod.js

@@ -1,8 +1,10 @@
 import {
   preparePodSql,
-  queryMysqlViaPod
-} from "../chunk-s06hs7a8.js";
+  queryMysqlViaPod,
+  queryMysqlViaPodBatch
+} from "../chunk-m91t44jh.js";
 export {
+  queryMysqlViaPodBatch,
   queryMysqlViaPod,
   preparePodSql
 };

package/dist/mysql/types.d.ts

@@ -8,6 +8,10 @@ export interface DatabaseTarget extends DatabaseIdentity {
     database: string;
 }
 export type DatabaseRow = Record<string, unknown>;
+export interface SqlStatement {
+    sql: string;
+    values: readonly unknown[];
+}
 export interface DatabaseQueryLimits {
     timeoutMs: number;
     maxRows: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compforge/harness-toolbox",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Shared infrastructure clients, transports and bounded data capture",
   "type": "module",
   "scripts": {