@parkingboss/api/dist/es6/api/queries.js

The Parking Boss API

import { isInterval, intervalString } from "../time";
export function queries(settings) {
    return {
        fetch: (method, url, query = {}, body = null, useAuthHeader = true) => apiFetch(settings, method, url, body, query, useAuthHeader),
        get: (url, query = {}, useAuthHeader = true) => apiFetch(settings, "GET", url, null, query, useAuthHeader),
        post: (url, query = {}, body = null, useAuthHeader = true) => apiFetch(settings, "POST", url, body, query, useAuthHeader),
    };
}
export class HttpError extends Error {
    status;
    constructor(message, status) {
        super(message);
        this.status = status;
    }
}
function loadAuthHeader(user) {
    return user && [user.type, user.token].filter((x) => x).join(" ");
}
async function resultJson(response) {
    let result;
    try {
        result = await response.clone().json();
    }
    catch (e) {
        result = { body: await response.text() };
    }
    let date = response.headers.get("Date") || response.headers.get("date");
    if (date) {
        date = new Date(date).toISOString();
    }
    let modified = response.headers.get("Last-Modified") ||
        response.headers.get("last-modified");
    if (modified) {
        modified = new Date(modified).toISOString();
    }
    let status = response.status;
    return Object.assign(result, {
        date,
        modified,
        status,
    });
}
function apiQuery(query, authHeader, settings) {
    const result = Object.assign({}, query, {
        viewpoint: query.viewpoint || new Date(),
        client: settings.client,
    });
    if (authHeader !== false) {
        result.Authorization =
            authHeader === true ? loadAuthHeader(settings.user) : authHeader;
    }
    return result;
}
function apiUrl(settings, url, query) {
    const fullUrl = new URL(settings.apiBase + url);
    Object.entries(query || {}).forEach(([key, val]) => {
        if (Array.isArray(val)) {
            val.forEach((v) => fullUrl.searchParams.append(key, v));
        }
        else if (isInterval(val)) {
            fullUrl.searchParams.append(key, intervalString(val));
        }
        else if (val instanceof Date) {
            fullUrl.searchParams.append(key, val.toISOString());
        }
        else if (val) {
            fullUrl.searchParams.append(key, val);
        }
    });
    return fullUrl.toString();
}
async function apiRequest(method, url, body) {
    try {
        const init = { method };
        if (body)
            init.body = body;
        return await self.fetch(url, init);
    }
    catch (e) {
        throw Object.assign(new Error("Network Error"), { url });
    }
}
async function apiFetch(settings, method, url, body = null, query = {}, authHeader = true) {
    const requested = new Date().toISOString();
    const fullUrl = apiUrl(settings, url, apiQuery(query, authHeader, settings));
    const result = await apiRequest(method, fullUrl, body);
    const json = await resultJson(result);
    if (json)
        json.requested = requested;
    if (result.ok) {
        return json;
    }
    else {
        throw Object.assign(new Error("API Error"), json);
    }
}