zcatalyst-cli 1.18.0-beta.9 → 1.18.1

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://localhost:${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;
@@ -127,7 +127,13 @@ const appsailInitJs = () => __awaiter(void 0, void 0, void 0, function* () {
     if (!initJsStr) {
         throw new error_1.default('Unable to read the init_js file', { exit: 2 });
     }
-    const feed = [(0, project_1.getProjectId)(), (0, project_1.getDomainKey)(), constants_1.ORIGIN.iamPortal, (0, project_1.getEnvId)()];
+    const feed = [
+        (0, project_1.getProjectId)(),
+        (0, project_1.getDomainKey)(),
+        constants_1.ORIGIN.iamPortal,
+        (0, project_1.getEnvId)(),
+        `-development${constants_1.ORIGIN.stratusSuffix}`
+    ];
     Object.values(constants_1.PLACEHOLDER.init_js).forEach((holder, idx) => {
         initJsStr = initJsStr === null || initJsStr === void 0 ? void 0 : initJsStr.replace(new RegExp(holder, 'g'), feed[idx]);
     });

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

@@ -0,0 +1,115 @@
+"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));
+    });
+};
+exports.default = (serverDetails) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    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 exist', {
+                exit: 1,
+                errorId: 'SERVE-SLATE-2',
+                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-3',
+                arg: ['catalyst slate:create']
+            });
+        }
+        child = yield startSlate(targetSlate.port.slate, {
+            target: targetSlate.source,
+            command: (_a = configJson === null || configJson === void 0 ? void 0 : configJson.slate) === null || _a === void 0 ? void 0 : _a.dev_command
+        });
+    }
+    const masterServe = yield (0, master_1.default)(targetSlate.port.proxy, {
+        slateDetails: serverDetails
+    });
+    child.once('exit', (code) => {
+        child.once('exit', () => {
+            masterServe.close((err) => {
+                if (err) {
+                    (0, logger_1.debug)('Error stopping the Slate proxy server: ', err);
+                }
+            });
+        });
+        if (code === 150) {
+            targetSlate.validity = {
+                valid: false,
+                reason: 'Unable to start the Slate'
+            };
+            throw new error_1.default('Slate start failed', {
+                exit: 1,
+                errorId: 'SERVE-SLATE-5',
+                arg: [(0, ansi_colors_1.bold)(targetSlate.name)]
+            });
+        }
+    });
+    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;
+});

package/lib/serve/server/lib/slate/static-server.js

@@ -0,0 +1,194 @@
+'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 express_1 = __importDefault(require("express"));
+const events_1 = require("events");
+const chokidar_1 = require("chokidar");
+const logger_js_1 = require("../../../../util_modules/logger.js");
+const index_js_1 = require("../../../../util_modules/constants/index.js");
+const error_js_1 = __importDefault(require("../../../../error.js"));
+const index_js_2 = require("../../../../util_modules/fs/index.js");
+const path_1 = require("path");
+const ws_1 = require("ws");
+const port_resolver_js_1 = __importDefault(require("../../../../port-resolver.js"));
+const ansi_colors_1 = require("ansi-colors");
+const server_js_1 = require("../../../../util_modules/server.js");
+function prepareScriptFile(dir, port) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const scriptFile = yield index_js_2.ASYNC.readFile(index_js_1.TEMPLATE.client.basic.socket);
+        if (!scriptFile) {
+            throw new error_js_1.default('Unable to read the script file', { exit: 2 });
+        }
+        const scriptReady = scriptFile.replace(new RegExp(index_js_1.PLACEHOLDER.client.port, 'g'), port + '');
+        yield index_js_2.ASYNC.ensureDir(dir);
+        const scriptFilePath = (0, path_1.join)(dir, 'reload-script.js');
+        yield index_js_2.ASYNC.writeFile(scriptFilePath, scriptReady);
+        return scriptFilePath;
+    });
+}
+function stringInjector(source, anchorIdx, marker, inject) {
+    const headLastIdx = anchorIdx + marker.length;
+    const scriptPrefix = source.slice(0, headLastIdx);
+    const scriptSuffix = source.slice(headLastIdx);
+    return scriptPrefix + inject + scriptSuffix;
+}
+function injectScript(scriptLocale, indexHtml) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const headIdx = indexHtml.search(/<head>/gi);
+        const scriptTag = `\n<!--  Catalyst web client reload script -->\n<script type="text/javascript" src="${scriptLocale}"></script>\n`;
+        if (headIdx !== -1) {
+            return stringInjector(indexHtml, headIdx, '<head>', scriptTag);
+        }
+        const htmlIdx = indexHtml.search(/<html>/gi);
+        const headTag = `\n<head>${scriptTag}</head>\n`;
+        return stringInjector(indexHtml, htmlIdx, '<html>', headTag);
+    });
+}
+function reloadApp(event, path, liveSockets) {
+    (0, logger_js_1.info)((0, ansi_colors_1.cyan)(`${event} detected in ${path} of the Web-Client.`));
+    liveSockets.forEach((socket) => socket.send('reload'));
+}
+function slateServer(httpPort, source, { homepage = '/index.html', enableWatch = true, notFoundPage } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const eventListener = new events_1.EventEmitter();
+        const catalystTempDir = (0, path_1.join)(source, '.catalyst');
+        const socketServerPort = yield port_resolver_js_1.default.getFreePort(httpPort, 20, true);
+        const reloadScriptSrc = enableWatch
+            ? (0, path_1.relative)(source, yield prepareScriptFile(catalystTempDir, socketServerPort))
+            : undefined;
+        if (reloadScriptSrc) {
+            const clientWatcher = (0, chokidar_1.watch)(source, {
+                ignoreInitial: true,
+                ignored: ['node_modules/**/*']
+            });
+            const liveSockets = [];
+            let watcherReady = false;
+            clientWatcher.on('error', (err) => {
+                watcherReady = false;
+                eventListener.emit('error', new error_js_1.default('client watcher error', {
+                    original: err,
+                    exit: 1,
+                    skipHelp: true
+                }));
+            });
+            clientWatcher.on('ready', () => {
+                watcherReady = true;
+                const socketServer = new ws_1.WebSocketServer({
+                    port: socketServerPort,
+                    path: '/client-reload'
+                })
+                    .on('connection', (clientSocket) => {
+                    if (!watcherReady) {
+                        clientSocket.send('watcher not ready');
+                        clientSocket.close();
+                        return;
+                    }
+                    clientSocket.on('close', () => {
+                        const socketIdx = liveSockets.findIndex((socket) => socket === clientSocket);
+                        liveSockets.splice(socketIdx, 1);
+                    });
+                    liveSockets.push(clientSocket);
+                    clientSocket.send('connected');
+                })
+                    .on('error', (err) => (0, logger_js_1.debug)(err));
+                setTimeout(() => {
+                    clientWatcher.on('change', (path) => {
+                        reloadApp('Change(s) is', (0, path_1.relative)(source, path), liveSockets);
+                    });
+                    clientWatcher.on('add', (path) => {
+                        reloadApp('Addition of file(s) is', (0, path_1.relative)(source, path), liveSockets);
+                    });
+                    clientWatcher.on('unlink', (path) => {
+                        reloadApp('Deletion of file(s) is', (0, path_1.relative)(source, path), liveSockets);
+                    });
+                }, 1000);
+                eventListener.addListener('close', () => socketServer === null || socketServer === void 0 ? void 0 : socketServer.close());
+            });
+            eventListener.addListener('close', () => {
+                if (clientWatcher) {
+                    clientWatcher.close();
+                }
+                liveSockets.forEach((socket) => socket.close());
+                index_js_2.SYNC.deleteDir(reloadScriptSrc);
+            });
+        }
+        const app = (0, express_1.default)();
+        app.use('/', (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const requestedFile = req.url === '/' ? homepage : decodeURIComponent(req.path);
+            if (enableWatch && (requestedFile.includes('.html') || requestedFile.includes('.htm'))) {
+                const htmlFile = yield index_js_2.ASYNC.readFile((0, path_1.join)(source, requestedFile));
+                if (!htmlFile) {
+                    res.contentType('text/html');
+                    res.status(404);
+                    res.end();
+                    eventListener.emit('error', new error_js_1.default('Unable to read the html file', {
+                        exit: 1,
+                        errorId: 'SL-SERVER-1',
+                        arg: [ansi_colors_1.red.italic(requestedFile)]
+                    }));
+                    return;
+                }
+                const injectedHtml = reloadScriptSrc
+                    ? yield injectScript(encodeURIComponent(reloadScriptSrc), htmlFile)
+                    : undefined;
+                res.contentType('text/html');
+                res.status(200);
+                res.send(injectedHtml || htmlFile);
+                return;
+            }
+            res.sendFile((0, path_1.join)(source, requestedFile), (err) => {
+                if (!err) {
+                    return;
+                }
+                if (err.code &&
+                    err.code === 'ENOENT') {
+                    (0, logger_js_1.error)((0, ansi_colors_1.red)('[404 - Resource not found]: ') + (0, ansi_colors_1.bold)(requestedFile));
+                    (0, logger_js_1.info)();
+                    (0, logger_js_1.debug)(err.stack || err.message);
+                    res.status(404);
+                    notFoundPage
+                        ? res.sendFile(notFoundPage, (e) => {
+                            if (!e) {
+                                return;
+                            }
+                            (0, logger_js_1.debug)('Unable to send the 404 page to server: ', e);
+                            res.status(500);
+                            res.send('Error sending 404 page to server: ' + e.stack);
+                        })
+                        : res.send('Resource not found');
+                    return;
+                }
+                (0, logger_js_1.error)('Error fetching the resource: ' + err);
+                (0, logger_js_1.debug)(err.stack);
+                res.status(500);
+                res.send('Error fetching the resource');
+            });
+        }));
+        const server = app.listen(httpPort, '127.0.0.1').on('error', (err) => {
+            eventListener.emit('error', err);
+        });
+        const expressDestroyer = new server_js_1.ConnectionDestroyer(server);
+        eventListener.on('error', (err) => {
+            (0, logger_js_1.error)('Error when serving the web-client: ' + err.message);
+            (0, logger_js_1.info)('Please exit the command to get more info');
+            eventListener.emit('close');
+        });
+        eventListener.on('close', () => __awaiter(this, void 0, void 0, function* () {
+            yield expressDestroyer.destroy();
+            (0, logger_js_1.debug)('client server closed');
+        }));
+        return new Promise((res) => server.on('listening', () => res(eventListener)));
+    });
+}
+exports.default = slateServer;

package/lib/serve/server/lib/web_client/server.js

@@ -151,7 +151,8 @@ function webClientServer(httpPort, source, { homepage = 'index.html', enableWatc
                 if (!err) {
                     return;
                 }
-                if (err.code && err.code === 'ENOENT') {
+                if (err.code &&
+                    err.code === 'ENOENT') {
                     (0, logger_js_1.error)((0, ansi_colors_1.red)('[404 - Resource not found]: ') + (0, ansi_colors_1.bold)(requestedFile));
                     (0, logger_js_1.info)();
                     (0, logger_js_1.debug)(err.stack || err.message);