@volant-autonomy/via-sdk 1.3743.1 → 1.3757.1

package/dist/composite.d.ts

@@ -1,5 +1,12 @@
-import { createPathingTask, Direct } from './direct';
-import { schemas, Waypoint } from './types';
+import { createPathingTask, Direct, PathingTaskEvent } from './direct';
+import { schemas } from './types';
+export type StreamError = {
+    errors: {
+        detail: string;
+        status: string;
+    }[];
+    status: string;
+};
 export declare class Composite {
     private direct;
     constructor(direct: Direct);
@@ -160,8 +167,23 @@ export declare class Composite {
             status: "401" | "400" | "422" | "404";
         };
     }>;
-    /** Handles creating and polling a pathing task for you */
-    doPathingTask(args: createPathingTask['requestBody']['content']['application/json']): Promise<{
+    /**
+     * 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
+     */
+    getPathingTaskResult(taskId: string, onMessage?: (payload: PathingTaskEvent) => void): Promise<{
+        data?: never;
         error: {
             errors: {
                 detail: string;
@@ -169,12 +191,48 @@ export declare class Composite {
             }[];
             status: "401" | "400" | "422" | "404";
         };
-        data?: undefined;
+        response: Response;
+        aborted: false;
     } | {
-        data: Waypoint[];
-        error?: undefined;
+        data: {
+            id: string;
+            type?: "pathing_task";
+            attributes?: import("./volant-schema").components["schemas"]["PathingTaskAttributes"] | null;
+            meta: import("./volant-schema").components["schemas"]["PathingTaskMeta"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /** Handles creating and waiting for the result of a pathing task. */
+    doPathingTask(args: createPathingTask['requestBody']['content']['application/json']): Promise<{
+        errors: {
+            detail: string;
+            status: "401" | "400" | "422";
+        }[];
+        status: "401" | "400" | "422";
     } | {
-        error: number;
-        data?: undefined;
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | {
+        data: {
+            id: string;
+            type?: "pathing_task";
+            attributes?: import("./volant-schema").components["schemas"]["PathingTaskAttributes"] | null;
+            meta: import("./volant-schema").components["schemas"]["PathingTaskMeta"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
     }>;
+    private pathingTaskStreamResult;
+    private pathingTaskPollResult;
 }

package/dist/direct.d.ts

@@ -5,7 +5,7 @@ type requestOptions = {
     abortKey?: string;
     fetch?: typeof globalThis.fetch;
 };
-type PathingTaskEvent = {
+export type PathingTaskEvent = {
     state: PathingTaskState;
     terminated: boolean;
 };
@@ -608,7 +608,7 @@ export declare class Direct {
      *     task changes. Once it has reached it's final state, the last update is pushed and the stream is automatically
      *     closed.
      */
-    getPathingTaskStateStream(id: pathOf<getPathingTaskStateStream>['pathing_task_id'], onMessage?: (payload: PathingTaskEvent) => void, onFail?: () => void): Promise<PathingTaskEvent>;
+    getPathingTaskStateStream(id: pathOf<getPathingTaskStateStream>['pathing_task_id']): EventSource;
     /**
      * List all available Charts
      * @description List user's charts, including chart id and bounds.

package/dist/fetch.d.ts

@@ -119,6 +119,7 @@ export declare class Fetcher<Paths extends Record<string, Record<HttpMethod, {}>
     DELETE<Path extends PathsWithMethod<Paths, 'delete'>, Data extends MaybeOptionalParams<Paths[Path], 'delete'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["delete"], Opts>>;
     OPTIONS<Path extends PathsWithMethod<Paths, 'options'>, Data extends MaybeOptionalParams<Paths[Path], 'options'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["options"], Opts>>;
     HEAD<Path extends PathsWithMethod<Paths, 'head'>, Data extends MaybeOptionalParams<Paths[Path], 'head'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["head"], Opts>>;
+    STREAM<Path extends PathsWithMethod<Paths, 'get'>, Data extends MaybeOptionalParams<Paths[Path], 'get'>>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data): EventSource;
 }
 export default function createFetcher<Paths extends {}>(...args: ConstructorParameters<typeof Fetcher>): Fetcher<Paths>;
 export {};

package/dist/index.cjs.js

@@ -15,6 +15,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;
@@ -55,36 +61,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;
             }
         }
     }
@@ -221,28 +298,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
@@ -727,7 +785,7 @@ function defaultPathSerializer(pathname, pathParams) {
   return nextURL;
 }
 
-var version = "1.3743.1";
+var version = "1.3757.1";
 
 const querySerializer = createQuerySerializer();
 class Fetcher {
@@ -896,6 +954,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 */