@volant-autonomy/via-sdk 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Volant Autonomy 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# Volant Via SDK
+
+`@volant-autonomy/via-sdk` is an auto-generated type-safe wrapper for the Via API with automatic authentication handling.
+Usable in TypeScript or JavaScript.
+
+**Note:** To use this SDK you need access to [the Via API](https://via.volantautonomy.com/api/v1.0/docs). Please contact us at via@volantautonomy.com to obtain access.
+
+## Installation
+
+Run `npm install --save @volant-autonomy/via-sdk` to add the SDK as a dependency.
+
+## Basic usage
+
+```typescript
+import createSDK from '@volant-autonomy/via-sdk'
+
+const SDK = createSDK({
+  username: "username",
+  password: "password"
+})
+
+const {error, data} = await SDK.direct.getAllAircraft()
+```
+
+## Further information
+
+### SDK Layout
+
+The SDK is split into three parts:
+
+- Direct: Gives you direct access to every single API endpoint, returning the raw data
+- Composite: Convenient wrappers around multi-endpoint operations
+- Schemas: Every schema from the api as a TypeScript type
+
+### Auth
+
+If you provide a username and password, the SDK will automatically check for expiry and refresh the authentication token whenever you make a request.
+
+### Request data format
+
+In the API, data may be passed in through the body, the URL, the query, the header, etc. The SDK simplifies this, and just always takes data in as function arguments.
+
+For example, `GET /flightplans/` takes in a filter from a query parameter. The SDK does this through function arguments, ie: `SDK.direct.getAllFlightplans(['Accepted'])` would filter for only accepted flightplans.
+
+Another example, `GET /flightplans/{flightplan_id}` takes in a flightplan ID through the path. The SDK does this through function arguments, ie: `SDK.direct.getFlightplan('aaaaa-bbbbb-ccccc')`
+
+### Response data format
+
+Direct functions return an object with a data field and an error field. Only exactly one of these is defined, the other is undefined.
+
+The data returned is also not *identical* to the API, as any "links" are skipped over, to make the data easier to use.
+
+For example, if the API would've returned:
+
+```js
+{
+  link:"/url",
+  data: [
+    {data: 1, link: "/url"}, 
+    {data: 2, link: "/url"}
+  ]
+}
+```
+
+The SDK will instead just return `[1,2]`.
+
+Keeping this in mind, [the API documentation](https://via.volantautonomy.com/api/v1.0/docs) is a great place to look for more information

package/dist/client.d.ts

@@ -0,0 +1,7 @@
+import { Composite } from './composite';
+import { Direct } from './direct';
+import { FetcherArgs } from './fetch';
+export declare function createSDK(opts: Partial<FetcherArgs>): {
+    direct: Direct;
+    composite: Composite;
+};

package/dist/client.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSDK = createSDK;
+const composite_1 = require("./composite");
+const direct_1 = require("./direct");
+const fetch_1 = __importDefault(require("./fetch"));
+const types_1 = require("./types");
+function createSDK(opts) {
+    if (!opts.ignoreAuth && (opts.username === undefined || opts.password === undefined)) {
+        throw new types_1.UnauthenticatedError('ignoreAuth is not true and either username or password is missing');
+    }
+    const fetcher = (0, fetch_1.default)(opts);
+    const newDirect = new direct_1.Direct(fetcher);
+    return {
+        direct: newDirect,
+        composite: new composite_1.Composite(newDirect)
+    };
+}

package/dist/composite.d.ts

@@ -0,0 +1,150 @@
+import { createPathingTask, Direct } from './direct';
+import { schemas, Waypoint } from './types';
+export declare class Composite {
+    private direct;
+    constructor(direct: Direct);
+    upsertFlightplan(args: schemas['Flightplan-Input'], id: string | null | undefined): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "403" | "404";
+            }[];
+            status: "401" | "400" | "422" | "403" | "404";
+        };
+        response: Response;
+        aborted: false;
+    } | {
+        data: {
+            id: string;
+            type?: "flightplan";
+            meta: import("./volant-schema").components["schemas"]["FlightplanMeta"];
+            attributes: import("./volant-schema").components["schemas"]["Flightplan-Output"];
+        };
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    getAllDraftFlightplans(): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422";
+            }[];
+            status: "401" | "400" | "422";
+        };
+        response: Response;
+        aborted: false;
+    } | {
+        data: {
+            id: string;
+            type?: "flightplan";
+            meta: import("./volant-schema").components["schemas"]["FlightplanMeta"];
+            attributes: import("./volant-schema").components["schemas"]["Flightplan-Output"];
+        }[];
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    getAllClosedFlightplans(): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422";
+            }[];
+            status: "401" | "400" | "422";
+        };
+        response: Response;
+        aborted: false;
+    } | {
+        data: {
+            id: string;
+            type?: "flightplan";
+            meta: import("./volant-schema").components["schemas"]["FlightplanMeta"];
+            attributes: import("./volant-schema").components["schemas"]["Flightplan-Output"];
+        }[];
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    getAllPendingFlightplans(): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422";
+            }[];
+            status: "401" | "400" | "422";
+        };
+        response: Response;
+        aborted: false;
+    } | {
+        data: {
+            id: string;
+            type?: "flightplan";
+            meta: import("./volant-schema").components["schemas"]["FlightplanMeta"];
+            attributes: import("./volant-schema").components["schemas"]["Flightplan-Output"];
+        }[];
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    getAllAcceptedFlightplans(): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422";
+            }[];
+            status: "401" | "400" | "422";
+        };
+        response: Response;
+        aborted: false;
+    } | {
+        data: {
+            id: string;
+            type?: "flightplan";
+            meta: import("./volant-schema").components["schemas"]["FlightplanMeta"];
+            attributes: import("./volant-schema").components["schemas"]["Flightplan-Output"];
+        }[];
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    attemptAcceptFlightplan(id: string): Promise<{
+        data?: never;
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404" | "409";
+            }[];
+            status: "401" | "400" | "422" | "404" | "409";
+        };
+        response: Response;
+        aborted: false;
+    } | {
+        data: boolean;
+        error?: never;
+        response: Response;
+        aborted: false;
+    }>;
+    /** Handles creating and polling a pathing task for you */
+    doPathingTask(args: createPathingTask['requestBody']['content']['application/json']): Promise<{
+        error: {
+            errors: {
+                detail: string;
+                status: "401" | "400" | "422" | "404";
+            }[];
+            status: "401" | "400" | "422" | "404";
+        };
+        data?: undefined;
+    } | {
+        data: Waypoint[];
+        error?: undefined;
+    } | {
+        error: number;
+        data?: undefined;
+    }>;
+}

package/dist/composite.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Composite = void 0;
+const types_1 = require("./types");
+class Composite {
+    constructor(direct) {
+        this.direct = direct;
+    }
+    /// flightplans
+    upsertFlightplan(args, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (id) {
+                return this.direct.modifyDraftFlightplan(id, args);
+            }
+            else {
+                return this.direct.createDraftFlightplan(args);
+            }
+        });
+    }
+    getAllDraftFlightplans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.direct.getAllFlightplans(['Draft']);
+        });
+    }
+    getAllClosedFlightplans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.direct.getAllFlightplans(['Closed']);
+        });
+    }
+    getAllPendingFlightplans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.direct.getAllFlightplans(['Pending']);
+        });
+    }
+    getAllAcceptedFlightplans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.direct.getAllFlightplans(['Accepted']);
+        });
+    }
+    // TODO: make error 409 more obvious, as it is different
+    attemptAcceptFlightplan(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.direct.changeFlightplanState(id, 'Accepted');
+        });
+    }
+    /// pathing tasks
+    /** Handles creating and polling a pathing task for you */
+    doPathingTask(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { error, data } = yield this.direct.createPathingTask(args);
+            if (error) {
+                return { error };
+            }
+            const id = data.id;
+            while (true) {
+                const { data, error } = yield this.direct.getPathingTask(id);
+                if (error) {
+                    return { error };
+                }
+                switch (data.meta.state) {
+                    case 'queued':
+                        yield (0, types_1.sleep)(500);
+                        continue;
+                    case 'in-progress':
+                        yield (0, types_1.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 };
+                }
+            }
+        });
+    }
+}
+exports.Composite = Composite;