@metacall/protocol 0.1.28 → 0.1.30

package/dist/index.d.ts

@@ -6,5 +6,5 @@ export * from './plan';
 export * from './protocol';
 export * from './signup';
 export * from './token';
-import metacallAPI from './protocol';
-export default metacallAPI;
+import Protocol from './protocol';
+export default Protocol;

package/dist/login.js

@@ -1,24 +1,26 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = __importDefault(require("axios"));
 const url_1 = require("url");
-exports.default = (email, password, baseURL) => {
+exports.default = async (email, password, baseURL) => {
     const request = {
         email,
         password
     };
-    if (!baseURL.includes('localhost'))
-        request['g-recaptcha-response'] = 'empty'; //TODO: Review the captcha
-    return axios_1.default
-        .post(baseURL + '/login', request, {
+    if (!baseURL.includes('localhost')) {
+        request['g-recaptcha-response'] = 'empty'; // TODO: Review the captcha
+    }
+    const res = await fetch(baseURL + '/login', {
+        method: 'POST',
         headers: {
             Accept: 'application/json, text/plain, */*',
             Host: new url_1.URL(baseURL).host,
-            Origin: baseURL
-        }
-    })
-        .then(res => res.data);
+            Origin: baseURL,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(request)
+    });
+    if (!res.ok) {
+        throw new Error(res.statusText);
+    }
+    return res.text();
 };

package/dist/protocol.d.ts

@@ -1,13 +1,16 @@
-import { AxiosError } from 'axios';
 import { Create, Deployment, LogType, MetaCallJSON } from './deployment';
 import { Plans } from './plan';
+export declare class ProtocolError extends Error {
+    status?: number;
+    data?: unknown;
+    constructor(message: string, status?: number, data?: unknown);
+}
 /**
- * Type guard for protocol-specific errors (Axios errors in this case).
+ * Type guard for protocol-specific errors.
  * @param err - The unknown error to check.
  * @returns True if the error is an ProtocolError, false otherwise.
  */
-export declare const isProtocolError: (err: unknown) => boolean;
-export { AxiosError as ProtocolError };
+export declare const isProtocolError: (err: unknown) => err is ProtocolError;
 declare type SubscriptionMap = Record<string, number>;
 export interface SubscriptionDeploy {
     id: string;
@@ -19,7 +22,7 @@ export declare enum ResourceType {
     Package = "Package",
     Repository = "Repository"
 }
-export interface AddResponse {
+export interface Resource {
     id: string;
 }
 export interface Branches {
@@ -66,8 +69,8 @@ export interface API {
     listSubscriptionsDeploys(): Promise<SubscriptionDeploy[]>;
     inspect(): Promise<Deployment[]>;
     inspectByName(suffix: string): Promise<Deployment>;
-    upload(name: string, blob: unknown, jsons?: MetaCallJSON[], runners?: string[]): Promise<string>;
-    add(url: string, branch: string, jsons: MetaCallJSON[]): Promise<AddResponse>;
+    upload(name: string, blob: unknown, jsons?: MetaCallJSON[], runners?: string[]): Promise<Resource>;
+    add(url: string, branch: string, jsons: MetaCallJSON[]): Promise<Resource>;
     deploy(name: string, env: {
         name: string;
         value: string;
@@ -82,8 +85,8 @@ export interface API {
 }
 declare const _default: (token: string, baseURL: string) => API;
 export default _default;
-export declare const MaxRetries = 30;
-export declare const MaxRetryInterval = 2000;
+export declare const MaxRetries = 100;
+export declare const MaxRetryInterval = 5000;
 export declare const MaxFuncLength = 64;
 /**
  * Executes an asynchronous function with automatic retry logic.
@@ -122,4 +125,4 @@ export declare const MaxFuncLength = 64;
  * );
  * ```
  */
-export declare const waitFor: <T>(fn: () => Promise<T>, maxRetries?: number, interval?: number) => Promise<T>;
+export declare const waitFor: <T>(fn: (cancel: (message: string) => void) => Promise<T>, maxRetries?: number, interval?: number) => Promise<T>;

package/dist/protocol.js

@@ -1,9 +1,7 @@
 "use strict";
 /*
-
-* About File:
-
-    this is just a client that implements all the rest API from the FaaS, so each function it contains is an endpoint in the FaaS for deploying and similar
+    This is just a client that implements all the rest API from the FaaS,
+    so each function it contains is an endpoint in the FaaS for deploying:
 
     refresh: updates the auth token
     validate: validates the auth token
@@ -18,41 +16,26 @@
     branchList: get the branches of a repository
     fileList: get files of a repository by branch
 */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitFor = exports.MaxFuncLength = exports.MaxRetryInterval = exports.MaxRetries = exports.InvokeType = exports.ResourceType = exports.ProtocolError = exports.isProtocolError = void 0;
-const axios_1 = __importStar(require("axios"));
-Object.defineProperty(exports, "ProtocolError", { enumerable: true, get: function () { return axios_1.AxiosError; } });
-const form_data_1 = __importDefault(require("form-data"));
+exports.waitFor = exports.MaxFuncLength = exports.MaxRetryInterval = exports.MaxRetries = exports.InvokeType = exports.ResourceType = exports.isProtocolError = exports.ProtocolError = void 0;
+const stream_1 = require("stream");
 const url_1 = require("url");
 const deployment_1 = require("./deployment");
+class ProtocolError extends Error {
+    constructor(message, status, data) {
+        super(message);
+        this.name = 'ProtocolError';
+        this.status = status;
+        this.data = data;
+    }
+}
+exports.ProtocolError = ProtocolError;
 /**
- * Type guard for protocol-specific errors (Axios errors in this case).
+ * Type guard for protocol-specific errors.
  * @param err - The unknown error to check.
  * @returns True if the error is an ProtocolError, false otherwise.
  */
-const isProtocolError = (err) => axios_1.default.isAxiosError(err);
+const isProtocolError = (err) => err instanceof ProtocolError;
 exports.isProtocolError = isProtocolError;
 var ResourceType;
 (function (ResourceType) {
@@ -64,33 +47,91 @@ var InvokeType;
     InvokeType["Call"] = "call";
     InvokeType["Await"] = "await";
 })(InvokeType = exports.InvokeType || (exports.InvokeType = {}));
-exports.default = (token, baseURL) => {
-    const getURL = (path) => new url_1.URL(path, baseURL).toString();
-    const getConfig = (headers = {}) => {
-        return {
-            headers: {
-                Authorization: 'jwt ' + token,
-                ...headers
-            }
+class Request {
+    constructor(token, baseURL) {
+        this.token = token;
+        this.baseURL = baseURL;
+        this.impl = {
+            url: '',
+            headers: new Headers({
+                Authorization: 'jwt ' + this.token
+            }),
+            method: 'GET',
+            body: undefined
         };
-    };
+    }
+    url(path) {
+        this.impl.url = new url_1.URL(path, this.baseURL).toString();
+        return this;
+    }
+    headers(headers = {}) {
+        this.impl.headers = new Headers({
+            Authorization: 'jwt ' + this.token,
+            ...headers
+        });
+        return this;
+    }
+    method(method) {
+        this.impl.method = method;
+        return this;
+    }
+    bodyRaw(body) {
+        this.impl.body = body;
+        return this;
+    }
+    body(body) {
+        this.impl.body = JSON.stringify(body);
+        this.impl.headers.set('Content-Type', 'application/json');
+        return this;
+    }
+    async execute() {
+        const config = {
+            method: this.impl.method,
+            headers: this.impl.headers
+        };
+        if (this.impl.body !== undefined) {
+            config.body = this.impl.body;
+        }
+        const res = await fetch(this.impl.url, config);
+        if (!res.ok) {
+            const data = await res.text().catch(() => null);
+            throw new Error(`HTTP ${res.status}: ${res.statusText}${data ? ` - ${data}` : ''}`);
+        }
+        return res;
+    }
+    async asJson() {
+        const res = await this.execute();
+        return res.json();
+    }
+    async asText() {
+        const res = await this.execute();
+        return res.text();
+    }
+    async asStatus() {
+        const res = await this.execute();
+        return res.status;
+    }
+    async asResponse() {
+        return await this.execute();
+    }
+}
+exports.default = (token, baseURL) => {
+    const request = (url = baseURL) => new Request(token, url);
+    const hostname = new url_1.URL(baseURL).hostname;
     const api = {
-        refresh: () => axios_1.default
-            .get(getURL('/api/account/refresh-token'), getConfig())
-            .then(res => res.data),
-        ready: () => axios_1.default
-            .get(getURL('/api/readiness'), getConfig())
-            .then(res => res.status == 200),
-        validate: () => axios_1.default
-            .get(getURL('/validate'), getConfig())
-            .then(res => res.data),
-        deployEnabled: () => axios_1.default
-            .get(getURL('/api/account/deploy-enabled'), getConfig())
-            .then(res => res.data),
+        refresh: () => request().url('/api/account/refresh-token').asText(),
+        ready: () => request()
+            .url('/api/readiness')
+            .asStatus()
+            .then(status => status === 200),
+        validate: () => request().url('/validate').asJson(),
+        deployEnabled: () => request().url('/api/account/deploy-enabled').asJson(),
         listSubscriptions: async () => {
-            const res = await axios_1.default.get(getURL('/api/billing/list-subscriptions'), getConfig());
+            const subscriptionsList = await request()
+                .url('/api/billing/list-subscriptions')
+                .asJson();
             const subscriptions = {};
-            for (const id of res.data) {
+            for (const id of subscriptionsList) {
                 if (subscriptions[id] === undefined) {
                     subscriptions[id] = 1;
                 }
@@ -100,12 +141,10 @@ exports.default = (token, baseURL) => {
             }
             return subscriptions;
         },
-        listSubscriptionsDeploys: () => axios_1.default
-            .get(getURL('/api/billing/list-subscriptions-deploys'), getConfig())
-            .then(res => res.data),
-        inspect: () => axios_1.default
-            .get(getURL('/api/inspect'), getConfig())
-            .then(res => res.data),
+        listSubscriptionsDeploys: () => request()
+            .url('/api/billing/list-subscriptions')
+            .asJson(),
+        inspect: () => request().url('/api/inspect').asJson(),
         inspectByName: async (suffix) => {
             const deployments = await api.inspect();
             const deploy = deployments.find(deploy => deploy.suffix == suffix);
@@ -114,79 +153,118 @@ exports.default = (token, baseURL) => {
             }
             return deploy;
         },
-        upload: async (name, blob, jsons = [], runners = []) => {
-            const fd = new form_data_1.default();
+        upload: async (name, data, jsons = [], runners = []) => {
+            const fd = new FormData();
             fd.append('id', name);
             fd.append('type', 'application/x-zip-compressed');
             fd.append('jsons', JSON.stringify(jsons));
             fd.append('runners', JSON.stringify(runners));
-            fd.append('raw', blob, {
-                filename: 'blob',
-                contentType: 'application/x-zip-compressed'
-            });
-            const res = await axios_1.default.post(getURL('/api/package/create'), fd, getConfig() // Axios automatically sets multipart headers
-            );
-            return res.data;
+            if (data instanceof Blob) {
+                fd.append('raw', data, `${name}.zip`);
+            }
+            else if (data instanceof stream_1.Readable) {
+                // This is terrible but NodeJS does not ensure that streaming and zero
+                // copy will be performed anyway, as the sizes are not really big (150mb is the limit)
+                // we can do this nasty intermediate buffer creation and forget about it
+                const chunks = [];
+                for await (const chunk of data) {
+                    chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+                }
+                const buffer = Buffer.concat(chunks);
+                fd.append('raw', new Blob([buffer]), `${name}.zip`);
+            }
+            else {
+                throw Error(`Type ${typeof data} not supported, use Blob or Readable`);
+            }
+            return await request()
+                .url('/api/package/create')
+                .method('POST')
+                .bodyRaw(fd)
+                .asJson();
         },
-        add: (url, branch, jsons = []) => axios_1.default
-            .post(getURL('/api/repository/add'), {
+        add: (url, branch, jsons = []) => request()
+            .url('/api/repository/add')
+            .method('POST')
+            .body({
             url,
             branch,
             jsons
-        }, getConfig())
-            .then(res => res.data),
-        branchList: (url) => axios_1.default
-            .post(getURL('/api/repository/branchlist'), {
+        })
+            .asJson(),
+        branchList: (url) => request()
+            .url('/api/repository/branchlist')
+            .method('POST')
+            .body({
             url
-        }, getConfig())
-            .then(res => res.data),
-        deploy: (name, env, plan, resourceType, release = Date.now().toString(16), version = 'v1') => axios_1.default
-            .post(getURL('/api/deploy/create'), {
+        })
+            .asJson(),
+        deploy: (name, env, plan, resourceType, release = Date.now().toString(16), version = 'v1') => request()
+            .url('/api/deploy/create')
+            .method('POST')
+            .body({
             resourceType,
             suffix: name,
             release,
             env,
             plan,
             version
-        }, getConfig())
-            .then(res => res.data),
-        deployDelete: (prefix, suffix, version = 'v1') => axios_1.default
-            .post(getURL('/api/deploy/delete'), {
+        })
+            .asJson(),
+        deployDelete: (prefix, suffix, version = 'v1') => request()
+            .url('/api/deploy/delete')
+            .method('POST')
+            .body({
             prefix,
             suffix,
             version
-        }, getConfig())
-            .then(res => res.data),
-        logs: (container, type = deployment_1.LogType.Deploy, suffix, prefix, version = 'v1') => axios_1.default
-            .post(getURL('/api/deploy/logs'), {
+        })
+            .asJson(),
+        logs: (container, type = deployment_1.LogType.Deploy, suffix, prefix, version = 'v1') => request()
+            .url('/api/deploy/logs')
+            .method('POST')
+            .body({
             container,
             type,
             suffix,
             prefix,
             version
-        }, getConfig())
-            .then(res => res.data),
-        fileList: (url, branch) => axios_1.default
-            .post(getURL('/api/repository/filelist'), {
+        })
+            .asJson(),
+        fileList: (url, branch) => request()
+            .url('/api/repository/filelist')
+            .method('POST')
+            .body({
             url,
             branch
-        }, getConfig())
-            .then(res => res.data['files']),
-        invoke: (type, prefix, suffix, version = 'v1', name, args) => {
-            const url = getURL(`/${prefix}/${suffix}/${version}/${type}/${name}`);
-            const config = getConfig();
-            const req = args === undefined
-                ? axios_1.default.get(url, config)
-                : axios_1.default.post(url, args, config);
-            return req.then(res => res.data);
+        })
+            .asJson()
+            .then(res => res['files']),
+        invoke: async (type, prefix, suffix, version = 'v1', name, args) => {
+            const req = (() => {
+                if (hostname === 'localhost') {
+                    // Old API in commercial FaaS and current API of FaaS reimplementation
+                    return request().url(`/${prefix}/${suffix}/${version}/${type}/${name}`);
+                }
+                else {
+                    // New API used by commercial FaaS
+                    return request(`https://${version}-${suffix}-${prefix}.api.metacall.io`).url(`/${type}/${name}`);
+                }
+            })();
+            if (args === undefined) {
+                req.method('GET');
+            }
+            else {
+                req.method('POST').body(args);
+            }
+            return await req.asJson();
         },
         call: (prefix, suffix, version = 'v1', name, args) => api.invoke(InvokeType.Call, prefix, suffix, version, name, args),
         await: (prefix, suffix, version = 'v1', name, args) => api.invoke(InvokeType.Await, prefix, suffix, version, name, args)
     };
     return api;
 };
-exports.MaxRetries = 30;
-exports.MaxRetryInterval = 2000;
+exports.MaxRetries = 100;
+exports.MaxRetryInterval = 5000;
 exports.MaxFuncLength = 64;
 /**
  * Executes an asynchronous function with automatic retry logic.
@@ -227,9 +305,14 @@ exports.MaxFuncLength = 64;
  */
 const waitFor = async (fn, maxRetries = exports.MaxRetries, interval = exports.MaxRetryInterval) => {
     let retry = 0;
+    let cancellation = undefined;
+    const cancel = (message) => {
+        retry = exports.MaxRetries;
+        cancellation = `Operation cancelled with message: ${message}`;
+    };
     for (;;) {
         try {
-            return await fn();
+            return await fn(cancel);
         }
         catch (error) {
             retry++;
@@ -239,11 +322,13 @@ const waitFor = async (fn, maxRetries = exports.MaxRetries, interval = exports.M
                     (fnStr.length > exports.MaxFuncLength
                         ? fnStr.slice(0, exports.MaxFuncLength) + '...'
                         : fnStr);
-                const message = exports.isProtocolError(error)
-                    ? error.message
-                    : error instanceof Error
+                const message = cancellation !== undefined
+                    ? cancellation
+                    : exports.isProtocolError(error)
                         ? error.message
-                        : String(error);
+                        : error instanceof Error
+                            ? error.message
+                            : String(error);
                 throw new Error(`Failed to execute '${func}' after ${maxRetries} retries: ${message}`);
             }
             await new Promise(r => setTimeout(r, interval));

package/dist/signup.js

@@ -1,25 +1,27 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = __importDefault(require("axios"));
 const url_1 = require("url");
-exports.default = (email, password, alias, baseURL) => {
+exports.default = async (email, password, alias, baseURL) => {
     const request = {
         email,
         password,
         alias
     };
-    if (!baseURL.includes('localhost'))
-        request['g-recaptcha-response'] = 'empty';
-    return axios_1.default
-        .post(baseURL + '/signup', request, {
+    if (!baseURL.includes('localhost')) {
+        request['g-recaptcha-response'] = 'empty'; // TODO: Review the captcha
+    }
+    const res = await fetch(baseURL + '/signup', {
+        method: 'POST',
         headers: {
             Accept: 'application/json, text/plain, */*',
             Host: new url_1.URL(baseURL).host,
-            Origin: baseURL
-        }
-    })
-        .then(res => res.data);
+            Origin: baseURL,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(request)
+    });
+    if (!res.ok) {
+        throw new Error(res.statusText);
+    }
+    return res.text();
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@metacall/protocol",
-	"version": "0.1.28",
+	"version": "0.1.30",
 	"description": "Tool for deploying into MetaCall FaaS platform.",
 	"exports": {
 		"./*": "./dist/*.js",
@@ -18,8 +18,9 @@
 		}
 	},
 	"scripts": {
+		"pretest": "npm --prefix ./src/test/resources/integration/api install",
 		"test": "npm run --silent build && mocha dist/test",
-		"unit": "npm run --silent test -- --ignore **/integration**",
+		"unit": "npm run --silent test -- --ignore **/**.integration.**",
 		"prepublishOnly": "npm run --silent build",
 		"postinstall": "node -e \"require('fs').existsSync('githooks') && require('./githooks/configure.js').configure()\"",
 		"build": "npm run --silent lint && tsc",
@@ -85,8 +86,6 @@
 		}
 	},
 	"dependencies": {
-		"axios": "^1.13.5",
-		"form-data": "^3.0.0",
 		"ignore-walk": "^3.0.4",
 		"jsonwebtoken": "^9.0.0"
 	},

package/src/index.ts

@@ -7,5 +7,5 @@ export * from './protocol';
 export * from './signup';
 export * from './token';
 
-import metacallAPI from './protocol';
-export default metacallAPI;
+import Protocol from './protocol';
+export default Protocol;

package/src/login.ts

@@ -1,4 +1,3 @@
-import axios from 'axios';
 import { URL } from 'url';
 
 interface Request {
@@ -7,7 +6,7 @@ interface Request {
 	'g-recaptcha-response'?: string;
 }
 
-export default (
+export default async (
 	email: string,
 	password: string,
 	baseURL: string
@@ -17,16 +16,24 @@ export default (
 		password
 	};
 
-	if (!baseURL.includes('localhost'))
-		request['g-recaptcha-response'] = 'empty'; //TODO: Review the captcha
+	if (!baseURL.includes('localhost')) {
+		request['g-recaptcha-response'] = 'empty'; // TODO: Review the captcha
+	}
 
-	return axios
-		.post<string>(baseURL + '/login', request, {
-			headers: {
-				Accept: 'application/json, text/plain, */*',
-				Host: new URL(baseURL).host,
-				Origin: baseURL
-			}
-		})
-		.then(res => res.data);
+	const res = await fetch(baseURL + '/login', {
+		method: 'POST',
+		headers: {
+			Accept: 'application/json, text/plain, */*',
+			Host: new URL(baseURL).host,
+			Origin: baseURL,
+			'Content-Type': 'application/json'
+		},
+		body: JSON.stringify(request)
+	});
+
+	if (!res.ok) {
+		throw new Error(res.statusText);
+	}
+
+	return res.text();
 };

package/src/protocol.ts

@@ -1,8 +1,6 @@
 /*
-
-* About File:
-
-	this is just a client that implements all the rest API from the FaaS, so each function it contains is an endpoint in the FaaS for deploying and similar
+	This is just a client that implements all the rest API from the FaaS,
+	so each function it contains is an endpoint in the FaaS for deploying:
 
 	refresh: updates the auth token
 	validate: validates the auth token
@@ -18,22 +16,30 @@
 	fileList: get files of a repository by branch
 */
 
-import axios, { AxiosError, AxiosRequestConfig } from 'axios';
-import FormData from 'form-data';
+import { Readable } from 'stream';
 import { URL } from 'url';
 import { Create, Deployment, LogType, MetaCallJSON } from './deployment';
 import { Plans } from './plan';
-import { ProtocolError } from './protocol';
+
+export class ProtocolError extends Error {
+	status?: number;
+	data?: unknown;
+
+	constructor(message: string, status?: number, data?: unknown) {
+		super(message);
+		this.name = 'ProtocolError';
+		this.status = status;
+		this.data = data;
+	}
+}
 
 /**
- * Type guard for protocol-specific errors (Axios errors in this case).
+ * Type guard for protocol-specific errors.
  * @param err - The unknown error to check.
  * @returns True if the error is an ProtocolError, false otherwise.
  */
-export const isProtocolError = (err: unknown): boolean =>
-	axios.isAxiosError(err);
-
-export { AxiosError as ProtocolError };
+export const isProtocolError = (err: unknown): err is ProtocolError =>
+	err instanceof ProtocolError;
 
 type SubscriptionMap = Record<string, number>;
 
@@ -49,7 +55,7 @@ export enum ResourceType {
 	Repository = 'Repository'
 }
 
-export interface AddResponse {
+export interface Resource {
 	id: string;
 }
 
@@ -106,12 +112,8 @@ export interface API {
 		blob: unknown,
 		jsons?: MetaCallJSON[],
 		runners?: string[]
-	): Promise<string>;
-	add(
-		url: string,
-		branch: string,
-		jsons: MetaCallJSON[]
-	): Promise<AddResponse>;
+	): Promise<Resource>;
+	add(url: string, branch: string, jsons: MetaCallJSON[]): Promise<Resource>;
 	deploy(
 		name: string,
 		env: { name: string; value: string }[],
@@ -158,50 +160,132 @@ export interface API {
 	): Promise<Result>;
 }
 
-export default (token: string, baseURL: string): API => {
-	const getURL = (path: string): string => new URL(path, baseURL).toString();
-	const getConfig = (headers = {}): AxiosRequestConfig => {
-		return {
-			headers: {
-				Authorization: 'jwt ' + token,
-				...headers
-			}
+interface RequestImpl {
+	url: string;
+	headers: Headers;
+	method: string;
+	body?: BodyInit;
+}
+
+class Request {
+	private token: string;
+	private baseURL: string;
+	private impl: RequestImpl;
+
+	constructor(token: string, baseURL: string) {
+		this.token = token;
+		this.baseURL = baseURL;
+		this.impl = {
+			url: '',
+			headers: new Headers({
+				Authorization: 'jwt ' + this.token
+			}),
+			method: 'GET',
+			body: undefined
 		};
-	};
+	}
+
+	url(path: string): Request {
+		this.impl.url = new URL(path, this.baseURL).toString();
+		return this;
+	}
+
+	headers(headers = {}): Request {
+		this.impl.headers = new Headers({
+			Authorization: 'jwt ' + this.token,
+			...headers
+		});
+		return this;
+	}
+
+	method(method: string): Request {
+		this.impl.method = method;
+		return this;
+	}
+
+	bodyRaw(body: BodyInit): Request {
+		this.impl.body = body;
+		return this;
+	}
+
+	body(body: unknown): Request {
+		this.impl.body = JSON.stringify(body);
+		this.impl.headers.set('Content-Type', 'application/json');
+		return this;
+	}
+
+	private async execute(): Promise<Response> {
+		const config: RequestInit = {
+			method: this.impl.method,
+			headers: this.impl.headers
+		};
+
+		if (this.impl.body !== undefined) {
+			config.body = this.impl.body;
+		}
+
+		const res = await fetch(this.impl.url, config);
+
+		if (!res.ok) {
+			const data = await res.text().catch(() => null);
+			throw new Error(
+				`HTTP ${res.status}: ${res.statusText}${
+					data ? ` - ${data}` : ''
+				}`
+			);
+		}
+
+		return res;
+	}
+
+	async asJson<T>(): Promise<T> {
+		const res = await this.execute();
+		return res.json() as Promise<T>;
+	}
+
+	async asText(): Promise<string> {
+		const res = await this.execute();
+		return res.text();
+	}
+
+	async asStatus(): Promise<number> {
+		const res = await this.execute();
+		return res.status;
+	}
+
+	async asResponse(): Promise<Response> {
+		return await this.execute();
+	}
+}
+
+export default (token: string, baseURL: string): API => {
+	const request = (url = baseURL) => new Request(token, url);
+	const hostname = new URL(baseURL).hostname;
 
 	const api: API = {
 		refresh: (): Promise<string> =>
-			axios
-				.get<string>(getURL('/api/account/refresh-token'), getConfig())
-				.then(res => res.data),
+			request().url('/api/account/refresh-token').asText(),
 
 		ready: (): Promise<boolean> =>
-			axios
-				.get<boolean>(getURL('/api/readiness'), getConfig())
-				.then(res => res.status == 200),
+			request()
+				.url('/api/readiness')
+				.asStatus()
+				.then(status => status === 200),
 
 		validate: (): Promise<boolean> =>
-			axios
-				.get<boolean>(getURL('/validate'), getConfig())
-				.then(res => res.data),
+			request().url('/validate').asJson<boolean>(),
 
 		deployEnabled: (): Promise<boolean> =>
-			axios
-				.get<boolean>(
-					getURL('/api/account/deploy-enabled'),
-					getConfig()
-				)
-				.then(res => res.data),
+			request().url('/api/account/deploy-enabled').asJson<boolean>(),
 
 		listSubscriptions: async (): Promise<SubscriptionMap> => {
-			const res = await axios.get<string[]>(
-				getURL('/api/billing/list-subscriptions'),
-				getConfig()
-			);
+			const subscriptionsList = await request()
+				.url('/api/billing/list-subscriptions')
+				.asJson<string[]>();
 
 			const subscriptions: SubscriptionMap = {};
 
-			for (const id of res.data) {
+			for (const id of subscriptionsList) {
 				if (subscriptions[id] === undefined) {
 					subscriptions[id] = 1;
 				} else {
@@ -213,17 +297,12 @@ export default (token: string, baseURL: string): API => {
 		},
 
 		listSubscriptionsDeploys: (): Promise<SubscriptionDeploy[]> =>
-			axios
-				.get<SubscriptionDeploy[]>(
-					getURL('/api/billing/list-subscriptions-deploys'),
-					getConfig()
-				)
-				.then(res => res.data),
+			request()
+				.url('/api/billing/list-subscriptions')
+				.asJson<SubscriptionDeploy[]>(),
 
 		inspect: (): Promise<Deployment[]> =>
-			axios
-				.get<Deployment[]>(getURL('/api/inspect'), getConfig())
-				.then(res => res.data),
+			request().url('/api/inspect').asJson<Deployment[]>(),
 
 		inspectByName: async (suffix: string): Promise<Deployment> => {
 			const deployments = await api.inspect();
@@ -239,52 +318,67 @@ export default (token: string, baseURL: string): API => {
 
 		upload: async (
 			name: string,
-			blob: unknown,
+			data: Blob | Readable,
 			jsons: MetaCallJSON[] = [],
 			runners: string[] = []
-		): Promise<string> => {
+		): Promise<Resource> => {
 			const fd = new FormData();
+
 			fd.append('id', name);
 			fd.append('type', 'application/x-zip-compressed');
 			fd.append('jsons', JSON.stringify(jsons));
 			fd.append('runners', JSON.stringify(runners));
-			fd.append('raw', blob, {
-				filename: 'blob',
-				contentType: 'application/x-zip-compressed'
-			});
-			const res = await axios.post<string>(
-				getURL('/api/package/create'),
-				fd,
-				getConfig() // Axios automatically sets multipart headers
-			);
-			return res.data;
+
+			if (data instanceof Blob) {
+				fd.append('raw', data, `${name}.zip`);
+			} else if (data instanceof Readable) {
+				// This is terrible but NodeJS does not ensure that streaming and zero
+				// copy will be performed anyway, as the sizes are not really big (150mb is the limit)
+				// we can do this nasty intermediate buffer creation and forget about it
+				const chunks: Uint8Array[] = [];
+				for await (const chunk of data) {
+					chunks.push(
+						typeof chunk === 'string' ? Buffer.from(chunk) : chunk
+					);
+				}
+				const buffer = Buffer.concat(chunks);
+				fd.append('raw', new Blob([buffer]), `${name}.zip`);
+			} else {
+				throw Error(
+					`Type ${typeof data} not supported, use Blob or Readable`
+				);
+			}
+
+			return await request()
+				.url('/api/package/create')
+				.method('POST')
+				.bodyRaw(fd)
+				.asJson<Resource>();
 		},
+
 		add: (
 			url: string,
 			branch: string,
 			jsons: MetaCallJSON[] = []
-		): Promise<AddResponse> =>
-			axios
-				.post<AddResponse>(
-					getURL('/api/repository/add'),
-					{
-						url,
-						branch,
-						jsons
-					},
-					getConfig()
-				)
-				.then(res => res.data),
+		): Promise<Resource> =>
+			request()
+				.url('/api/repository/add')
+				.method('POST')
+				.body({
+					url,
+					branch,
+					jsons
+				})
+				.asJson<Resource>(),
+
 		branchList: (url: string): Promise<Branches> =>
-			axios
-				.post<Branches>(
-					getURL('/api/repository/branchlist'),
-					{
-						url
-					},
-					getConfig()
-				)
-				.then(res => res.data),
+			request()
+				.url('/api/repository/branchlist')
+				.method('POST')
+				.body({
+					url
+				})
+				.asJson<Branches>(),
 
 		deploy: (
 			name: string,
@@ -294,37 +388,33 @@ export default (token: string, baseURL: string): API => {
 			release: string = Date.now().toString(16),
 			version = 'v1'
 		): Promise<Create> =>
-			axios
-				.post<Create>(
-					getURL('/api/deploy/create'),
-					{
-						resourceType,
-						suffix: name,
-						release,
-						env,
-						plan,
-						version
-					},
-					getConfig()
-				)
-				.then(res => res.data),
+			request()
+				.url('/api/deploy/create')
+				.method('POST')
+				.body({
+					resourceType,
+					suffix: name,
+					release,
+					env,
+					plan,
+					version
+				})
+				.asJson<Create>(),
 
 		deployDelete: (
 			prefix: string,
 			suffix: string,
 			version = 'v1'
 		): Promise<string> =>
-			axios
-				.post<string>(
-					getURL('/api/deploy/delete'),
-					{
-						prefix,
-						suffix,
-						version
-					},
-					getConfig()
-				)
-				.then(res => res.data),
+			request()
+				.url('/api/deploy/delete')
+				.method('POST')
+				.body({
+					prefix,
+					suffix,
+					version
+				})
+				.asJson<string>(),
 
 		logs: (
 			container: string,
@@ -333,33 +423,30 @@ export default (token: string, baseURL: string): API => {
 			prefix: string,
 			version = 'v1'
 		): Promise<string> =>
-			axios
-				.post<string>(
-					getURL('/api/deploy/logs'),
-					{
-						container,
-						type,
-						suffix,
-						prefix,
-						version
-					},
-					getConfig()
-				)
-				.then(res => res.data),
+			request()
+				.url('/api/deploy/logs')
+				.method('POST')
+				.body({
+					container,
+					type,
+					suffix,
+					prefix,
+					version
+				})
+				.asJson<string>(),
 
 		fileList: (url: string, branch: string): Promise<string[]> =>
-			axios
-				.post<{ [k: string]: string[] }>(
-					getURL('/api/repository/filelist'),
-					{
-						url,
-						branch
-					},
-					getConfig()
-				)
-				.then(res => res.data['files']),
-
-		invoke: <Result, Args = unknown>(
+			request()
+				.url('/api/repository/filelist')
+				.method('POST')
+				.body({
+					url,
+					branch
+				})
+				.asJson<{ [k: string]: string[] }>()
+				.then(res => res['files']),
+
+		invoke: async <Result, Args = unknown>(
 			type: InvokeType,
 			prefix: string,
 			suffix: string,
@@ -367,17 +454,27 @@ export default (token: string, baseURL: string): API => {
 			name: string,
 			args?: Args
 		): Promise<Result> => {
-			const url = getURL(
-				`/${prefix}/${suffix}/${version}/${type}/${name}`
-			);
-			const config = getConfig();
+			const req = (() => {
+				if (hostname === 'localhost') {
+					// Old API in commercial FaaS and current API of FaaS reimplementation
+					return request().url(
+						`/${prefix}/${suffix}/${version}/${type}/${name}`
+					);
+				} else {
+					// New API used by commercial FaaS
+					return request(
+						`https://${version}-${suffix}-${prefix}.api.metacall.io`
+					).url(`/${type}/${name}`);
+				}
+			})();
 
-			const req =
-				args === undefined
-					? axios.get<Result>(url, config)
-					: axios.post<Result>(url, args, config);
+			if (args === undefined) {
+				req.method('GET');
+			} else {
+				req.method('POST').body(args);
+			}
 
-			return req.then(res => res.data);
+			return await req.asJson<Result>();
 		},
 
 		call: <Result, Args = unknown>(
@@ -402,8 +499,8 @@ export default (token: string, baseURL: string): API => {
 	return api;
 };
 
-export const MaxRetries = 30;
-export const MaxRetryInterval = 2000;
+export const MaxRetries = 100;
+export const MaxRetryInterval = 5000;
 export const MaxFuncLength = 64;
 
 /**
@@ -444,15 +541,21 @@ export const MaxFuncLength = 64;
  * ```
  */
 export const waitFor = async <T>(
-	fn: () => Promise<T>,
+	fn: (cancel: (message: string) => void) => Promise<T>,
 	maxRetries: number = MaxRetries,
 	interval: number = MaxRetryInterval
 ): Promise<T> => {
 	let retry = 0;
+	let cancellation = undefined;
+
+	const cancel = (message: string) => {
+		retry = MaxRetries;
+		cancellation = `Operation cancelled with message: ${message}`;
+	};
 
 	for (;;) {
 		try {
-			return await fn();
+			return await fn(cancel);
 		} catch (error) {
 			retry++;
 			if (retry >= maxRetries) {
@@ -462,11 +565,14 @@ export const waitFor = async <T>(
 					(fnStr.length > MaxFuncLength
 						? fnStr.slice(0, MaxFuncLength) + '...'
 						: fnStr);
-				const message = isProtocolError(error)
-					? (error as ProtocolError).message
-					: error instanceof Error
-					? error.message
-					: String(error);
+				const message =
+					cancellation !== undefined
+						? cancellation
+						: isProtocolError(error)
+						? error.message
+						: error instanceof Error
+						? error.message
+						: String(error);
 
 				throw new Error(
 					`Failed to execute '${func}' after ${maxRetries} retries: ${message}`

package/src/signup.ts

@@ -1,4 +1,3 @@
-import axios from 'axios';
 import { URL } from 'url';
 interface Request {
 	email: string;
@@ -7,7 +6,7 @@ interface Request {
 	'g-recaptcha-response'?: string;
 }
 
-export default (
+export default async (
 	email: string,
 	password: string,
 	alias: string,
@@ -18,15 +17,25 @@ export default (
 		password,
 		alias
 	};
-	if (!baseURL.includes('localhost'))
-		request['g-recaptcha-response'] = 'empty';
-	return axios
-		.post<string>(baseURL + '/signup', request, {
-			headers: {
-				Accept: 'application/json, text/plain, */*',
-				Host: new URL(baseURL).host,
-				Origin: baseURL
-			}
-		})
-		.then(res => res.data);
+
+	if (!baseURL.includes('localhost')) {
+		request['g-recaptcha-response'] = 'empty'; // TODO: Review the captcha
+	}
+
+	const res = await fetch(baseURL + '/signup', {
+		method: 'POST',
+		headers: {
+			Accept: 'application/json, text/plain, */*',
+			Host: new URL(baseURL).host,
+			Origin: baseURL,
+			'Content-Type': 'application/json'
+		},
+		body: JSON.stringify(request)
+	});
+
+	if (!res.ok) {
+		throw new Error(res.statusText);
+	}
+
+	return res.text();
 };

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
 	"compilerOptions": {
 		"strict": true,
-		"lib": ["es2020", "dom"],
+		"lib": ["es2020", "DOM"],
 		"moduleResolution": "node",
 		"target": "es2020",
 		"module": "CommonJS",