@metacall/protocol 0.1.5

package/dist/protocol.js

@@ -0,0 +1,141 @@
+"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
+
+    refresh: updates the auth token
+    validate: validates the auth token
+    deployEnabled: checks if you're able to deploy
+    listSubscriptions: gives you a list of the subscription available
+    inspect: gives you are deploys with it's endpoints
+    upload: uploads a zip (package) into the faas
+    deploy: deploys the previously uploaded zip into the faas
+    deployDelete: deletes the deploy and the zip
+
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProtocolError = void 0;
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const deployment_1 = require("./deployment");
+const isProtocolError = (err) => axios_1.default.isAxiosError(err);
+exports.isProtocolError = isProtocolError;
+exports.default = (token, baseURL) => {
+    const api = {
+        refresh: () => axios_1.default
+            .get(baseURL + '/api/account/refresh-token', {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then(res => res.data),
+        validate: () => axios_1.default
+            .get(baseURL + '/validate', {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then(res => res.data),
+        deployEnabled: () => axios_1.default
+            .get(baseURL + '/api/account/deploy-enabled', {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then(res => res.data),
+        listSubscriptions: async () => {
+            const res = await axios_1.default.get(baseURL + '/api/billing/list-subscriptions', {
+                headers: { Authorization: 'jwt ' + token }
+            });
+            const subscriptions = {};
+            for (const id of res.data) {
+                if (subscriptions[id] === undefined) {
+                    subscriptions[id] = 1;
+                }
+                else {
+                    ++subscriptions[id];
+                }
+            }
+            return subscriptions;
+        },
+        inspect: async () => axios_1.default
+            .get(baseURL + '/api/inspect', {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then(res => res.data),
+        upload: async (name, blob, jsons = [], runners = []) => {
+            const fd = new form_data_1.default();
+            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(baseURL + '/api/package/create', fd, {
+                headers: {
+                    Authorization: 'jwt ' + token,
+                    ...fd.getHeaders()
+                }
+            });
+            return res.data;
+        },
+        add: (url, branch, jsons = []) => axios_1.default
+            .post(baseURL + '/api/repository/add', {
+            url,
+            branch,
+            jsons
+        }, {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then((res) => res.data),
+        branchList: (url) => axios_1.default
+            .post(baseURL + '/api/repository/branchlist', {
+            url
+        }, {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then((res) => res.data),
+        deploy: (name, env, plan, resourceType, release = Date.now().toString(16), version = 'v1') => axios_1.default
+            .post(baseURL + '/api/deploy/create', {
+            resourceType,
+            suffix: name,
+            release,
+            env,
+            plan,
+            version
+        }, {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then(res => res.data),
+        deployDelete: (prefix, suffix, version = 'v1') => axios_1.default
+            .post(baseURL + '/api/deploy/delete', {
+            prefix,
+            suffix,
+            version
+        }, {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then(res => res.data),
+        logs: (container, type = deployment_1.LogType.Deploy, suffix, prefix, version = 'v1') => axios_1.default
+            .post(baseURL + '/api/deploy/logs', {
+            container,
+            type,
+            suffix,
+            prefix,
+            version
+        }, {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then(res => res.data),
+        fileList: (url, branch) => axios_1.default
+            .post(baseURL + '/api/repository/filelist', {
+            url,
+            branch
+        }, {
+            headers: { Authorization: 'jwt ' + token }
+        })
+            .then(res => res.data['files'])
+    };
+    return api;
+};

package/dist/token.d.ts

@@ -0,0 +1 @@
+export declare const expiresIn: (token: string) => number;

package/dist/token.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expiresIn = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const expiresIn = (token) => {
+    const decoded = jsonwebtoken_1.default.decode(token);
+    if (typeof decoded === 'string') {
+        return 0;
+    }
+    const now = Date.now() / 1000;
+    return new Date(((decoded === null || decoded === void 0 ? void 0 : decoded['exp']) || now) * 1000).getTime() - now * 1000;
+};
+exports.expiresIn = expiresIn;

package/package.json

@@ -0,0 +1,110 @@
+{
+	"name": "@metacall/protocol",
+	"version": "0.1.5",
+	"description": "Tool for deploying into MetaCall FaaS platform.",
+	"exports": {
+		"./*": "./dist/*.js",
+		"./package.json": "./package.json"
+	},
+	"typesVersions": {
+		"*": {
+			"*": [
+				"dist/*.d.ts"
+			]
+		}
+	},
+	"scripts": {
+		"test": "npm run --silent build && mocha dist/test",
+		"unit": "npm run --silent test -- --ignore **/integration**",
+		"prepublishOnly": "npm run --silent build",
+		"build": "npm run --silent lint && tsc",
+		"postinstall": "npm run build",
+		"lint": "eslint . --ignore-pattern dist",
+		"fix": "eslint . --ignore-pattern dist --fix",
+		"doc": "node dist/doc/index.js"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/metacall/protocol.git"
+	},
+	"keywords": [
+		"MetaCall",
+		"FaaS",
+		"protocol"
+	],
+	"author": "Thomas Rory Gummerson <thomas@gummerson.no> (https://trgwii.no/)",
+	"contributors": [
+		"Vicente Eduardo Ferrer Garcia <vic798@gmail.com> (https://metacall.io/)"
+	],
+	"license": "Apache-2.0",
+	"bugs": {
+		"url": "https://github.com/metacall/protocol/issues"
+	},
+	"homepage": "https://github.com/metacall/protocol#readme",
+	"prettier": {
+		"tabWidth": 4,
+		"useTabs": true,
+		"singleQuote": true,
+		"trailingComma": "none",
+		"arrowParens": "avoid"
+	},
+	"eslintConfig": {
+		"env": {
+			"es6": true,
+			"node": true
+		},
+		"plugins": [
+			"@typescript-eslint",
+			"eslint-plugin-tsdoc"
+		],
+		"extends": [
+			"eslint:recommended",
+			"prettier",
+			"plugin:@typescript-eslint/eslint-recommended",
+			"plugin:@typescript-eslint/recommended",
+			"plugin:@typescript-eslint/recommended-requiring-type-checking",
+			"prettier/@typescript-eslint",
+			"plugin:prettier/recommended"
+		],
+		"globals": {
+			"Atomics": "readonly",
+			"SharedArrayBuffer": "readonly"
+		},
+		"parser": "@typescript-eslint/parser",
+		"parserOptions": {
+			"ecmaVersion": 2020,
+			"sourceType": "module",
+			"project": "./tsconfig.json"
+		},
+		"rules": {
+			"tsdoc/syntax": "warn"
+		}
+	},
+	"dependencies": {
+		"@types/ignore-walk": "^4.0.0",
+		"@types/jsonwebtoken": "^8.5.8",
+		"axios": "^0.21.0",
+		"form-data": "^3.0.0",
+		"ignore-walk": "^3.0.4",
+		"jsonwebtoken": "^8.5.1"
+	},
+	"devDependencies": {
+		"@types/express": "^4.17.13",
+		"@types/mocha": "^8.2.2",
+		"@types/node": "^14.14.7",
+		"@types/swagger-ui-express": "^4.1.3",
+		"@types/yamljs": "^0.2.31",
+		"@typescript-eslint/eslint-plugin": "^4.7.0",
+		"@typescript-eslint/parser": "^4.7.0",
+		"eslint": "^7.13.0",
+		"eslint-config-prettier": "^6.15.0",
+		"eslint-plugin-prettier": "^3.1.4",
+		"eslint-plugin-tsdoc": "^0.2.7",
+		"express": "^4.17.2",
+		"mocha": "^9.2.0",
+		"prettier": "^2.1.2",
+		"swagger-ui-express": "^4.3.0",
+		"typescript": "4.3.2",
+		"yamljs": "^0.3.0"
+	}
+}

package/src/deployment.ts

@@ -0,0 +1,118 @@
+/*
+
+* About File:
+	it defines the structure of the deployments (when we do inspect for example), it also defines the structure of metacall.json
+
+*/
+
+export type DeployStatus = 'create' | 'ready' | 'fail';
+
+export enum LogType {
+	Job = 'job',
+	Deploy = 'deploy'
+}
+
+export type LanguageId =
+	| 'node'
+	| 'ts'
+	| 'rb'
+	| 'py'
+	| 'cs'
+	// | 'wasm'
+	// | 'java'
+	// | 'c'
+	| 'cob'
+	| 'file'
+	| 'rpc';
+
+enum ValueId {
+	METACALL_BOOL = 0,
+	METACALL_CHAR = 1,
+	METACALL_SHORT = 2,
+	METACALL_INT = 3,
+	METACALL_LONG = 4,
+	METACALL_FLOAT = 5,
+	METACALL_DOUBLE = 6,
+	METACALL_STRING = 7,
+	METACALL_BUFFER = 8,
+	METACALL_ARRAY = 9,
+	METACALL_MAP = 10,
+	METACALL_PTR = 11,
+	METACALL_FUTURE = 12,
+	METACALL_FUNCTION = 13,
+	METACALL_NULL = 14,
+	METACALL_CLASS = 15,
+	METACALL_OBJECT = 16,
+
+	METACALL_SIZE,
+	METACALL_INVALID
+}
+
+interface Type {
+	name: string;
+	id: ValueId;
+}
+
+interface Return {
+	type: Type;
+}
+
+interface Argument {
+	name: string;
+	type: Type;
+}
+
+interface Signature {
+	ret: Return;
+	args: Argument[];
+}
+
+interface Func {
+	name: string;
+	signature: Signature;
+	async: boolean;
+}
+
+// TODO
+/*
+interface Class {
+
+}
+
+interface Object {
+
+}
+*/
+
+interface Scope {
+	name: string;
+	funcs: Func[];
+	classes: string[]; // TODO: Class[];
+	objects: string[]; // TODO: Object[];
+}
+
+interface Handle {
+	name: string;
+	scope: Scope;
+}
+
+export interface Deployment {
+	status: DeployStatus;
+	prefix: string;
+	suffix: string;
+	version: string;
+	packages: Record<LanguageId, Handle[]>;
+	ports: number[];
+}
+
+export interface Create {
+	suffix: string;
+	prefix: string;
+	version: string;
+}
+
+export type MetaCallJSON = {
+	language_id: LanguageId;
+	path: string;
+	scripts: string[];
+};

package/src/language.ts

@@ -0,0 +1,94 @@
+/*
+
+* About File:
+	this is already documented but it defines the languages supported, extensions, runners, coloring, etc
+
+*/
+
+import { LanguageId } from './deployment';
+
+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
+	runnerFilesRegexes: RegExp[]; // Regex for generating the runners list
+}
+
+export const Languages: Record<LanguageId, Language> = {
+	cs: {
+		tag: 'cs',
+		displayName: 'C#',
+		hexColor: '#953dac',
+		fileExtRegex: /^cs$/,
+		runnerName: 'csharp',
+		runnerFilesRegexes: [/^project\.json$/, /\.csproj$/]
+	},
+	py: {
+		tag: 'py',
+		displayName: 'Python',
+		hexColor: '#ffd43b',
+		fileExtRegex: /^py$/,
+		runnerName: 'python',
+		runnerFilesRegexes: [/^requirements\.txt$/]
+	},
+	rb: {
+		tag: 'rb',
+		displayName: 'Ruby',
+		hexColor: '#e53935',
+		fileExtRegex: /^rb$/,
+		runnerName: 'ruby',
+		runnerFilesRegexes: [/^Gemfile$/]
+	},
+	node: {
+		tag: 'node',
+		displayName: 'NodeJS',
+		hexColor: '#3c873a',
+		fileExtRegex: /^js$/,
+		runnerName: 'nodejs',
+		runnerFilesRegexes: [/^package\.json$/]
+	},
+	ts: {
+		tag: 'ts',
+		displayName: 'TypeScript',
+		hexColor: '#007acc',
+		fileExtRegex: /^(ts|tsx)$/,
+		runnerName: 'nodejs',
+		runnerFilesRegexes: [/^package\.json$/] // TODO: Use tsconfig instead?
+	},
+	file: {
+		tag: 'file',
+		displayName: 'Static Files',
+		hexColor: '#de5500',
+		fileExtRegex: /^\w+$/,
+		runnerName: undefined, // File has no runner (yet?)
+		runnerFilesRegexes: [] // File has no runner files (yet?)
+	},
+	cob: {
+		tag: 'cob',
+		displayName: 'Cobol',
+		hexColor: '#01325a',
+		fileExtRegex: /^(cob|cbl|cbl)$/,
+		runnerName: undefined, // Cobol has no runner (yet?)
+		runnerFilesRegexes: [] // Cobol has no runner files (yet?)
+	},
+	rpc: {
+		tag: 'rpc',
+		displayName: 'RPC',
+		hexColor: '#0f564d',
+		fileExtRegex: /^rpc$/,
+		runnerName: undefined, // RPC has no runner (yet?)
+		runnerFilesRegexes: [] // RPC has no runner files (yet?)
+	}
+};
+
+export const DisplayNameToLanguageId: Record<string, LanguageId> = Object.keys(
+	Languages
+).reduce(
+	(obj, lang) =>
+		Object.assign(obj, {
+			[Languages[lang as LanguageId].displayName]: lang
+		}),
+	{}
+);

package/src/login.ts

@@ -0,0 +1,31 @@
+import axios from 'axios';
+
+interface Request {
+	email: string;
+	password: string;
+	'g-recaptcha-response'?: string;
+}
+
+export default (
+	email: string,
+	password: string,
+	baseURL: string
+): Promise<string> => {
+	const request: Request = {
+		email,
+		password
+	};
+
+	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: baseURL.split('//')[1],
+				Origin: baseURL
+			}
+		})
+		.then(res => res.data);
+};

package/src/package.ts

@@ -0,0 +1,132 @@
+/*
+
+* About File:
+
+	defines a package and its routines, a package is just a metacall.json with some extra details, for example, the runners needed to build a it (for example, if we find a requirements.txt then it means we need to run the python installer pip, so the python runner is needed)
+
+	it includes ignore files (like .gitignore), it is able to list all files in a path and classify them depending on what loader is the correct for each file extension
+
+	generatePackage is an exported function that given a path it generates all the information needed, for example, what runners are needed, what metacall-*.json are generated (depending on file extension) and the list of files that will be in that package (excluding the ones in gitignore)
+
+	generateJsonsFromFiles is similar but it is more fine grained, it uses a list of files and returns what are the metacall-*.json generated from them
+
+*/
+
+import walk from 'ignore-walk';
+import { basename, extname } from 'path';
+import { LanguageId, MetaCallJSON } from './deployment';
+import { Languages } from './language';
+
+export const findFilesPath = async (
+	path: string = process.cwd(),
+	ignoreFiles: string[] = ['.gitignore']
+): Promise<string[]> =>
+	(
+		await walk({
+			path,
+			ignoreFiles,
+			includeEmpty: false,
+			follow: true
+		})
+	).filter(x => !x.startsWith('.git'));
+
+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);
+				}
+			}
+		}
+	}
+
+	return runners;
+};
+
+export enum PackageError {
+	Empty = 'No files found in the current folder',
+	JsonNotFound = 'No metacall.json found in the current folder',
+	None = 'Package correctly generated'
+}
+
+interface PackageDescriptor {
+	error: PackageError;
+	files: string[];
+	jsons: string[];
+	runners: string[];
+}
+
+const NullPackage: PackageDescriptor = {
+	error: PackageError.None,
+	files: [],
+	jsons: [],
+	runners: []
+};
+
+export const generatePackage = async (
+	path: string = process.cwd()
+): Promise<PackageDescriptor> => {
+	const files = await findFilesPath(path);
+
+	if (files.length === 0) {
+		return { ...NullPackage, error: PackageError.Empty };
+	}
+
+	const jsons = findMetaCallJsons(files);
+
+	return {
+		error:
+			jsons.length === 0 ? PackageError.JsonNotFound : PackageError.None,
+		files,
+		jsons,
+		runners: Array.from(findRunners(files))
+	};
+};
+
+const getExtension = (file: string) => {
+	const ext = extname(file || '').split('.');
+	return ext[ext.length - 1];
+};
+
+const matchFilesByLanguage = (lang: LanguageId, files: string[]): string[] =>
+	files.reduce(
+		(arr: string[], file: string) =>
+			Languages[lang].fileExtRegex.exec(
+				getExtension(file) || basename(file)
+			)
+				? [...arr, file]
+				: arr,
+		[]
+	);
+
+export const generateJsonsFromFiles = (files: string[]): MetaCallJSON[] =>
+	(Object.keys(Languages) as LanguageId[]).reduce<MetaCallJSON[]>(
+		(jsons, lang) => {
+			const scripts = matchFilesByLanguage(lang, files);
+
+			if (scripts.length === 0) {
+				return jsons;
+			} else {
+				return [
+					{
+						language_id: lang,
+						path: '.',
+						scripts
+					} as MetaCallJSON,
+					...jsons
+				];
+			}
+		},
+		[]
+	);

package/src/plan.ts

@@ -0,0 +1,5 @@
+export enum Plans {
+	Essential = 'Essential',
+	Standard = 'Standard',
+	Premium = 'Premium'
+}