zcatalyst-cli 1.21.0 → 1.22.1

package/lib/shell/dependencies/non-http-function/slave-manager.js

@@ -0,0 +1,173 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlaveManager = void 0;
+const error_1 = __importDefault(require("../../../error"));
+const runtime_store_1 = __importDefault(require("../../../runtime-store"));
+const path_1 = require("path");
+const fs_1 = require("../../../util_modules/fs");
+const constants_1 = require("../../../util_modules/constants");
+const logger_1 = require("../../../util_modules/logger");
+const credential_1 = __importDefault(require("../../../authentication/credential"));
+const project_1 = require("../../../util_modules/project");
+const port_resolver_1 = __importDefault(require("../../../port-resolver"));
+const fn_utils_1 = require("../../../fn-utils");
+const container_1 = require("../../../util_modules/container");
+const fn_execution_handler_1 = require("./fn-execution-handler");
+class SlaveManager extends fn_execution_handler_1.FnExecutionHandler {
+    constructor(fn, repl, localFnEvents) {
+        var _a, _b, _c, _d, _e;
+        super(fn, localFnEvents);
+        this.killed = false;
+        this.isContainer = (0, container_1.isContainer)();
+        this.call = (shell = true) => (rawData = {}) => {
+            var _a;
+            let data = {};
+            try {
+                if (shell) {
+                    if (typeof rawData === 'string') {
+                        const content = fs_1.SYNC.readJSONFile((0, path_1.resolve)(runtime_store_1.default.get('cwd'), rawData));
+                        if (content === undefined) {
+                            return new error_1.default('content is undefined for provided file path');
+                        }
+                        data = content;
+                    }
+                    else {
+                        if (typeof rawData !== 'object') {
+                            return new error_1.default('content is not of type object');
+                        }
+                        data = Object.assign({}, rawData);
+                    }
+                    switch ((_a = this.fn.target) === null || _a === void 0 ? void 0 : _a.type) {
+                        case constants_1.FN_TYPE.cron: {
+                            data = { data };
+                            break;
+                        }
+                        case constants_1.FN_TYPE.event:
+                            if (!('event_bus_details' in data)) {
+                                (0, logger_1.info)('For event function kindly use event:generate command to generate the input json.');
+                                (0, logger_1.info)('You can also provide event details as per documentation.');
+                                return new error_1.default('Event bus details missing', {
+                                    exit: 1,
+                                    skipHelp: true
+                                });
+                            }
+                            break;
+                    }
+                }
+                else {
+                    if (typeof rawData === 'string') {
+                        return new error_1.default('tunnel data cannot be of type string', {
+                            exit: 1
+                        });
+                    }
+                    data = Object.assign({}, rawData);
+                }
+            }
+            catch (e) {
+                (0, logger_1.info)('the input must be in the form of json or a path to a file containing json data.');
+                return new error_1.default('Invalid input');
+            }
+            return (() => __awaiter(this, void 0, void 0, function* () {
+                var _b, _c, _d, _e, _f, _g, _h, _j, _k;
+                if (!this.fn.target) {
+                    throw new error_1.default('Invalid function target: ' + this.fn.target, {
+                        exit: 2
+                    });
+                }
+                const accessToken = yield credential_1.default.getAccessToken();
+                yield fs_1.ASYNC.ensureFile(this.responseFile, true);
+                yield fs_1.ASYNC.ensureFile(this.metaFile, true);
+                if (((_b = this.fn.target) === null || _b === void 0 ? void 0 : _b.type) === constants_1.FN_TYPE.job) {
+                    if ('params' in data) {
+                        data.job_details = Object.assign({
+                            job_meta_details: {
+                                params: data.params
+                            }
+                        }, (data.job_details || {}));
+                        delete data.params;
+                    }
+                    const jobData = data;
+                    const jobMetaDetails = {
+                        headers: Object.assign(Object.assign({}, (_d = (_c = jobData === null || jobData === void 0 ? void 0 : jobData.job_details) === null || _c === void 0 ? void 0 : _c.job_meta_details) === null || _d === void 0 ? void 0 : _d.headers), {
+                            'x-zc-projectid': (0, project_1.getProjectId)(),
+                            'x-zc-project-domain': (0, project_1.getDomainPrefix)() + '.' + constants_1.ORIGIN.app.replace('https://', ''),
+                            'x-zc-project-key': (0, project_1.getDomainKey)(),
+                            'x-zc-environment': (0, project_1.getEnvName)(),
+                            'x-zc-user-cred-type': 'token',
+                            'x-zc-user-cred-token': accessToken,
+                            'x-zc-admin-cred-type': 'token',
+                            'x-zc-admin-cred-token': accessToken,
+                            'x-zc-user-type': 'admin'
+                        }),
+                        params: ((_f = (_e = jobData === null || jobData === void 0 ? void 0 : jobData.job_details) === null || _e === void 0 ? void 0 : _e.job_meta_details) === null || _f === void 0 ? void 0 : _f.params) || {},
+                        jobpool_details: Object.assign({ type: 'Function', project_details: {
+                                project_name: (0, project_1.getProjectName)(),
+                                id: (0, project_1.getProjectId)()
+                            } }, (_h = (_g = jobData === null || jobData === void 0 ? void 0 : jobData.job_details) === null || _g === void 0 ? void 0 : _g.job_meta_details) === null || _h === void 0 ? void 0 : _h.jobpool_details)
+                    };
+                    jobData.job_details = Object.assign(Object.assign({}, jobData.job_details), { capacity: jobData.capacity || {
+                            memory: '256'
+                        }, job_meta_details: jobMetaDetails });
+                    jobData.capacity = jobData.capacity || {
+                        memory: '256'
+                    };
+                    data = jobData;
+                }
+                if (this.isContainer) {
+                    yield this.executeWithContainer(data, accessToken);
+                }
+                else {
+                    yield this.execute(data, accessToken);
+                }
+                if (!this.slave) {
+                    throw new error_1.default('Slave listening started before initializing', {
+                        exit: 2
+                    });
+                }
+                (_j = this.slave.stdout) === null || _j === void 0 ? void 0 : _j.on('data', (message) => {
+                    process.stdout.write(message.toString());
+                });
+                (_k = this.slave.stderr) === null || _k === void 0 ? void 0 : _k.on('data', (message) => {
+                    process.stderr.write(message.toString());
+                });
+                this.slave.on('error', (err) => {
+                    this.localFnEvents.listenerCount('error') > 0 &&
+                        this.localFnEvents.emit('error', err);
+                });
+                this.slave.once('exit', (code, sig) => __awaiter(this, void 0, void 0, function* () {
+                    (0, logger_1.debug)(`local fn slave exit: ${code}, ${sig}`);
+                    if (this.isContainer && [143, 130].includes(code)) {
+                        code = 0;
+                    }
+                    yield this.fnResponseHandler(code, sig);
+                    if (this.fn.debugPort !== -1) {
+                        port_resolver_1.default.freePort(this.fn.debugPort);
+                    }
+                    this.repl.resume();
+                    this.repl.showPrompt();
+                }));
+                return this.slave;
+            }))();
+        };
+        this.repl = repl;
+        const projectRoot = (0, project_1.getProjectRoot)();
+        this.watcher = (_a = fn.target) === null || _a === void 0 ? void 0 : _a.watcher;
+        if ((_c = (_b = this.fn.target) === null || _b === void 0 ? void 0 : _b.stack) === null || _c === void 0 ? void 0 : _c.startsWith(constants_1.RUNTIME.language.java.value)) {
+            this.javaInvoker = (0, path_1.join)(projectRoot, constants_1.FOLDERNAME.build, '.catalyst', (_d = this.fn.target) === null || _d === void 0 ? void 0 : _d.stack, 'Java' + ((_e = this.fn.target) === null || _e === void 0 ? void 0 : _e.type) + 'Invoker');
+            fn_utils_1.fnUtils.java.ensureJavaInvoker(this.javaInvoker, (0, path_1.normalize)((0, path_1.join)(__dirname, '../invoker', this.fn.target.type, 'java', 'Java' + this.fn.target.type + 'Invoker.java')), this.fn.target);
+        }
+    }
+}
+exports.SlaveManager = SlaveManager;

package/lib/shell/dependencies/tunnel-server.d.ts

@@ -0,0 +1,23 @@
+import express from 'express';
+import Repl from '../../repl-server';
+import LocalFunction from './non-http-function';
+type TTunnelData = {
+    function_data: Record<string, unknown>;
+    function_details: {
+        project_id: string;
+        function_name: string;
+        function_id: string;
+        function_type: 'cron' | 'event' | 'job' | 'integration';
+    };
+    default: Record<string, unknown>;
+};
+export default class TunnelServer {
+    #private;
+    constructor(repel: Repl);
+    isAsyncFn(fnType: TTunnelData['function_details']['function_type']): boolean;
+    send(req: express.Request, res: express.Response, status?: number, data?: string, contentType?: string): Promise<void>;
+    startServer(): Promise<void>;
+    addContext(name: string, target: LocalFunction): this;
+    stopServer(): Promise<void>;
+}
+export {};

package/lib/shell/dependencies/tunnel-server.js

@@ -27,7 +27,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
 const runtime_store_1 = __importDefault(require("../../runtime-store"));
 const error_1 = __importDefault(require("../../error"));
-const logger_1 = require("../../util_modules/logger");
+const index_1 = require("../../util_modules/logger/index");
 const port_resolver_1 = __importDefault(require("../../port-resolver"));
 const server_1 = require("../../util_modules/server");
 const ansi_colors_1 = require("ansi-colors");
@@ -72,7 +72,7 @@ class TunnelServer {
             if (Number.isNaN(tunnelPortOpt)) {
                 return;
             }
-            const port = yield port_resolver_1.default.getFreePort(tunnelPortOpt).catch((e) => (0, logger_1.debug)(e));
+            const port = yield port_resolver_1.default.getFreePort(tunnelPortOpt).catch((e) => (0, index_1.debug)(e));
             if (!port || tunnelPortOpt !== port) {
                 throw new error_1.default(`Port unavailable ${tunnelPortOpt}`, {
                     exit: 1,
@@ -138,7 +138,7 @@ class TunnelServer {
                     target.call(false)(fnData);
                     const errorHandler = (e) => __awaiter(this, void 0, void 0, function* () {
                         yield this.send(req, res, 500);
-                        (0, logger_1.debug)('Target error: ' + e);
+                        (0, index_1.debug)('Target error: ' + e);
                     });
                     target.once('error', errorHandler);
                     const response = yield new Promise((resolve, reject) => {
@@ -154,7 +154,7 @@ class TunnelServer {
                 }
                 catch (e) {
                     yield this.send(req, res, 500);
-                    (0, logger_1.debug)(e);
+                    (0, index_1.debug)(e);
                 }
             }));
             return new Promise((res, rej) => {

package/lib/shell/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/shell/index.js

@@ -16,15 +16,15 @@ const path_1 = require("path");
 const util_1 = require("util");
 const repl_server_1 = __importDefault(require("../repl-server"));
 const ansi_colors_1 = require("ansi-colors");
-const error_1 = __importDefault(require("../error"));
+const index_1 = __importDefault(require("../error/index"));
 const fn_utils_1 = require("../fn-utils");
 const runtime_store_1 = __importDefault(require("../runtime-store"));
 const constants_1 = require("../util_modules/constants");
 const fs_1 = require("../util_modules/fs");
-const logger_js_1 = require("../util_modules/logger.js");
+const index_2 = require("../util_modules/logger/index");
 const option_1 = require("../util_modules/option");
 const http_functions_1 = __importDefault(require("./dependencies/http-functions"));
-const local_function_1 = __importDefault(require("./dependencies/local-function"));
+const non_http_function_1 = __importDefault(require("./dependencies/non-http-function"));
 const prepare_1 = __importDefault(require("./prepare"));
 const fn_watcher_1 = __importDefault(require("../fn-watcher"));
 const tunnel_server_1 = __importDefault(require("./dependencies/tunnel-server"));
@@ -36,7 +36,9 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
         writer: (output) => {
             if (output !== undefined) {
                 if (output instanceof Promise) {
-                    return '[cli] Function has been invoked\n';
+                    replServer.pause();
+                    output.finally(() => replServer.resume());
+                    return '[cli] Function has been invoked';
                 }
                 if (output instanceof Error) {
                     return ansi_colors_1.bold.red('Error: ') + output.message;
@@ -49,24 +51,28 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
     const httpServer = new http_functions_1.default({ repl: replServer });
     const tunnelServer = new tunnel_server_1.default(replServer);
     const projectRoot = runtime_store_1.default.get('project.root');
-    yield (0, prepare_1.default)([constants_1.FN_TYPE.basic, constants_1.FN_TYPE.cron, constants_1.FN_TYPE.event, constants_1.FN_TYPE.integration, constants_1.FN_TYPE.job]);
+    yield (0, prepare_1.default)([constants_1.FN_TYPE.basic, constants_1.FN_TYPE.cron, constants_1.FN_TYPE.event, constants_1.FN_TYPE.integration, constants_1.FN_TYPE.job], true);
     const targets = runtime_store_1.default
         .get('context.functions.targets', [])
         .filter((target) => {
         if (!target.valid) {
-            (0, logger_js_1.warning)('target [' +
+            (0, index_2.warning)('target [' +
                 target.name +
                 '] is not a valid one reason : ' +
                 target.failure_reason);
-            Array.isArray(target.compilationError) &&
-                target.compilationError.forEach((er) => (0, logger_js_1.error)(er));
-            Array.isArray(target.compilationWarning) &&
-                target.compilationWarning.forEach((warn) => (0, logger_js_1.warning)(warn));
+            target.failure_reason instanceof Error &&
+                (0, index_2.debug)(`Invalid function target :: ${target.name} :: ${(0, util_1.inspect)(target.failure_reason)}`);
+            if (target.additionalInfo && 'compilerOut' in target.additionalInfo) {
+                Array.isArray(target.additionalInfo.compilerOut.error) &&
+                    target.additionalInfo.compilerOut.error.forEach((er) => (0, index_2.error)(er));
+                Array.isArray(target.additionalInfo.compilerOut.warning) &&
+                    target.additionalInfo.compilerOut.warning.forEach((warn) => (0, index_2.warning)(warn));
+            }
         }
         return target.valid;
     });
     if (targets.length === 0) {
-        throw new error_1.default('No functions are ready for serving', {
+        throw new index_1.default('No functions are ready for serving', {
             exit: 0,
             errorId: 'SHELL-IDX-1'
         });
@@ -81,19 +87,19 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
                 yield _tunnelAPI.enableTunnel(typeof tunnelUrl === 'string' ? tunnelUrl : undefined);
             }
             catch (er) {
-                const _er = error_1.default.getErrorInstance(er);
+                const _er = index_1.default.getErrorInstance(er);
                 !replServer.closed && replServer.close();
                 yield tunnelServer.stopServer();
                 if (_er.status === 400) {
                     const data = (_a = _er.context) === null || _a === void 0 ? void 0 : _a.body.data;
-                    throw new error_1.default('Unable to enable tunnel: ' + _er.message, {
+                    throw new index_1.default('Unable to enable tunnel: ' + _er.message, {
                         exit: 1,
                         original: _er,
                         errorId: 'SHELL-IDX-2',
                         arg: [ansi_colors_1.italic.red(data.message + ''), ansi_colors_1.italic.red(data.error_code + '')]
                     });
                 }
-                throw new error_1.default('Unable to enable tunnel: ' + _er.message, {
+                throw new index_1.default('Unable to enable tunnel: ' + _er.message, {
                     exit: 2,
                     original: _er
                 });
@@ -102,14 +108,14 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
         }
         const watchOpt = (0, option_1.getOptionValue)('watch');
         if (watchOpt === true) {
-            (0, logger_js_1.info)();
-            (0, logger_js_1.labeled)('DEPRECATED', `The ${ansi_colors_1.italic.bold('--watch')} option is deprecated. \nThe watch mode will be enabled by default. If you wish to disable it use the ${ansi_colors_1.italic.bold('--no-watch')} option. \nPlease execute ${(0, ansi_colors_1.bold)('catalyst functions:shell ' + (0, ansi_colors_1.italic)('--help'))} command for more usage details.`).WARN();
+            (0, index_2.info)();
+            (0, index_2.labeled)('DEPRECATED', `The ${ansi_colors_1.italic.bold('--watch')} option is deprecated. \nThe watch mode will be enabled by default. If you wish to disable it use the ${ansi_colors_1.italic.bold('--no-watch')} option. \nPlease execute ${(0, ansi_colors_1.bold)('catalyst functions:shell ' + (0, ansi_colors_1.italic)('--help'))} command for more usage details.`).WARN();
         }
         yield Promise.all(targets.map((target) => __awaiter(void 0, void 0, void 0, function* () {
             if (watchOpt !== false) {
                 yield (0, fn_watcher_1.default)(target);
             }
-            const localFn = new local_function_1.default(replServer, target);
+            const localFn = new non_http_function_1.default(replServer, target);
             replServer.setContext(target.name, localFn.call());
             tunnelServer.addContext(target.id || target.name, localFn);
             target.localFn = localFn;
@@ -127,24 +133,24 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
                 const tunnelDetails = yield _tunnelAPI.getTunnel();
                 if (tunnelDetails.tunnel_status === 'Enabled') {
                     yield _tunnelAPI.disableTunnel();
-                    (0, logger_js_1.info)();
-                    (0, logger_js_1.info)(ansi_colors_1.green.bold('Tunneling disabled'));
+                    (0, index_2.info)();
+                    (0, index_2.info)(ansi_colors_1.green.bold('Tunneling disabled'));
                 }
             }
             catch (er) {
-                (0, logger_js_1.error)('Error disabling the tunnel');
-                (0, logger_js_1.debug)(er);
+                (0, index_2.error)('Error disabling the tunnel');
+                (0, index_2.debug)(er);
             }
         }));
         yield Promise.all(targets.map((target) => __awaiter(void 0, void 0, void 0, function* () {
             if (target.localFn) {
-                return target.localFn.shutdown();
+                return target.localFn.slaveManager.shutdown();
             }
         })));
         yield fs_1.ASYNC.deleteDir((0, path_1.join)(projectRoot, constants_1.FOLDERNAME.build)).catch();
-        fn_utils_1.fnUtils.common.executeHook({ prefix: 'post', command: 'serve' });
-        (0, logger_js_1.info)();
-        (0, logger_js_1.success)('shell complete');
+        yield fn_utils_1.fnUtils.common.executeHook({ prefix: 'post', command: 'serve' });
+        (0, index_2.info)();
+        (0, index_2.success)('shell complete');
     }
     catch (e) {
         !replServer.closed && replServer.close();

package/lib/shell/prepare/index.d.ts

@@ -0,0 +1,4 @@
+import { IFnTarget } from '../../fn-utils/lib/common';
+import { REMOTE_REF } from '../../util_modules/constants';
+declare const _default: (fnTypes: Array<keyof typeof REMOTE_REF.functions.type>, skipFnFilter?: boolean) => Promise<Array<IFnTarget>>;
+export default _default;

package/lib/shell/prepare/index.js

@@ -12,20 +12,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ansi_colors_1 = require("ansi-colors");
 const fn_utils_1 = require("../../fn-utils");
 const common_1 = require("../../fn-utils/lib/common");
+const compile_1 = require("../../fn-utils/lib/java/compile");
 const pip_install_1 = require("../../init/dependencies/python/pip-install");
 const runtime_store_1 = __importDefault(require("../../runtime-store"));
 const throbber_1 = __importDefault(require("../../throbber"));
 const constants_1 = require("../../util_modules/constants");
-const runtime_1 = __importDefault(require("../../util_modules/constants/lib/runtime"));
 const languages_1 = require("./languages");
-const char_1 = require("../../util_modules/char");
-exports.default = (fnTypes) => __awaiter(void 0, void 0, void 0, function* () {
-    fn_utils_1.fnUtils.common.executeHook({ prefix: 'pre', command: 'serve' });
+exports.default = (fnTypes, skipFnFilter = false) => __awaiter(void 0, void 0, void 0, function* () {
+    yield fn_utils_1.fnUtils.common.executeHook({ prefix: 'pre', command: 'serve' });
     const throbber = throbber_1.default.getInstance();
-    const targets = yield fn_utils_1.fnUtils.common.validate();
+    const targets = yield fn_utils_1.fnUtils.common.validate(skipFnFilter);
     let refinedTargets = yield fn_utils_1.fnUtils.common.refineTargets(targets);
     refinedTargets = refinedTargets.map((target) => {
         if (target.type && !fnTypes.includes(target.type)) {
@@ -43,28 +41,12 @@ exports.default = (fnTypes) => __awaiter(void 0, void 0, void 0, function* () {
         return target;
     });
     runtime_store_1.default.set('context.functions.targets', refinedTargets);
-    yield (0, languages_1.prepareFunctions)(refinedTargets);
-    refinedTargets.forEach((target) => {
-        if (target.compilationError) {
-            target.compilationError.forEach((error) => {
-                console.log(`${(0, ansi_colors_1.red)(char_1.CHAR.error)} Error while compiling function[${target.name}]`);
-                console.log(error);
-            });
-        }
-        if (target.compilationWarning) {
-            target.compilationWarning.forEach((warn) => {
-                console.warn(`${(0, ansi_colors_1.yellow)(char_1.CHAR.warning)} Warning while compiling function[${target.name}]`);
-                console.warn(warn);
-            });
-        }
-    });
+    const [_nodeFns, javaFns, pythonFns] = yield (0, languages_1.prepareFunctions)(refinedTargets);
+    javaFns && (0, compile_1.printCompilationLog)(javaFns);
     const pyStacks = [];
-    refinedTargets.filter((target) => {
-        var _a;
-        if (((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.python.value)) &&
-            !pyStacks.includes(target.stack) &&
-            target.valid) {
-            pyStacks.push(target.stack);
+    pythonFns === null || pythonFns === void 0 ? void 0 : pythonFns.filter((target) => {
+        if (!pyStacks.includes(target.stack + '') && target.valid) {
+            pyStacks.push(target.stack + '');
         }
     });
     yield Promise.all(pyStacks.map((stack) => __awaiter(void 0, void 0, void 0, function* () {

package/lib/shell/prepare/languages/index.d.ts

@@ -0,0 +1,6 @@
+import { IFnTarget, JavaFn, NodeFn, PythonFn } from '../../../fn-utils/lib/common';
+export declare function prepareFunctions(targets: Array<IFnTarget>): Promise<[
+    Array<IFnTarget<NodeFn>> | undefined,
+    Array<IFnTarget<JavaFn>> | undefined,
+    Array<IFnTarget<PythonFn>> | undefined
+]>;

package/lib/shell/prepare/languages/index.js

@@ -54,11 +54,26 @@ function python(targets) {
 }
 function prepareFunctions(targets) {
     return __awaiter(this, void 0, void 0, function* () {
-        return Promise.all([
-            node(targets.filter((target) => { var _a; return ((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.node.value)) && target.valid; })),
-            java(targets.filter((target) => { var _a; return ((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.java.value)) && target.valid; })),
-            python(targets.filter((target) => { var _a; return ((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.python.value)) && target.valid; }))
-        ]);
+        const nodeFns = [];
+        const javaFns = [];
+        const pythonFns = [];
+        targets.forEach((tar) => {
+            var _a, _b, _c;
+            if (!tar.valid) {
+                return;
+            }
+            if ((_a = tar.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.node.value)) {
+                return nodeFns.push(tar);
+            }
+            if ((_b = tar.stack) === null || _b === void 0 ? void 0 : _b.startsWith(runtime_1.default.language.java.value)) {
+                return javaFns.push(tar);
+            }
+            if ((_c = tar.stack) === null || _c === void 0 ? void 0 : _c.startsWith(runtime_1.default.language.python.value)) {
+                return pythonFns.push(tar);
+            }
+            return;
+        });
+        return Promise.all([node(nodeFns), java(javaFns), python(pythonFns)]);
     });
 }
 exports.prepareFunctions = prepareFunctions;

package/lib/shell/prepare/languages/java.d.ts

@@ -0,0 +1,3 @@
+import { IFnTarget, JavaFn } from '../../../fn-utils/lib/common';
+declare const _default: (targets?: Array<IFnTarget<JavaFn>>) => Promise<Array<IFnTarget<JavaFn>> | undefined>;
+export default _default;

package/lib/shell/prepare/languages/java.js

@@ -25,30 +25,22 @@ exports.default = (targets) => __awaiter(void 0, void 0, void 0, function* () {
         return;
     }
     const throbber = throbber_1.default.getInstance();
-    yield fn_utils_1.fnUtils.java.validate(targets, 0);
-    const javaTargets = targets
-        .filter((target) => {
-        if (!target.valid) {
-            throbber.remove('function_serve_' + target.name);
-        }
-        return target.valid;
-    })
-        .map((target) => {
-        fn_utils_1.fnUtils.common.generateUrlForTarget(target);
-        return target;
-    });
+    yield fn_utils_1.fnUtils.java.validate(targets);
     const projectRoot = runtime_store_1.default.get('project.root');
-    return Promise.all(javaTargets.map((target) => __awaiter(void 0, void 0, void 0, function* () {
+    return Promise.all(targets.map((target) => __awaiter(void 0, void 0, void 0, function* () {
         if (!target.valid) {
+            throbber.remove('function_serve_' + target.name);
             return target;
         }
+        fn_utils_1.fnUtils.common.generateUrlForTarget(target);
         const targetBuildPath = (0, path_1.join)(projectRoot, constants_1.FOLDERNAME.build, constants_1.FOLDERNAME.functions, target.name);
         if (yield fs_1.ASYNC.isPathExists(targetBuildPath)) {
             yield fs_1.ASYNC.emptyDir(targetBuildPath);
         }
         if (target.type === constants_1.FN_TYPE.advanced ||
             target.type === constants_1.FN_TYPE.applogic ||
-            target.type === constants_1.FN_TYPE.browserLogic) {
+            target.type === constants_1.FN_TYPE.browserLogic ||
+            target.type === constants_1.FN_TYPE.basic) {
             const javaServer = (0, path_1.join)(projectRoot, constants_1.FOLDERNAME.build, '.catalyst', target.stack, 'aioserver', 'JavaaioServer');
             const javaInvoker = (0, path_1.join)(__dirname, '../../../serve/server/lib/java/aio_server/JavaaioServer.java');
             (0, java_1.ensureJavaInvoker)(javaServer, javaInvoker, target);

package/lib/shell/prepare/languages/node.d.ts

@@ -0,0 +1,3 @@
+import { IFnTarget, NodeFn } from '../../../fn-utils/lib/common';
+declare const _default: (targets?: Array<IFnTarget<NodeFn>>) => Promise<Array<IFnTarget<NodeFn>> | undefined>;
+export default _default;

package/lib/shell/prepare/languages/node.js

@@ -13,17 +13,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
+const error_1 = __importDefault(require("../../../error"));
 const fn_utils_1 = require("../../../fn-utils");
 const runtime_store_1 = __importDefault(require("../../../runtime-store"));
 const throbber_1 = __importDefault(require("../../../throbber"));
 const constants_1 = require("../../../util_modules/constants");
+const index_1 = require("../../../util_modules/logger/index");
 const fs_1 = require("../../../util_modules/fs");
 exports.default = (targets) => __awaiter(void 0, void 0, void 0, function* () {
     if (targets === undefined || targets.length === 0) {
         return;
     }
+    try {
+        yield fn_utils_1.fnUtils.node.checkNodePresence();
+    }
+    catch (err) {
+        (0, index_1.debug)('Check node presence error: ', err);
+        return targets.map((targ) => {
+            targ.valid = false;
+            targ.failure_reason = error_1.default.getErrorInstance(err).message;
+            return targ;
+        });
+    }
     const throbber = throbber_1.default.getInstance();
-    yield fn_utils_1.fnUtils.node.validate(targets, 0);
+    yield fn_utils_1.fnUtils.node.validate(targets);
     const nodeTargets = targets
         .filter((target) => {
         if (!target.valid) {

package/lib/shell/prepare/languages/python.d.ts

@@ -0,0 +1,3 @@
+import { IFnTarget, PythonFn } from '../../../fn-utils/lib/common';
+declare const _default: (targets?: Array<IFnTarget<PythonFn>>) => Promise<Array<IFnTarget<PythonFn>> | undefined>;
+export default _default;

package/lib/shell/prepare/languages/python.js

@@ -26,7 +26,7 @@ exports.default = (targets) => __awaiter(void 0, void 0, void 0, function* () {
         return;
     }
     const throbber = throbber_1.default.getInstance();
-    yield fn_utils_1.fnUtils.python.validate(targets, 0);
+    yield fn_utils_1.fnUtils.python.validate(targets);
     const pyTargets = targets
         .filter((target) => {
         if (!target.valid) {
@@ -38,6 +38,7 @@ exports.default = (targets) => __awaiter(void 0, void 0, void 0, function* () {
         fn_utils_1.fnUtils.common.generateUrlForTarget(target);
         return target;
     });
+    const _debugFns = runtime_store_1.default.get('context.port.debug', {});
     return Promise.all(pyTargets.map((target) => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
         const buildPath = (0, path_1.join)(runtime_store_1.default.get('project.root'), constants_1.FOLDERNAME.build, constants_1.FOLDERNAME.functions, target.name);
@@ -46,11 +47,21 @@ exports.default = (targets) => __awaiter(void 0, void 0, void 0, function* () {
         yield fs_1.ASYNC.emptyDir(buildPath);
         try {
             yield (0, pip_install_1.installRequirements)(reqFile, buildPath, (_a = target.stack) === null || _a === void 0 ? void 0 : _a.replace('python_', ''));
+            const debugFns = _debugFns[target.type] || {};
+            if (debugFns[target.name]) {
+                yield (0, pip_install_1.installPkgs)(['debugpy'], '3_9', buildPath);
+                if (!target.additionalInfo)
+                    target.additionalInfo = { binPath: '' };
+                target.additionalInfo.debug = {
+                    port: Number.parseInt(debugFns[target.name]),
+                    debugger: 'debugpy'
+                };
+            }
         }
         catch (err) {
             const error = error_1.default.getErrorInstance(err);
             target.valid = false;
-            target.failure_reason = error.message;
+            target.failure_reason = error;
         }
         yield fs_1.ASYNC.copyDir(target.source, buildPath);
         throbber.remove('function_serve_' + target.name);

package/lib/slate-utils.d.ts

@@ -0,0 +1,12 @@
+import { ReadStream } from 'fs-extra';
+import { ISlateConfig } from './util_modules/config/lib/slate';
+export declare const slateUtils: {
+    validate: (source: string) => Promise<void>;
+    getSlateFilters(targetStr: string): Array<string>;
+    filterTargets(allTargets: Array<ISlateConfig>): Array<ISlateConfig>;
+    pack: (source?: string) => Promise<{
+        stream: ReadStream;
+        length: number;
+    }>;
+};
+export declare function validateServeCommand(targDetails: Array<ISlateConfig>): Array<ISlateConfig>;