@teamkeel/functions-runtime 0.414.4 → 0.414.6

package/dist/index.cjs

@@ -37,6 +37,7 @@ __export(index_exports, {
   InlineFile: () => InlineFile,
   KSUID: () => import_ksuid2.default,
   ModelAPI: () => ModelAPI,
+  NonRetriableError: () => NonRetriableError,
   PERMISSION_STATE: () => PERMISSION_STATE,
   Permissions: () => Permissions,
   RequestHeaders: () => RequestHeaders,
@@ -1977,8 +1978,8 @@ async function handleRequest(request, config) {
       let db = null;
       try {
         const { createContextAPI, functions, permissionFns, actionTypes } = config;
-        if (!(request.method in functions)) {
-          const message = `no corresponding function found for '${request.method}'`;
+        if (!functions[request.method]) {
+          const message = `function '${request.method}' does not exist or has not been implemented`;
           span.setStatus({
             code: opentelemetry2.SpanStatusCode.ERROR,
             message
@@ -2098,8 +2099,8 @@ async function handleJob(request, config) {
       let db = null;
       try {
         const { createJobContextAPI, jobs } = config;
-        if (!(request.method in jobs)) {
-          const message = `no corresponding job found for '${request.method}'`;
+        if (!jobs[request.method]) {
+          const message = `job '${request.method}' does not exist or has not been implemented`;
           span.setStatus({
             code: opentelemetry3.SpanStatusCode.ERROR,
             message
@@ -2186,8 +2187,8 @@ async function handleSubscriber(request, config) {
       let db = null;
       try {
         const { createSubscriberContextAPI, subscribers } = config;
-        if (!(request.method in subscribers)) {
-          const message = `no corresponding subscriber found for '${request.method}'`;
+        if (!subscribers[request.method]) {
+          const message = `subscriber '${request.method}' does not exist or has not been implemented`;
           span.setStatus({
             code: opentelemetry4.SpanStatusCode.ERROR,
             message
@@ -2257,8 +2258,8 @@ async function handleRoute(request, config) {
       let db = null;
       try {
         const { createContextAPI, functions } = config;
-        if (!(request.method in functions)) {
-          const message = `no route function found for '${request.method}'`;
+        if (!functions[request.method]) {
+          const message = `route function '${request.method}' does not exist or has not been implemented`;
           span.setStatus({
             code: opentelemetry5.SpanStatusCode.ERROR,
             message
@@ -2421,20 +2422,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,30 +2470,41 @@ 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
           };
         }
       }
       return c.uiConfig;
     }).filter(Boolean)
   );
+  if (data && options.validate) {
+    const validationResult = await options.validate(data);
+    if (typeof validationResult === "string") {
+      hasValidationErrors = true;
+      validationError = validationResult;
+    }
+  }
   return {
     page: {
       __type: "ui.page",
@@ -2497,7 +2519,9 @@ async function page(options, data, action) {
           a.mode = a.mode || "primary";
         }
         return a;
-      })
+      }),
+      hasValidationErrors,
+      validationError
     },
     hasValidationErrors
   };
@@ -2632,6 +2656,89 @@ 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/errors.ts
+var NonRetriableError = class extends Error {
+  static {
+    __name(this, "NonRetriableError");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+
 // src/flows/index.ts
 var STEP_STATUS = /* @__PURE__ */ ((STEP_STATUS2) => {
   STEP_STATUS2["NEW"] = "NEW";
@@ -2649,7 +2756,7 @@ var STEP_TYPE = /* @__PURE__ */ ((STEP_TYPE2) => {
   return STEP_TYPE2;
 })(STEP_TYPE || {});
 var defaultOpts = {
-  retries: 5,
+  retries: 4,
   timeout: 6e4
 };
 function createFlowContext(runId, data, action, spanId, ctx) {
@@ -2659,10 +2766,17 @@ 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;
+      options.retries = options.retries ?? defaultOpts.retries;
+      options.timeout = options.timeout ?? defaultOpts.timeout;
       const db = useDatabase();
       if (usedNames.has(name)) {
         await db.insertInto("keel.flow_step").values({
@@ -2706,10 +2820,11 @@ function createFlowContext(runId, data, action, spanId, ctx) {
           startTime: /* @__PURE__ */ new Date()
         }).where("id", "=", newSteps[0].id).returningAll().executeTakeFirst();
         try {
-          result = await withTimeout(
-            actualFn(),
-            options.timeout ?? defaultOpts.timeout
-          );
+          const stepArgs = {
+            attempt: failedSteps.length + 1,
+            stepOptions: options
+          };
+          result = await withTimeout(actualFn(stepArgs), options.timeout);
         } catch (e) {
           await db.updateTable("keel.flow_step").set({
             status: "FAILED" /* FAILED */,
@@ -2717,7 +2832,10 @@ function createFlowContext(runId, data, action, spanId, ctx) {
             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.retries ?? defaultOpts.retries)) {
+          if (failedSteps.length >= options.retries || e instanceof NonRetriableError) {
+            if (options.onFailure) {
+              await options.onFailure();
+            }
             throw new ExhuastedRetriesDisrupt();
           }
           await db.insertInto("keel.flow_step").values({
@@ -2790,9 +2908,22 @@ function createFlowContext(runId, data, action, spanId, ctx) {
             (await page(options, null, null)).page
           );
         }
-        const p = await page(options, data, action);
-        if (p.hasValidationErrors) {
-          throw new UIRenderDisrupt(step?.id, p.page);
+        try {
+          const p = await page(options, data, action);
+          if (p.hasValidationErrors) {
+            throw new UIRenderDisrupt(step?.id, p.page);
+          }
+        } catch (e) {
+          if (e instanceof UIRenderDisrupt) {
+            throw e;
+          }
+          await db.updateTable("keel.flow_step").set({
+            status: "FAILED" /* FAILED */,
+            spanId,
+            endTime: /* @__PURE__ */ new Date(),
+            error: e instanceof Error ? e.message : "An error occurred"
+          }).where("id", "=", step?.id).returningAll().executeTakeFirst();
+          throw e;
         }
         await db.updateTable("keel.flow_step").set({
           status: "COMPLETED" /* COMPLETED */,
@@ -2806,7 +2937,8 @@ function createFlowContext(runId, data, action, spanId, ctx) {
       inputs: {
         text: textInput,
         number: numberInput,
-        boolean: booleanInput
+        boolean: booleanInput,
+        dataGrid: dataGridInput
       },
       display: {
         divider,
@@ -2821,7 +2953,8 @@ function createFlowContext(runId, data, action, spanId, ctx) {
         keyValue
       },
       select: {
-        one: selectOne
+        one: selectOne,
+        table: selectTable
       }
     }
   };
@@ -2843,26 +2976,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(),
@@ -2878,8 +3010,8 @@ async function handleFlow(request, config) {
           throw new Error("no runId provided");
         }
         const { flows, createFlowContextAPI } = config;
-        if (!(request.method in flows)) {
-          const message = `no corresponding flow found for '${request.method}'`;
+        if (!flows[request.method]) {
+          const message = `flow '${request.method}' does not exist or has not been implemented`;
           span.setStatus({
             code: opentelemetry6.SpanStatusCode.ERROR,
             message
@@ -2906,7 +3038,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 +3093,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 +3104,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 +3116,7 @@ async function handleFlow(request, config) {
           runId,
           runCompleted: true,
           data,
-          config: flowConfig,
-          ui
+          config: flowConfig
         });
       } catch (e) {
         if (e instanceof Error) {
@@ -3029,6 +3161,7 @@ __name(ksuid, "ksuid");
   InlineFile,
   KSUID,
   ModelAPI,
+  NonRetriableError,
   PERMISSION_STATE,
   Permissions,
   RequestHeaders,