zcatalyst-cli 1.18.0-beta.10 → 1.18.0-beta.11-slate

package/lib/serve/features/slate.js

@@ -0,0 +1,47 @@
+"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 });
+const error_1 = __importDefault(require("../../error"));
+const port_resolver_1 = __importDefault(require("../../port-resolver"));
+const runtime_store_1 = __importDefault(require("../../runtime-store"));
+const slate_utils_1 = require("../../slate-utils");
+const config_1 = require("../../util_modules/config");
+const logger_1 = require("../../util_modules/logger");
+exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
+    const allTargets = yield config_1.slateConfig.getAllTargetDetails();
+    const optionTargets = slate_utils_1.slateUtils.filterTargets(allTargets || []);
+    if (optionTargets.length === 0) {
+        (0, logger_1.debug)('Slate targets are empty');
+        return;
+    }
+    const validated = (0, slate_utils_1.validateServeCommand)(optionTargets);
+    const filledTargets = yield Promise.all(validated.map((targ) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!targ.validity.valid) {
+            return targ;
+        }
+        const proxyPort = yield port_resolver_1.default.getPort('slate', 'http', {
+            name: targ.name + '_proxy',
+            searchSpan: 10,
+            server: 'master'
+        }).catch((err) => {
+            throw new error_1.default('No free ports between 3000 and 3010. Slate needs the ports within this range to function properly', { original: err });
+        });
+        const slatePort = yield port_resolver_1.default.getPort('slate', 'http', {
+            name: targ.name + '_proxy',
+            server: 'service'
+        });
+        return Object.assign(Object.assign({}, targ), { port: { slate: slatePort, proxy: proxyPort }, trigger: { kill: false } });
+    })));
+    runtime_store_1.default.set('context.slate.targets', filledTargets);
+});

package/lib/serve/index.js

@@ -124,6 +124,25 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
                 runtime_store_1.default.set('context.targets', serveTargets);
             }
         }
+        if (serveTargets.includes('slate')) {
+            const slates = runtime_store_1.default.get('context.slate.targets', []);
+            const validSlates = slates.filter((slate) => {
+                if (!slate.validity.valid) {
+                    (0, logger_1.warning)('skipping serve of Slate service [' +
+                        slate.name +
+                        '] since ' +
+                        slate.validity.reason);
+                    return false;
+                }
+                advancedServer.add('slate', slate);
+                return true;
+            });
+            if (validSlates.length === 0) {
+                (0, logger_1.labeled)('Slate', 'No targets are ready to be served in local').WARN();
+                serveTargets.splice(serveTargets.indexOf('slate'), 1);
+                runtime_store_1.default.set('context.targets', serveTargets);
+            }
+        }
         if (serveTargets.includes('client')) {
             const client = runtime_store_1.default.get('context.client', false);
             if (client && client.valid) {

package/lib/serve/server/index.js

@@ -24,6 +24,7 @@ const index_js_2 = __importDefault(require("./lib/node/index.js"));
 const index_js_3 = __importDefault(require("./lib/python/index.js"));
 const index_js_4 = __importDefault(require("./lib/web_client/index.js"));
 const index_js_5 = __importDefault(require("./lib/appsail/index.js"));
+const index_js_6 = __importDefault(require("./lib/slate/index.js"));
 const cli_table_1 = require("../../cli_table");
 const ansi_colors_1 = require("ansi-colors");
 const bioLogUrl = (details, masterPort, addSpaces) => {
@@ -50,7 +51,8 @@ class Server {
             functions: [],
             server: [],
             client: [],
-            appSail: []
+            appSail: [],
+            slate: []
         };
     }
     _addBasicFnDetails(bioUrlLogs) {
@@ -95,6 +97,15 @@ class Server {
             });
             return;
         }
+        if (type === 'slate') {
+            this.targetsMap.slate.push({
+                type,
+                target: target,
+                httpPort: -1,
+                debugPort: -1
+            });
+            return;
+        }
         const httpPort = runtime_store_1.default.get(`context.port.http.${type === 'server' ? 'functions' : type}.${target.name}`, -1);
         const debugPort = runtime_store_1.default.get(`context.port.debug.${type === 'server' ? 'functions' : type}.${target.name}`, -1);
         if (httpPort === -1) {
@@ -129,6 +140,10 @@ class Server {
                         currentProcess = yield (0, index_js_5.default)(details);
                         break;
                     }
+                    case 'slate': {
+                        currentProcess = yield (0, index_js_6.default)(details);
+                        break;
+                    }
                     case 'client': {
                         currentProcess = yield (0, index_js_4.default)(details, masterPort);
                         break;
@@ -177,6 +192,11 @@ class Server {
                     target.valid = false;
                     (0, logger_1.labeled)(`WebClient[${details.target}]`, error).ERROR();
                 }
+                else if (details.type === 'slate') {
+                    const target = details.target;
+                    target.validity.valid = false;
+                    (0, logger_1.labeled)(`Slate[${target.name}]`, error).ERROR();
+                }
                 else {
                     const target = details.target;
                     target.valid = false;
@@ -195,6 +215,7 @@ class Server {
                     browserlogic: { targs: [], nameMaxLength: 0 }
                 },
                 appsail: { targs: [], nameMaxLength: 0 },
+                slate: { targs: [], nameMaxLength: 0 },
                 client: {}
             };
             this._addBasicFnDetails(logUrls.functions.bio);
@@ -297,6 +318,21 @@ class Server {
                             : logUrls.appsail.nameMaxLength;
                 })));
             }
+            if (this.targetsMap.slate.length > 0) {
+                yield Promise.all(this.targetsMap.slate.map((targSlate) => this.startServer(targSlate, -1).then((details) => {
+                    var _a, _b, _c, _d;
+                    const serverDetails = details;
+                    if (!((_a = serverDetails.target) === null || _a === void 0 ? void 0 : _a.validity.valid)) {
+                        return;
+                    }
+                    logUrls.slate.targs.push(targSlate);
+                    logUrls.slate.nameMaxLength =
+                        ((_b = targSlate.target) === null || _b === void 0 ? void 0 : _b.name) &&
+                            ((_c = targSlate.target) === null || _c === void 0 ? void 0 : _c.name.length) > logUrls.slate.nameMaxLength
+                            ? (_d = targSlate.target) === null || _d === void 0 ? void 0 : _d.name.length
+                            : logUrls.slate.nameMaxLength;
+                })));
+            }
             let loggedEntries = 0;
             Object.entries(logUrls).forEach(([targType, logTarg]) => {
                 var _a;
@@ -422,6 +458,30 @@ class Server {
                         (0, logger_1.info)();
                         break;
                     }
+                    case 'slate': {
+                        const _logTarg = logTarg;
+                        if (_logTarg.targs.length === 0) {
+                            return;
+                        }
+                        loggedEntries++;
+                        let isHeaderDisplayed = false;
+                        _logTarg.targs.forEach((t) => {
+                            const targetSlate = t.target;
+                            if (!targetSlate.validity.valid) {
+                                return;
+                            }
+                            if (isHeaderDisplayed === false) {
+                                (0, logger_1.info)();
+                                (0, logger_1.info)((0, ansi_colors_1.bold)(' >>>>>>>>>>>>>> Slate <<<<<<<<<<<<<< '));
+                                isHeaderDisplayed = true;
+                            }
+                            const targName = targetSlate.name + '';
+                            (0, logger_1.labeled)(targName +
+                                ' '.repeat((_logTarg.nameMaxLength || targName.length) - targName.length), `http://localhost:${targetSlate.port.proxy}`).MESSAGE();
+                        });
+                        (0, logger_1.info)();
+                        break;
+                    }
                 }
             });
             return loggedEntries > 0

package/lib/serve/server/lib/appsail/index.js

@@ -114,7 +114,7 @@ exports.default = (serverDetails) => __awaiter(void 0, void 0, void 0, function*
                         const zip = new archiver_1.default();
                         zip.load(jettyZip);
                         zip.extract(jettyPath, '/', {
-                            ignoreInitial: false,
+                            ignoreLevel: 0,
                             isFolder: true
                         });
                         yield zip.finalize();

package/lib/serve/server/lib/master/index.js

@@ -34,10 +34,12 @@ const utils_1 = require("./utils");
 const appsail_1 = require("./appsail");
 const web_client_1 = require("./web-client");
 const functions_1 = require("./functions");
-function spinUpMaster(listenPort, { otherServerDetails, appSailDetails }) {
+const slate_1 = require("./slate");
+function spinUpMaster(listenPort, { otherServerDetails, appSailDetails, slateDetails }) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
-        if ((otherServerDetails && appSailDetails) || (!otherServerDetails && !appSailDetails)) {
+        if ((otherServerDetails && appSailDetails && slateDetails) ||
+            (!otherServerDetails && !appSailDetails && !slateDetails)) {
             throw new error_1.default('Either functions/client or AppSail is need to start the master server. But both cannot use the same master', { exit: 2 });
         }
         const projectDetails = {
@@ -56,12 +58,11 @@ function spinUpMaster(listenPort, { otherServerDetails, appSailDetails }) {
         app.use(cookie_parser_1.default);
         app.use((0, project_1.default)(projectDetails));
         app.use(authenticator_1.default);
-        !appSailDetails &&
+        if (!appSailDetails && !slateDetails) {
             app.use(nonApigURL, (req, res) => {
                 req.url = req.originalUrl;
                 unknownProxy(req, res);
             });
-        !appSailDetails &&
             app.use('*/.catalyst%2Freload-script.js', (req, res) => {
                 var _a;
                 req.url = '/.catalyst%2Freload-script.js';
@@ -73,33 +74,35 @@ function spinUpMaster(listenPort, { otherServerDetails, appSailDetails }) {
                     });
                 });
             });
-        if (rules !== -1 && !appSailDetails) {
-            for (const [sourceURL, methodByConfig] of Object.entries(rules)) {
-                const router = app.route(sourceURL);
-                for (const [method, config] of Object.entries(methodByConfig)) {
-                    if (config.system) {
-                        if (systemRoutes === undefined) {
-                            systemRoutes = {};
+            if (rules !== -1) {
+                for (const [sourceURL, methodByConfig] of Object.entries(rules)) {
+                    const router = app.route(sourceURL);
+                    for (const [method, config] of Object.entries(methodByConfig)) {
+                        if (config.system) {
+                            if (systemRoutes === undefined) {
+                                systemRoutes = {};
+                            }
+                            js_1.JS.set(systemRoutes, [sourceURL, method], config);
                         }
-                        js_1.JS.set(systemRoutes, [sourceURL, method], config);
+                        router[method]((req, res, next) => {
+                            if (res.locals.apigRules === undefined) {
+                                res.locals.apigRules = [];
+                            }
+                            res.locals.apigRules.push(Object.assign({ source_endpoint: sourceURL, params: req.params }, config));
+                            next();
+                        });
                     }
-                    router[method]((req, res, next) => {
-                        if (res.locals.apigRules === undefined) {
-                            res.locals.apigRules = [];
-                        }
-                        res.locals.apigRules.push(Object.assign({ source_endpoint: sourceURL, params: req.params }, config));
-                        next();
-                    });
                 }
+                app.use('/', apig_matcher_1.default, auth_checker_1.default, url_rewriter_1.default);
             }
-            app.use('/', apig_matcher_1.default, auth_checker_1.default, url_rewriter_1.default);
         }
         const proxy = (0, utils_1.createProxyServer)(listenPort);
+        const signRedirectUrl = slateDetails ? undefined : '/app/local-redirect';
         appSailDetails && ((_b = (_a = appSailDetails.target) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.catalyst_auth) === true
             ? proxy.on('proxyRes', (0, utils_1.proxyResponseHandler)({
                 signInRedirect: appSailDetails.target.config.login_redirect || '/'
             }))
-            : proxy.on('proxyRes', (0, utils_1.proxyResponseHandler)({ systemRoutes }));
+            : proxy.on('proxyRes', (0, utils_1.proxyResponseHandler)({ systemRoutes, signInRedirect: signRedirectUrl }));
         const proxyDestroyer = new server_js_1.ConnectionDestroyer(proxy);
         const unknownProxy = (0, unknown_req_proxy_1.default)(proxy, listenPort, customProxyUrl);
         otherServerDetails &&
@@ -132,6 +135,7 @@ function spinUpMaster(listenPort, { otherServerDetails, appSailDetails }) {
                 }
             });
         appSailDetails && (0, appsail_1.addAppSailRoutes)(app, appSailDetails, proxy, unknownProxy);
+        slateDetails && (0, slate_1.addSlateRoutes)(app, slateDetails, proxy, unknownProxy);
         app.use('/', (0, unknown_req_proxy_1.default)(proxy, listenPort, customProxyUrl));
         app.use(error_handler_1.default);
         const expressServer = app.listen(listenPort, '127.0.0.1').on('error', (err) => {

package/lib/serve/server/lib/master/slate.js

@@ -0,0 +1,45 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSlateRoutes = void 0;
+function addSlateRoutes(app, details, proxy, unknownProxy) {
+    app.use('/__catalyst/sdk/init', (req, res) => __awaiter(this, void 0, void 0, function* () {
+        req.url = req.originalUrl;
+        unknownProxy(req, res);
+    }));
+    app.use(['/accounts', '/oauthorize'], (req, res) => {
+        req.url = req.originalUrl;
+        unknownProxy(req, res);
+    });
+    app.use('/__catalyst', (req, res) => {
+        req.url = req.originalUrl;
+        if (req.url.includes('redirect_url')) {
+            res.redirect(req.url.split('redirect_url=')[1]);
+        }
+        else if (req.url.includes('service_url')) {
+            res.redirect(req.url.split('service_url=')[1]);
+        }
+        else {
+            unknownProxy(req, res);
+        }
+    });
+    app.use('/', (req, res) => __awaiter(this, void 0, void 0, function* () {
+        if (req.header('catalyst-component') === 'true') {
+            unknownProxy(req, res);
+            return;
+        }
+        proxy.web(req, res, {
+            target: `http://127.0.0.1:${details.target.port.slate}`,
+            ws: true
+        });
+    }));
+}
+exports.addSlateRoutes = addSlateRoutes;

package/lib/serve/server/lib/master/utils.js

@@ -78,7 +78,7 @@ const createProxyServer = (port) => {
     return proxy;
 };
 exports.createProxyServer = createProxyServer;
-const proxyResponseHandler = ({ systemRoutes, signInRedirect = '/app/local-redirect' }) => (proxyRes, req, res) => {
+const proxyResponseHandler = ({ systemRoutes, signInRedirect }) => (proxyRes, req, res) => {
     var _a, _b;
     if (!req.url) {
         return;
@@ -89,7 +89,7 @@ const proxyResponseHandler = ({ systemRoutes, signInRedirect = '/app/local-redir
         return cookie;
     });
     if (req.url.startsWith('/baas') || req.url.startsWith('/__catalyst')) {
-        if (req.url.includes('/signin-redirect')) {
+        if (req.url.includes('/signin-redirect') && signInRedirect) {
             if (systemRoutes === undefined) {
                 (0, exports.redirectByAuth)(req, res, signInRedirect);
                 return;

package/lib/serve/server/lib/slate/index.js

@@ -0,0 +1,144 @@
+"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 });
+const path_1 = require("path");
+const error_1 = __importDefault(require("../../../../error"));
+const fs_1 = require("../../../../util_modules/fs");
+const logger_1 = require("../../../../util_modules/logger");
+const shell_1 = require("../../../../util_modules/shell");
+const master_1 = __importDefault(require("../master"));
+const ansi_colors_1 = require("ansi-colors");
+const file_names_1 = __importDefault(require("../../../../util_modules/constants/lib/file-names"));
+const static_server_1 = __importDefault(require("./static-server"));
+const open_1 = __importDefault(require("open"));
+const async_1 = require("../../../../util_modules/fs/lib/async");
+const startSlate = (port, opts) => {
+    const child = (0, shell_1.spawn)(opts.command, [], {
+        cwd: opts.target,
+        shell: true,
+        env: {
+            ZC_SLATE_PORT: port + ''
+        }
+    }).RAW();
+    return new Promise((_res, _rej) => {
+        child.on('spawn', () => _res(child));
+        child.on('error', (reason) => _rej(reason));
+    });
+};
+const installPackages = (opts) => {
+    const child = (0, shell_1.spawn)(opts.command, [], {
+        cwd: opts.target,
+        shell: true
+    }).RAW();
+    return new Promise((_res, _rej) => {
+        child.on('spawn', () => _res(child));
+        child.on('error', (reason) => _rej(reason));
+    });
+};
+exports.default = (serverDetails) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const targetSlate = serverDetails.target;
+    if (!targetSlate || !targetSlate.config) {
+        throw new error_1.default('Slate details not found');
+    }
+    let child;
+    if (targetSlate.config.framework === 'static') {
+        child = yield (0, static_server_1.default)(targetSlate.port.slate, targetSlate.source, {
+            enableWatch: true
+        });
+        child.addListener('start', () => {
+            (0, open_1.default)('http://localhost:' + targetSlate.port.slate).catch();
+        });
+    }
+    else {
+        const configFile = (0, path_1.join)(targetSlate.source, file_names_1.default.cli_config);
+        if (!fs_1.ASYNC.fileExists(configFile)) {
+            throw new error_1.default('Unable to find the development command.', {
+                exit: 1,
+                errorId: 'SERVE-SLATE-1',
+                arg: ['catalyst slate:create']
+            });
+        }
+        if (!(yield fs_1.ASYNC.isPathExists(targetSlate.source))) {
+            throw new error_1.default('The given Slate source path does not exists', {
+                exit: 1,
+                errorId: 'SERVE-SlATE-1',
+                arg: [ansi_colors_1.italic.underline.red(targetSlate.source), (0, ansi_colors_1.bold)(targetSlate.name)]
+            });
+        }
+        const configJson = yield (0, async_1.readJSONFile)(configFile);
+        if (!configJson) {
+            throw new error_1.default('Development command not found', {
+                exit: 1,
+                errorId: 'SERVE-SLATE-1',
+                arg: ['catalyst slate:create']
+            });
+        }
+        if ((_a = targetSlate.config) === null || _a === void 0 ? void 0 : _a.install_command) {
+            const spwnProcess = yield installPackages({
+                target: targetSlate.source,
+                command: (_b = targetSlate.config) === null || _b === void 0 ? void 0 : _b.install_command
+            });
+            spwnProcess.once('exit', (code) => {
+                if (code === 150) {
+                    targetSlate.validity = {
+                        valid: false,
+                        reason: 'Unable to install the dependencies'
+                    };
+                    throw new error_1.default('Unable to start the Slate', {
+                        exit: 1,
+                        errorId: 'SERVE-SLATE-3',
+                        arg: [(0, ansi_colors_1.bold)('catalyst serve')]
+                    });
+                }
+            });
+        }
+        child = yield startSlate(targetSlate.port.slate, {
+            target: targetSlate.source,
+            command: (_c = configJson === null || configJson === void 0 ? void 0 : configJson.slate) === null || _c === void 0 ? void 0 : _c.dev_command
+        });
+        child.once('exit', (code) => {
+            if (code === 150) {
+                targetSlate.validity = {
+                    valid: false,
+                    reason: 'Unable to start the Slate'
+                };
+                throw new error_1.default('Unable to start the Slate', {
+                    exit: 1,
+                    errorId: 'SERVE-SLATE-2',
+                    arg: [(0, ansi_colors_1.bold)(targetSlate.name), (0, ansi_colors_1.underline)((configJson === null || configJson === void 0 ? void 0 : configJson.dev_command) || '')]
+                });
+            }
+        });
+    }
+    const masterServe = yield (0, master_1.default)(targetSlate.port.proxy, {
+        slateDetails: serverDetails
+    });
+    child.once('exit', () => {
+        masterServe.close((err) => {
+            if (err) {
+                (0, logger_1.debug)('Error stopping the Slate proxy server: ', err);
+            }
+        });
+    });
+    process.on('SIGINT', () => {
+        masterServe.close((err) => {
+            if (err) {
+                (0, logger_1.debug)('Error stopping the Slate proxy server: ', err);
+            }
+        });
+        targetSlate.trigger.kill = true;
+    });
+    return child;
+});