@teamkeel/functions-runtime 0.430.0 → 0.432.0

package/dist/index.js

@@ -343,7 +343,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");
@@ -1033,9 +1039,7 @@ var opMapping = {
   equals: {
     op: /* @__PURE__ */ __name((v) => v === null || Array.isArray(v) ? sql2`is not distinct from` : "=", "op")
   },
-  notEquals: {
-    op: /* @__PURE__ */ __name((v) => v === null || Array.isArray(v) ? sql2`is distinct from` : "!=", "op")
-  },
+  notEquals: { op: sql2`is distinct from` },
   equalsRelative: {
     op: sql2`BETWEEN`,
     value: /* @__PURE__ */ __name((v) => sql2`${sql2.raw(
@@ -1797,72 +1801,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");
@@ -1881,12 +1864,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");
@@ -1904,12 +1887,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");
@@ -1927,14 +1910,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");
@@ -1953,12 +1936,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");
@@ -1976,7 +1959,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);
     });
   }
 };
@@ -1986,13 +1992,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 = 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.
@@ -2000,7 +2010,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.
@@ -2008,13 +2018,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");
@@ -2039,9 +2050,46 @@ 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