@teamkeel/functions-runtime 0.460.0 → 0.461.0

package/dist/index.js

@@ -472,6 +472,20 @@ function isRichType(obj) {
 }
 __name(isRichType, "isRichType");
 
+// src/jsonColumnValue.js
+var JsonColumnValue = class {
+  static {
+    __name(this, "JsonColumnValue");
+  }
+  constructor(value) {
+    this.value = value;
+  }
+};
+function parseJsonColumnValue(value) {
+  return new JsonColumnValue(JSON.parse(value));
+}
+__name(parseJsonColumnValue, "parseJsonColumnValue");
+
 // src/camelCasePlugin.js
 var KeelCamelCasePlugin = class {
   static {
@@ -479,41 +493,77 @@ var KeelCamelCasePlugin = class {
   }
   constructor(opt) {
     this.opt = opt;
+    this.auditQueryIds = /* @__PURE__ */ new WeakSet();
     this.CamelCasePlugin = new CamelCasePlugin({
       ...opt,
       underscoreBeforeDigits: true
     });
   }
   transformQuery(args) {
+    if (args.queryId && referencesTable(args.node, "keel_audit")) {
+      this.auditQueryIds.add(args.queryId);
+    }
     return this.CamelCasePlugin.transformQuery(args);
   }
   async transformResult(args) {
     if (args.result.rows && Array.isArray(args.result.rows)) {
+      const mapAuditJson = args.queryId && this.auditQueryIds.has(args.queryId);
       return {
         ...args.result,
-        rows: args.result.rows.map((row) => this.mapRow(row))
+        rows: args.result.rows.map((row) => this.mapRow(row, { mapAuditJson }))
       };
     }
     return args.result;
   }
-  mapRow(row) {
+  mapRow(row, context7 = {}) {
     return Object.keys(row).reduce((obj, key) => {
       if (key.endsWith("__sequence")) {
         return obj;
       }
       let value = row[key];
+      if (value instanceof JsonColumnValue) {
+        value = shouldMapJsonColumn(row, key, context7) && canMap(value.value, this.opt) ? this.mapRow(value.value, context7) : value.value;
+        obj[this.CamelCasePlugin.camelCase(key)] = value;
+        return obj;
+      }
       if (Array.isArray(value)) {
         value = value.map(
-          (it) => canMap(it, this.opt) ? this.mapRow(it) : it
+          (it) => canMap(it, this.opt) ? this.mapRow(it, context7) : it
         );
       } else if (canMap(value, this.opt)) {
-        value = this.mapRow(value);
+        value = this.mapRow(value, context7);
       }
       obj[this.CamelCasePlugin.camelCase(key)] = value;
       return obj;
     }, {});
   }
 };
+function shouldMapJsonColumn(row, key, context7) {
+  return context7.mapAuditJson && key === "data" && "id" in row && "table_name" in row && "op" in row && "identity_id" in row && "trace_id" in row && "created_at" in row && "event_processed_at" in row;
+}
+__name(shouldMapJsonColumn, "shouldMapJsonColumn");
+function referencesTable(node, tableName) {
+  if (!node || typeof node !== "object") {
+    return false;
+  }
+  if (node.kind === "IdentifierNode" && (node.name === tableName || node.name === "keelAudit")) {
+    return true;
+  }
+  if (node.kind === "RawNode" && Array.isArray(node.sqlFragments) && node.sqlFragments.some(
+    (fragment) => new RegExp(`(^|[^A-Za-z0-9_])${tableName}($|[^A-Za-z0-9_])`, "i").test(
+      fragment
+    )
+  )) {
+    return true;
+  }
+  return Object.values(node).some((value) => {
+    if (Array.isArray(value)) {
+      return value.some((item) => referencesTable(item, tableName));
+    }
+    return referencesTable(value, tableName);
+  });
+}
+__name(referencesTable, "referencesTable");
 function canMap(obj, opt) {
   return isPlainObject(obj) && !opt?.maintainNestedObjectKeys && !isRichType(obj);
 }
@@ -914,6 +964,8 @@ function getDialect(connString) {
         pgTypes.builtins.INTERVAL,
         (val) => new Duration(val)
       );
+      pgTypes.setTypeParser(pgTypes.builtins.JSON, parseJsonColumnValue);
+      pgTypes.setTypeParser(pgTypes.builtins.JSONB, parseJsonColumnValue);
       const poolConfig = {
         Client: InstrumentedClient,
         // Increased idle time before closing a connection in the local pool (from 10s default).
@@ -948,6 +1000,8 @@ function getDialect(connString) {
         pgTypes.builtins.INTERVAL,
         (val) => new Duration(val)
       );
+      neon.types.setTypeParser(pgTypes.builtins.JSON, parseJsonColumnValue);
+      neon.types.setTypeParser(pgTypes.builtins.JSONB, parseJsonColumnValue);
       neon.neonConfig.webSocketConstructor = WebSocket;
       const pool = new InstrumentedNeonServerlessPool({
         // If connString is not passed fall back to reading from env var
@@ -2900,30 +2954,30 @@ var FlowsAPI = class _FlowsAPI {
   }
 };
 
-// src/integrationServer.js
+// src/auth/serviceToken.ts
 import jwt3 from "jsonwebtoken";
-function buildHeaders3(identity) {
-  const headers = { "Content-Type": "application/json" };
+function buildServiceAuthHeaders(audience) {
   const base64pk = process.env.KEEL_PRIVATE_KEY;
   if (!base64pk) {
     throw new Error(
-      "KEEL_PRIVATE_KEY is not set; cannot sign the integration proxy token"
+      `KEEL_PRIVATE_KEY is not set; cannot sign the ${audience} service token`
     );
   }
   const privateKey = Buffer.from(base64pk, "base64").toString("utf8");
-  const subject = identity && identity.id ? identity.id : "integration-proxy";
-  headers["Authorization"] = "Bearer " + jwt3.sign({}, privateKey, {
+  const token = jwt3.sign({}, privateKey, {
     algorithm: "RS256",
     expiresIn: 60 * 60 * 24,
-    subject,
-    // Scope the token to the integration proxy so it can't be mistaken for an ordinary user
-    // access token; the runtime proxy verifies this audience before injecting credentials.
-    audience: "integration-proxy",
+    audience,
     issuer: "https://keel.so"
   });
-  return headers;
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${token}`
+  };
 }
-__name(buildHeaders3, "buildHeaders");
+__name(buildServiceAuthHeaders, "buildServiceAuthHeaders");
+
+// src/integrationServer.js
 function getApiUrl3() {
   const apiUrl = process.env.KEEL_API_URL;
   if (!apiUrl) {
@@ -2940,7 +2994,7 @@ function createIntegrationServer(name, identity) {
       )}/proxy`;
       const response = await fetch(url, {
         method: "POST",
-        headers: buildHeaders3(identity ?? null),
+        headers: buildServiceAuthHeaders("integration-proxy"),
         body: JSON.stringify(request ?? {})
       });
       if (!response.ok) {
@@ -3723,12 +3777,29 @@ async function applyElementGetData(content, data) {
   return data;
 }
 __name(applyElementGetData, "applyElementGetData");
-async function callbackFn(elements, elementName, callbackName, data) {
-  const element = elements.find(
-    (el) => el.uiConfig && el.uiConfig.name === elementName
+var ITERATOR_SCOPED_ELEMENT = /^([^[]+)\[(\d+)\]:(.+)$/;
+async function callbackFn(elements, elementPath, callbackName, data) {
+  const scoped = ITERATOR_SCOPED_ELEMENT.exec(elementPath);
+  let searchScope = elements;
+  let elementName = elementPath;
+  let iteratorName = null;
+  if (scoped) {
+    iteratorName = scoped[1];
+    elementName = scoped[3];
+    const iter = elements.find(
+      (el) => el?.uiConfig?.__type === "ui.iterator" && el.uiConfig.name === iteratorName
+    );
+    if (!iter) {
+      throw new Error(`Iterator with name ${iteratorName} not found`);
+    }
+    searchScope = iter.uiConfig.content;
+  }
+  const element = searchScope.find(
+    (el) => el?.uiConfig && el.uiConfig.name === elementName
   );
   if (!element) {
-    throw new Error(`Element with name ${elementName} not found`);
+    const where = iteratorName ? ` in iterator ${iteratorName}` : "";
+    throw new Error(`Element with name ${elementName} not found${where}`);
   }
   const cb = element[callbackName];
   if (typeof cb !== "function") {
@@ -4674,6 +4745,19 @@ var defaultOpts = {
   retries: 4,
   timeout: 6e4
 };
+var STEP_VALUE_WARN_BYTES = 1024 * 1024;
+function serializeStepValue(span, name, value) {
+  const serialized = JSON.stringify(value);
+  const bytes = serialized == null ? 0 : Buffer.byteLength(serialized, "utf8");
+  span.setAttribute("step.value.bytes", bytes);
+  if (bytes > STEP_VALUE_WARN_BYTES) {
+    console.warn(
+      `flow step "${name}" returned a ${Math.round(bytes / 1024)}KB value. Step values are reloaded on every flow invocation during replay, so large values slow the whole run down. Consider storing large data as a file and returning a reference to it instead.`
+    );
+  }
+  return serialized;
+}
+__name(serializeStepValue, "serializeStepValue");
 async function insertNewStep(db, runId, name, stage) {
   await db.transaction().execute(async (trx) => {
     await trx.selectFrom("keel.flow_run").select("id").where("id", "=", runId).forUpdate().executeTakeFirst();
@@ -4694,6 +4778,30 @@ async function insertNewStep(db, runId, name, stage) {
 __name(insertNewStep, "insertNewStep");
 function createFlowContext(runId, data, action, callback, element, spanId, ctx) {
   const usedNames = /* @__PURE__ */ new Set();
+  let stepsSnapshot = null;
+  let uiBoundaryCrossed = false;
+  async function loadStepsSnapshot(db) {
+    if (stepsSnapshot) {
+      return stepsSnapshot;
+    }
+    const rows = await db.selectFrom("keel.flow_step").where("run_id", "=", runId).select(["id", "name", "status", "type", "action"]).select(sql4`value::text`.as("valueRaw")).execute();
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const existing = map.get(row.name);
+      if (existing) {
+        existing.push(row);
+      } else {
+        map.set(row.name, [row]);
+      }
+    }
+    stepsSnapshot = map;
+    return map;
+  }
+  __name(loadStepsSnapshot, "loadStepsSnapshot");
+  async function readStepRows(db, name) {
+    return await db.selectFrom("keel.flow_step").where("run_id", "=", runId).where("name", "=", name).select(["id", "name", "status", "type", "action"]).select(sql4`value::text`.as("valueRaw")).execute();
+  }
+  __name(readStepRows, "readStepRows");
   const context7 = {
     identity: ctx.identity,
     env: ctx.env,
@@ -4733,7 +4841,15 @@ function createFlowContext(runId, data, action, callback, element, spanId, ctx)
             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().select(sql4`value::text`.as("valueRaw")).execute();
+          let past;
+          if (uiBoundaryCrossed) {
+            past = await readStepRows(db, name);
+          } else {
+            past = (await loadStepsSnapshot(db)).get(name) ?? [];
+            if (!past.some((step) => step.status === "COMPLETED" /* COMPLETED */)) {
+              past = await readStepRows(db, name);
+            }
+          }
           const newSteps = past.filter(
             (step) => step.status === "NEW" /* NEW */
           );
@@ -4816,7 +4932,7 @@ function createFlowContext(runId, data, action, callback, element, spanId, ctx)
             }
             await db.updateTable("keel.flow_step").set({
               status: "COMPLETED" /* COMPLETED */,
-              value: JSON.stringify(result),
+              value: serializeStepValue(span, name, result),
               spanId,
               endTime: /* @__PURE__ */ new Date()
             }).where("id", "=", newSteps[0].id).returningAll().executeTakeFirst();
@@ -4854,6 +4970,20 @@ function createFlowContext(runId, data, action, callback, element, spanId, ctx)
               throw new Error(`Duplicate step name: ${name}`);
             }
             usedNames.add(name);
+            const replayCompletedUiStep = /* @__PURE__ */ __name(async (completed) => {
+              span.setAttribute(KEEL_INTERNAL_ATTR, KEEL_INTERNAL_CHILDREN);
+              span.setAttribute("step.status", "COMPLETED" /* COMPLETED */);
+              const rawValue = completed.valueRaw;
+              const storedData = rawValue == null ? null : JSON.parse(rawValue);
+              const parsedData2 = await applyElementGetData(
+                options.content,
+                transformRichDataTypes(storedData)
+              );
+              if (completed.action) {
+                return { data: parsedData2, action: completed.action };
+              }
+              return parsedData2;
+            }, "replayCompletedUiStep");
             const { step, inserted } = await db.transaction().execute(async (trx) => {
               await trx.selectFrom("keel.flow_run").select("id").where("id", "=", runId).forUpdate().executeTakeFirst();
               const existing = await trx.selectFrom("keel.flow_step").where("run_id", "=", runId).where("name", "=", name).selectAll().select(sql4`value::text`.as("valueRaw")).executeTakeFirst();
@@ -4872,18 +5002,8 @@ function createFlowContext(runId, data, action, callback, element, spanId, ctx)
               return { step: created, inserted: true };
             });
             if (step && step.status === "COMPLETED" /* COMPLETED */) {
-              span.setAttribute(KEEL_INTERNAL_ATTR, KEEL_INTERNAL_CHILDREN);
-              span.setAttribute("step.status", "COMPLETED" /* COMPLETED */);
-              const rawValue = step.valueRaw;
-              const storedData = rawValue == null ? null : JSON.parse(rawValue);
-              const parsedData2 = await applyElementGetData(
-                options.content,
-                transformRichDataTypes(storedData)
-              );
-              if (step.action) {
-                return { data: parsedData2, action: step.action };
-              }
-              return parsedData2;
+              uiBoundaryCrossed = true;
+              return replayCompletedUiStep(step);
             }
             if (inserted) {
               span.setAttribute("rendered", true);
@@ -4942,12 +5062,13 @@ function createFlowContext(runId, data, action, callback, element, spanId, ctx)
             }
             await db.updateTable("keel.flow_step").set({
               status: "COMPLETED" /* COMPLETED */,
-              value: JSON.stringify(data),
+              value: serializeStepValue(span, name, data),
               action,
               spanId,
               endTime: /* @__PURE__ */ new Date()
             }).where("id", "=", step.id).returningAll().executeTakeFirst();
             span.setAttribute("step.status", "COMPLETED" /* COMPLETED */);
+            uiBoundaryCrossed = true;
             const parsedData = await applyElementGetData(
               options.content,
               transformRichDataTypes(data)
@@ -5361,7 +5482,7 @@ async function notifyEmail(input) {
     };
     const response = await fetch(`${getApiUrl4()}/notifications/json/email`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: buildServiceAuthHeaders("notifications"),
       body: JSON.stringify(body)
     });
     if (!response.ok) {