@botpress/runtime 1.7.1 → 1.7.3

package/dist/runtime/actions/computed-columns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computed-columns.d.ts","sourceRoot":"","sources":["../../../src/runtime/actions/computed-columns.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAGpD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkD9B,CAAA"}
+{"version":3,"file":"computed-columns.d.ts","sourceRoot":"","sources":["../../../src/runtime/actions/computed-columns.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAKpD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+E9B,CAAA"}

package/dist/runtime/actions/order-recompute-columns.d.ts

@@ -0,0 +1,30 @@
+type ColumnDefinition = {
+    computed: boolean;
+    dependencies?: string[];
+    value: (row: Record<string, any>) => Promise<any>;
+};
+/**
+ * Orders columns for recomputation based on their dependencies using topological sort.
+ * Ensures that dependencies are computed before columns that depend on them.
+ *
+ * @param toRecompute - Array of column names that need to be recomputed
+ * @param staleColumns - Set of column names that are currently stale (need recomputation)
+ * @param columns - Record of all column definitions with their dependencies
+ * @returns Array of column names in the order they should be computed
+ *
+ * @example
+ * ```ts
+ * // Column C depends on B, B depends on A
+ * const columns = {
+ *   a: { computed: true, dependencies: [], value: async (row) => row.base * 2 },
+ *   b: { computed: true, dependencies: ['a'], value: async (row) => row.a + 10 },
+ *   c: { computed: true, dependencies: ['b'], value: async (row) => row.b * 3 }
+ * }
+ *
+ * const ordered = orderRecomputeColumns(['c'], new Set(['a', 'b', 'c']), columns)
+ * // Result: ['a', 'b', 'c'] - dependencies computed first
+ * ```
+ */
+export declare function orderRecomputeColumns(toRecompute: string[], staleColumns: Set<string>, columns: Record<string, ColumnDefinition>): string[];
+export {};
+//# sourceMappingURL=order-recompute-columns.d.ts.map

package/dist/runtime/actions/order-recompute-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-recompute-columns.d.ts","sourceRoot":"","sources":["../../../src/runtime/actions/order-recompute-columns.ts"],"names":[],"mappings":"AAAA,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;CAClD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,MAAM,EAAE,EACrB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GACxC,MAAM,EAAE,CA2BV"}

package/dist/runtime.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" };
   }
 });
 
@@ -44494,6 +44494,33 @@ init_define_PACKAGE_VERSIONS();
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
 import { z as z19 } 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
@@ -44518,26 +44545,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 };
   }
 });