@volant-autonomy/via-sdk 1.3748.1 → 1.3760.1

package/dist/index.esm.js

@@ -13,6 +13,12 @@ class UnauthenticatedError extends Error {
     }
 }
 
+class StreamFailedError extends Error {
+}
+class TaskTimeoutError extends Error {
+}
+const PathingTaskTimeout = 30000;
+const ValidStreamTimeout = 5000;
 class Composite {
     constructor(direct) {
         this.direct = direct;
@@ -53,36 +59,107 @@ class Composite {
         return this.direct.modifyDraftFlightplan(id, data.attributes);
     }
     /// pathing tasks
-    /** Handles creating and polling a pathing task for you */
-    async doPathingTask(args) {
-        var _a, _b;
-        const { error, data } = await this.direct.createPathingTask(args);
-        if (error) {
-            return { error };
+    /**
+     * Handles fetching a pathing task once it has reached a final state. This will be completed through one of two
+     * methods:
+     *
+     * - Event stream (default) - Opens an event stream and optionally calls onMessage when the state changes. The
+     *   callback will not be called once the task is complete as the task being complete can be inferred from the stream
+     *   being closed.
+     *
+     * - Polling (fallback) - Occurs automatically if the connection to the event stream is unsuccessful or the stream
+     *   fails. Polls every 0.5s whilst queuing and every 0.2s whilst in progress. Note if onMessage is defined it is
+     *   called on every poll.
+     * @param taskId - A UUID value that identifies a pathing task
+     * @param onMessage - Callback that is called upon receiving details on the state of the pathing task
+     * @returns - The result of the pathing task
+     */
+    async getPathingTaskResult(taskId, onMessage) {
+        try {
+            await this.pathingTaskStreamResult(taskId, onMessage);
+        }
+        catch (error) {
+            if (error instanceof StreamFailedError) {
+                await this.pathingTaskPollResult(taskId, onMessage);
+            }
         }
-        const id = data.id;
-        while (true) {
-            const { data, error } = await this.direct.getPathingTask(id);
-            if (error) {
-                return { error };
+        return this.direct.getPathingTask(taskId);
+    }
+    /** Handles creating and waiting for the result of a pathing task. */
+    async doPathingTask(args) {
+        const createdTask = await this.direct.createPathingTask(args);
+        if (createdTask.error) {
+            return createdTask.error;
+        }
+        const id = createdTask.data.id;
+        return await this.getPathingTaskResult(id);
+    }
+    async pathingTaskStreamResult(taskId, onMessage) {
+        let streamConnectionTimeout;
+        let streamNotSuccessfulTimeout;
+        const promise = new Promise((resolve, reject) => {
+            const stream = this.direct.getPathingTaskStateStream(taskId);
+            streamConnectionTimeout = setTimeout(() => {
+                if (stream.readyState !== EventSource.OPEN) {
+                    stream.close();
+                    reject(new StreamFailedError('Timeout connecting'));
+                }
+            }, ValidStreamTimeout);
+            streamNotSuccessfulTimeout = setTimeout(() => {
+                stream.close();
+                reject(new TaskTimeoutError('Timeout whilst waiting for successful result'));
+            }, PathingTaskTimeout);
+            stream.onmessage = async (event) => {
+                // TODO(Jack): Use a discriminated union
+                const data = JSON.parse(event.data);
+                if (data.error === true) {
+                    stream.close();
+                    reject(new Error(`Task stream returned error: ${data.payload}`));
+                    return;
+                }
+                onMessage === null || onMessage === void 0 ? void 0 : onMessage(data.payload);
+                if (data.payload.terminated === true) {
+                    stream.close();
+                    resolve(data.payload);
+                }
+            };
+            stream.onerror = (error) => {
+                stream.close();
+                reject(new StreamFailedError(`Stream failed: ${error}`));
+            };
+        });
+        return promise.finally(() => {
+            clearTimeout(streamConnectionTimeout);
+            clearTimeout(streamNotSuccessfulTimeout);
+        });
+    }
+    async pathingTaskPollResult(taskId, onMessage) {
+        let runPathing = true;
+        while (runPathing) {
+            setTimeout(() => {
+                runPathing = false;
+            }, PathingTaskTimeout);
+            const pathingTaskResult = await this.direct.getPathingTask(taskId);
+            if (pathingTaskResult.error) {
+                return pathingTaskResult.error;
+            }
+            if (pathingTaskResult.data.meta.state === 'successful' ||
+                pathingTaskResult.data.meta.state === 'failed') {
+                return;
             }
-            switch (data.meta.state) {
+            const pathingTaskPayload = {
+                state: pathingTaskResult.data.meta.state,
+                terminated: false
+            };
+            // TODO: Make this only on change from previous
+            onMessage === null || onMessage === void 0 ? void 0 : onMessage(pathingTaskPayload);
+            switch (pathingTaskResult.data.meta.state) {
                 case 'queued':
                     await sleep(500);
-                    continue;
+                    break;
                 case 'in-progress':
-                    await sleep(50);
-                    continue;
-                case 'successful':
-                    if ((_a = data.attributes) === null || _a === void 0 ? void 0 : _a.waypoints) {
-                        return { data: (_b = data.attributes) === null || _b === void 0 ? void 0 : _b.waypoints };
-                    }
-                    else {
-                        throw new Error(`endpoint did not return waypoints ${data}`); // TODO:
-                    }
-                case 'failed':
-                    // TODO: this is bad, do this better.
-                    return { error: data.meta.error_code };
+                    await sleep(200);
+                    break;
             }
         }
     }
@@ -219,28 +296,9 @@ class Direct {
         }
         return resp;
     }
-    getPathingTaskStateStream(id, onMessage, onFail) {
-        return new Promise((resolve, reject) => {
-            const eventSource = new EventSource(`/api/v1.0/pathing_tasks/${id}/state`);
-            eventSource.onmessage = (event) => {
-                const data = JSON.parse(event.data);
-                if (data.error === true) {
-                    onFail === null || onFail === void 0 ? void 0 : onFail();
-                    eventSource.close();
-                    reject(new Error(`Task stream returned error: ${data.payload}`));
-                    return;
-                }
-                if (data.payload.terminated) {
-                    eventSource.close();
-                    resolve(data.payload);
-                }
-                onMessage === null || onMessage === void 0 ? void 0 : onMessage(data.payload);
-            };
-            eventSource.onerror = (err) => {
-                eventSource.close();
-                onFail === null || onFail === void 0 ? void 0 : onFail();
-                reject(err);
-            };
+    getPathingTaskStateStream(id) {
+        return this.fetcher.STREAM(`/pathing_tasks/{pathing_task_id}/state`, {
+            path: { pathing_task_id: id }
         });
     }
     /// charts
@@ -725,7 +783,7 @@ function defaultPathSerializer(pathname, pathParams) {
   return nextURL;
 }
 
-var version = "1.3748.1";
+var version = "1.3760.1";
 
 const querySerializer = createQuerySerializer();
 class Fetcher {
@@ -894,6 +952,14 @@ class Fetcher {
     async HEAD(path, data, opts) {
         return this.fetcher('post', path, data, opts);
     }
+    STREAM(path, data) {
+        const downcastedData = data;
+        const url = this.createFinalURL(path, {
+            query: downcastedData === null || downcastedData === void 0 ? void 0 : downcastedData.query,
+            path: downcastedData === null || downcastedData === void 0 ? void 0 : downcastedData.path
+        });
+        return new EventSource(url);
+    }
 }
 // indirection is required to get ts to accept the type magic
 //* * `paths` MUST be passed in as a generic type arg or type inference falls apart */