@teamkeel/functions-runtime 0.413.9 → 0.414.1

package/dist/index.cjs

@@ -2454,9 +2454,16 @@ var selectOne = /* @__PURE__ */ __name((name, options) => {
 }, "selectOne");
 
 // src/flows/ui/page.ts
-async function page(options, data) {
+async function page(options, data, action) {
   const content = options.content;
   let hasValidationErrors = false;
+  if (options.actions) {
+    const isValidAction = options.actions.some((a) => {
+      if (typeof a === "string") return a === action;
+      return a && typeof a === "object" && "value" in a && a.value === action;
+    });
+    hasValidationErrors = !isValidAction;
+  }
   const contentUiConfig = await Promise.all(
     content.map(async (c) => {
       const isInput = "__type" in c && c.__type == "input";
@@ -2481,7 +2488,14 @@ async function page(options, data) {
       title: options.title,
       description: options.description,
       content: contentUiConfig,
-      actions: options.actions
+      actions: options.actions?.map((a) => {
+        if (typeof a === "string") {
+          return { label: a, value: a, mode: "primary" };
+        } else if (typeof a === "object") {
+          a.mode = a.mode || "primary";
+        }
+        return a;
+      })
     },
     hasValidationErrors
   };
@@ -2607,15 +2621,33 @@ var header = /* @__PURE__ */ __name((options) => {
 
 // src/flows/index.ts
 var defaultOpts = {
-  maxRetries: 5,
-  timeoutInMs: 6e4
+  retries: 5,
+  timeout: 6e4
 };
-function createFlowContext(runId, data, spanId) {
+function createFlowContext(runId, data, action, spanId, ctx) {
+  const usedNames = /* @__PURE__ */ new Set();
   return {
+    env: ctx.env,
+    now: ctx.now,
+    secrets: ctx.secrets,
     step: /* @__PURE__ */ __name(async (name, optionsOrFn, fn) => {
       const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
       const actualFn = typeof optionsOrFn === "function" ? optionsOrFn : fn;
       const db = useDatabase();
+      if (usedNames.has(name)) {
+        await db.insertInto("keel.flow_step").values({
+          run_id: runId,
+          name,
+          stage: options.stage,
+          status: "FAILED" /* FAILED */,
+          type: "FUNCTION" /* FUNCTION */,
+          error: `Duplicate step name: ${name}`,
+          startTime: /* @__PURE__ */ new Date(),
+          endTime: /* @__PURE__ */ new Date()
+        }).returningAll().executeTakeFirst();
+        throw new Error(`Duplicate step name: ${name}`);
+      }
+      usedNames.add(name);
       const past = await db.selectFrom("keel.flow_step").where("run_id", "=", runId).where("name", "=", name).selectAll().execute();
       const newSteps = past.filter((step) => step.status === "NEW" /* NEW */);
       const completedSteps = past.filter(
@@ -2646,7 +2678,7 @@ function createFlowContext(runId, data, spanId) {
         try {
           result = await withTimeout(
             actualFn(),
-            options.timeoutInMs ?? defaultOpts.timeoutInMs
+            options.timeout ?? defaultOpts.timeout
           );
         } catch (e) {
           await db.updateTable("keel.flow_step").set({
@@ -2655,7 +2687,7 @@ function createFlowContext(runId, data, spanId) {
             endTime: /* @__PURE__ */ new Date(),
             error: e instanceof Error ? e.message : "An error occurred"
           }).where("id", "=", newSteps[0].id).returningAll().executeTakeFirst();
-          if (failedSteps.length + 1 >= (options.maxRetries ?? defaultOpts.maxRetries)) {
+          if (failedSteps.length + 1 >= (options.retries ?? defaultOpts.retries)) {
             throw new ExhuastedRetriesDisrupt();
           }
           await db.insertInto("keel.flow_step").values({
@@ -2687,8 +2719,25 @@ function createFlowContext(runId, data, spanId) {
     ui: {
       page: /* @__PURE__ */ __name(async (name, options) => {
         const db = useDatabase();
+        if (usedNames.has(name)) {
+          await db.insertInto("keel.flow_step").values({
+            run_id: runId,
+            name,
+            stage: options.stage,
+            status: "FAILED" /* FAILED */,
+            type: "UI" /* UI */,
+            error: `Duplicate step name: ${name}`,
+            startTime: /* @__PURE__ */ new Date(),
+            endTime: /* @__PURE__ */ new Date()
+          }).returningAll().executeTakeFirst();
+          throw new Error(`Duplicate step name: ${name}`);
+        }
+        usedNames.add(name);
         let step = await db.selectFrom("keel.flow_step").where("run_id", "=", runId).where("name", "=", name).selectAll().executeTakeFirst();
         if (step && step.status === "COMPLETED" /* COMPLETED */) {
+          if (step.action) {
+            return { data: step.value, action: step.action };
+          }
           return step.value;
         }
         if (!step) {
@@ -2700,22 +2749,29 @@ function createFlowContext(runId, data, spanId) {
             type: "UI" /* UI */,
             startTime: /* @__PURE__ */ new Date()
           }).returningAll().executeTakeFirst();
-          throw new UIRenderDisrupt(step?.id, (await page(options, null)).page);
+          throw new UIRenderDisrupt(
+            step?.id,
+            (await page(options, null, null)).page
+          );
         }
         if (!data) {
-          throw new UIRenderDisrupt(step?.id, (await page(options, null)).page);
+          throw new UIRenderDisrupt(
+            step?.id,
+            (await page(options, null, null)).page
+          );
         }
-        const p = await page(options, data);
+        const p = await page(options, data, action);
         if (p.hasValidationErrors) {
           throw new UIRenderDisrupt(step?.id, p.page);
         }
         await db.updateTable("keel.flow_step").set({
           status: "COMPLETED" /* COMPLETED */,
           value: JSON.stringify(data),
+          action,
           spanId,
           endTime: /* @__PURE__ */ new Date()
         }).where("id", "=", step.id).returningAll().executeTakeFirst();
-        return data;
+        return { data, action };
       }, "page"),
       inputs: {
         text: textInput,
@@ -2770,7 +2826,7 @@ async function handleFlow(request, config) {
         if (!runId) {
           throw new Error("no runId provided");
         }
-        const { flows } = config;
+        const { flows, createFlowContextAPI } = config;
         if (!(request.method in flows)) {
           const message = `no corresponding flow found for '${request.method}'`;
           span.setStatus({
@@ -2789,7 +2845,11 @@ async function handleFlow(request, config) {
         const ctx = createFlowContext(
           request.meta.runId,
           request.meta.data,
-          span.spanContext().spanId
+          request.meta.action,
+          span.spanContext().spanId,
+          createFlowContextAPI({
+            meta: request.meta
+          })
         );
         const flowFunction = flows[request.method].fn;
         const rawFlowConfig = flows[request.method].config;