@teamkeel/functions-runtime 0.429.2 → 0.431.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,
@@ -398,7 +399,13 @@ __name(init, "init");
 async function forceFlush() {
   const provider = opentelemetry.trace.getTracerProvider().getDelegate();
   if (provider && provider.forceFlush) {
-    await provider.forceFlush();
+    try {
+      await provider.forceFlush();
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.error("tracing forceFlush failed:", err.message);
+      }
+    }
   }
 }
 __name(forceFlush, "forceFlush");
@@ -1081,7 +1088,9 @@ var opMapping = {
   onOrBefore: { op: "<=" },
   after: { op: ">" },
   onOrAfter: { op: ">=" },
-  equals: { op: import_kysely4.sql`is not distinct from` },
+  equals: {
+    op: /* @__PURE__ */ __name((v) => v === null || Array.isArray(v) ? import_kysely4.sql`is not distinct from` : "=", "op")
+  },
   notEquals: { op: import_kysely4.sql`is distinct from` },
   equalsRelative: {
     op: import_kysely4.sql`BETWEEN`,
@@ -1137,7 +1146,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 +1164,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]}`
         );
       }
@@ -1842,72 +1853,51 @@ function getApiUrl() {
   return apiUrl;
 }
 __name(getApiUrl, "getApiUrl");
-var Task = class _Task {
+var Task = class {
   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.
+   * Sets the identity for authentication and returns this instance.
    * @param {Object} identity The identity object
-   * @returns {Task} A new Task instance with the identity set
+   * @returns {Task} This Task instance with the identity set
    */
   withIdentity(identity) {
-    const data = this._toApiData();
-    return new _Task(data, this._taskName, identity, null);
+    this._identity = identity;
+    this._authToken = null;
+    return this;
   }
   /**
-   * Returns a new Task instance that will use the given auth token for authentication.
+   * Sets the auth token for authentication and returns this instance.
    * @param {string} token The auth token to use
-   * @returns {Task} A new Task instance with the auth token set
+   * @returns {Task} This Task instance with the auth token set
    */
   withAuthToken(token) {
-    const data = this._toApiData();
-    return new _Task(data, this._taskName, null, token);
+    this._identity = null;
+    this._authToken = token;
+    return this;
   }
   /**
-   * Converts the task back to API data format for creating new instances.
-   * @returns {Object} The task data in API format
+   * Updates the current task instance with data from the API response.
+   * The API returns camelCase fields matching the Go struct JSON tags.
+   * @param {Object} data The API response data
    */
-  _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
-    };
+  _updateFromResponse(data) {
+    this.id = data.id;
+    this.status = data.status;
+    this.deferredUntil = data.deferredUntil ? new Date(data.deferredUntil) : null;
+    this.createdAt = new Date(data.createdAt);
+    this.updatedAt = new Date(data.updatedAt);
+    this.assignedToId = data.assignedTo ?? null;
+    this.assignedAt = data.assignedAt ? new Date(data.assignedAt) : null;
+    this.resolvedAt = data.resolvedAt ? new Date(data.resolvedAt) : null;
+    this.flowRunId = data.flowRunId ?? null;
   }
   /**
    * 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
+   * @returns {Promise<void>}
    */
   async assign({ identityId }) {
     const name = spanNameForModelAPI(this._taskName, "assign");
@@ -1926,12 +1916,12 @@ var Task = class _Task {
         );
       }
       const result = await response.json();
-      return new _Task(result, this._taskName, this._identity, this._authToken);
+      this._updateFromResponse(result);
     });
   }
   /**
    * Starts the task, creating and running the associated flow.
-   * @returns {Promise<Task>} The updated task with flowRunId
+   * @returns {Promise<void>}
    */
   async start() {
     const name = spanNameForModelAPI(this._taskName, "start");
@@ -1949,12 +1939,12 @@ var Task = class _Task {
         );
       }
       const result = await response.json();
-      return new _Task(result, this._taskName, this._identity, this._authToken);
+      this._updateFromResponse(result);
     });
   }
   /**
    * Completes the task.
-   * @returns {Promise<Task>} The updated task
+   * @returns {Promise<void>}
    */
   async complete() {
     const name = spanNameForModelAPI(this._taskName, "complete");
@@ -1972,14 +1962,14 @@ var Task = class _Task {
         );
       }
       const result = await response.json();
-      return new _Task(result, this._taskName, this._identity, this._authToken);
+      this._updateFromResponse(result);
     });
   }
   /**
    * 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
+   * @returns {Promise<void>}
    */
   async defer({ deferUntil }) {
     const name = spanNameForModelAPI(this._taskName, "defer");
@@ -1998,12 +1988,12 @@ var Task = class _Task {
         );
       }
       const result = await response.json();
-      return new _Task(result, this._taskName, this._identity, this._authToken);
+      this._updateFromResponse(result);
     });
   }
   /**
    * Cancels the task.
-   * @returns {Promise<Task>} The updated task
+   * @returns {Promise<void>}
    */
   async cancel() {
     const name = spanNameForModelAPI(this._taskName, "cancel");
@@ -2021,7 +2011,30 @@ var Task = class _Task {
         );
       }
       const result = await response.json();
-      return new _Task(result, this._taskName, this._identity, this._authToken);
+      this._updateFromResponse(result);
+    });
+  }
+  /**
+   * Unassigns the task, removing the current assignee.
+   * @returns {Promise<void>}
+   */
+  async unassign() {
+    const name = spanNameForModelAPI(this._taskName, "unassign");
+    return withSpan(name, async () => {
+      const apiUrl = getApiUrl();
+      const url = `${apiUrl}/topics/json/${this._taskName}/tasks/${this.id}/unassign`;
+      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 unassign task: ${response.status} ${response.statusText} - ${errorBody.message || JSON.stringify(errorBody)}`
+        );
+      }
+      const result = await response.json();
+      this._updateFromResponse(result);
     });
   }
 };
@@ -2031,13 +2044,17 @@ var TaskAPI = class _TaskAPI {
   }
   /**
    * @param {string} taskName The name of the task/topic
+   * @param {Object} tableConfigMap Configuration for table relationships
    * @param {Object|null} identity Optional identity object for authentication
    * @param {string|null} authToken Optional auth token for authentication
    */
-  constructor(taskName, identity = null, authToken = null) {
+  constructor(taskName, tableConfigMap = {}, identity = null, authToken = null) {
     this._taskName = taskName;
+    this._tableName = (0, import_change_case.snakeCase)(taskName);
+    this._tableConfigMap = tableConfigMap;
     this._identity = identity;
     this._authToken = authToken;
+    this._modelAPI = new ModelAPI(this._tableName, null, tableConfigMap);
   }
   /**
    * Returns a new TaskAPI instance that will use the given identity for authentication.
@@ -2045,7 +2062,7 @@ var TaskAPI = class _TaskAPI {
    * @returns {TaskAPI} A new TaskAPI instance with the identity set
    */
   withIdentity(identity) {
-    return new _TaskAPI(this._taskName, identity, null);
+    return new _TaskAPI(this._taskName, this._tableConfigMap, identity, null);
   }
   /**
    * Returns a new TaskAPI instance that will use the given auth token for authentication.
@@ -2053,13 +2070,14 @@ var TaskAPI = class _TaskAPI {
    * @returns {TaskAPI} A new TaskAPI instance with the auth token set
    */
   withAuthToken(token) {
-    return new _TaskAPI(this._taskName, null, token);
+    return new _TaskAPI(this._taskName, this._tableConfigMap, null, token);
   }
   /**
    * Creates a new task with the given data by calling the tasks API.
+   * After creation, fetches the full task data from the database to include all fields.
    * @param {Object} data The task data fields
    * @param {Object} options Optional settings like deferredUntil
-   * @returns {Promise<Task>} The created task
+   * @returns {Promise<Task>} The created task with all fields
    */
   async create(data = {}, options = {}) {
     const name = spanNameForModelAPI(this._taskName, "create");
@@ -2084,7 +2102,332 @@ var TaskAPI = class _TaskAPI {
         );
       }
       const result = await response.json();
-      return new Task(result, this._taskName, this._identity, this._authToken);
+      const task = await this.findOne({ id: result.id });
+      if (!task) {
+        throw new Error(`Failed to fetch created task with id: ${result.id}`);
+      }
+      return task;
+    });
+  }
+  /**
+   * Wraps an entity with Task methods by setting its prototype and adding required fields.
+   * @param {Object} entity The entity from ModelAPI
+   * @returns {Task} The entity with Task methods
+   */
+  _wrapAsTask(entity) {
+    if (!entity) return null;
+    entity._taskName = this._taskName;
+    entity._identity = this._identity;
+    entity._authToken = this._authToken;
+    Object.setPrototypeOf(entity, Task.prototype);
+    return entity;
+  }
+  /**
+   * Finds a single task matching the given conditions.
+   * Returns a Task instance with both entity fields and action methods.
+   * @param {Object} where Conditions to match
+   * @returns {Promise<Task|null>} The Task instance or null if not found
+   */
+  async findOne(where = {}) {
+    const entity = await this._modelAPI.findOne(where);
+    return this._wrapAsTask(entity);
+  }
+  /**
+   * Finds multiple tasks matching the given conditions.
+   * Returns Task instances with both entity fields and action methods.
+   * @param {Object} params Query parameters including where, limit, offset, orderBy
+   * @returns {Promise<Array<Task>>} Array of Task instances
+   */
+  async findMany(params = {}) {
+    const entities = await this._modelAPI.findMany(params);
+    return entities.map((entity) => this._wrapAsTask(entity));
+  }
+};
+
+// 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
+        }
+      };
     });
   }
 };
@@ -2262,6 +2605,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 +4215,7 @@ __name(ksuid, "ksuid");
   Duration,
   ErrorPresets,
   File,
+  FlowsAPI,
   InlineFile,
   KSUID,
   ModelAPI,