@teamkeel/functions-runtime 0.414.4 → 0.414.5

package/dist/index.cjs

@@ -2421,20 +2421,30 @@ var markdown = /* @__PURE__ */ __name((options) => {
 
 // src/flows/ui/elements/display/table.ts
 var table = /* @__PURE__ */ __name((options) => {
-  const filteredData = options.columns ? options.data.map((item) => {
-    return Object.fromEntries(
-      Object.entries(item).filter(
-        ([key]) => options.columns?.includes(key)
-      )
-    );
-  }) : options.data;
+  const { data, columns } = processTableData(options.data, options.columns);
   return {
     uiConfig: {
       __type: "ui.display.table",
-      data: filteredData || []
+      data: data || [],
+      columns: columns || []
     }
   };
 }, "table");
+var processTableData = /* @__PURE__ */ __name((data, columnsConfig) => {
+  const filteredData = columnsConfig ? data.map((item) => {
+    return Object.fromEntries(
+      Object.entries(item).filter(
+        ([key]) => columnsConfig?.includes(key)
+      )
+    );
+  }) : data;
+  const cols = Object.keys(filteredData[0] || {});
+  const columns = cols.map((column, index) => ({
+    name: column,
+    index
+  }));
+  return { data: filteredData, columns };
+}, "processTableData");
 
 // src/flows/ui/elements/select/one.ts
 var selectOne = /* @__PURE__ */ __name((name, options) => {
@@ -2459,24 +2469,28 @@ var selectOne = /* @__PURE__ */ __name((name, options) => {
 async function page(options, data, action) {
   const content = options.content;
   let hasValidationErrors = false;
-  if (options.actions) {
+  let validationError;
+  if (options.actions && action !== null) {
     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;
+    if (!isValidAction) {
+      hasValidationErrors = true;
+      validationError = "invalid action";
+    }
   }
   const contentUiConfig = await Promise.all(
     content.map(async (c) => {
       const isInput = "__type" in c && c.__type == "input";
       const hasData = data && c.uiConfig.name in data;
       if (isInput && hasData && c.validate) {
-        const validationError = await c.validate(data[c.uiConfig.name]);
-        if (typeof validationError === "string") {
+        const validationError2 = await c.validate(data[c.uiConfig.name]);
+        if (typeof validationError2 === "string") {
           hasValidationErrors = true;
           return {
             ...c.uiConfig,
-            validationError
+            validationError: validationError2
           };
         }
       }
@@ -2497,7 +2511,9 @@ async function page(options, data, action) {
           a.mode = a.mode || "primary";
         }
         return a;
-      })
+      }),
+      hasValidationErrors,
+      validationError
     },
     hasValidationErrors
   };
@@ -2632,6 +2648,79 @@ var keyValue = /* @__PURE__ */ __name((options) => {
   };
 }, "keyValue");
 
+// src/flows/ui/elements/select/table.ts
+var selectTable = /* @__PURE__ */ __name((name, options) => {
+  const { data, columns } = processTableData(options.data, options.columns);
+  return {
+    __type: "input",
+    uiConfig: {
+      __type: "ui.select.table",
+      name,
+      data,
+      columns,
+      mode: options?.mode || "multi",
+      optional: options?.optional || false,
+      disabled: options?.disabled || false,
+      helpText: options?.helpText
+    },
+    validate: options?.validate,
+    getData: /* @__PURE__ */ __name((x) => x, "getData")
+  };
+}, "selectTable");
+
+// src/flows/ui/elements/input/dataGrid.ts
+var import_change_case2 = require("change-case");
+var dataGridInput = /* @__PURE__ */ __name((name, options) => {
+  const { data } = processTableData(
+    options.data,
+    options.columns?.map((c) => c.key)
+  );
+  const inferType = /* @__PURE__ */ __name((key) => {
+    const inferredTypeRaw = typeof data[0][key];
+    const inferredTypeMap = {
+      string: "text",
+      number: "number",
+      boolean: "boolean",
+      bigint: "number",
+      symbol: "text",
+      undefined: "text",
+      object: "text",
+      function: "text"
+    };
+    return inferredTypeMap[inferredTypeRaw] ?? "text";
+  }, "inferType");
+  const columns = options.columns ? options.columns?.map((column, idx) => ({
+    key: column.key,
+    label: column.label || column.key,
+    index: idx,
+    type: column.type || inferType(column.key),
+    editable: column.editable === void 0 ? column.type === "id" ? false : true : column.editable
+  })) : Object.keys(data[0]).map((key, idx) => {
+    return {
+      index: idx,
+      key,
+      label: (0, import_change_case2.sentenceCase)(key),
+      type: inferType(key),
+      editable: true
+    };
+  });
+  return {
+    __type: "input",
+    uiConfig: {
+      __type: "ui.input.dataGrid",
+      name,
+      data,
+      columns,
+      helpText: options?.helpText,
+      allowAddRows: options?.allowAddRows ?? false,
+      allowDeleteRows: options?.allowDeleteRows ?? false
+    },
+    validate: options?.validate,
+    // TODO have some built in validation that checks the types of the response
+    getData: /* @__PURE__ */ __name((x) => x, "getData")
+  };
+}, "dataGridInput");
+
 // src/flows/index.ts
 var STEP_STATUS = /* @__PURE__ */ ((STEP_STATUS2) => {
   STEP_STATUS2["NEW"] = "NEW";
@@ -2659,7 +2748,12 @@ function createFlowContext(runId, data, action, spanId, ctx) {
     env: ctx.env,
     now: ctx.now,
     secrets: ctx.secrets,
-    complete: /* @__PURE__ */ __name((options) => options, "complete"),
+    complete: /* @__PURE__ */ __name((options) => {
+      return {
+        __type: "ui.complete",
+        ...options
+      };
+    }, "complete"),
     step: /* @__PURE__ */ __name(async (name, optionsOrFn, fn) => {
       const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
       const actualFn = typeof optionsOrFn === "function" ? optionsOrFn : fn;
@@ -2806,7 +2900,8 @@ function createFlowContext(runId, data, action, spanId, ctx) {
       inputs: {
         text: textInput,
         number: numberInput,
-        boolean: booleanInput
+        boolean: booleanInput,
+        dataGrid: dataGridInput
       },
       display: {
         divider,
@@ -2821,7 +2916,8 @@ function createFlowContext(runId, data, action, spanId, ctx) {
         keyValue
       },
       select: {
-        one: selectOne
+        one: selectOne,
+        table: selectTable
       }
     }
   };
@@ -2843,26 +2939,25 @@ __name(withTimeout, "withTimeout");
 
 // src/flows/ui/complete.ts
 async function complete(options) {
-  const content = options.content;
+  const content = options.content || [];
   const contentUiConfig = await Promise.all(
     content.map(async (c) => {
       return c.uiConfig;
     })
   );
   return {
-    complete: {
-      __type: "ui.complete",
-      stage: options.stage,
-      title: options.title,
-      description: options.description,
-      content: contentUiConfig
-    }
+    __type: "ui.complete",
+    stage: options.stage,
+    title: options.title,
+    description: options.description,
+    content: contentUiConfig || [],
+    autoClose: options.autoClose
   };
 }
 __name(complete, "complete");
 
 // src/handleFlow.ts
-var import_change_case2 = require("change-case");
+var import_change_case3 = require("change-case");
 async function handleFlow(request, config) {
   const activeContext = opentelemetry6.propagation.extract(
     opentelemetry6.context.active(),
@@ -2906,7 +3001,7 @@ async function handleFlow(request, config) {
         const rawFlowConfig = flows[request.method].config;
         flowConfig = {
           ...rawFlowConfig,
-          title: rawFlowConfig.title || (0, import_change_case2.sentenceCase)(request.method || "flow"),
+          title: rawFlowConfig.title || (0, import_change_case3.sentenceCase)(request.method || "flow"),
           stages: rawFlowConfig.stages?.map((stage) => {
             if (typeof stage === "string") {
               return {
@@ -2961,7 +3056,8 @@ async function handleFlow(request, config) {
         }
         let ui = null;
         let data = null;
-        if (response && typeof response == "object" && "content" in response) {
+        if (response && typeof response == "object" && "__type" in response && response.__type === "ui.complete") {
+          ui = await complete(response);
           const completeStep = await db.selectFrom("keel.flow_step").where("run_id", "=", runId).where("type", "=", "COMPLETE" /* COMPLETE */).selectAll().executeTakeFirst();
           if (!completeStep) {
             await db.insertInto("keel.flow_step").values({
@@ -2971,10 +3067,10 @@ async function handleFlow(request, config) {
               status: "COMPLETED" /* COMPLETED */,
               type: "COMPLETE" /* COMPLETE */,
               startTime: /* @__PURE__ */ new Date(),
-              endTime: /* @__PURE__ */ new Date()
+              endTime: /* @__PURE__ */ new Date(),
+              ui: JSON.stringify(ui)
             }).returningAll().executeTakeFirst();
           }
-          ui = (await complete(response)).complete;
           data = response.data;
         } else if (response) {
           data = response;
@@ -2983,8 +3079,7 @@ async function handleFlow(request, config) {
           runId,
           runCompleted: true,
           data,
-          config: flowConfig,
-          ui
+          config: flowConfig
         });
       } catch (e) {
         if (e instanceof Error) {