@botpress/runtime 1.7.1 → 1.7.3

package/dist/definition.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.1", 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.3", adk: "1.7.2", sdk: "4.18.1", llmz: "0.0.27", zai: "2.5.0", cognitive: "0.2.0" };
   }
 });
 
@@ -44557,6 +44557,33 @@ init_define_PACKAGE_VERSIONS();
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
 import { z as z24 } from "@botpress/sdk";
+
+// 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",
   // skynet/packages/tables-api/src/services/computed/compute-stale-rows.ts
@@ -44581,26 +44608,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 = context2.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 };
   }
 });