@binaris/spice-node-client/client.js

"use strict";
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
// tslint:disable
const node_fetch_1 = require("node-fetch");
const abort_controller_1 = require("abort-controller");
const common_1 = require("./common");
exports.ValidationError = common_1.ValidationError;
const interfaces_1 = require("./interfaces");
class RequestError extends Error {
    constructor(message, 
    /**
     * The original error causing this request to fail
     * Inherits Error in case of network or parse errors
     * In case of an invalid HTTP response it will contain an object with the body/trimmed text of the response
     */
    cause, method, options) {
        super(message);
        this.cause = cause;
        this.method = method;
        this.options = options;
        this.name = 'RequestError';
    }
}
exports.RequestError = RequestError;
class TimeoutError extends Error {
    constructor(message, method, options) {
        super(message);
        this.method = method;
        this.options = options;
        this.name = 'TimeoutError';
    }
}
exports.TimeoutError = TimeoutError;
class LycanClient {
    constructor(serverUrl, options = {}) {
        this.serverUrl = serverUrl;
        this.options = options;
        this.props = interfaces_1.schema.definitions.Lycan.properties;
        this.validators = LycanClient.validators;
    }
    async createTicket(options) {
        const body = {};
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/createTicket`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'createTicket', mergedOptions);
            }
            throw new RequestError(err.message, err, 'createTicket', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.createTicket;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'createTicket', mergedOptions);
    }
    async claimTicket(ticket, options) {
        const body = {
            ticket,
        };
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/claimTicket`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'claimTicket', mergedOptions);
            }
            throw new RequestError(err.message, err, 'claimTicket', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.claimTicket;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'NotFoundError') {
                throw new interfaces_1.NotFoundError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'claimTicket', mergedOptions);
    }
    async listTemplates(options) {
        const body = {};
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/listTemplates`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'listTemplates', mergedOptions);
            }
            throw new RequestError(err.message, err, 'listTemplates', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.listTemplates;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'listTemplates', mergedOptions);
    }
    async tryTemplate(id, options) {
        const body = {
            id,
        };
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/tryTemplate`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'tryTemplate', mergedOptions);
            }
            throw new RequestError(err.message, err, 'tryTemplate', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.tryTemplate;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'NotFoundError') {
                throw new interfaces_1.NotFoundError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'tryTemplate', mergedOptions);
    }
    async whoami(options) {
        const body = {};
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/whoami`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'whoami', mergedOptions);
            }
            throw new RequestError(err.message, err, 'whoami', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.whoami;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'UnauthorizedError') {
                throw new interfaces_1.UnauthorizedError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'whoami', mergedOptions);
    }
    async listApps(options) {
        const body = {};
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/listApps`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'listApps', mergedOptions);
            }
            throw new RequestError(err.message, err, 'listApps', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.listApps;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'UnauthorizedError') {
                throw new interfaces_1.UnauthorizedError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'listApps', mergedOptions);
    }
    async getApp(id, options) {
        const body = {
            id,
        };
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/getApp`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'getApp', mergedOptions);
            }
            throw new RequestError(err.message, err, 'getApp', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.getApp;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'UnauthorizedError') {
                throw new interfaces_1.UnauthorizedError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'getApp', mergedOptions);
    }
    async deployInitial(env, name, digest, envVars, options) {
        const body = {
            env,
            name,
            digest,
            envVars,
        };
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/deployInitial`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'deployInitial', mergedOptions);
            }
            throw new RequestError(err.message, err, 'deployInitial', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.deployInitial;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'UnauthorizedError') {
                throw new interfaces_1.UnauthorizedError(responseBody.message);
            }
            if (responseBody.name === 'ExistsError') {
                throw new interfaces_1.ExistsError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'deployInitial', mergedOptions);
    }
    async deploy(appId, env, digest, envVars, options) {
        const body = {
            appId,
            env,
            digest,
            envVars,
        };
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/deploy`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'deploy', mergedOptions);
            }
            throw new RequestError(err.message, err, 'deploy', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.deploy;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'UnauthorizedError') {
                throw new interfaces_1.UnauthorizedError(responseBody.message);
            }
            if (responseBody.name === 'NotFoundError') {
                throw new interfaces_1.NotFoundError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'deploy', mergedOptions);
    }
    async claimApp(token, options) {
        const body = {
            token,
        };
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/claimApp`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'claimApp', mergedOptions);
            }
            throw new RequestError(err.message, err, 'claimApp', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.claimApp;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'UnauthorizedError') {
                throw new interfaces_1.UnauthorizedError(responseBody.message);
            }
            if (responseBody.name === 'NotFoundError') {
                throw new interfaces_1.NotFoundError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'claimApp', mergedOptions);
    }
    async getLogs(appId, env, opts, options) {
        const body = {
            appId,
            env,
            opts,
        };
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/getLogs`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'getLogs', mergedOptions);
            }
            throw new RequestError(err.message, err, 'getLogs', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.getLogs;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'UnauthorizedError') {
                throw new interfaces_1.UnauthorizedError(responseBody.message);
            }
            if (responseBody.name === 'NotFoundError') {
                throw new interfaces_1.NotFoundError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'getLogs', mergedOptions);
    }
    async destroyApp(appId, options) {
        const body = {
            appId,
        };
        const mergedOptions = Object.assign(Object.assign({ serverUrl: this.serverUrl }, this.options), options);
        const { fetchImplementation, timeoutMs, headers, serverUrl } = mergedOptions, fetchOptions = __rest(mergedOptions, ["fetchImplementation", "timeoutMs", "headers", "serverUrl"]);
        const fetchImpl = fetchImplementation || node_fetch_1.default;
        let timeout;
        if (timeoutMs) {
            const controller = new abort_controller_1.default();
            timeout = setTimeout(() => controller.abort(), timeoutMs);
            fetchOptions.signal = controller.signal;
        }
        let response;
        let responseBody;
        let responseText;
        let isJSON;
        try {
            response = await fetchImpl(`${serverUrl}/destroyApp`, Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }), body: JSON.stringify(body), method: 'POST' }));
            isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
            if (isJSON) {
                responseBody = await response.json();
            }
            else {
                responseText = await response.text();
            }
        }
        catch (err) {
            if (err.message === 'The user aborted a request.') {
                timeout = undefined;
                throw new TimeoutError('Request aborted due to timeout', 'destroyApp', mergedOptions);
            }
            throw new RequestError(err.message, err, 'destroyApp', mergedOptions);
        }
        finally {
            if (timeout)
                clearTimeout(timeout);
        }
        if (response.status >= 200 && response.status < 300) {
            const validator = this.validators.destroyApp;
            const wrapped = { returns: responseBody }; // wrapped for coersion
            if (!validator(wrapped)) {
                throw new common_1.ValidationError('Failed to validate response', validator.errors);
            }
            return wrapped.returns;
        }
        else if (!isJSON) {
            // fall through to throw
        }
        else if (response.status === 400) {
            if (responseBody.name === 'ValidationError') {
                throw new common_1.ValidationError(responseBody.message, responseBody.errors);
            }
        }
        else if (response.status === 500) {
            if (responseBody.name === 'UnauthorizedError') {
                throw new interfaces_1.UnauthorizedError(responseBody.message);
            }
            if (responseBody.name === 'NotFoundError') {
                throw new interfaces_1.NotFoundError(responseBody.message);
            }
            throw new interfaces_1.InternalServerError(responseBody.message);
        }
        throw new RequestError(`${response.status} - ${response.statusText}`, { responseText: responseText && responseText.slice(0, 256), responseBody }, 'destroyApp', mergedOptions);
    }
}
exports.LycanClient = LycanClient;
LycanClient.methods = [
    'createTicket',
    'claimTicket',
    'listTemplates',
    'tryTemplate',
    'whoami',
    'listApps',
    'getApp',
    'deployInitial',
    'deploy',
    'claimApp',
    'getLogs',
    'destroyApp',
];
LycanClient.validators = common_1.createReturnTypeValidator(interfaces_1.schema, 'Lycan');
//# sourceMappingURL=client.js.map