@volant-autonomy/via-sdk 1.0.1

package/dist/fetch.js

@@ -0,0 +1,197 @@
+"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.Fetcher = void 0;
+exports.default = createFetcher;
+const openapi_fetch_1 = require("openapi-fetch");
+const types_1 = require("./types");
+const querySerializer = (0, openapi_fetch_1.createQuerySerializer)();
+class Fetcher {
+    constructor(args) {
+        var _a, _b, _c, _d;
+        this.opts = {
+            url: (_a = args.url) !== null && _a !== void 0 ? _a : 'https://via.volantautonomy.com/api/v1.0',
+            fetchFn: (_b = args.fetchFn) !== null && _b !== void 0 ? _b : undefined,
+            authFetchFn: (_c = args.authFetchFn) !== null && _c !== void 0 ? _c : globalThis.fetch,
+            username: args.username,
+            password: args.password,
+            ignoreAuth: (_d = args.ignoreAuth) !== null && _d !== void 0 ? _d : false
+        };
+        this.aborts = {};
+        this.accessToken = undefined;
+        this.expiry = Date.now() - 5;
+    }
+    doAuth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // NOTE: THIS REQUEST IS NOT TYPE CHECKED PROPERLY AS paths IS NOT KNOWN HERE!
+            if (this.opts.username === undefined || this.opts.password === undefined) {
+                throw new types_1.UnauthenticatedError('ignoreAuth is not true and either username or password is missing');
+            }
+            const resp = yield this.opts.authFetchFn(this.opts.url + '/login', {
+                body: JSON.stringify({
+                    username: this.opts.username,
+                    password: this.opts.password
+                }),
+                redirect: 'follow'
+            });
+            if (resp.ok) {
+                const data = (yield resp.json());
+                this.expiry = Date.now() + data.expires_in - 10;
+                this.accessToken = data.access_token;
+            }
+            else {
+                throw new types_1.UnauthenticatedError('Invalid credentials');
+            }
+        });
+    }
+    /** Takes in an abort key to determine what abort signals should be fired and a new signal */
+    handleAbortKey(abortKey) {
+        var _a;
+        if (abortKey) {
+            (_a = this.aborts[abortKey]) === null || _a === void 0 ? void 0 : _a.abort();
+            const abortController = new AbortController();
+            this.aborts[abortKey] = abortController;
+            return abortController.signal;
+        }
+        return undefined;
+    }
+    /** Transforms an error from the api into an {@link SdkErrorModel} */
+    parseError(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const error = (yield response.json());
+            // NOTE: throws away the status codes inside of the individual errors
+            if (((_a = error === null || error === void 0 ? void 0 : error.errors) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+                return {
+                    status: String(response.status),
+                    errors: [
+                        {
+                            status: String(response.status),
+                            detail: ''
+                        }
+                    ]
+                };
+            }
+            else {
+                return {
+                    status: String(response.status),
+                    errors: error === null || error === void 0 ? void 0 : error.errors.map((err) => {
+                        return {
+                            status: String(err.status),
+                            detail: err.detail
+                        };
+                    })
+                };
+            }
+        });
+    }
+    // source: https://github.com/openapi-ts/openapi-typescript/blob/f21c05b9afcc89ee6ef73edab4045620b410eb01/packages/openapi-fetch/src/index.js#L447
+    createFinalURL(path, options) {
+        var _a;
+        let finalURL = `${this.opts.url}${path}`;
+        if (options === null || options === void 0 ? void 0 : options.path) {
+            finalURL = (0, openapi_fetch_1.defaultPathSerializer)(finalURL, options.path);
+        }
+        const search = querySerializer((_a = options.query) !== null && _a !== void 0 ? _a : {});
+        if (search) {
+            finalURL += `?${search}`;
+        }
+        return finalURL;
+    }
+    /** The actual fetch wrapper. It is type inference blind, beyond the parseAs type */
+    fetcher(method, path, data, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (!this.opts.ignoreAuth) {
+                if (!this.accessToken || this.expiry <= Date.now()) {
+                    yield this.doAuth();
+                }
+            }
+            const fetchFn = (_b = (_a = opts === null || opts === void 0 ? void 0 : opts.fetch) !== null && _a !== void 0 ? _a : this.opts.fetchFn) !== null && _b !== void 0 ? _b : globalThis.fetch;
+            const parseAs = (_c = opts === null || opts === void 0 ? void 0 : opts.parseAs) !== null && _c !== void 0 ? _c : 'json';
+            const request = new Request(this.createFinalURL(path, { query: data === null || data === void 0 ? void 0 : data.query, path: data === null || data === void 0 ? void 0 : data.path }), {
+                redirect: 'follow',
+                signal: this.handleAbortKey(opts === null || opts === void 0 ? void 0 : opts.abortKey),
+                body: JSON.stringify(data === null || data === void 0 ? void 0 : data.body),
+                headers: Object.assign({ 'Content-Type': 'application/json' }, data === null || data === void 0 ? void 0 : data.header),
+                method
+            });
+            if (!this.opts.ignoreAuth) {
+                request.headers.set('Authorization', `Bearer ${this.accessToken}`);
+            }
+            let response;
+            try {
+                response = yield fetchFn(request);
+            }
+            catch (err) {
+                if (err.name === 'AbortError') {
+                    return { aborted: true };
+                }
+                throw err;
+            }
+            if (response.status === 401) {
+                throw new types_1.UnauthenticatedError('Unauthenticated');
+            }
+            // handle empty content
+            // note: we return `{}` because we want user truthy checks for `.data` or `.error` to succeed
+            // NOTE: this does lie to the user, as we say it is undefined
+            if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                return response.ok
+                    ? { data: {}, aborted: false, response }
+                    : { error: {}, aborted: false, response };
+            }
+            if (response.ok) {
+                // if "stream", skip parsing entirely
+                if (parseAs === 'stream') {
+                    return { data: response.body, aborted: false, response };
+                }
+                return { data: yield response[parseAs](), aborted: false, response };
+            }
+            return { error: yield this.parseError(response), aborted: false };
+        });
+    }
+    GET(path, data, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetcher('get', path, data, opts);
+        });
+    }
+    PUT(path, data, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetcher('put', path, data, opts);
+        });
+    }
+    POST(path, data, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetcher('post', path, data, opts);
+        });
+    }
+    DELETE(path, data, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetcher('delete', path, data, opts);
+        });
+    }
+    OPTIONS(path, data, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetcher('options', path, data, opts);
+        });
+    }
+    HEAD(path, data, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetcher('post', path, data, opts);
+        });
+    }
+}
+exports.Fetcher = Fetcher;
+// 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 */
+function createFetcher(...args) {
+    return new Fetcher(...args);
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createSDK } from './client';
+export * from './utils';
+export { SdkErrorModel } from './fetch';
+export { schemas, UnauthenticatedError } from './types';
+export type { paths } from './volant-schema';
+export type { Direct } from './direct';
+export type { Composite } from './composite';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthenticatedError = exports.createSDK = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "createSDK", { enumerable: true, get: function () { return client_1.createSDK; } });
+__exportStar(require("./utils"), exports);
+var types_1 = require("./types");
+Object.defineProperty(exports, "UnauthenticatedError", { enumerable: true, get: function () { return types_1.UnauthenticatedError; } });

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+import type { components } from './volant-schema';
+export declare const sleep: (ms: number) => Promise<unknown>;
+/**
+ * Coerces typescript into more fully evaluating a type to make it more readable
+ * @example
+ * type X = {
+ * a: string | number
+ * } & {
+ *  a: string
+ * }
+ * Expand<X> == {a: string}
+ * // without expand it is not simplified by TS when being shown,
+ * // even though it is equivalent to just {a: string}
+ */
+export type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+/** The raw API schemas from openapi.json */
+export type schemas = components['schemas'];
+export type Waypoint = schemas['StartWaypoint'] | schemas['GotoWaypoint-Input'];
+export type Checkpoint = schemas['GotoPathingCheckpoint'] | schemas['StartPathingCheckpoint'];
+export declare class UnauthenticatedError extends Error {
+    name: string;
+}
+/**
+ * Gets the type of the body input for an endpoint
+ * @example
+ * bodyOf<paths["/login"]["post"]> = {username: string, password: string}
+ */
+export type bodyOf<T> = T extends {
+    requestBody: {
+        content: {
+            'application/json': infer P;
+        };
+    };
+} ? P : never;
+/** Gets the type of the query input for an endpoint */
+export type queryOf<T> = T extends {
+    parameters: {
+        query: infer P;
+    };
+} ? P : never;
+/** Gets the type of the path input for an endpoint */
+export type pathOf<T> = T extends {
+    parameters: {
+        path: infer P;
+    };
+} ? P : never;
+/** Gets the type of the header input for an endpoint */
+export type headerOf<T> = T extends {
+    parameters: {
+        header: infer P;
+    };
+} ? P : never;

package/dist/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthenticatedError = exports.sleep = void 0;
+// eslint-disable-next-line promise/param-names
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+exports.sleep = sleep;
+class UnauthenticatedError extends Error {
+    constructor() {
+        super(...arguments);
+        // Both properties are needed to allow for errors to be identified when used in scenarios such
+        // as 'PromiseRejectionEvent' such as:
+        // `if (errorEvent.reason.name === UnauthenticatedError.name)`
+        // In the above, the first is the instance property and the latter a class property
+        this.name = 'Unauthenticated';
+        // FIXME: this was valid in the via codebase for some reason.
+        // public static override name = 'Unauthenticated'
+    }
+}
+exports.UnauthenticatedError = UnauthenticatedError;

package/dist/utils.d.ts

@@ -0,0 +1,16 @@
+import { schemas, Checkpoint, Waypoint } from './types';
+/** Takes in an array of coordinates and flight options, and returns an array of checkpoints for use in the other functions */
+export declare function generateCheckpointsFromCoordinates(args: {
+    coordinates: Array<schemas['Wgs84Position']>;
+    options: schemas['PathingCheckpointParameters'];
+}): Checkpoint[];
+/** Takes in an array of coordinates and flight options, and returns an array of waypoints for use in the other functions */
+export declare function generateWaypointsFromCoordinates(args: {
+    coordinates: Array<schemas['Wgs84Position']>;
+    options: {
+        flight_parameters: schemas['FlightParameters'];
+        wind_parameters?: schemas['WindParameters'];
+    };
+}): Waypoint[];
+/** Converts from seconds since epoch to a RFC3339-formatted datetime string */
+export declare function rfcDateTime(secondsEpoch: EpochTimeStamp): string;

package/dist/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCheckpointsFromCoordinates = generateCheckpointsFromCoordinates;
+exports.generateWaypointsFromCoordinates = generateWaypointsFromCoordinates;
+exports.rfcDateTime = rfcDateTime;
+/** Takes in an array of coordinates and flight options, and returns an array of checkpoints for use in the other functions */
+function generateCheckpointsFromCoordinates(args) {
+    const { coordinates, options } = args;
+    if (coordinates.length <= 2) {
+        throw Error('Must have at least two coordinates');
+    }
+    const waypoints = [
+        {
+            type: 'start',
+            position: coordinates[0] // first coord exists because of length check above
+        }
+    ];
+    for (const position of coordinates.slice(1)) {
+        waypoints.push({
+            type: 'goto',
+            position,
+            parameters: options
+        });
+    }
+    return waypoints;
+}
+/** Takes in an array of coordinates and flight options, and returns an array of waypoints for use in the other functions */
+function generateWaypointsFromCoordinates(args) {
+    const { coordinates, options } = args;
+    if (coordinates.length <= 2) {
+        throw Error('Must have at least two coordinates');
+    }
+    const waypoints = [
+        {
+            type: 'start',
+            position: coordinates[0] // first coord exists because of length check above
+        }
+    ];
+    for (const position of coordinates.slice(1)) {
+        if (options.wind_parameters)
+            waypoints.push({
+                type: 'goto',
+                position,
+                flight_parameters: options.flight_parameters,
+                wind_parameters: options.wind_parameters
+            });
+        else
+            waypoints.push({
+                type: 'goto',
+                position,
+                flight_parameters: options.flight_parameters
+            });
+    }
+    return waypoints;
+}
+/** Converts from seconds since epoch to a RFC3339-formatted datetime string */
+function rfcDateTime(secondsEpoch) {
+    return new Date(secondsEpoch * 1000).toISOString().slice(0, 16) + 'Z';
+}