@teamkeel/functions-runtime 0.428.2 → 0.429.1

package/dist/index.cjs

@@ -46,6 +46,7 @@ __export(index_exports, {
   RetryConstant: () => RetryConstant,
   STEP_STATUS: () => STEP_STATUS,
   STEP_TYPE: () => STEP_TYPE,
+  TaskAPI: () => TaskAPI,
   checkBuiltInPermissions: () => checkBuiltInPermissions,
   createFlowContext: () => createFlowContext,
   handleFlow: () => handleFlow,
@@ -848,24 +849,34 @@ async function storeFile(contents, key, filename, contentType, size, expires) {
 __name(storeFile, "storeFile");
 
 // src/parsing.js
+var dateFormat = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
 function parseInputs(inputs) {
   if (inputs != null && typeof inputs === "object") {
     for (const k of Object.keys(inputs)) {
-      if (inputs[k] !== null && typeof inputs[k] === "object") {
-        if (Array.isArray(inputs[k])) {
-          inputs[k] = inputs[k].map((item) => {
+      const value = inputs[k];
+      if (value === null) {
+        continue;
+      }
+      if (typeof value === "string" && dateFormat.test(value)) {
+        inputs[k] = new Date(value);
+      } else if (typeof value === "object") {
+        if (Array.isArray(value)) {
+          inputs[k] = value.map((item) => {
             if (item && typeof item === "object") {
               if ("__typename" in item) {
                 return parseComplexInputType(item);
               }
               return parseInputs(item);
             }
+            if (typeof item === "string" && dateFormat.test(item)) {
+              return new Date(item);
+            }
             return item;
           });
-        } else if ("__typename" in inputs[k]) {
-          inputs[k] = parseComplexInputType(inputs[k]);
+        } else if ("__typename" in value) {
+          inputs[k] = parseComplexInputType(value);
         } else {
-          inputs[k] = parseInputs(inputs[k]);
+          inputs[k] = parseInputs(value);
         }
       }
     }
@@ -1800,6 +1811,284 @@ async function create(conn, tableName, tableConfigs, values) {
 }
 __name(create, "create");
 
+// src/TaskAPI.js
+var import_jsonwebtoken = __toESM(require("jsonwebtoken"), 1);
+function buildHeaders(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_jsonwebtoken.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(buildHeaders, "buildHeaders");
+function getApiUrl() {
+  const apiUrl = process.env.KEEL_API_URL;
+  if (!apiUrl) {
+    throw new Error("KEEL_API_URL environment variable is not set");
+  }
+  return apiUrl;
+}
+__name(getApiUrl, "getApiUrl");
+var Task = class _Task {
+  static {
+    __name(this, "Task");
+  }
+  /**
+   * @param {Object} data The task data from the API
+   * @param {string} taskName The name of the task/topic
+   * @param {Object|null} identity Optional identity object for authentication
+   * @param {string|null} authToken Optional auth token for authentication
+   */
+  constructor(data, taskName, identity = null, authToken = null) {
+    this.id = data.id;
+    this.topic = data.name;
+    this.status = data.status;
+    this.deferredUntil = data.deferredUntil ? new Date(data.deferredUntil) : void 0;
+    this.createdAt = new Date(data.createdAt);
+    this.updatedAt = new Date(data.updatedAt);
+    this.assignedTo = data.assignedTo;
+    this.assignedAt = data.assignedAt ? new Date(data.assignedAt) : void 0;
+    this.resolvedAt = data.resolvedAt ? new Date(data.resolvedAt) : void 0;
+    this.flowRunId = data.flowRunId;
+    this._taskName = taskName;
+    this._identity = identity;
+    this._authToken = authToken;
+  }
+  /**
+   * Returns a new Task instance that will use the given identity for authentication.
+   * @param {Object} identity The identity object
+   * @returns {Task} A new Task instance with the identity set
+   */
+  withIdentity(identity) {
+    const data = this._toApiData();
+    return new _Task(data, this._taskName, identity, null);
+  }
+  /**
+   * Returns a new Task instance that will use the given auth token for authentication.
+   * @param {string} token The auth token to use
+   * @returns {Task} A new Task instance with the auth token set
+   */
+  withAuthToken(token) {
+    const data = this._toApiData();
+    return new _Task(data, this._taskName, null, token);
+  }
+  /**
+   * Converts the task back to API data format for creating new instances.
+   * @returns {Object} The task data in API format
+   */
+  _toApiData() {
+    return {
+      id: this.id,
+      name: this.topic,
+      status: this.status,
+      deferredUntil: this.deferredUntil?.toISOString(),
+      createdAt: this.createdAt.toISOString(),
+      updatedAt: this.updatedAt.toISOString(),
+      assignedTo: this.assignedTo,
+      assignedAt: this.assignedAt?.toISOString(),
+      resolvedAt: this.resolvedAt?.toISOString(),
+      flowRunId: this.flowRunId
+    };
+  }
+  /**
+   * Assigns the task to an identity.
+   * @param {Object} options Options containing identityId
+   * @param {string} options.identityId The ID of the identity to assign the task to
+   * @returns {Promise<Task>} The updated task
+   */
+  async assign({ identityId }) {
+    const name = spanNameForModelAPI(this._taskName, "assign");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl();
+      const url = `${apiUrl}/topics/json/${this._taskName}/tasks/${this.id}/assign`;
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: buildHeaders(this._identity, this._authToken),
+        body: JSON.stringify({ assigned_to: identityId })
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to assign task: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new _Task(result, this._taskName, this._identity, this._authToken);
+    });
+  }
+  /**
+   * Starts the task, creating and running the associated flow.
+   * @returns {Promise<Task>} The updated task with flowRunId
+   */
+  async start() {
+    const name = spanNameForModelAPI(this._taskName, "start");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl();
+      const url = `${apiUrl}/topics/json/${this._taskName}/tasks/${this.id}/start`;
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: buildHeaders(this._identity, this._authToken)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to start task: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new _Task(result, this._taskName, this._identity, this._authToken);
+    });
+  }
+  /**
+   * Completes the task.
+   * @returns {Promise<Task>} The updated task
+   */
+  async complete() {
+    const name = spanNameForModelAPI(this._taskName, "complete");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl();
+      const url = `${apiUrl}/topics/json/${this._taskName}/tasks/${this.id}/complete`;
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: buildHeaders(this._identity, this._authToken)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to complete task: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new _Task(result, this._taskName, this._identity, this._authToken);
+    });
+  }
+  /**
+   * Defers the task until a specified date.
+   * @param {Object} options Options containing deferUntil
+   * @param {Date} options.deferUntil The date to defer the task until
+   * @returns {Promise<Task>} The updated task
+   */
+  async defer({ deferUntil }) {
+    const name = spanNameForModelAPI(this._taskName, "defer");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl();
+      const url = `${apiUrl}/topics/json/${this._taskName}/tasks/${this.id}/defer`;
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: buildHeaders(this._identity, this._authToken),
+        body: JSON.stringify({ defer_until: deferUntil.toISOString() })
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to defer task: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new _Task(result, this._taskName, this._identity, this._authToken);
+    });
+  }
+  /**
+   * Cancels the task.
+   * @returns {Promise<Task>} The updated task
+   */
+  async cancel() {
+    const name = spanNameForModelAPI(this._taskName, "cancel");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl();
+      const url = `${apiUrl}/topics/json/${this._taskName}/tasks/${this.id}/cancel`;
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: buildHeaders(this._identity, this._authToken)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to cancel task: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new _Task(result, this._taskName, this._identity, this._authToken);
+    });
+  }
+};
+var TaskAPI = class _TaskAPI {
+  static {
+    __name(this, "TaskAPI");
+  }
+  /**
+   * @param {string} taskName The name of the task/topic
+   * @param {Object|null} identity Optional identity object for authentication
+   * @param {string|null} authToken Optional auth token for authentication
+   */
+  constructor(taskName, identity = null, authToken = null) {
+    this._taskName = taskName;
+    this._identity = identity;
+    this._authToken = authToken;
+  }
+  /**
+   * Returns a new TaskAPI instance that will use the given identity for authentication.
+   * @param {Object} identity The identity object
+   * @returns {TaskAPI} A new TaskAPI instance with the identity set
+   */
+  withIdentity(identity) {
+    return new _TaskAPI(this._taskName, identity, null);
+  }
+  /**
+   * Returns a new TaskAPI instance that will use the given auth token for authentication.
+   * @param {string} token The auth token to use
+   * @returns {TaskAPI} A new TaskAPI instance with the auth token set
+   */
+  withAuthToken(token) {
+    return new _TaskAPI(this._taskName, null, token);
+  }
+  /**
+   * Creates a new task with the given data by calling the tasks API.
+   * @param {Object} data The task data fields
+   * @param {Object} options Optional settings like deferredUntil
+   * @returns {Promise<Task>} The created task
+   */
+  async create(data = {}, options = {}) {
+    const name = spanNameForModelAPI(this._taskName, "create");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl();
+      const url = `${apiUrl}/topics/json/${this._taskName}/tasks`;
+      const body = {
+        data
+      };
+      if (options.deferredUntil) {
+        body.defer_until = options.deferredUntil.toISOString();
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        headers: buildHeaders(this._identity, this._authToken),
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(
+          `Failed to create task: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      return new Task(result, this._taskName, this._identity, this._authToken);
+    });
+  }
+};
+
 // src/RequestHeaders.ts
 var RequestHeaders = class {
   /**
@@ -3592,6 +3881,7 @@ __name(ksuid, "ksuid");
   RetryConstant,
   STEP_STATUS,
   STEP_TYPE,
+  TaskAPI,
   checkBuiltInPermissions,
   createFlowContext,
   handleFlow,