@nu-art/build-and-install 0.204.90 → 0.204.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.204.90",
+  "version": "0.204.92",
   "description": "",
   "keywords": [
     "TacB0sS",

package/v2/phase-runner/PhaseRunner.d.ts

@@ -10,6 +10,12 @@ export declare class PhaseRunner extends BaseUnit implements UnitPhaseImplemento
     private killed?;
     private runningStatus;
     private phaseFilter;
+    /**
+     * kill counter that will intercept the kill event and if the threshold will be met the main process will be killed as well
+     * @private
+     */
+    private killCounter;
+    private static KILL_THRESHOLD;
     constructor(projectPath: RelativePath);
     protected init(): Promise<void>;
     private filterUnits;

package/v2/phase-runner/PhaseRunner.js

@@ -46,6 +46,11 @@ const CONST_ProjectDependencyKey = 'APP_VERSION_DEPENDENCY';
 class PhaseRunner extends core_1.BaseUnit {
     constructor(projectPath) {
         super({ label: 'Phase Runner', key: 'phase-runner' });
+        /**
+         * kill counter that will intercept the kill event and if the threshold will be met the main process will be killed as well
+         * @private
+         */
+        this.killCounter = 0;
         //######################### Internal Logic #########################
         this.phaseFilters = {
             [types_1.PhaseRunnerMode_Normal]: async (phase) => {
@@ -372,17 +377,34 @@ class PhaseRunner extends core_1.BaseUnit {
     //######################### Public Functions #########################
     async execute() {
         return new MemStorage_1.MemStorage().init(async () => {
+            process.on('SIGINT', () => {
+                this.killRunner();
+            });
             await this.init();
             await this.buildUnitDependencyTree();
             await this.executeImpl();
         });
     }
     async killRunner() {
-        this.killed = true;
+        this.killCounter++;
+        if (this.killCounter === PhaseRunner.KILL_THRESHOLD)
+            process.exit(1);
+        if (this.killed)
+            process.exit(1);
         await this.setRunningStatus();
         this.logDebug('Killing units');
-        await Promise.all(this.units.map(unit => unit.kill()));
+        await Promise.all(this.units.map(async (unit) => {
+            try {
+                await unit.kill();
+            }
+            catch (e) {
+                unit.logError(`Error killing unit`, e);
+            }
+        }));
         this.logDebug('Units killed');
+        this.killed = true;
+        if (params_1.RuntimeParams.closeOnExit)
+            process.exit(1);
     }
     //######################### Phase Implementation #########################
     async printHelp() {
@@ -421,4 +443,5 @@ class PhaseRunner extends core_1.BaseUnit {
         this.logInfo('Unit Dependencies Tree:', dependencyTree);
     }
 }
+PhaseRunner.KILL_THRESHOLD = 5;
 exports.PhaseRunner = PhaseRunner;

package/v2/screens/BAIScreen.js

@@ -4,7 +4,6 @@ exports.BAIScreen = void 0;
 const ConsoleContainer_1 = require("@nu-art/commando/console/ConsoleContainer");
 const ts_common_1 = require("@nu-art/ts-common");
 const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
-const params_1 = require("../../core/params/params");
 class BAIScreen extends ConsoleContainer_1.ConsoleContainer {
     //######################### Initialization #########################
     /**
@@ -63,8 +62,6 @@ class BAIScreen extends ConsoleContainer_1.ConsoleContainer {
         this.logInfo('Kill command received');
         await ((_a = this.onKillCallback) === null || _a === void 0 ? void 0 : _a.call(this));
         this.logInfo('Killed!');
-        if (params_1.RuntimeParams.closeOnExit)
-            process.exit(1);
     }
 }
 exports.BAIScreen = BAIScreen;

package/v2/unit/core/BaseUnit.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@nu-art/ts-common';
+import { AsyncVoidFunction, Logger } from '@nu-art/ts-common';
 import { RunnerParamKey } from '../../phase-runner/RunnerParams';
 export type BaseUnit_Config = {
     key: string;
@@ -15,7 +15,10 @@ export declare class BaseUnit<C extends BaseUnit_Config = BaseUnit_Config, RTC e
     private unitStatus?;
     private logger;
     private classStack;
+    private processTerminator;
     constructor(config: C);
+    registerTerminatable(terminatable: AsyncVoidFunction): void;
+    unregisterTerminatable(terminatable: AsyncVoidFunction): void;
     protected init(setInitialized?: boolean): Promise<void>;
     protected getRunnerParam(key: RunnerParamKey): string | undefined;
     private initLogClient;

package/v2/unit/core/BaseUnit.js

@@ -8,6 +8,7 @@ const params_1 = require("../../../core/params/params");
 class BaseUnit extends ts_common_1.Logger {
     constructor(config) {
         super(config.key);
+        this.processTerminator = [];
         //######################### Class Stack Logic #########################
         this.addToClassStack = (cls) => {
             this.classStack.add(cls.name);
@@ -24,6 +25,12 @@ class BaseUnit extends ts_common_1.Logger {
         this.addToClassStack(BaseUnit);
         this.initLogClient();
     }
+    registerTerminatable(terminatable) {
+        this.processTerminator.push(terminatable);
+    }
+    unregisterTerminatable(terminatable) {
+        (0, ts_common_1.removeItemFromArray)(this.processTerminator, terminatable);
+    }
     async init(setInitialized = true) {
         this.setStatus('Initializing');
         //Register the unit to PhaseRunnerEvent dispatcher
@@ -59,7 +66,15 @@ class BaseUnit extends ts_common_1.Logger {
         return this.unitStatus;
     }
     async kill() {
-        return;
+        if (!this.processTerminator.length)
+            return this.setStatus('Killed');
+        this.setStatus('Killing');
+        try {
+            await Promise.all(this.processTerminator.map(toTerminate => toTerminate()));
+        }
+        finally {
+            this.setStatus('Killed');
+        }
     }
     getLogs() {
         return this.logger.buffers[0];

package/v2/unit/core/Unit_TypescriptLib.d.ts

@@ -21,6 +21,7 @@ export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Un
     Phase_Lint
 ]>, OnWatchEvent {
     private compilationError;
+    private debounceWatch?;
     constructor(config: Unit_TypescriptLib<C, RTC>['config']);
     __onWatchEvent(type: WatchEventType, path?: string): Promise<void>;
     protected init(setInitialized?: boolean): Promise<void>;

package/v2/unit/core/Unit_TypescriptLib.js

@@ -58,7 +58,10 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
     async __onWatchEvent(type, path) {
         if (type === consts_2.WatchEvent_Ready)
             return this.setStatus('Watching');
-        await this.handleWatchChange(path, [consts_2.WatchEvent_RemoveFile, consts_2.WatchEvent_RemoveDir].includes(type));
+        if (this.debounceWatch)
+            delete this.debounceWatch;
+        this.debounceWatch = (0, ts_common_1.debounce)(() => this.handleWatchChange(path, [consts_2.WatchEvent_RemoveFile, consts_2.WatchEvent_RemoveDir].includes(type)), ts_common_1.Second * 4, ts_common_1.Second * 10);
+        this.debounceWatch();
     }
     async init(setInitialized = true) {
         await super.init(false);
@@ -101,13 +104,17 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
         const pathToCompile = `${this.runtime.pathTo.pkg}/src/main`;
         const pathToTSConfig = `${pathToCompile}/tsconfig.json`;
         try {
-            await nvm_1.NVM
-                .createInteractiveCommando(basic_1.Cli_Basic)
-                .setUID(this.config.key)
+            let pid;
+            const commando = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic);
+            this.registerTerminatable(async () => {
+                console.log(`killing ${pid}`);
+                process.kill(pid, 2);
+            });
+            await commando.setUID(this.config.key)
                 .cd(this.runtime.pathTo.pkg)
                 .append(`tsc -p "${pathToTSConfig}" --rootDir "${pathToCompile}" --outDir "${this.runtime.pathTo.output}"`)
                 .addLogProcessor((log) => !log.includes('Now using node') && !log.includes('.nvmrc\' with version'))
-                .execute((stdout, stderr, exitCode) => {
+                .executeAsync(_pid => pid = _pid, (stdout, stderr, exitCode) => {
                 if (exitCode > 0)
                     throw new CliError_1.CommandoException(`Error compiling`, stdout, stderr, exitCode);
             });

package/v2/unit/core/Unit_TypescriptProject.js

@@ -116,10 +116,8 @@ class Unit_TypescriptProject extends Unit_Typescript_1.Unit_Typescript {
                     runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_RemoveFile, path);
                 });
             });
-            process.on('SIGINT', async (status) => {
+            this.registerTerminatable(async () => {
                 await watcher.close();
-                process.exit(0);
-                resolve();
             });
         });
     }

package/v2/unit/firebase-units/Unit_FirebaseFunctionsApp.d.ts

@@ -9,9 +9,6 @@ export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
 };
 export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_ResolveConfigs, Phase_Launch, Phase_DeployBackend]>, OnUnitWatchCompiled {
     static staggerCount: number;
-    private emulatorPid?;
-    private proxyPid?;
-    private launchCommandos;
     __onUnitWatchCompiled(unit: BaseUnit): Promise<void>;
     constructor(config: Unit_FirebaseFunctionsApp<C>['config']);
     resolveConfigs(): Promise<void>;
@@ -26,13 +23,8 @@ export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsA
     private resolveFunctionsRuntimeConfig;
     private createAppVersionFile;
     private createDependenciesDir;
-    private clearPorts;
-    private onLaunched;
-    private initLaunch;
-    private initLaunchListeners;
+    private releasePorts;
     private runProxy;
     private runEmulator;
-    kill(): Promise<void>;
-    private printFiles;
     private deployImpl;
 }

package/v2/unit/firebase-units/Unit_FirebaseFunctionsApp.js

@@ -52,16 +52,13 @@ class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
     async launch() {
         this.setStatus('Launching');
         await (0, ts_common_1.sleep)(2 * ts_common_1.Second * Unit_FirebaseFunctionsApp.staggerCount++);
-        await this.initLaunch();
-        await this.initLaunchListeners();
-        await this.clearPorts();
+        await this.releasePorts();
         await Promise.all([
             this.runProxy(),
             this.runEmulator(),
         ]);
     }
     async deployBackend() {
-        await this.printFiles();
         await this.deployImpl();
     }
     //######################### ResolveConfig Logic #########################
@@ -237,55 +234,45 @@ class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
         this.packageJson.dist = packageJsonConverter(this.packageJson.dist);
     }
     //######################### Launch Logic #########################
-    async clearPorts() {
+    async releasePorts() {
+        const commando = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic);
         const allPorts = Array.from({ length: 10 }, (_, i) => `${this.config.firebaseConfig.basePort + i}`);
-        await shell_1.Commando.create(basic_1.Cli_Basic)
+        await commando.setUID(this.config.key)
             .append(`array=($(lsof -ti:${allPorts.join(',')}))`)
             .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)
             .append('echo ')
             .execute();
     }
-    onLaunched() {
-        this.setStatus('Launch Complete');
-    }
-    async initLaunch() {
-        this.launchCommandos = {
-            emulator: nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic).setUID(this.config.key).cd(this.runtime.pathTo.pkg),
-            proxy: nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic).setUID(this.config.key).cd(this.runtime.pathTo.pkg),
-        };
-    }
-    async initLaunchListeners() {
-        this.launchCommandos.emulator.onLog(/.*Emulator Hub running.*/, () => this.onLaunched());
-    }
     async runProxy() {
-        await this.launchCommandos.proxy
+        let pid;
+        const commando = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic);
+        const terminatable = () => commando.gracefullyKill(pid);
+        this.registerTerminatable(terminatable);
+        await commando.setUID(this.config.key)
+            .cd(this.runtime.pathTo.pkg)
             .append('ts-node src/main/proxy.ts')
-            .executeAsync(pid => this.proxyPid = pid);
+            .executeAsync(_pid => pid = _pid);
+        this.unregisterTerminatable(terminatable);
     }
     async runEmulator() {
-        await this.launchCommandos.emulator
+        let pid;
+        const commando = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic);
+        const terminatable = () => commando.gracefullyKill(pid);
+        this.registerTerminatable(terminatable);
+        await commando.setUID(this.config.key)
+            .cd(this.runtime.pathTo.pkg)
+            .onLog(/.*Emulator Hub running.*/, () => this.setStatus('Launch Complete'))
             .append(`firebase emulators:start --export-on-exit --import=.trash/data ${params_1.RuntimeParams.debugBackend ? `--inspect-functions ${this.config.firebaseConfig.debugPort}` : ''}`)
-            .executeAsync(pid => this.emulatorPid = pid);
-    }
-    async kill() {
-        if (!this.launchCommandos)
-            return;
-        this.logWarning(`Killing unit - ${this.config.label}`);
-        await this.launchCommandos.emulator.gracefullyKill(this.emulatorPid);
-        await this.launchCommandos.proxy.gracefullyKill(this.proxyPid);
-        this.logWarning(`Unit killed - ${this.config.label}`);
+            .executeAsync(_pid => pid = _pid);
+        this.unregisterTerminatable(terminatable);
     }
     //######################### Deploy Logic #########################
-    async printFiles() {
-        await shell_1.Commando.create(basic_1.Cli_Basic)
+    async deployImpl() {
+        await nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic)
             .cd(this.runtime.pathTo.output)
             .ls()
             .cat('package.json')
             .cat('index.js')
-            .execute();
-    }
-    async deployImpl() {
-        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
             .cd(this.runtime.pathTo.pkg)
             .append(`firebase --debug deploy --only functions --force`)
             .execute();
@@ -293,48 +280,3 @@ class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
 }
 Unit_FirebaseFunctionsApp.staggerCount = 0;
 exports.Unit_FirebaseFunctionsApp = Unit_FirebaseFunctionsApp;
-// export class CommandoCLIListener {
-//
-// 	private cb: CommandoCLIListener_Callback;
-// 	protected filter?: RegExp;
-//
-// 	constructor(callback: CommandoCLIListener_Callback, filter?: string | RegExp) {
-// 		this.cb = callback;
-// 		if (!filter)
-// 			return;
-//
-// 		if (typeof filter === 'string')
-// 			this.filter = new RegExp(filter);
-// 		else
-// 			this.filter = filter as RegExp;
-// 	}
-//
-// 	//######################### Inner Logic #########################
-//
-// 	private _process(stdout: string) {
-// 		if (!this.stdoutPassesFilter(stdout))
-// 			return false;
-//
-// 		this.process(stdout);
-// 		return true;
-// 	}
-//
-// 	private stdoutPassesFilter = (stdout: string): boolean => {
-// 		if (!this.filter)
-// 			return true;
-//
-// 		return this.filter.test(stdout);
-// 	};
-//
-// 	//######################### Functions #########################
-//
-// 	public listen = <T extends Commando | CommandoInteractive>(commando: T): T => {
-// 		const process = this._process.bind(this);
-// 		commando.addLogProcessor(process);
-// 		return commando;
-// 	};
-//
-// 	protected process(stdout: string) {
-// 		this.cb(stdout);
-// 	}
-// }

package/v2/unit/firebase-units/Unit_FirebaseHostingApp.d.ts

@@ -7,9 +7,8 @@ export type Unit_FirebaseHostingApp_Config = Unit_TypescriptLib_Config & {
     sources?: string[];
 };
 export declare class Unit_FirebaseHostingApp<C extends Unit_FirebaseHostingApp_Config = Unit_FirebaseHostingApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_ResolveConfigs, Phase_Launch, Phase_DeployFrontend]> {
-    private launchCommando;
-    private hostingPid;
     constructor(config: Unit_FirebaseHostingApp<C>['config']);
+    protected init(setInitialized?: boolean): Promise<void>;
     resolveConfigs(): Promise<void>;
     compile(): Promise<void>;
     launch(): Promise<void>;
@@ -20,9 +19,6 @@ export declare class Unit_FirebaseHostingApp<C extends Unit_FirebaseHostingApp_C
     private resolveHostingRuntimeConfig;
     protected compileImpl(): Promise<void>;
     private createAppVersionFile;
-    private initLaunch;
-    private clearPorts;
     private runApp;
-    kill(): Promise<void>;
     private deployImpl;
 }

package/v2/unit/firebase-units/Unit_FirebaseHostingApp.js

@@ -18,6 +18,11 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
         this.addToClassStack(Unit_FirebaseHostingApp);
         runner_dispatchers_1.dispatcher_WatchEvent.removeListener(this);
     }
+    async init(setInitialized = true) {
+        await super.init(setInitialized);
+        if (!this.config.firebaseConfig.hostingPort)
+            throw new ts_common_1.BadImplementationException(`Unit ${this.config.label} missing hosting port in firebaseConfig`);
+    }
     //######################### Phase Implementations #########################
     async resolveConfigs() {
         await this.resolveHostingRC();
@@ -34,8 +39,6 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
     }
     async launch() {
         this.setStatus('Launching');
-        await this.initLaunch();
-        await this.clearPorts();
         await this.runApp();
     }
     async deployFrontend() {
@@ -94,7 +97,7 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
     //######################### Compile Logic #########################
     async compileImpl() {
         await nvm_1.NVM
-            .createCommando(basic_1.Cli_Basic)
+            .createInteractiveCommando(basic_1.Cli_Basic)
             .cd(this.runtime.pathTo.pkg)
             .append(`ENV=${params_1.RuntimeParams.environment} npm run build`)
             .execute();
@@ -108,36 +111,24 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
         await fs_1.promises.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
     }
     //######################### Launch Logic #########################
-    async initLaunch() {
-        if (!this.config.firebaseConfig.hostingPort)
-            throw new ts_common_1.BadImplementationException(`Unit ${this.config.label} missing hosting port in firebaseConfig`);
-        this.launchCommando = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic)
+    async runApp() {
+        let pid;
+        const commando = nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic);
+        const terminatable = () => commando.gracefullyKill(pid);
+        this.registerTerminatable(terminatable);
+        await commando
             .setUID(this.config.key)
-            .cd(this.runtime.pathTo.pkg);
-    }
-    async clearPorts() {
-        await this.launchCommando
+            .cd(this.runtime.pathTo.pkg)
             .append(`array=($(lsof -ti:${[this.config.firebaseConfig.hostingPort].join(',')}))`)
             .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)
             .append('echo ')
-            .execute();
-    }
-    async runApp() {
-        await this.launchCommando
             .append('npm run start')
-            .executeAsync(pid => this.hostingPid = pid);
-    }
-    async kill() {
-        var _a;
-        if (!this.launchCommando)
-            return;
-        this.logWarning(`Killing unit - ${this.config.label}`);
-        await ((_a = this.launchCommando) === null || _a === void 0 ? void 0 : _a.gracefullyKill(this.hostingPid));
-        this.logWarning(`Unit killed - ${this.config.label}`);
+            .executeAsync(_pid => pid = _pid);
+        this.unregisterTerminatable(terminatable);
     }
     //######################### Deploy Logic #########################
     async deployImpl() {
-        await nvm_1.NVM.createCommando(basic_1.Cli_Basic)
+        await nvm_1.NVM.createInteractiveCommando(basic_1.Cli_Basic)
             .cd(this.runtime.pathTo.pkg)
             .append(`firebase --debug deploy --only hosting`)
             .execute();