@metacall/protocol 0.1.25 → 0.1.27

package/README.md

@@ -0,0 +1,34 @@
+# MetaCall Protocol
+
+This repository contains the protocol implementation for MetaCall FaaS. It is a client that allows deploying to [MetaCall FaaS](https://dashboard.metacall.io) or its [open source reimplementation](https://github.com/metacall/faas) written in TypeScript.
+
+## Documentation
+
+Explore the detailed documentation for the MetaCall Protocol in the [doc](doc) directory. It provides comprehensive information on the protocol, its implementation details, and best practices for integration.
+
+## [Core](https://github.com/metacall/core)
+
+The ultimate polyglot programming experience.
+
+## [Deploy](https://github.com/metacall/deploy)
+
+Tool for deploying into MetaCall FaaS platform.
+
+## [Examples](https://github.com/metacall/examples)
+
+A collection of use cases and examples to be deployed in MetaCall.
+
+## [FaaS](https://github.com/metacall/faas)
+
+The FaaS platform reimplementation for MetaCall.
+
+## Testing
+
+The [test](test) directory contains various tests for the MetaCall Protocol. These tests are designed to ensure the reliability and correctness of the protocol implementation. If you encounter any issues or inconsistencies, please report them by opening an [issue](https://github.com/metacall/protocol-repo/issues).
+
+## Contributing
+
+We welcome contributions from the community. If you have ideas, suggestions, or want to report a bug, please feel free to open an [issue](https://github.com/metacall/protocol/issues) or submit a [pull request](https://github.com/metacall/protocol/pulls).
+## License
+
+This repository is licensed under the [Apache License, Version 2.0](LICENSE). Feel free to use, modify, and distribute the code in accordance with the terms specified in the license.

package/dist/index.d.ts

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

package/dist/index.js

@@ -21,4 +21,5 @@ __exportStar(require("./plan"), exports);
 __exportStar(require("./token"), exports);
 const protocol_1 = __importDefault(require("./protocol"));
 __exportStar(require("./protocol"), exports);
+__exportStar(require("./signup"), exports);
 exports.default = protocol_1.default;

package/dist/language.d.ts

@@ -1,13 +1,23 @@
 import { LanguageId } from './deployment';
+export declare type Runner = 'nodejs' | 'python' | 'ruby' | 'csharp';
+export interface RunnerInfo {
+    id: Runner;
+    languageId: LanguageId;
+    filePatterns: RegExp[];
+    installCommand: string;
+    displayName: string;
+}
+export declare const Runners: Record<Runner, RunnerInfo>;
 interface Language {
     tag: string;
     displayName: string;
     hexColor: string;
     fileExtRegex: RegExp;
-    runnerName?: string;
+    runnerName?: Runner;
     runnerFilesRegexes: RegExp[];
 }
 export declare const Languages: Record<LanguageId, Language>;
 export declare const DisplayNameToLanguageId: Record<string, LanguageId>;
 export declare const RunnerToDisplayName: (runner: string) => string;
+export declare const detectRunnersFromFiles: (files: string[]) => Runner[];
 export {};

package/dist/language.js

@@ -6,7 +6,38 @@
 
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnerToDisplayName = exports.DisplayNameToLanguageId = exports.Languages = void 0;
+exports.detectRunnersFromFiles = exports.RunnerToDisplayName = exports.DisplayNameToLanguageId = exports.Languages = exports.Runners = void 0;
+const path_1 = require("path");
+exports.Runners = {
+    nodejs: {
+        id: 'nodejs',
+        languageId: 'node',
+        filePatterns: [/^package\.json$/],
+        installCommand: 'npm install',
+        displayName: 'NPM'
+    },
+    python: {
+        id: 'python',
+        languageId: 'py',
+        filePatterns: [/^requirements\.txt$/],
+        installCommand: 'pip install -r requirements.txt',
+        displayName: 'Pip'
+    },
+    ruby: {
+        id: 'ruby',
+        languageId: 'rb',
+        filePatterns: [/^Gemfile$/],
+        installCommand: 'bundle install',
+        displayName: 'Gem'
+    },
+    csharp: {
+        id: 'csharp',
+        languageId: 'cs',
+        filePatterns: [/^project\.json$/, /\.csproj$/],
+        installCommand: 'dotnet restore',
+        displayName: 'NuGet'
+    }
+};
 exports.Languages = {
     cs: {
         tag: 'cs',
@@ -14,7 +45,7 @@ exports.Languages = {
         hexColor: '#953dac',
         fileExtRegex: /^cs$/,
         runnerName: 'csharp',
-        runnerFilesRegexes: [/^project\.json$/, /\.csproj$/]
+        runnerFilesRegexes: exports.Runners.csharp.filePatterns
     },
     py: {
         tag: 'py',
@@ -22,7 +53,7 @@ exports.Languages = {
         hexColor: '#ffd43b',
         fileExtRegex: /^py$/,
         runnerName: 'python',
-        runnerFilesRegexes: [/^requirements\.txt$/]
+        runnerFilesRegexes: exports.Runners.python.filePatterns
     },
     rb: {
         tag: 'rb',
@@ -30,7 +61,7 @@ exports.Languages = {
         hexColor: '#e53935',
         fileExtRegex: /^rb$/,
         runnerName: 'ruby',
-        runnerFilesRegexes: [/^Gemfile$/]
+        runnerFilesRegexes: exports.Runners.ruby.filePatterns
     },
     node: {
         tag: 'node',
@@ -38,7 +69,7 @@ exports.Languages = {
         hexColor: '#3c873a',
         fileExtRegex: /^js$/,
         runnerName: 'nodejs',
-        runnerFilesRegexes: [/^package\.json$/]
+        runnerFilesRegexes: exports.Runners.nodejs.filePatterns
     },
     ts: {
         tag: 'ts',
@@ -46,7 +77,7 @@ exports.Languages = {
         hexColor: '#007acc',
         fileExtRegex: /^(ts|tsx)$/,
         runnerName: 'nodejs',
-        runnerFilesRegexes: [/^package\.json$/] // TODO: Use tsconfig instead?
+        runnerFilesRegexes: exports.Runners.nodejs.filePatterns
     },
     file: {
         tag: 'file',
@@ -77,12 +108,23 @@ exports.DisplayNameToLanguageId = Object.keys(exports.Languages).reduce((obj, la
     [exports.Languages[lang].displayName]: lang
 }), {});
 const RunnerToDisplayName = (runner) => {
-    const displayNameMap = {
-        nodejs: 'NPM',
-        python: 'Pip',
-        ruby: 'Gem',
-        csharp: 'NuGet'
-    };
-    return displayNameMap[runner] || 'Build';
+    const match = exports.Runners[runner];
+    return match ? match.displayName : 'Build';
 };
 exports.RunnerToDisplayName = RunnerToDisplayName;
+const detectRunnersFromFiles = (files) => {
+    const runners = new Set();
+    for (const file of files) {
+        const fileName = path_1.basename(file);
+        for (const runner of Object.values(exports.Runners)) {
+            for (const pattern of runner.filePatterns) {
+                if (pattern.exec(fileName)) {
+                    runners.add(runner.id);
+                    break;
+                }
+            }
+        }
+    }
+    return Array.from(runners);
+};
+exports.detectRunnersFromFiles = detectRunnersFromFiles;

package/dist/package.d.ts

@@ -1,7 +1,10 @@
 import { MetaCallJSON } from './deployment';
+import { Runner } from './language';
 export declare const findFilesPath: (path?: string, ignoreFiles?: string[]) => Promise<string[]>;
+export declare const pathIsMetaCallJson: (path: string) => boolean;
 export declare const findMetaCallJsons: (files: string[]) => string[];
-export declare const findRunners: (files: string[]) => Set<string>;
+export declare const findRunners: (files: string[]) => Set<Runner>;
+export declare const detectRunners: (path?: string, ignoreFiles?: string[]) => Promise<Runner[]>;
 export declare enum PackageError {
     Empty = "No files found in the current folder",
     JsonNotFound = "No metacall.json found in the current folder",
@@ -11,7 +14,7 @@ interface PackageDescriptor {
     error: PackageError;
     files: string[];
     jsons: string[];
-    runners: string[];
+    runners: Runner[];
 }
 export declare const generatePackage: (path?: string) => Promise<PackageDescriptor>;
 export declare const generateJsonsFromFiles: (files: string[]) => MetaCallJSON[];

package/dist/package.js

@@ -16,7 +16,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateJsonsFromFiles = exports.generatePackage = exports.PackageError = exports.findRunners = exports.findMetaCallJsons = exports.findFilesPath = void 0;
+exports.generateJsonsFromFiles = exports.generatePackage = exports.PackageError = exports.detectRunners = exports.findRunners = exports.findMetaCallJsons = exports.pathIsMetaCallJson = exports.findFilesPath = void 0;
 const ignore_walk_1 = __importDefault(require("ignore-walk"));
 const path_1 = require("path");
 const language_1 = require("./language");
@@ -28,24 +28,13 @@ const findFilesPath = async (path = process.cwd(), ignoreFiles = ['.gitignore'])
 })).filter(x => !x.startsWith('.git'));
 exports.findFilesPath = findFilesPath;
 const pathIsMetaCallJson = (path) => !!/^metacall(-.+)?\.json$/.exec(path_1.basename(path));
-const findMetaCallJsons = (files) => files.filter(pathIsMetaCallJson);
+exports.pathIsMetaCallJson = pathIsMetaCallJson;
+const findMetaCallJsons = (files) => files.filter(exports.pathIsMetaCallJson);
 exports.findMetaCallJsons = findMetaCallJsons;
-const findRunners = (files) => {
-    const runners = new Set();
-    for (const file of files) {
-        const fileName = path_1.basename(file);
-        for (const langId of Object.keys(language_1.Languages)) {
-            const lang = language_1.Languages[langId];
-            for (const re of lang.runnerFilesRegexes) {
-                if (re.exec(fileName) && lang.runnerName) {
-                    runners.add(lang.runnerName);
-                }
-            }
-        }
-    }
-    return runners;
-};
+const findRunners = (files) => new Set(language_1.detectRunnersFromFiles(files));
 exports.findRunners = findRunners;
+const detectRunners = async (path = process.cwd(), ignoreFiles = ['.gitignore']) => language_1.detectRunnersFromFiles(await exports.findFilesPath(path, ignoreFiles));
+exports.detectRunners = detectRunners;
 var PackageError;
 (function (PackageError) {
     PackageError["Empty"] = "No files found in the current folder";

package/dist/protocol.d.ts

@@ -1,6 +1,11 @@
 import { AxiosError } from 'axios';
 import { Create, Deployment, LogType, MetaCallJSON } from './deployment';
 import { Plans } from './plan';
+/**
+ * Type guard for protocol-specific errors (Axios errors in this case).
+ * @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 };
 declare type SubscriptionMap = Record<string, number>;
@@ -20,13 +25,47 @@ export interface AddResponse {
 export interface Branches {
     branches: [string];
 }
+export declare enum InvokeType {
+    Call = "call",
+    Await = "await"
+}
+export interface DeployCreateRequest {
+    suffix: string;
+    resourceType: ResourceType;
+    release: string;
+    env: {
+        name: string;
+        value: string;
+    }[];
+    plan: Plans;
+    version: string;
+}
+export interface DeployDeleteRequest {
+    prefix: string;
+    suffix: string;
+    version: string;
+}
+export interface RepositoryAddRequest {
+    url: string;
+    branch: string;
+    jsons: MetaCallJSON[];
+}
+export interface RepositoryBranchListRequest {
+    url: string;
+}
+export interface RepositoryFileListRequest {
+    url: string;
+    branch: string;
+}
 export interface API {
     refresh(): Promise<string>;
+    ready(): Promise<boolean>;
     validate(): Promise<boolean>;
     deployEnabled(): Promise<boolean>;
     listSubscriptions(): Promise<SubscriptionMap>;
     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>;
     deploy(name: string, env: {
@@ -37,6 +76,50 @@ export interface API {
     logs(container: string, type: LogType, suffix: string, prefix: string, version?: string): Promise<string>;
     branchList(url: string): Promise<Branches>;
     fileList(url: string, branch: string): Promise<string[]>;
+    invoke<Result, Args = unknown>(type: InvokeType, prefix: string, suffix: string, version: string, name: string, args?: Args): Promise<Result>;
+    call<Result, Args = unknown>(prefix: string, suffix: string, version: string, name: string, args?: Args): Promise<Result>;
+    await<Result, Args = unknown>(prefix: string, suffix: string, version: string, name: string, args?: Args): Promise<Result>;
 }
 declare const _default: (token: string, baseURL: string) => API;
 export default _default;
+export declare const MaxRetries = 30;
+export declare const MaxRetryInterval = 2000;
+export declare const MaxFuncLength = 64;
+/**
+ * Executes an asynchronous function with automatic retry logic.
+ *
+ * The function will be retried up to `maxRetries` times, waiting `interval`
+ * milliseconds between each attempt. If all retries fail, the last error is
+ * wrapped in a new `Error` with a descriptive message, including:
+ * - Function name (or string representation truncated to `MaxFuncLength` chars if anonymous)
+ * - Number of retries attempted
+ * - Original error message
+ *
+ * Error handling is fully type-safe:
+ * - If the error is an ProtocolError (checked via `isProtocolError`), its
+ *   message is used.
+ * - If the error is a standard `Error`, its `message` is used.
+ * - Otherwise, the error is converted to a string.
+ *
+ * @typeParam T - The return type of the function being retried.
+ * @param fn - A lambda or bound function returning a `Promise<T>`. The
+ *             function should contain the logic you want to retry.
+ * @param maxRetries - Maximum number of retry attempts. Default: `MaxRetries`.
+ * @param interval - Delay between retries in milliseconds. Default: `MaxRetryInterval`.
+ * @returns A `Promise` resolving to the return value of `fn` if successful.
+ * @throws Error If all retry attempts fail, throws a new Error containing
+ *                 information about the function and the last error.
+ *
+ * @example
+ * ```ts
+ * const deployment = await waitFor(() => api.inspectByName('my-suffix'));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const result = await waitFor(
+ *   () => api.deploy(name, env, plan, resourceType)
+ * );
+ * ```
+ */
+export declare const waitFor: <T>(fn: () => Promise<T>, maxRetries?: number, interval?: number) => Promise<T>;

package/dist/protocol.js

@@ -18,14 +18,40 @@
     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.ResourceType = exports.isProtocolError = void 0;
-const axios_1 = __importDefault(require("axios"));
+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"));
+const url_1 = require("url");
 const deployment_1 = require("./deployment");
+/**
+ * Type guard for protocol-specific errors (Axios errors in this case).
+ * @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);
 exports.isProtocolError = isProtocolError;
 var ResourceType;
@@ -33,27 +59,36 @@ var ResourceType;
     ResourceType["Package"] = "Package";
     ResourceType["Repository"] = "Repository";
 })(ResourceType = exports.ResourceType || (exports.ResourceType = {}));
+var InvokeType;
+(function (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
+            }
+        };
+    };
     const api = {
         refresh: () => axios_1.default
-            .get(baseURL + '/api/account/refresh-token', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+            .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(baseURL + '/validate', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+            .get(getURL('/validate'), getConfig())
             .then(res => res.data),
         deployEnabled: () => axios_1.default
-            .get(baseURL + '/api/account/deploy-enabled', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+            .get(getURL('/api/account/deploy-enabled'), getConfig())
             .then(res => res.data),
         listSubscriptions: async () => {
-            const res = await axios_1.default.get(baseURL + '/api/billing/list-subscriptions', {
-                headers: { Authorization: 'jwt ' + token }
-            });
+            const res = await axios_1.default.get(getURL('/api/billing/list-subscriptions'), getConfig());
             const subscriptions = {};
             for (const id of res.data) {
                 if (subscriptions[id] === undefined) {
@@ -65,18 +100,21 @@ exports.default = (token, baseURL) => {
             }
             return subscriptions;
         },
-        listSubscriptionsDeploys: async () => axios_1.default
-            .get(baseURL + '/api/billing/list-subscriptions-deploys', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        listSubscriptionsDeploys: () => axios_1.default
+            .get(getURL('/api/billing/list-subscriptions-deploys'), getConfig())
             .then(res => res.data),
-        inspect: async () => axios_1.default
-            .get(baseURL + '/api/inspect', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        inspect: () => axios_1.default
+            .get(getURL('/api/inspect'), getConfig())
             .then(res => res.data),
+        inspectByName: async (suffix) => {
+            const deployments = await api.inspect();
+            const deploy = deployments.find(deploy => deploy.suffix == suffix);
+            if (!deploy) {
+                throw new Error(`Deployment with suffix '${suffix}' not found`);
+            }
+            return deploy;
+        },
         upload: async (name, blob, jsons = [], runners = []) => {
-            var _a, _b;
             const fd = new form_data_1.default();
             fd.append('id', name);
             fd.append('type', 'application/x-zip-compressed');
@@ -86,70 +124,130 @@ exports.default = (token, baseURL) => {
                 filename: 'blob',
                 contentType: 'application/x-zip-compressed'
             });
-            const res = await axios_1.default.post(baseURL + '/api/package/create', fd, {
-                headers: {
-                    Authorization: 'jwt ' + token,
-                    ...((_b = (_a = fd.getHeaders) === null || _a === void 0 ? void 0 : _a.call(fd)) !== null && _b !== void 0 ? _b : {}) // operator chaining to make it compatible with frontend
-                }
-            });
+            const res = await axios_1.default.post(getURL('/api/package/create'), fd, getConfig(fd.getHeaders?.() ?? {}) // Operator chaining to make it compatible with frontend
+            );
             return res.data;
         },
         add: (url, branch, jsons = []) => axios_1.default
-            .post(baseURL + '/api/repository/add', {
+            .post(getURL('/api/repository/add'), {
             url,
             branch,
             jsons
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
-            .then((res) => res.data),
+        }, getConfig())
+            .then(res => res.data),
         branchList: (url) => axios_1.default
-            .post(baseURL + '/api/repository/branchlist', {
+            .post(getURL('/api/repository/branchlist'), {
             url
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
-            .then((res) => res.data),
+        }, getConfig())
+            .then(res => res.data),
         deploy: (name, env, plan, resourceType, release = Date.now().toString(16), version = 'v1') => axios_1.default
-            .post(baseURL + '/api/deploy/create', {
+            .post(getURL('/api/deploy/create'), {
             resourceType,
             suffix: name,
             release,
             env,
             plan,
             version
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        }, getConfig())
             .then(res => res.data),
         deployDelete: (prefix, suffix, version = 'v1') => axios_1.default
-            .post(baseURL + '/api/deploy/delete', {
+            .post(getURL('/api/deploy/delete'), {
             prefix,
             suffix,
             version
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        }, getConfig())
             .then(res => res.data),
         logs: (container, type = deployment_1.LogType.Deploy, suffix, prefix, version = 'v1') => axios_1.default
-            .post(baseURL + '/api/deploy/logs', {
+            .post(getURL('/api/deploy/logs'), {
             container,
             type,
             suffix,
             prefix,
             version
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        }, getConfig())
             .then(res => res.data),
         fileList: (url, branch) => axios_1.default
-            .post(baseURL + '/api/repository/filelist', {
+            .post(getURL('/api/repository/filelist'), {
             url,
             branch
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
-            .then(res => res.data['files'])
+        }, 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);
+        },
+        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.MaxFuncLength = 64;
+/**
+ * Executes an asynchronous function with automatic retry logic.
+ *
+ * The function will be retried up to `maxRetries` times, waiting `interval`
+ * milliseconds between each attempt. If all retries fail, the last error is
+ * wrapped in a new `Error` with a descriptive message, including:
+ * - Function name (or string representation truncated to `MaxFuncLength` chars if anonymous)
+ * - Number of retries attempted
+ * - Original error message
+ *
+ * Error handling is fully type-safe:
+ * - If the error is an ProtocolError (checked via `isProtocolError`), its
+ *   message is used.
+ * - If the error is a standard `Error`, its `message` is used.
+ * - Otherwise, the error is converted to a string.
+ *
+ * @typeParam T - The return type of the function being retried.
+ * @param fn - A lambda or bound function returning a `Promise<T>`. The
+ *             function should contain the logic you want to retry.
+ * @param maxRetries - Maximum number of retry attempts. Default: `MaxRetries`.
+ * @param interval - Delay between retries in milliseconds. Default: `MaxRetryInterval`.
+ * @returns A `Promise` resolving to the return value of `fn` if successful.
+ * @throws Error If all retry attempts fail, throws a new Error containing
+ *                 information about the function and the last error.
+ *
+ * @example
+ * ```ts
+ * const deployment = await waitFor(() => api.inspectByName('my-suffix'));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const result = await waitFor(
+ *   () => api.deploy(name, env, plan, resourceType)
+ * );
+ * ```
+ */
+const waitFor = async (fn, maxRetries = exports.MaxRetries, interval = exports.MaxRetryInterval) => {
+    let retry = 0;
+    for (;;) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            retry++;
+            if (retry >= maxRetries) {
+                const fnStr = fn.toString();
+                const func = fn.name ||
+                    (fnStr.length > exports.MaxFuncLength
+                        ? fnStr.slice(0, exports.MaxFuncLength) + '...'
+                        : fnStr);
+                const message = exports.isProtocolError(error)
+                    ? error.message
+                    : 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));
+        }
+    }
+};
+exports.waitFor = waitFor;

package/dist/token.js

@@ -11,6 +11,6 @@ const expiresIn = (token) => {
         return 0;
     }
     const now = Date.now() / 1000;
-    return new Date(((decoded === null || decoded === void 0 ? void 0 : decoded['exp']) || now) * 1000).getTime() - now * 1000;
+    return new Date((decoded?.['exp'] || now) * 1000).getTime() - now * 1000;
 };
 exports.expiresIn = expiresIn;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@metacall/protocol",
-	"version": "0.1.25",
+	"version": "0.1.27",
 	"description": "Tool for deploying into MetaCall FaaS platform.",
 	"exports": {
 		"./*": "./dist/*.js",
@@ -85,15 +85,15 @@
 		}
 	},
 	"dependencies": {
-		"@types/ignore-walk": "^4.0.0",
-		"@types/jsonwebtoken": "^8.5.8",
-		"axios": "^0.21.0",
+		"axios": "^1.13.5",
 		"form-data": "^3.0.0",
 		"ignore-walk": "^3.0.4",
 		"jsonwebtoken": "^9.0.0"
 	},
 	"devDependencies": {
 		"@types/express": "^4.17.13",
+		"@types/ignore-walk": "^4.0.0",
+		"@types/jsonwebtoken": "^8.5.8",
 		"@types/mocha": "^8.2.3",
 		"@types/node": "^14.14.7",
 		"@types/swagger-ui-express": "^4.1.3",
@@ -111,4 +111,4 @@
 		"typescript": "4.3.2",
 		"yamljs": "^0.3.0"
 	}
-}
+}

package/src/index.ts

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

package/src/language.ts

@@ -5,14 +5,56 @@
 
 */
 
+import { basename } from 'path';
 import { LanguageId } from './deployment';
 
+export type Runner = 'nodejs' | 'python' | 'ruby' | 'csharp';
+
+export interface RunnerInfo {
+	id: Runner;
+	languageId: LanguageId;
+	filePatterns: RegExp[];
+	installCommand: string;
+	displayName: string;
+}
+
+export const Runners: Record<Runner, RunnerInfo> = {
+	nodejs: {
+		id: 'nodejs',
+		languageId: 'node',
+		filePatterns: [/^package\.json$/],
+		installCommand: 'npm install',
+		displayName: 'NPM'
+	},
+	python: {
+		id: 'python',
+		languageId: 'py',
+		filePatterns: [/^requirements\.txt$/],
+		installCommand: 'pip install -r requirements.txt',
+		displayName: 'Pip'
+	},
+	ruby: {
+		id: 'ruby',
+		languageId: 'rb',
+		filePatterns: [/^Gemfile$/],
+		installCommand: 'bundle install',
+		displayName: 'Gem'
+	},
+	csharp: {
+		id: 'csharp',
+		languageId: 'cs',
+		filePatterns: [/^project\.json$/, /\.csproj$/],
+		installCommand: 'dotnet restore',
+		displayName: 'NuGet'
+	}
+};
+
 interface Language {
 	tag: string; // Tag which corresponds to language_id in metacall.json
 	displayName: string; // Name for displaying the language
 	hexColor: string; // Color for displaying the language related things
 	fileExtRegex: RegExp; // Regex for selecting the metacall.json scripts field
-	runnerName?: string; // Id of the runner
+	runnerName?: Runner; // Id of the runner
 	runnerFilesRegexes: RegExp[]; // Regex for generating the runners list
 }
 
@@ -23,7 +65,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#953dac',
 		fileExtRegex: /^cs$/,
 		runnerName: 'csharp',
-		runnerFilesRegexes: [/^project\.json$/, /\.csproj$/]
+		runnerFilesRegexes: Runners.csharp.filePatterns
 	},
 	py: {
 		tag: 'py',
@@ -31,7 +73,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#ffd43b',
 		fileExtRegex: /^py$/,
 		runnerName: 'python',
-		runnerFilesRegexes: [/^requirements\.txt$/]
+		runnerFilesRegexes: Runners.python.filePatterns
 	},
 	rb: {
 		tag: 'rb',
@@ -39,7 +81,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#e53935',
 		fileExtRegex: /^rb$/,
 		runnerName: 'ruby',
-		runnerFilesRegexes: [/^Gemfile$/]
+		runnerFilesRegexes: Runners.ruby.filePatterns
 	},
 	node: {
 		tag: 'node',
@@ -47,7 +89,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#3c873a',
 		fileExtRegex: /^js$/,
 		runnerName: 'nodejs',
-		runnerFilesRegexes: [/^package\.json$/]
+		runnerFilesRegexes: Runners.nodejs.filePatterns
 	},
 	ts: {
 		tag: 'ts',
@@ -55,7 +97,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#007acc',
 		fileExtRegex: /^(ts|tsx)$/,
 		runnerName: 'nodejs',
-		runnerFilesRegexes: [/^package\.json$/] // TODO: Use tsconfig instead?
+		runnerFilesRegexes: Runners.nodejs.filePatterns
 	},
 	file: {
 		tag: 'file',
@@ -94,12 +136,26 @@ export const DisplayNameToLanguageId: Record<string, LanguageId> = Object.keys(
 );
 
 export const RunnerToDisplayName = (runner: string): string => {
-	const displayNameMap: Record<string, string> = {
-		nodejs: 'NPM',
-		python: 'Pip',
-		ruby: 'Gem',
-		csharp: 'NuGet'
-	};
+	const match = Runners[runner as Runner];
+
+	return match ? match.displayName : 'Build';
+};
+
+export const detectRunnersFromFiles = (files: string[]): Runner[] => {
+	const runners = new Set<Runner>();
+
+	for (const file of files) {
+		const fileName = basename(file);
+
+		for (const runner of Object.values(Runners)) {
+			for (const pattern of runner.filePatterns) {
+				if (pattern.exec(fileName)) {
+					runners.add(runner.id);
+					break;
+				}
+			}
+		}
+	}
 
-	return displayNameMap[runner] || 'Build';
+	return Array.from(runners);
 };

package/src/package.ts

@@ -15,7 +15,7 @@
 import walk from 'ignore-walk';
 import { basename, extname } from 'path';
 import { LanguageId, MetaCallJSON } from './deployment';
-import { Languages } from './language';
+import { detectRunnersFromFiles, Languages, Runner } from './language';
 
 export const findFilesPath = async (
 	path: string = process.cwd(),
@@ -30,29 +30,20 @@ export const findFilesPath = async (
 		})
 	).filter(x => !x.startsWith('.git'));
 
-const pathIsMetaCallJson = (path: string): boolean =>
+export const pathIsMetaCallJson = (path: string): boolean =>
 	!!/^metacall(-.+)?\.json$/.exec(basename(path));
 
 export const findMetaCallJsons = (files: string[]): string[] =>
 	files.filter(pathIsMetaCallJson);
 
-export const findRunners = (files: string[]): Set<string> => {
-	const runners: Set<string> = new Set<string>();
-
-	for (const file of files) {
-		const fileName = basename(file);
-		for (const langId of Object.keys(Languages)) {
-			const lang = Languages[langId as LanguageId];
-			for (const re of lang.runnerFilesRegexes) {
-				if (re.exec(fileName) && lang.runnerName) {
-					runners.add(lang.runnerName);
-				}
-			}
-		}
-	}
+export const findRunners = (files: string[]): Set<Runner> =>
+	new Set<Runner>(detectRunnersFromFiles(files));
 
-	return runners;
-};
+export const detectRunners = async (
+	path: string = process.cwd(),
+	ignoreFiles: string[] = ['.gitignore']
+): Promise<Runner[]> =>
+	detectRunnersFromFiles(await findFilesPath(path, ignoreFiles));
 
 export enum PackageError {
 	Empty = 'No files found in the current folder',
@@ -64,7 +55,7 @@ interface PackageDescriptor {
 	error: PackageError;
 	files: string[];
 	jsons: string[];
-	runners: string[];
+	runners: Runner[];
 }
 
 const NullPackage: PackageDescriptor = {

package/src/protocol.ts

@@ -18,11 +18,18 @@
 	fileList: get files of a repository by branch
 */
 
-import axios, { AxiosError, AxiosResponse } from 'axios';
+import axios, { AxiosError, AxiosRequestConfig } from 'axios';
 import FormData from 'form-data';
+import { URL } from 'url';
 import { Create, Deployment, LogType, MetaCallJSON } from './deployment';
 import { Plans } from './plan';
+import { ProtocolError } from './protocol';
 
+/**
+ * Type guard for protocol-specific errors (Axios errors in this case).
+ * @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);
 
@@ -50,13 +57,50 @@ export interface Branches {
 	branches: [string];
 }
 
+export enum InvokeType {
+	Call = 'call',
+	Await = 'await'
+}
+
+export interface DeployCreateRequest {
+	suffix: string;
+	resourceType: ResourceType;
+	release: string;
+	env: { name: string; value: string }[];
+	plan: Plans;
+	version: string;
+}
+
+export interface DeployDeleteRequest {
+	prefix: string;
+	suffix: string;
+	version: string;
+}
+
+export interface RepositoryAddRequest {
+	url: string;
+	branch: string;
+	jsons: MetaCallJSON[];
+}
+
+export interface RepositoryBranchListRequest {
+	url: string;
+}
+
+export interface RepositoryFileListRequest {
+	url: string;
+	branch: string;
+}
+
 export interface API {
 	refresh(): Promise<string>;
+	ready(): Promise<boolean>;
 	validate(): Promise<boolean>;
 	deployEnabled(): Promise<boolean>;
 	listSubscriptions(): Promise<SubscriptionMap>;
 	listSubscriptionsDeploys(): Promise<SubscriptionDeploy[]>;
 	inspect(): Promise<Deployment[]>;
+	inspectByName(suffix: string): Promise<Deployment>;
 	upload(
 		name: string,
 		blob: unknown,
@@ -90,37 +134,69 @@ export interface API {
 	): Promise<string>;
 	branchList(url: string): Promise<Branches>;
 	fileList(url: string, branch: string): Promise<string[]>;
+	invoke<Result, Args = unknown>(
+		type: InvokeType,
+		prefix: string,
+		suffix: string,
+		version: string,
+		name: string,
+		args?: Args
+	): Promise<Result>;
+	call<Result, Args = unknown>(
+		prefix: string,
+		suffix: string,
+		version: string,
+		name: string,
+		args?: Args
+	): Promise<Result>;
+	await<Result, Args = unknown>(
+		prefix: string,
+		suffix: string,
+		version: string,
+		name: string,
+		args?: Args
+	): 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
+			}
+		};
+	};
+
 	const api: API = {
 		refresh: (): Promise<string> =>
 			axios
-				.get<string>(baseURL + '/api/account/refresh-token', {
-					headers: { Authorization: 'jwt ' + token }
-				})
+				.get<string>(getURL('/api/account/refresh-token'), getConfig())
 				.then(res => res.data),
 
+		ready: (): Promise<boolean> =>
+			axios
+				.get<boolean>(getURL('/api/readiness'), getConfig())
+				.then(res => res.status == 200),
+
 		validate: (): Promise<boolean> =>
 			axios
-				.get<boolean>(baseURL + '/validate', {
-					headers: { Authorization: 'jwt ' + token }
-				})
+				.get<boolean>(getURL('/validate'), getConfig())
 				.then(res => res.data),
 
 		deployEnabled: (): Promise<boolean> =>
 			axios
-				.get<boolean>(baseURL + '/api/account/deploy-enabled', {
-					headers: { Authorization: 'jwt ' + token }
-				})
+				.get<boolean>(
+					getURL('/api/account/deploy-enabled'),
+					getConfig()
+				)
 				.then(res => res.data),
 
 		listSubscriptions: async (): Promise<SubscriptionMap> => {
 			const res = await axios.get<string[]>(
-				baseURL + '/api/billing/list-subscriptions',
-				{
-					headers: { Authorization: 'jwt ' + token }
-				}
+				getURL('/api/billing/list-subscriptions'),
+				getConfig()
 			);
 
 			const subscriptions: SubscriptionMap = {};
@@ -136,23 +212,31 @@ export default (token: string, baseURL: string): API => {
 			return subscriptions;
 		},
 
-		listSubscriptionsDeploys: async (): Promise<SubscriptionDeploy[]> =>
+		listSubscriptionsDeploys: (): Promise<SubscriptionDeploy[]> =>
 			axios
 				.get<SubscriptionDeploy[]>(
-					baseURL + '/api/billing/list-subscriptions-deploys',
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getURL('/api/billing/list-subscriptions-deploys'),
+					getConfig()
 				)
 				.then(res => res.data),
 
-		inspect: async (): Promise<Deployment[]> =>
+		inspect: (): Promise<Deployment[]> =>
 			axios
-				.get<Deployment[]>(baseURL + '/api/inspect', {
-					headers: { Authorization: 'jwt ' + token }
-				})
+				.get<Deployment[]>(getURL('/api/inspect'), getConfig())
 				.then(res => res.data),
 
+		inspectByName: async (suffix: string): Promise<Deployment> => {
+			const deployments = await api.inspect();
+
+			const deploy = deployments.find(deploy => deploy.suffix == suffix);
+
+			if (!deploy) {
+				throw new Error(`Deployment with suffix '${suffix}' not found`);
+			}
+
+			return deploy;
+		},
+
 		upload: async (
 			name: string,
 			blob: unknown,
@@ -169,14 +253,9 @@ export default (token: string, baseURL: string): API => {
 				contentType: 'application/x-zip-compressed'
 			});
 			const res = await axios.post<string>(
-				baseURL + '/api/package/create',
+				getURL('/api/package/create'),
 				fd,
-				{
-					headers: {
-						Authorization: 'jwt ' + token,
-						...(fd.getHeaders?.() ?? {}) // operator chaining to make it compatible with frontend
-					}
-				}
+				getConfig(fd.getHeaders?.() ?? {}) // Operator chaining to make it compatible with frontend
 			);
 			return res.data;
 		},
@@ -186,30 +265,26 @@ export default (token: string, baseURL: string): API => {
 			jsons: MetaCallJSON[] = []
 		): Promise<AddResponse> =>
 			axios
-				.post<string>(
-					baseURL + '/api/repository/add',
+				.post<AddResponse>(
+					getURL('/api/repository/add'),
 					{
 						url,
 						branch,
 						jsons
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
-				.then((res: AxiosResponse) => res.data as AddResponse),
+				.then(res => res.data),
 		branchList: (url: string): Promise<Branches> =>
 			axios
-				.post<string>(
-					baseURL + '/api/repository/branchlist',
+				.post<Branches>(
+					getURL('/api/repository/branchlist'),
 					{
 						url
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
-				.then((res: AxiosResponse) => res.data as Branches),
+				.then(res => res.data),
 
 		deploy: (
 			name: string,
@@ -221,7 +296,7 @@ export default (token: string, baseURL: string): API => {
 		): Promise<Create> =>
 			axios
 				.post<Create>(
-					baseURL + '/api/deploy/create',
+					getURL('/api/deploy/create'),
 					{
 						resourceType,
 						suffix: name,
@@ -230,9 +305,7 @@ export default (token: string, baseURL: string): API => {
 						plan,
 						version
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
 				.then(res => res.data),
 
@@ -243,15 +316,13 @@ export default (token: string, baseURL: string): API => {
 		): Promise<string> =>
 			axios
 				.post<string>(
-					baseURL + '/api/deploy/delete',
+					getURL('/api/deploy/delete'),
 					{
 						prefix,
 						suffix,
 						version
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
 				.then(res => res.data),
 
@@ -264,7 +335,7 @@ export default (token: string, baseURL: string): API => {
 		): Promise<string> =>
 			axios
 				.post<string>(
-					baseURL + '/api/deploy/logs',
+					getURL('/api/deploy/logs'),
 					{
 						container,
 						type,
@@ -272,26 +343,137 @@ export default (token: string, baseURL: string): API => {
 						prefix,
 						version
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
 				.then(res => res.data),
 
 		fileList: (url: string, branch: string): Promise<string[]> =>
 			axios
 				.post<{ [k: string]: string[] }>(
-					baseURL + '/api/repository/filelist',
+					getURL('/api/repository/filelist'),
 					{
 						url,
 						branch
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
-				.then(res => res.data['files'])
+				.then(res => res.data['files']),
+
+		invoke: <Result, Args = unknown>(
+			type: InvokeType,
+			prefix: string,
+			suffix: string,
+			version = 'v1',
+			name: string,
+			args?: Args
+		): Promise<Result> => {
+			const url = getURL(
+				`/${prefix}/${suffix}/${version}/${type}/${name}`
+			);
+			const config = getConfig();
+
+			const req =
+				args === undefined
+					? axios.get<Result>(url, config)
+					: axios.post<Result>(url, args, config);
+
+			return req.then(res => res.data);
+		},
+
+		call: <Result, Args = unknown>(
+			prefix: string,
+			suffix: string,
+			version = 'v1',
+			name: string,
+			args?: Args
+		): Promise<Result> =>
+			api.invoke(InvokeType.Call, prefix, suffix, version, name, args),
+
+		await: <Result, Args = unknown>(
+			prefix: string,
+			suffix: string,
+			version = 'v1',
+			name: string,
+			args?: Args
+		): Promise<Result> =>
+			api.invoke(InvokeType.Await, prefix, suffix, version, name, args)
 	};
 
 	return api;
 };
+
+export const MaxRetries = 30;
+export const MaxRetryInterval = 2000;
+export const MaxFuncLength = 64;
+
+/**
+ * Executes an asynchronous function with automatic retry logic.
+ *
+ * The function will be retried up to `maxRetries` times, waiting `interval`
+ * milliseconds between each attempt. If all retries fail, the last error is
+ * wrapped in a new `Error` with a descriptive message, including:
+ * - Function name (or string representation truncated to `MaxFuncLength` chars if anonymous)
+ * - Number of retries attempted
+ * - Original error message
+ *
+ * Error handling is fully type-safe:
+ * - If the error is an ProtocolError (checked via `isProtocolError`), its
+ *   message is used.
+ * - If the error is a standard `Error`, its `message` is used.
+ * - Otherwise, the error is converted to a string.
+ *
+ * @typeParam T - The return type of the function being retried.
+ * @param fn - A lambda or bound function returning a `Promise<T>`. The
+ *             function should contain the logic you want to retry.
+ * @param maxRetries - Maximum number of retry attempts. Default: `MaxRetries`.
+ * @param interval - Delay between retries in milliseconds. Default: `MaxRetryInterval`.
+ * @returns A `Promise` resolving to the return value of `fn` if successful.
+ * @throws Error If all retry attempts fail, throws a new Error containing
+ *                 information about the function and the last error.
+ *
+ * @example
+ * ```ts
+ * const deployment = await waitFor(() => api.inspectByName('my-suffix'));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const result = await waitFor(
+ *   () => api.deploy(name, env, plan, resourceType)
+ * );
+ * ```
+ */
+export const waitFor = async <T>(
+	fn: () => Promise<T>,
+	maxRetries: number = MaxRetries,
+	interval: number = MaxRetryInterval
+): Promise<T> => {
+	let retry = 0;
+
+	for (;;) {
+		try {
+			return await fn();
+		} catch (error) {
+			retry++;
+			if (retry >= maxRetries) {
+				const fnStr = fn.toString();
+				const func =
+					fn.name ||
+					(fnStr.length > MaxFuncLength
+						? fnStr.slice(0, MaxFuncLength) + '...'
+						: fnStr);
+				const message = isProtocolError(error)
+					? (error as ProtocolError).message
+					: 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/tsconfig.json

@@ -1,8 +1,9 @@
 {
 	"compilerOptions": {
 		"strict": true,
-		"lib": ["ES2020"],
-		"target": "ES2019",
+		"lib": ["es2020", "dom"],
+		"moduleResolution": "node",
+		"target": "es2020",
 		"module": "CommonJS",
 		"outDir": "dist",
 		"esModuleInterop": true,