zcatalyst-cli 1.21.0 → 1.22.1

package/lib/serve/index.js

@@ -38,32 +38,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ansi_colors_1 = require("ansi-colors");
 const path_1 = require("path");
 const client_utils_1 = require("../client-utils");
-const error_1 = __importDefault(require("../error"));
+const index_js_1 = __importDefault(require("../error/index.js"));
 const fn_utils_1 = require("../fn-utils");
 const fn_watcher_1 = __importDefault(require("../fn-watcher"));
 const port_resolver_1 = __importDefault(require("../port-resolver"));
 const runtime_store_1 = __importDefault(require("../runtime-store"));
-const http_functions_1 = __importDefault(require("../shell/dependencies/http-functions"));
 const constants_1 = require("../util_modules/constants");
-const runtime_1 = __importDefault(require("../util_modules/constants/lib/runtime"));
 const fs_1 = require("../util_modules/fs");
-const logger_1 = require("../util_modules/logger");
+const index_1 = require("../util_modules/logger/index");
 const option_1 = require("../util_modules/option");
 const features = __importStar(require("./features"));
 const server_1 = __importDefault(require("./server"));
+const utils_1 = require("./server/lib/master/utils");
+const util_1 = require("util");
+const container_1 = require("../util_modules/container");
 exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
     const serveTargets = runtime_store_1.default.get('context.targets', []);
     const advancedServer = new server_1.default();
-    const basicFnServer = new http_functions_1.default({ primary: false });
     const projectRoot = runtime_store_1.default.get('project.root');
     const buildFolder = (0, path_1.join)(projectRoot, constants_1.FOLDERNAME.build);
+    (0, container_1.isContainer)() && (yield (0, container_1.isSocketAccessible)());
     if (yield fs_1.ASYNC.isPathExists(buildFolder)) {
         try {
-            (0, logger_1.debug)('Build folder already exists, starting cleanup');
+            (0, index_1.debug)('Build folder already exists, starting cleanup');
             yield fs_1.ASYNC.deleteDir(buildFolder);
         }
         catch (err) {
-            throw new error_1.default('Error running pre cleanup', {
+            throw new index_js_1.default('Error running pre cleanup', {
                 original: err,
                 exit: 1,
                 errorId: 'SERVE-2',
@@ -78,38 +79,48 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
             searchSpan: 10
         });
         runtime_store_1.default.set('context.port.http.master', masterPort);
-        yield Promise.all(serveTargets.map((target) => features[target]()));
-        const rawTargets = runtime_store_1.default.get('context.functions.targets', []);
         const watchOpt = (0, option_1.getOptionValue)('watch', false);
-        if (watchOpt) {
-            yield Promise.all(rawTargets.map((target) => __awaiter(void 0, void 0, void 0, function* () { return (target.valid ? (0, fn_watcher_1.default)(target) : undefined); })));
-        }
-        const functionTargets = rawTargets.filter((target) => {
-            var _a;
-            if (!target.valid) {
-                (0, logger_1.warning)('skipping serve of function [' +
-                    target.name +
-                    '] since ' +
-                    target.failure_reason);
-                return false;
-            }
-            if (target.type === constants_1.FN_TYPE.advanced) {
-                advancedServer.add('server', target);
-            }
-            else if (target.type === constants_1.FN_TYPE.browserLogic) {
-                advancedServer.add('functions', target);
+        const isFunctionsServed = serveTargets.includes('functions');
+        if (isFunctionsServed) {
+            const rawTargets = yield features.functions();
+            if (watchOpt) {
+                yield Promise.all(rawTargets.map((target) => __awaiter(void 0, void 0, void 0, function* () { return (target.valid ? (0, fn_watcher_1.default)(target) : undefined); })));
             }
-            else if (target.type === constants_1.FN_TYPE.basic &&
-                ((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.python.value))) {
-                advancedServer.add('functions', target);
+            const functionTargets = rawTargets.filter((target) => {
+                var _a;
+                if (!target.valid) {
+                    (0, index_1.warning)('skipping serve of function [' +
+                        target.name +
+                        '] since ' +
+                        ((_a = target.failure_reason) === null || _a === void 0 ? void 0 : _a.toString()));
+                    target.failure_reason instanceof Error &&
+                        (0, index_1.debug)(`Invalid function target :: ${target.name} :: ${(0, util_1.inspect)(target.failure_reason)}`);
+                    return false;
+                }
+                switch (target.type) {
+                    case constants_1.FN_TYPE.advanced: {
+                        advancedServer.add('server', target);
+                        break;
+                    }
+                    case constants_1.FN_TYPE.basic:
+                    case constants_1.FN_TYPE.browserLogic: {
+                        advancedServer.add('functions', target);
+                    }
+                }
+                return target.valid;
+            });
+            if (functionTargets.length === 0) {
+                (0, index_1.labeled)('functions', 'No targets are ready to be served in local').WARN();
+                serveTargets.splice(serveTargets.indexOf('functions'), 1);
+                runtime_store_1.default.set('context.targets', serveTargets);
             }
-            return target.valid;
-        });
+            runtime_store_1.default.set('context.functions.targets', functionTargets);
+        }
         if (serveTargets.includes('appsail')) {
-            const appSail = runtime_store_1.default.get('context.appsail.targets', []);
+            const appSail = yield features.appsail();
             const validAppSail = appSail.filter((sail) => {
                 if (!sail.validity.valid) {
-                    (0, logger_1.warning)('skipping serve of AppSail service [' +
+                    (0, index_1.warning)('skipping serve of AppSail [' +
                         sail.name +
                         '] since ' +
                         sail.validity.reason);
@@ -119,16 +130,16 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
                 return true;
             });
             if (validAppSail.length === 0) {
-                (0, logger_1.labeled)('AppSail', 'No targets are ready to be served in local').WARN();
+                (0, index_1.labeled)('AppSail', 'No targets are ready to be served in local').WARN();
                 serveTargets.splice(serveTargets.indexOf('appsail'), 1);
                 runtime_store_1.default.set('context.targets', serveTargets);
             }
         }
         if (serveTargets.includes('slate')) {
-            const slates = runtime_store_1.default.get('context.slate.targets', []);
+            const slates = yield features.slate();
             const validSlates = slates.filter((slate) => {
                 if (!slate.validity.valid) {
-                    (0, logger_1.warning)('skipping serve of Slate service [' +
+                    (0, index_1.warning)('skipping serve of Slate service [' +
                         slate.name +
                         '] since ' +
                         slate.validity.reason);
@@ -138,12 +149,13 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
                 return true;
             });
             if (validSlates.length === 0) {
-                (0, logger_1.labeled)('Slate', 'No targets are ready to be served in local').WARN();
+                (0, index_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')) {
+            yield features.client();
             const client = runtime_store_1.default.get('context.client', false);
             if (client && client.valid) {
                 client.opts = {
@@ -156,57 +168,43 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
                 serveTargets.splice(serveTargets.indexOf('client'), 1);
             }
         }
-        const isFunctionsServed = serveTargets.includes('functions');
-        if (isFunctionsServed && functionTargets.length === 0) {
-            (0, logger_1.labeled)('functions', 'No targets are ready to be served in local').WARN();
-            serveTargets.splice(serveTargets.indexOf('functions'), 1);
-            runtime_store_1.default.set('context.targets', serveTargets);
-        }
-        if (isFunctionsServed) {
-            runtime_store_1.default.set('context.functions.targets', functionTargets);
-        }
         if (serveTargets.length === 0 ||
             (serveTargets.length === 1 && serveTargets[0] === 'apig')) {
-            throw new error_1.default('No components to serve', { exit: 0, errorId: 'SERVE-1' });
-        }
-        const basicFn = functionTargets.find((target) => {
-            var _a;
-            return target.type === constants_1.FN_TYPE.basic &&
-                !((_a = target.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.python.value));
-        });
-        if (basicFn) {
-            yield basicFnServer.start();
+            throw new index_js_1.default('No components to serve', { exit: 0, errorId: 'SERVE-1' });
         }
+        const waitPromise = advancedServer.wait();
         yield advancedServer.start();
-        yield advancedServer.wait();
-        (0, logger_1.info)('Shutting down server');
+        yield waitPromise;
+        (0, index_1.info)('Shutting down server');
         yield Promise.all([
-            fs_1.ASYNC.deleteDir(buildFolder).catch((err) => (0, logger_1.debug)('Error while deleting directory ', err)),
-            advancedServer ? advancedServer.stop() : undefined,
-            basicFnServer ? basicFnServer.stop() : undefined
+            fs_1.ASYNC.deleteDir(buildFolder).catch((err) => (0, index_1.debug)('Error while deleting directory ', err)),
+            advancedServer ? advancedServer.stop() : undefined
         ]);
-        if (serveTargets.includes('functions')) {
-            fn_utils_1.fnUtils.common.executeHook({
+        if (isFunctionsServed) {
+            yield fn_utils_1.fnUtils.common.executeHook({
                 prefix: 'post',
                 command: 'serve'
             });
         }
         if (serveTargets.includes('client')) {
-            client_utils_1.clientUtils.executeHook({
+            yield client_utils_1.clientUtils.executeHook({
                 prefix: 'post',
                 command: 'serve'
             });
         }
-        (0, logger_1.info)();
-        (0, logger_1.success)('Shutdown complete');
+        (0, index_1.info)();
+        (0, index_1.success)('Shutdown complete');
+        (0, index_1.info)();
     }
     catch (e) {
-        (0, logger_1.debug)('Error serving the resources: ', e);
+        (0, index_1.debug)('Error serving the resources: ', e);
         yield Promise.all([
             fs_1.ASYNC.deleteDir(buildFolder).catch(),
-            advancedServer ? advancedServer.stop() : undefined,
-            basicFnServer ? basicFnServer.stop() : undefined
+            advancedServer ? advancedServer.stop() : undefined
         ]);
         throw e;
     }
+    finally {
+        utils_1.serverEvent.emit('close');
+    }
 });

package/lib/serve/server/index.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
+import { IFnTarget } from '../../fn-utils/lib/common';
+import type { IClientTarget } from './lib/web_client/types';
+import { TAppSailServerDetails } from '../features/appsail';
+import { TSlateServerDetails } from '../features/slate';
+export interface IServerDetails<T = IFnTarget | IClientTarget | TAppSailServerDetails | TSlateServerDetails> {
+    type: 'client' | 'server' | 'functions' | 'appsail' | 'slate';
+    target: T;
+    httpPort: T extends IFnTarget | IClientTarget ? number : undefined;
+    debugPort: T extends IFnTarget ? number : undefined;
+    process?: ChildProcess | EventEmitter;
+    isAlive: boolean | null;
+    restarting: boolean;
+}
+export type TServerTargets = {
+    functions: Array<IServerDetails<IFnTarget>>;
+    server: Array<IServerDetails<IFnTarget>>;
+    client: Array<IServerDetails<IClientTarget>>;
+    appSail: Array<IServerDetails<TAppSailServerDetails>>;
+    slate: Array<IServerDetails<TSlateServerDetails>>;
+};
+declare class Server {
+    private targetsMap;
+    private masterServer?;
+    private _addBasicFnDetails;
+    add(type: 'client' | 'server' | 'appsail' | 'functions' | 'slate', target: IFnTarget | TAppSailServerDetails | IClientTarget | TSlateServerDetails): void;
+    private startServer;
+    start(): Promise<void>;
+    wait(): Promise<void>;
+    private kill;
+    restart(target: IServerDetails<IFnTarget>): Promise<void>;
+    stop(): Promise<void>;
+}
+export default Server;