@botpress/runtime 1.7.2 → 1.7.4

package/dist/internal.js

@@ -48,7 +48,7 @@ var init_define_BUILD = __esm({
 var define_PACKAGE_VERSIONS_default;
 var init_define_PACKAGE_VERSIONS = __esm({
   "<define:__PACKAGE_VERSIONS__>"() {
-    define_PACKAGE_VERSIONS_default = { runtime: "1.7.2", adk: "1.7.0", sdk: "4.18.1", llmz: "0.0.27", zai: "2.5.0", cognitive: "0.2.0" };
+    define_PACKAGE_VERSIONS_default = { runtime: "1.7.4", adk: "1.7.2", sdk: "4.18.1", llmz: "0.0.27", zai: "2.5.0", cognitive: "0.2.0" };
   }
 });
 
@@ -34481,6 +34481,8 @@ ${issues.join("\n")}`;
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
 import { z as z17 } from "@botpress/sdk";
+import { Cognitive as Cognitive2 } from "@botpress/cognitive";
+import { Zai as Zai2 } from "@botpress/zai";
 
 // src/runtime/index.ts
 init_define_BUILD();
@@ -41381,6 +41383,31 @@ var BaseAction = class {
   }
 };
 
+// src/runtime/actions/order-recompute-columns.ts
+init_define_BUILD();
+init_define_PACKAGE_VERSIONS();
+function orderRecomputeColumns(toRecompute, staleColumns, columns) {
+  const ordered = [];
+  const visited = /* @__PURE__ */ new Set();
+  function visit(colName) {
+    if (visited.has(colName)) return;
+    visited.add(colName);
+    const deps = columns[colName]?.dependencies || [];
+    for (const dep of deps) {
+      if (staleColumns.has(dep)) {
+        visit(dep);
+      }
+    }
+    if (staleColumns.has(colName) || toRecompute.includes(colName)) {
+      ordered.push(colName);
+    }
+  }
+  for (const col of toRecompute) {
+    visit(col);
+  }
+  return ordered;
+}
+
 // src/runtime/actions/computed-columns.ts
 var tablesRecomputeRows = new BaseAction({
   name: "tablesRecomputeRows",
@@ -41406,26 +41433,48 @@ var tablesRecomputeRows = new BaseAction({
     const table = adk.project.tables.find((x) => x.name === remoteTable.name);
     async function computeRow(row, columnsToRecompute) {
       const newRow = { id: row.id };
-      for (const colName of columnsToRecompute) {
+      const recompute = orderRecomputeColumns(
+        columnsToRecompute,
+        new Set(row.stale ?? []),
+        table?.columns || {}
+      );
+      for (const colName of recompute) {
         const col = table?.columns[colName];
         if (!col || !col.computed) {
           newRow[colName] = { status: "error", error: "Column not found or not computed" };
           continue;
         }
+        const value = await col.value(row);
+        row[colName] = value;
         newRow[colName] = {
           status: "computed",
-          value: await col.value(row)
+          value
         };
       }
       return newRow;
     }
-    const computedRows = await Promise.all(
+    const MIN_REMAINING_TIME_MS = 5e3;
+    const BUFFER_TIME_MS = 5e3;
+    let recomputed = [];
+    let isFinished = true;
+    const remainingTime = context.get("runtime").getRemainingExecutionTimeInMs();
+    if (remainingTime && remainingTime < MIN_REMAINING_TIME_MS) {
+      return { isFinished: false, rows: [] };
+    }
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        isFinished = false;
+        resolve();
+      }, remainingTime - BUFFER_TIME_MS);
+    });
+    const allRowsPromise = Promise.all(
       requests.map(async (r) => {
         const computedRow = await computeRow(r.row, r.columnsToRecompute);
-        return computedRow;
+        recomputed.push(computedRow);
       })
     );
-    return { isFinished: true, rows: computedRows };
+    await Promise.race([timeoutPromise, allRowsPromise]);
+    return { isFinished, rows: recomputed };
   }
 });