@bounded-sh/core 0.0.39 → 0.0.41

package/dist/index.mjs

@@ -5012,10 +5012,28 @@ async function getMany(paths, opts = {}) {
     return results;
 }
 async function runQuery(absolutePath, queryName, queryArgs, opts) {
-    const result = await runQueryMany([{ absolutePath, queryName, queryArgs }], opts);
-    return result[0];
+    var _a;
+    const rows = await runQueryManyRows([{ absolutePath, queryName, queryArgs }], opts);
+    const row = rows[0];
+    // The worker disambiguates a computed null from a failed/undeclared query
+    // with a per-row `error` string — surface it instead of returning undefined.
+    if ((row === null || row === void 0 ? void 0 : row.error) != null) {
+        const err = new Error(String(row.error));
+        err.isQueryError = true;
+        err.queryName = queryName;
+        err.path = absolutePath;
+        throw err;
+    }
+    return (_a = row === null || row === void 0 ? void 0 : row.result) !== null && _a !== void 0 ? _a : null;
 }
 async function runQueryMany(many, opts) {
+    // Batch shape stays an array of result values (errored rows map to null) so
+    // existing callers keep working; use runQuery for per-row error surfacing.
+    const rows = await runQueryManyRows(many, opts);
+    return rows.map((row) => { var _a; return (_a = row === null || row === void 0 ? void 0 : row.result) !== null && _a !== void 0 ? _a : null; });
+}
+async function runQueryManyRows(many, opts) {
+    var _a, _b, _c, _d;
     try {
         let queries = [];
         for (const { absolutePath, queryName, queryArgs } of many) {
@@ -5027,7 +5045,16 @@ async function runQueryMany(many, opts) {
             queries.push({ path: normalizedPath, queryName, queryArgs });
         }
         const response = await makeApiRequest('POST', 'queries', { queries }, opts === null || opts === void 0 ? void 0 : opts._overrides);
-        return response.data.queries.map((result) => result.result);
+        // makeApiRequest returns `{ data: <httpBody> }`, and the worker's httpBody
+        // is `{ data: { queries: [...] }, status }` — so the rows are double-nested
+        // at response.data.data.queries. (Reading response.data.queries here is
+        // undefined → "Cannot read properties of undefined".) Tolerate both shapes,
+        // same as getMany does for items/batch.
+        const rows = (_c = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.queries) !== null && _c !== void 0 ? _c : (_d = response.data) === null || _d === void 0 ? void 0 : _d.queries;
+        if (!Array.isArray(rows)) {
+            throw new Error(`queries endpoint returned an unexpected response shape (status ${response.status})`);
+        }
+        return rows;
     }
     catch (error) {
         throw error;
@@ -5039,6 +5066,7 @@ async function runExpression(expression, queryArgs, options) {
     return results[0];
 }
 async function runExpressionMany(many) {
+    var _a, _b, _c, _d;
     try {
         let queries = [];
         let overrides = undefined;
@@ -5050,13 +5078,25 @@ async function runExpressionMany(many) {
             queries.push({ queryArgs, expression, returnType });
         }
         const response = await makeApiRequest('POST', 'queries', { queries }, overrides);
+        // Same double-nesting as runQueryMany: the worker's httpBody is
+        // { data: { queries: [...] }, status } under makeApiRequest's own
+        // { data: <httpBody> } wrapper. Tolerate both shapes.
+        const rows = (_c = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.queries) !== null && _c !== void 0 ? _c : (_d = response.data) === null || _d === void 0 ? void 0 : _d.queries;
+        if (!Array.isArray(rows)) {
+            throw new Error(`queries endpoint returned an unexpected response shape (status ${response.status})`);
+        }
         // Map results - trace is automatically included by server for non-mainnet networks
-        return response.data.queries.map((queryResult) => {
+        return rows.map((queryResult) => {
             const result = { result: queryResult.result };
             // Include trace if present (server includes it for non-mainnet networks)
             if (queryResult.trace) {
                 result.trace = queryResult.trace;
             }
+            // Pass through the server's per-row failure so callers can distinguish
+            // a computed null from a failed row.
+            if (queryResult.error != null) {
+                result.error = String(queryResult.error);
+            }
             return result;
         });
     }