zcatalyst-cli 1.21.0 → 1.22.0

package/lib/deploy/features/appsail/utils.d.ts

@@ -0,0 +1,15 @@
+import { IRuntime } from '../../../fn-utils/lib/common';
+import { IAppSailServerConfig, TAppSailDetails } from '../../../util_modules/config/lib/appsail';
+export declare function validateOptions<T>(validationFn: (...args: Array<unknown>) => Promise<T | false>, option: string, ...args: Array<unknown>): Promise<T | boolean>;
+export declare function validateBuildPath(path: string): Promise<string | false>;
+export declare function validateStack(stack: string, stackPromise: Promise<IRuntime>): Promise<{
+    runtime: string;
+    lang?: string;
+} | false>;
+export declare function validatePlatform(platform: string, stack: {
+    lang: string;
+    runtime: string;
+}): Promise<string | false>;
+export declare function urlLogger(): Array<TAppSailDetails>;
+export declare function getConfigJsonInputs(): Promise<IAppSailServerConfig>;
+export declare function getStandAloneTarget(): Promise<TAppSailDetails>;

package/lib/deploy/features/appsail/utils.js

@@ -12,13 +12,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.urlLogger = exports.validateName = exports.validatePlatform = exports.validateStack = exports.validateBuildPath = exports.validateOptions = void 0;
+exports.getStandAloneTarget = exports.getConfigJsonInputs = exports.urlLogger = exports.validatePlatform = exports.validateStack = exports.validateBuildPath = exports.validateOptions = void 0;
 const path_1 = require("path");
 const runtime_store_1 = __importDefault(require("../../../runtime-store"));
+const appsail_1 = require("../../../util_modules/config/lib/appsail");
 const constants_1 = require("../../../util_modules/constants");
 const fs_1 = require("../../../util_modules/fs");
-const logger_1 = require("../../../util_modules/logger");
+const common_1 = require("../../../init/util/common");
+const prompt_1 = __importDefault(require("../../../prompt"));
+const project_1 = require("../../../util_modules/project");
+const error_1 = __importDefault(require("../../../error"));
+const index_1 = require("../../../util_modules/logger/index");
 const option_1 = require("../../../util_modules/option");
+const util_1 = require("../../util");
+const ansi_colors_1 = require("ansi-colors");
+const utils_1 = require("../../../init/features/appsail/utils");
 function validateOptions(validationFn, option, ...args) {
     return __awaiter(this, void 0, void 0, function* () {
         const value = (0, option_1.getOptionValue)(option, false);
@@ -27,7 +35,7 @@ function validateOptions(validationFn, option, ...args) {
         }
         const validationRes = yield validationFn(value, ...args);
         if (validationRes === false) {
-            (0, logger_1.debug)(`Invalid value for option: ${option}`);
+            (0, index_1.debug)(`Invalid value for option: ${option}`);
             return false;
         }
         return validationRes;
@@ -67,24 +75,162 @@ function validatePlatform(platform, stack) {
     });
 }
 exports.validatePlatform = validatePlatform;
-function validateName(name) {
+function urlLogger() {
+    const deployTargets = runtime_store_1.default.get('context.payload.appsail.targets', []);
+    (0, util_1.logPaddedLabels)(deployTargets.reduce((logTargs, sail) => {
+        logTargs.push({
+            label: 'DEPLOYMENT SUCCESSFUL',
+            message: sail.name,
+            logType: 'SUCCESS'
+        });
+        logTargs.push({
+            label: 'APPSAIL URL',
+            message: (0, ansi_colors_1.underline)(sail.url || 'Unknown'),
+            logType: 'MESSAGE'
+        });
+        logTargs.push('');
+        return logTargs;
+    }, []));
+    return deployTargets;
+}
+exports.urlLogger = urlLogger;
+function getConfigJsonInputs() {
     return __awaiter(this, void 0, void 0, function* () {
-        if (name.match(constants_1.REGEX.functions.package.name)) {
-            return name;
+        const runtimeDetailsPromise = (0, common_1.getRuntimeDetails)();
+        const stack = yield validateOptions(validateStack, 'stack', runtimeDetailsPromise);
+        const platform = yield validateOptions(validatePlatform, 'platform', stack);
+        const optValues = {
+            build_path: yield validateOptions(validateBuildPath, 'buildPath'),
+            stack,
+            platform,
+            command: (0, option_1.getOptionValue)('command', false)
+        };
+        yield prompt_1.default.register('file-path');
+        const appConfigAns = yield prompt_1.default.ask(prompt_1.default.question('build_path', 'Please provide the build directory of your AppSail:', {
+            type: 'input',
+            when: () => optValues.build_path === false,
+            validate: (value) => __awaiter(this, void 0, void 0, function* () {
+                const pathRes = yield validateBuildPath(value);
+                if (!pathRes) {
+                    return `Invalid path: ${value}`;
+                }
+                return true;
+            })
+        }), prompt_1.default.question('stack', 'Please select the stack for your AppSail:', {
+            type: 'list',
+            choices: yield (0, common_1.getRuntimeChoices)({ runtimeDetails: yield runtimeDetailsPromise }),
+            when: () => optValues.stack === false
+        }), prompt_1.default.question('platform', 'Please choose a platform for your AppSail: ', {
+            type: 'list',
+            choices: [
+                prompt_1.default.choice('JavaSE', {
+                    value: 'javase',
+                    short: 'JavaSE'
+                }),
+                prompt_1.default.choice('JavaWAR', {
+                    value: 'war',
+                    short: 'JavaWAR'
+                })
+            ],
+            when: (answers) => {
+                var _a;
+                const _stack = ((_a = answers.stack) === null || _a === void 0 ? void 0 : _a.lang) ||
+                    (typeof optValues.stack === 'boolean' ? '' : optValues.stack.lang) ||
+                    '';
+                return (optValues.platform === false &&
+                    _stack.startsWith(constants_1.RUNTIME.language.java.value));
+            }
+        }), prompt_1.default.question('command', 'Please specify the command to start the AppSail:', {
+            type: 'input',
+            when: (answers) => {
+                var _a;
+                const stack = ((_a = answers.stack) === null || _a === void 0 ? void 0 : _a.lang) ||
+                    (typeof optValues.stack === 'boolean' ? '' : optValues.stack.lang) ||
+                    '';
+                const _platform = answers.platform || optValues.platform || '';
+                return (optValues.command === false &&
+                    !(stack.startsWith(constants_1.RUNTIME.language.java.value) &&
+                        _platform === 'war'));
+            }
+        }));
+        const finalConfig = Object.entries(optValues).reduce((config, [key, val]) => {
+            config[key] = val === false ? appConfigAns[key] : val;
+            return config;
+        }, {});
+        if (typeof finalConfig.stack !== 'string') {
+            finalConfig.stack = finalConfig.stack.runtime;
         }
-        return false;
+        if (!finalConfig.stack.startsWith(constants_1.RUNTIME.language.java.value) &&
+            finalConfig.platform) {
+            (0, index_1.message)('Platform argument is not supported for stack: ' + finalConfig.stack);
+            delete finalConfig.platform;
+        }
+        if (finalConfig.platform === 'war' && finalConfig.command) {
+            (0, index_1.message)('Command argument not need for platform type war');
+            delete finalConfig.command;
+        }
+        return finalConfig;
     });
 }
-exports.validateName = validateName;
-function urlLogger() {
-    const deployTargets = runtime_store_1.default.get('payload.appsail.targets', []);
-    deployTargets.forEach((sail) => {
-        if (sail.url !== undefined) {
-            (0, logger_1.labeled)(`AppSail(${sail.name})`, 'URL => ' + sail.url).MESSAGE();
+exports.getConfigJsonInputs = getConfigJsonInputs;
+function getStandAloneTarget() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const isProjectInfo = (0, project_1.getProjectId)(false) || (0, project_1.getProjectName)(false);
+        if (!isProjectInfo) {
+            throw new error_1.default('Project info is not present');
+        }
+        const cwd = runtime_store_1.default.get('cwd');
+        const catalystConfigPath = (0, path_1.join)(cwd, constants_1.FILENAME.app_config);
+        const imgSourceOpt = (0, option_1.getOptionValue)('source');
+        const imgSource = yield (() => __awaiter(this, void 0, void 0, function* () {
+            const tag = imgSourceOpt;
+            if (tag === undefined) {
+                (0, index_1.debug)('--source option not specified. Hence, using Catalyst runtime');
+                return false;
+            }
+            if (tag.startsWith(appsail_1.CONTAINER_IMAGE_PROTOCOLS.dockerArchive)) {
+                const tarPath = tag.replace(appsail_1.CONTAINER_IMAGE_PROTOCOLS.dockerArchive, '');
+                const normalizedTarPath = (0, path_1.isAbsolute)(tarPath) ? tarPath : (0, path_1.resolve)(cwd, tarPath);
+                return `docker-archive://${normalizedTarPath}`;
+            }
+            return tag;
+        }))();
+        const nameOpt = yield validateOptions(((name) => __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.info)();
+            (0, index_1.warning)(`Skipping ${(0, ansi_colors_1.yellow)('--name')} option. Since AppSail name value supplied with the option is invalid`);
+            (0, index_1.warning)('Name must contain only alphanumeric and hyphen');
+            (0, index_1.info)();
+            return name.match(constants_1.REGEX.appsail.name) ? name : false;
+        })), 'name');
+        const appSailName = yield (0, utils_1.getAppSailName)();
+        if (typeof imgSource === 'string') {
+            return {
+                source: imgSource,
+                runtime: 'custom',
+                name: typeof nameOpt === 'boolean' ? appSailName : nameOpt,
+                validity: {
+                    valid: true
+                },
+                config: {
+                    command: (0, option_1.getOptionValue)('command', undefined),
+                    port: {
+                        http: Number((0, option_1.getOptionValue)('port', undefined)) || undefined
+                    },
+                    raw: {}
+                }
+            };
+        }
+        const configJson = (yield fs_1.ASYNC.readJSONFile(catalystConfigPath).catch((err) => (0, index_1.debug)(err))) || (yield getConfigJsonInputs());
+        if (typeof configJson.stack === 'object') {
+            configJson.stack = configJson.stack.runtime;
         }
-        (0, logger_1.labeled)(`AppSail(${sail.name})`, 'deploy successful').SUCCESS();
-        (0, logger_1.info)();
+        return {
+            name: typeof nameOpt === 'boolean' ? appSailName : nameOpt,
+            runtime: 'catalyst',
+            source: cwd,
+            config: configJson,
+            validity: { valid: true }
+        };
     });
-    return deployTargets;
 }
-exports.urlLogger = urlLogger;
+exports.getStandAloneTarget = getStandAloneTarget;

package/lib/deploy/features/client.d.ts

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

package/lib/deploy/features/client.js

@@ -17,16 +17,17 @@ const endpoints_1 = require("../../endpoints");
 const runtime_store_1 = __importDefault(require("../../runtime-store"));
 const constants_1 = require("../../util_modules/constants");
 exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
-    client_utils_1.clientUtils.executeHook({ prefix: 'pre', command: 'deploy' });
+    yield client_utils_1.clientUtils.executeHook({ prefix: 'pre', command: 'deploy' });
     yield client_utils_1.clientUtils.validate();
     const readStream = yield client_utils_1.clientUtils.pack();
     const resp = (yield (yield (0, endpoints_1.clientAPI)()).deploy(readStream.stream, readStream.length));
     const homepage = runtime_store_1.default.get('context.client.homepage', '');
-    runtime_store_1.default.set('payload.client.url', 'https://' +
+    runtime_store_1.default.set('context.payload.client.url', 'https://' +
         resp.url_prefix +
         '.' +
         constants_1.ORIGIN.app.replace('https://', '') +
         (homepage.startsWith('/__catalyst') ? homepage : '/app/' + homepage));
-    runtime_store_1.default.set('payload.client.deploy', true);
-    client_utils_1.clientUtils.executeHook({ prefix: 'post', command: 'deploy' });
+    runtime_store_1.default.set('context.payload.client.deploy', true);
+    runtime_store_1.default.set('context.payload.client.name', resp.app_name);
+    yield client_utils_1.clientUtils.executeHook({ prefix: 'post', command: 'deploy' });
 });

package/lib/deploy/features/functions/index.d.ts

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

package/lib/deploy/features/functions/index.js

@@ -14,24 +14,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const ansi_colors_1 = require("ansi-colors");
 const endpoints_1 = require("../../../endpoints");
-const error_1 = __importDefault(require("../../../error"));
+const index_js_1 = __importDefault(require("../../../error/index.js"));
 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 runtime_1 = __importDefault(require("../../../util_modules/constants/lib/runtime"));
-const logger_1 = require("../../../util_modules/logger");
+const index_1 = require("../../../util_modules/logger/index");
 const option_1 = require("../../../util_modules/option");
 const languages_1 = require("./languages");
-const char_1 = require("../../../util_modules/char");
+const compile_1 = require("../../../fn-utils/lib/java/compile");
 exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
-    fn_utils_1.fnUtils.common.executeHook({ prefix: 'pre', command: 'deploy' });
+    yield fn_utils_1.fnUtils.common.executeHook({ prefix: 'pre', command: 'deploy' });
     const targets = yield fn_utils_1.fnUtils.common.validate();
     if (targets.length === 0) {
         const only = (0, option_1.getOptionValue)('only', false);
         const except = (0, option_1.getOptionValue)('except', false);
         const option = only ? 'only' : except ? 'except' : 'none';
-        throw new error_1.default('No functions are ready to be deployed', {
+        throw new index_js_1.default('No functions are ready to be deployed', {
             exit: 1,
             errorId: 'IDX-1',
             arg: [(0, ansi_colors_1.bold)(option)]
@@ -39,30 +39,34 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
     }
     const refinedTargets = yield fn_utils_1.fnUtils.common.refineTargets(targets);
     runtime_store_1.default.set('context.functions.targets', refinedTargets);
-    refinedTargets
-        .filter((target) => target.valid)
-        .forEach((target) => throbber_1.default.getInstance().add('function_deploy_' + target.name, {
-        text: `packaging function [${target.name}]`
-    }));
-    const [nodeTarget, javaTarget, pythonTarget] = yield Promise.all([
-        (0, languages_1.node)(refinedTargets.filter((target) => { var _a; return ((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.node.value)) && target.valid; })),
-        (0, languages_1.java)(refinedTargets.filter((target) => { var _a; return ((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.java.value)) && target.valid; })),
-        (0, languages_1.python)(refinedTargets.filter((target) => { var _a; return ((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.python.value)) && target.valid; }))
-    ]);
-    refinedTargets === null || refinedTargets === void 0 ? void 0 : 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);
-            });
+    const nodeFns = [];
+    const javaFns = [];
+    const pythonFns = [];
+    refinedTargets.filter((target) => {
+        var _a, _b, _c;
+        if (!target.valid) {
+            return false;
+        }
+        throbber_1.default.getInstance().add('function_deploy_' + target.name, {
+            text: `packaging function [${target.name}]`
+        });
+        if ((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.node.value)) {
+            return nodeFns.push(target);
         }
-        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);
-            });
+        if ((_b = target.stack) === null || _b === void 0 ? void 0 : _b.startsWith(runtime_1.default.language.java.value)) {
+            return javaFns.push(target);
         }
+        if ((_c = target.stack) === null || _c === void 0 ? void 0 : _c.startsWith(runtime_1.default.language.python.value)) {
+            return pythonFns.push(target);
+        }
+        return false;
     });
+    const [nodeTarget, javaTarget, pythonTarget] = yield Promise.all([
+        (0, languages_1.node)(nodeFns),
+        (0, languages_1.java)(javaFns),
+        (0, languages_1.python)(pythonFns)
+    ]);
+    javaTarget && (0, compile_1.printCompilationLog)(javaTarget);
     const combinedTarget = [...(nodeTarget || []), ...(javaTarget || []), ...(pythonTarget || [])];
     const batchSize = 1;
     const fnAPI = yield (0, endpoints_1.functionsAPI)();
@@ -106,8 +110,8 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
                 fn_utils_1.fnUtils.common.generateUrlForTarget(target);
             }
             catch (e) {
-                const err = error_1.default.getErrorInstance(e);
-                (0, logger_1.debug)(err.stack);
+                const err = index_js_1.default.getErrorInstance(e);
+                (0, index_1.debug)(err.stack);
                 target.valid = false;
                 target.failure_reason = err.message;
             }
@@ -115,13 +119,18 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
     }
     const allTargets = refinedTargets.filter((target) => {
         if (!target.valid) {
-            (0, logger_1.warning)('skipping deploy of target [' + target.name + '] since ' + target.failure_reason);
+            (0, index_1.warning)('skipping deploy of target [' + target.name + '] since ' + target.failure_reason);
         }
         return target.valid;
     });
-    runtime_store_1.default.set('payload.functions.targets', allTargets);
+    runtime_store_1.default.set('context.payload.functions.targets', allTargets);
     if (allTargets.length > 0) {
-        runtime_store_1.default.set('payload.functions.deploy', true);
+        runtime_store_1.default.set('context.payload.functions.deploy', true);
+    }
+    yield fn_utils_1.fnUtils.common.executeHook({ prefix: 'post', command: 'deploy' });
+    if (allTargets.length < refinedTargets.length) {
+        throw new index_js_1.default('Error deploying functions: Invalid functions', {
+            skipHelp: true
+        });
     }
-    fn_utils_1.fnUtils.common.executeHook({ prefix: 'post', command: 'deploy' });
 });

package/lib/deploy/features/functions/languages/index.d.ts

@@ -0,0 +1,4 @@
+import { IFnTarget, JavaFn, NodeFn, PythonFn } from '../../../../fn-utils/lib/common';
+export declare function node(targets: Array<IFnTarget<NodeFn>>): Promise<Array<IFnTarget<NodeFn>> | void>;
+export declare function java(targets: Array<IFnTarget<JavaFn>>): Promise<Array<IFnTarget<JavaFn>> | void>;
+export declare function python(targets: Array<IFnTarget<PythonFn>>): Promise<Array<IFnTarget<PythonFn>> | void>;

package/lib/deploy/features/functions/languages/index.js

@@ -21,7 +21,20 @@ function deploy(targets, lang) {
             return;
         }
         const throbber = throbber_1.default.getInstance();
-        yield fn_utils_1.fnUtils[lang].validate(targets, 0);
+        switch (lang) {
+            case 'java': {
+                yield fn_utils_1.fnUtils.java.validate(targets);
+                break;
+            }
+            case 'node': {
+                yield fn_utils_1.fnUtils.node.validate(targets);
+                break;
+            }
+            case 'python': {
+                yield fn_utils_1.fnUtils.python.validate(targets);
+                break;
+            }
+        }
         return Promise.all(targets
             .filter((target) => {
             if (!target.valid) {

package/lib/deploy/features/functions/utils.d.ts

@@ -0,0 +1 @@
+export declare const fnLogger: () => void;

package/lib/deploy/features/functions/utils.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnLogger = void 0;
+const ansi_colors_1 = require("ansi-colors");
+const runtime_store_1 = __importDefault(require("../../../runtime-store"));
+const util_1 = require("../../util");
+const logger_1 = require("../../../util_modules/logger");
+const fnLogger = () => {
+    const _logTagets = runtime_store_1.default
+        .get('context.payload.functions.targets', [])
+        .reduce((logTargs, target) => {
+        target.name = (0, ansi_colors_1.bold)(target.name);
+        switch (target.type) {
+            case 'aio': {
+                if (logTargs.aio.length === 0) {
+                    logTargs.aio.push((0, ansi_colors_1.bold)('==> Advanced I/O'));
+                }
+                logTargs.aio.push({
+                    label: 'DEPLOYMENT SUCCESSFUL',
+                    message: target.name,
+                    logType: 'SUCCESS'
+                });
+                logTargs.aio.push({
+                    label: 'FUNCTION URL         ',
+                    message: (0, ansi_colors_1.underline)(target.url || 'Unknown'),
+                    logType: 'MESSAGE'
+                });
+                logTargs.aio.push('');
+                break;
+            }
+            case 'bio': {
+                if (logTargs.bio.length === 0) {
+                    logTargs.bio.push((0, ansi_colors_1.bold)('==> Basic I/O'));
+                }
+                logTargs.bio.push({
+                    label: 'DEPLOYMENT SUCCESSFUL',
+                    message: target.name,
+                    logType: 'SUCCESS'
+                });
+                logTargs.bio.push({
+                    label: 'FUNCTION URL         ',
+                    message: (0, ansi_colors_1.underline)(target.url || 'Unknown'),
+                    logType: 'MESSAGE'
+                });
+                logTargs.bio.push('');
+                break;
+            }
+            case 'browserlogic': {
+                if (logTargs.browserlogic.length === 0) {
+                    logTargs.browserlogic.push((0, ansi_colors_1.bold)('==> BrowserLogic'));
+                }
+                logTargs.browserlogic.push({
+                    label: 'DEPLOYMENT SUCCESSFUL',
+                    message: target.name,
+                    logType: 'SUCCESS'
+                });
+                logTargs.browserlogic.push({
+                    label: 'FUNCTION URL         ',
+                    message: (0, ansi_colors_1.underline)(target.url || 'Unknown'),
+                    logType: 'MESSAGE'
+                });
+                logTargs.browserlogic.push('');
+                break;
+            }
+            case 'cron': {
+                if (logTargs.cron.length === 0) {
+                    logTargs.cron.push((0, ansi_colors_1.bold)('==> CRON'));
+                }
+                logTargs.cron.push({
+                    label: 'DEPLOYMENT SUCCESSFUL',
+                    message: target.name,
+                    logType: 'SUCCESS'
+                });
+                logTargs.cron.push('');
+                break;
+            }
+            case 'event': {
+                if (logTargs.event.length === 0) {
+                    logTargs.event.push((0, ansi_colors_1.bold)('==> EVENT'));
+                }
+                logTargs.event.push({
+                    label: 'DEPLOYMENT SUCCESSFUL',
+                    message: target.name,
+                    logType: 'SUCCESS'
+                });
+                logTargs.event.push('');
+                break;
+            }
+            case 'integ': {
+                if (logTargs.integ.length === 0) {
+                    logTargs.integ.push((0, ansi_colors_1.bold)('==> INTEGRATION'));
+                }
+                logTargs.integ.push({
+                    label: 'DEPLOYMENT SUCCESSFUL',
+                    message: target.name,
+                    logType: 'SUCCESS'
+                });
+                logTargs.integ.push('');
+                break;
+            }
+            case 'job': {
+                if (logTargs.job.length === 0) {
+                    logTargs.job.push((0, ansi_colors_1.bold)('==> JOB'));
+                }
+                logTargs.job.push({
+                    label: 'DEPLOYMENT SUCCESSFUL',
+                    message: target.name,
+                    logType: 'SUCCESS'
+                });
+                logTargs.job.push('');
+                break;
+            }
+        }
+        return logTargs;
+    }, {
+        aio: [],
+        bio: [],
+        browserlogic: [],
+        event: [],
+        cron: [],
+        job: [],
+        integ: []
+    });
+    Object.entries(_logTagets).forEach(([_type, logs]) => {
+        if (logs.length === 0) {
+            return;
+        }
+        (0, logger_1.info)(' '.repeat(2) + logs.shift());
+        (0, logger_1.info)();
+        (0, util_1.logPaddedLabels)(logs, ' '.repeat(4));
+    });
+};
+exports.fnLogger = fnLogger;

package/lib/deploy/features/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    functions: () => Promise<void>;
+    client: () => Promise<void>;
+    slate: () => Promise<void>;
+    apig: () => Promise<void>;
+    appsail: (standAlone: boolean) => Promise<void>;
+};
+export default _default;

package/lib/deploy/features/slate.d.ts

@@ -0,0 +1,5 @@
+import { ISlateConfig } from '../../util_modules/config/lib/slate';
+declare const _default: () => Promise<void>;
+export default _default;
+export declare function getEnvironmentType(): string;
+export declare function slateLogger(): Array<ISlateConfig>;

package/lib/deploy/features/slate.js

@@ -90,9 +90,9 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
             }
             return (_c = targ.validity) === null || _c === void 0 ? void 0 : _c.valid;
         });
-        runtime_store_1.default.set('payload.slate.targets', deployedValidTargets);
+        runtime_store_1.default.set('context.payload.slate.targets', deployedValidTargets);
         if (deployedValidTargets.length > 0) {
-            runtime_store_1.default.set('payload.slate.deploy', true);
+            runtime_store_1.default.set('context.payload.slate.deploy', true);
         }
     }
     else {
@@ -102,8 +102,8 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const deployRes = yield (yield (0, endpoints_1.slateAPI)({ env })).deploy(readStream.stream, readStream.length, process.env.ZC_APP_NAME, dId);
             deployRes.name = process.env.ZC_APP_NAME;
-            runtime_store_1.default.set('payload.slate.targets', [deployRes]);
-            runtime_store_1.default.set('payload.slate.deploy', true);
+            runtime_store_1.default.set('context.payload.slate.targets', [deployRes]);
+            runtime_store_1.default.set('context.payload.slate.deploy', true);
         }
         catch (err) {
             throw err;
@@ -118,7 +118,7 @@ function getEnvironmentType() {
 }
 exports.getEnvironmentType = getEnvironmentType;
 function slateLogger() {
-    const deployTargets = runtime_store_1.default.get('payload.slate.targets', []);
+    const deployTargets = runtime_store_1.default.get('context.payload.slate.targets', []);
     deployTargets.forEach((slate) => {
         var _a, _b;
         (0, logger_1.labeled)(`Slate(${slate.name})`, 'Deploy is live!').SUCCESS();

package/lib/deploy/index.d.ts

@@ -0,0 +1,6 @@
+import CatalystError from '../error/index.js';
+declare function deploy({ feature, error }?: {
+    feature?: string;
+    error?: Array<CatalystError>;
+}): Promise<Array<CatalystError>>;
+export default deploy;

package/lib/deploy/index.js

@@ -12,32 +12,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const error_1 = __importDefault(require("../error"));
+const index_js_1 = __importDefault(require("../error/index.js"));
 const runtime_store_1 = __importDefault(require("../runtime-store"));
-const logger_1 = require("../util_modules/logger");
+const index_1 = require("../util_modules/logger/index");
 const features_1 = __importDefault(require("./features"));
-function deploy(feature) {
+function deploy({ feature = '', error = [] } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const deployTargets = runtime_store_1.default.get('context.targets', feature ? [feature] : []);
         if (deployTargets.length === 0) {
-            return;
+            return error;
         }
         const currentTarget = deployTargets.shift();
         if (currentTarget === undefined) {
-            return deploy();
+            return deploy({ error });
         }
         const featureModule = features_1.default[currentTarget];
-        runtime_store_1.default.set('context.current.target', currentTarget);
         try {
-            runtime_store_1.default.set('payload.targets', runtime_store_1.default.get('payload.targets', []).concat(currentTarget));
+            runtime_store_1.default.set('context.payload.targets', runtime_store_1.default.get('context.payload.targets', []).concat(currentTarget));
             yield featureModule(feature ? true : false);
         }
         catch (e) {
-            const error = error_1.default.getErrorInstance(e);
-            (0, logger_1.debug)(`${currentTarget} deploy unsuccessful, reason : ${error.stack}`);
-            (0, logger_1.labeled)(currentTarget, error.message).WARN();
+            const err = index_js_1.default.getErrorInstance(e);
+            (0, index_1.debug)(`${currentTarget} deploy unsuccessful, reason : ${err.stack}`);
+            (0, index_1.labeled)(currentTarget, err.message).WARN();
+            error.push(err);
+            return deploy({ error });
         }
-        return deploy();
+        return deploy({ error });
     });
 }
 exports.default = deploy;