@teamkeel/functions-runtime 0.429.1 → 0.430.0

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   Duration: () => Duration,
   ErrorPresets: () => ErrorPresets,
   File: () => File,
+  FlowsAPI: () => FlowsAPI,
   InlineFile: () => InlineFile,
   KSUID: () => import_ksuid2.default,
   ModelAPI: () => ModelAPI,
@@ -1081,8 +1082,12 @@ var opMapping = {
   onOrBefore: { op: "<=" },
   after: { op: ">" },
   onOrAfter: { op: ">=" },
-  equals: { op: import_kysely4.sql`is not distinct from` },
-  notEquals: { op: import_kysely4.sql`is distinct from` },
+  equals: {
+    op: /* @__PURE__ */ __name((v) => v === null || Array.isArray(v) ? import_kysely4.sql`is not distinct from` : "=", "op")
+  },
+  notEquals: {
+    op: /* @__PURE__ */ __name((v) => v === null || Array.isArray(v) ? import_kysely4.sql`is distinct from` : "!=", "op")
+  },
   equalsRelative: {
     op: import_kysely4.sql`BETWEEN`,
     value: /* @__PURE__ */ __name((v) => import_kysely4.sql`${import_kysely4.sql.raw(
@@ -1137,7 +1142,8 @@ function applyWhereConditions(context6, qb, where = {}) {
     }
     const fieldName = `${context6.tableAlias()}.${(0, import_change_case.snakeCase)(key)}`;
     if (Object.prototype.toString.call(v) !== "[object Object]") {
-      qb = qb.where(fieldName, import_kysely4.sql`is not distinct from`, import_kysely4.sql`${v}`);
+      const operator = v === null || Array.isArray(v) ? import_kysely4.sql`is not distinct from` : "=";
+      qb = qb.where(fieldName, operator, import_kysely4.sql`${v}`);
       continue;
     }
     for (const op of Object.keys(v)) {
@@ -1154,9 +1160,10 @@ function applyWhereConditions(context6, qb, where = {}) {
           );
         }
       } else {
+        const operator = typeof mapping.op === "function" ? mapping.op(v[op]) : mapping.op;
         qb = qb.where(
           fieldName,
-          mapping.op,
+          operator,
           mapping.value ? mapping.value(v[op]) : import_kysely4.sql`${v[op]}`
         );
       }
@@ -2089,6 +2096,294 @@ var TaskAPI = class _TaskAPI {
   }
 };
 
+// src/FlowsAPI.js
+var import_jsonwebtoken2 = __toESM(require("jsonwebtoken"), 1);
+function buildHeaders2(identity, authToken) {
+  const headers = { "Content-Type": "application/json" };
+  if (identity !== null) {
+    const base64pk = process.env.KEEL_PRIVATE_KEY;
+    let privateKey = void 0;
+    if (base64pk) {
+      privateKey = Buffer.from(base64pk, "base64").toString("utf8");
+    }
+    headers["Authorization"] = "Bearer " + import_jsonwebtoken2.default.sign({}, privateKey, {
+      algorithm: privateKey ? "RS256" : "none",
+      expiresIn: 60 * 60 * 24,
+      subject: identity.id,
+      issuer: "https://keel.so"
+    });
+  }
+  if (authToken !== null) {
+    headers["Authorization"] = "Bearer " + authToken;
+  }
+  return headers;
+}
+__name(buildHeaders2, "buildHeaders");
+function getApiUrl2() {
+  const apiUrl = process.env.KEEL_API_URL;
+  if (!apiUrl) {
+    throw new Error("KEEL_API_URL environment variable is not set");
+  }
+  return apiUrl;
+}
+__name(getApiUrl2, "getApiUrl");
+var FlowRun = class _FlowRun {
+  static {
+    __name(this, "FlowRun");
+  }
+  /**
+   * @param {Object} data The flow run data from the API
+   * @param {string} flowName The name of the flow
+   * @param {Object|null} identity Optional identity object for authentication
+   * @param {string|null} authToken Optional auth token for authentication
+   */
+  constructor(data, flowName, identity = null, authToken = null) {
+    this.id = data.id;
+    this.name = data.name;
+    this.status = data.status;
+    this.inputs = data.inputs;
+    this.outputs = data.outputs;
+    this.steps = data.steps;
+    this.pendingStep = data.pendingStep;
+    this.createdAt = data.createdAt ? new Date(data.createdAt) : void 0;
+    this.updatedAt = data.updatedAt ? new Date(data.updatedAt) : void 0;
+    this.completedAt = data.completedAt ? new Date(data.completedAt) : void 0;
+    this._flowName = flowName;
+    this._identity = identity;
+    this._authToken = authToken;
+  }
+  /**
+   * Returns a new FlowRun instance that will use the given identity for authentication.
+   * @param {Object} identity The identity object
+   * @returns {FlowRun} A new FlowRun instance with the identity set
+   */
+  withIdentity(identity) {
+    const data = this._toApiData();
+    return new _FlowRun(data, this._flowName, identity, null);
+  }
+  /**
+   * Returns a new FlowRun instance that will use the given auth token for authentication.
+   * @param {string} token The auth token to use
+   * @returns {FlowRun} A new FlowRun instance with the auth token set
+   */
+  withAuthToken(token) {
+    const data = this._toApiData();
+    return new _FlowRun(data, this._flowName, null, token);
+  }
+  /**
+   * Converts the flow run back to API data format for creating new instances.
+   * @returns {Object} The flow run data in API format
+   */
+  _toApiData() {
+    return {
+      id: this.id,
+      name: this.name,
+      status: this.status,
+      inputs: this.inputs,
+      outputs: this.outputs,
+      steps: this.steps,
+      pendingStep: this.pendingStep,
+      createdAt: this.createdAt?.toISOString(),
+      updatedAt: this.updatedAt?.toISOString(),
+      completedAt: this.completedAt?.toISOString()
+    };
+  }
+  /**
+   * Refreshes the flow run state from the API.
+   * @returns {Promise<FlowRun>} The updated flow run
+   */
+  async refresh() {
+    const name = spanNameForModelAPI(this._flowName, "refresh");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl2();
+      const url = `${apiUrl}/flows/json/${this._flowName}/${this.id}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders2(this._identity, this._authToken)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to refresh flow run: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new _FlowRun(
+        result,
+        this._flowName,
+        this._identity,
+        this._authToken
+      );
+    });
+  }
+  /**
+   * Cancels the flow run.
+   * @returns {Promise<FlowRun>} The updated flow run
+   */
+  async cancel() {
+    const name = spanNameForModelAPI(this._flowName, "cancel");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl2();
+      const url = `${apiUrl}/flows/json/${this._flowName}/${this.id}/cancel`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: buildHeaders2(this._identity, this._authToken)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to cancel flow run: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new _FlowRun(
+        result,
+        this._flowName,
+        this._identity,
+        this._authToken
+      );
+    });
+  }
+};
+var FlowsAPI = class _FlowsAPI {
+  static {
+    __name(this, "FlowsAPI");
+  }
+  /**
+   * @param {string} flowName The name of the flow
+   * @param {Object|null} identity Optional identity object for authentication
+   * @param {string|null} authToken Optional auth token for authentication
+   */
+  constructor(flowName, identity = null, authToken = null) {
+    this._flowName = flowName;
+    this._identity = identity;
+    this._authToken = authToken;
+  }
+  /**
+   * Returns a new FlowsAPI instance that will use the given identity for authentication.
+   * @param {Object} identity The identity object
+   * @returns {FlowsAPI} A new FlowsAPI instance with the identity set
+   */
+  withIdentity(identity) {
+    return new _FlowsAPI(this._flowName, identity, null);
+  }
+  /**
+   * Returns a new FlowsAPI instance that will use the given auth token for authentication.
+   * @param {string} token The auth token to use
+   * @returns {FlowsAPI} A new FlowsAPI instance with the auth token set
+   */
+  withAuthToken(token) {
+    return new _FlowsAPI(this._flowName, null, token);
+  }
+  /**
+   * Starts a new flow run with the given inputs.
+   * @param {Object} inputs The flow input data
+   * @returns {Promise<FlowRun>} The created flow run
+   */
+  async start(inputs = {}) {
+    const name = spanNameForModelAPI(this._flowName, "start");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl2();
+      const url = `${apiUrl}/flows/json/${this._flowName}`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: buildHeaders2(this._identity, this._authToken),
+        body: JSON.stringify(inputs)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to start flow: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new FlowRun(
+        result,
+        this._flowName,
+        this._identity,
+        this._authToken
+      );
+    });
+  }
+  /**
+   * Gets a flow run by ID.
+   * @param {string} runId The flow run ID
+   * @returns {Promise<FlowRun>} The flow run
+   */
+  async get(runId) {
+    const name = spanNameForModelAPI(this._flowName, "get");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl2();
+      const url = `${apiUrl}/flows/json/${this._flowName}/${runId}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders2(this._identity, this._authToken)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to get flow run: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new FlowRun(
+        result,
+        this._flowName,
+        this._identity,
+        this._authToken
+      );
+    });
+  }
+  /**
+   * Lists flow runs for this flow.
+   * @param {Object} options Optional pagination options
+   * @param {number} options.limit Maximum number of runs to return
+   * @param {number} options.offset Offset for pagination
+   * @returns {Promise<{results: FlowRun[], pageInfo: Object}>} List of flow runs with pagination info
+   */
+  async list(options = {}) {
+    const name = spanNameForModelAPI(this._flowName, "list");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl2();
+      const params = new URLSearchParams();
+      if (options.limit) params.set("limit", options.limit.toString());
+      if (options.offset) params.set("offset", options.offset.toString());
+      const url = `${apiUrl}/flows/json/${this._flowName}${params.toString() ? "?" + params.toString() : ""}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders2(this._identity, this._authToken)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to list flow runs: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      if (Array.isArray(result)) {
+        return {
+          results: result.map(
+            (run) => new FlowRun(run, this._flowName, this._identity, this._authToken)
+          ),
+          pageInfo: {
+            totalCount: result.length,
+            hasNextPage: false
+          }
+        };
+      }
+      return {
+        results: (result.results || []).map(
+          (run) => new FlowRun(run, this._flowName, this._identity, this._authToken)
+        ),
+        pageInfo: result.pageInfo || {
+          totalCount: (result.results || []).length,
+          hasNextPage: false
+        }
+      };
+    });
+  }
+};
+
 // src/RequestHeaders.ts
 var RequestHeaders = class {
   /**
@@ -2262,6 +2557,9 @@ __name(tryExecuteFunction, "tryExecuteFunction");
 // src/handleRequest.js
 var opentelemetry2 = __toESM(require("@opentelemetry/api"), 1);
 async function handleRequest(request, config) {
+  if (request.method === "__ping") {
+    return (0, import_json_rpc_22.createJSONRPCSuccessResponse)(request.id, { status: "ok" });
+  }
   const activeContext = opentelemetry2.propagation.extract(
     opentelemetry2.context.active(),
     request.meta?.tracing
@@ -3869,6 +4167,7 @@ __name(ksuid, "ksuid");
   Duration,
   ErrorPresets,
   File,
+  FlowsAPI,
   InlineFile,
   KSUID,
   ModelAPI,