@nu-art/build-and-install 0.400.4 → 0.400.6

package/build-and-install-v3.d.ts

@@ -1,6 +1,7 @@
 import { Logger } from '@nu-art/ts-common';
 import { BaiParams } from './core/params/params.js';
 import { Phase } from './v3/phase/index.js';
+import { UnitsMapper } from './v3/UnitsMapper/UnitsMapper.js';
 import { ProjectUnit } from './v3/units/ProjectUnit.js';
 import { Unit_NodeProject } from './v3/units/index.js';
 import { BaseCliParam } from '@nu-art/commando/cli-params/types';
@@ -11,6 +12,7 @@ type BAI_Options = {
     runtimeParams: BaseCliParam<string, any>[];
 };
 export declare class BuildAndInstall extends Logger {
+    private unitsMapper;
     private phases;
     private pathToProject;
     private allUnits;
@@ -21,6 +23,7 @@ export declare class BuildAndInstall extends Logger {
     readonly runningStatus: RunningStatusHandler;
     constructor(config?: Partial<BAI_Options>);
     init(): Promise<void>;
+    prepareUnitsMapper(unitsMapper: UnitsMapper): void;
     setApplicativeUnits(projectUnits: ProjectUnit[]): void;
     setPhases(phases: Phase<string>[][]): void;
     build(): Promise<ProjectUnit<import("./v3/units/ProjectUnit.js").Config_ProjectUnit>[]>;

package/build-and-install-v3.js

@@ -1,6 +1,6 @@
 import { _keys, arrayToMap, BeLogged, DebugFlag, filterDuplicates, LogClient_Terminal, Logger, LogLevel, merge } from '@nu-art/ts-common';
 import { AllBaiParams } from './core/params/params.js';
-import { phases_Build, phases_Deploy, phases_Launch } from './v3/phase/index.js';
+import { phases_Build, phases_Deploy, phases_Launch, phases_Terminating } from './v3/phase/index.js';
 import { UnitsMapper } from './v3/UnitsMapper/UnitsMapper.js';
 import { UnitsDependencyMapper } from './v3/UnitsDependencyMapper/UnitsDependencyMapper.js';
 import { FilesCache } from './v3/core/FilesCache.js';
@@ -15,10 +15,12 @@ import { RunningStatusHandler } from './v3/RunningStatusHandler.js';
 import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 export const DefaultPhases = [
     ...phases_Build,
+    ...phases_Terminating,
     ...phases_Launch,
     ...phases_Deploy,
 ];
 export class BuildAndInstall extends Logger {
+    unitsMapper;
     phases = DefaultPhases;
     pathToProject;
     allUnits = [];
@@ -46,6 +48,16 @@ export class BuildAndInstall extends Logger {
             DebugFlag.DefaultLogLevel = LogLevel.Verbose;
         this.setMinLevel(DebugFlag.DefaultLogLevel);
         this.logDebug('Runtime params:', this.runtimeParams);
+        this.unitsMapper = new UnitsMapper();
+        this.prepareUnitsMapper(this.unitsMapper);
+    }
+    prepareUnitsMapper(unitsMapper) {
+        unitsMapper
+            .addRules(UnitMapper_NodeLib)
+            .addRules(UnitMapper_NodeProject)
+            .addRules(UnitMapper_FirebaseHosting)
+            .addRules(UnitMapper_FirebaseFunction)
+            .setRuntimeParams(this.runtimeParams);
     }
     setApplicativeUnits(projectUnits) {
         this.projectUnits.push(...projectUnits);
@@ -56,14 +68,7 @@ export class BuildAndInstall extends Logger {
     async build() {
         await this.init();
         this.logVerbose(`Resolving units from: ${this.pathToProject}`);
-        const unitsMapper = new UnitsMapper();
-        this.allUnits = await unitsMapper
-            .addRules(UnitMapper_NodeLib)
-            .addRules(UnitMapper_NodeProject)
-            .addRules(UnitMapper_FirebaseHosting)
-            .addRules(UnitMapper_FirebaseFunction)
-            .setRuntimeParams(this.runtimeParams)
-            .resolveUnits(this.pathToProject);
+        this.allUnits = await this.unitsMapper.resolveUnits(this.pathToProject);
         Object.freeze(this.allUnits);
         this.logDebug('Units found:', this.allUnits.map(unit => `${unit.constructor?.['name']}: ${unit.config.key}`).join('\n'));
         const unitKeyToUnitMap = arrayToMap(this.allUnits, unit => unit.config.key);

package/core/params/params.d.ts

@@ -1,10 +1,8 @@
 import { BaseCliParam, CliParams } from '@nu-art/commando/cli-params/types';
 export declare const BaiParam_AllUnits: BaseCliParam<'allUnits', boolean>;
 export declare const BaiParam_DependencyTree: BaseCliParam<'dependencyTree', boolean>;
-export declare const BaiParam_CheckCyclicImports: BaseCliParam<'checkCyclicImports', boolean>;
 export declare const BaiParam_continue: BaseCliParam<'continue', boolean>;
 export declare const BaiParam_SetEnv: BaseCliParam<'environment', string>;
-export declare const BaiParam_Setup: BaseCliParam<'setup', boolean>;
 export declare const BaiParam_Install: BaseCliParam<'install', boolean>;
 export declare const BaiParam_Clean: BaseCliParam<'clean', boolean>;
 export declare const BaiParam_Purge: BaseCliParam<'purge', boolean>;
@@ -25,7 +23,7 @@ export declare const BaiParam_TestCase: BaseCliParam<'testCases', string[]>;
 export declare const BaiParam_TestDebugPort: BaseCliParam<'testDebugPort', number>;
 export declare const BaiParam_Launch: BaseCliParam<'launch', boolean>;
 export declare const BaiParam_DebugBackend: BaseCliParam<'debugBackend', boolean>;
-export declare const BaiParam_Deploy: BaseCliParam<'deploy', string>;
+export declare const BaiParam_Deploy: BaseCliParam<'deploy', boolean>;
 export declare const BaiParam_Debug: BaseCliParam<'debug', boolean>;
 export declare const BaiParam_DebugLifecycle: BaseCliParam<'debugLifecycle', boolean>;
 export declare const BaiParam_Verbose: BaseCliParam<'verbose', boolean>;
@@ -33,8 +31,10 @@ export declare const BaiParam_QuickDeploy: BaseCliParam<'quickDeploy', boolean>;
 type PromoteType = 'patch' | 'minor' | 'major';
 export declare const BaiParam_Publish: BaseCliParam<'publish', PromoteType>;
 export declare const BaiParam_UsePackage: BaseCliParam<'usePackage', string[]>;
+export declare const BaiParam_includePackage: BaseCliParam<'includePackage', string[]>;
 export declare const BaiParam_ToESM: BaseCliParam<'toESM', boolean>;
 export declare const BaiParam_Simulate: BaseCliParam<'simulation', boolean>;
-export declare const AllBaiParams: (BaseCliParam<"allUnits", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"setup", boolean> | BaseCliParam<"install", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"prepare", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"watchBuildTree", boolean> | BaseCliParam<"test", boolean> | BaseCliParam<"testType", string[]> | BaseCliParam<"testFiles", string[]> | BaseCliParam<"testCases", string[]> | BaseCliParam<"testDebugPort", number> | BaseCliParam<"launch", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", string> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", PromoteType> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean>)[];
+export declare const BaiParam_CheckCyclicImports: BaseCliParam<'checkCyclicImports', boolean>;
+export declare const AllBaiParams: (BaseCliParam<"allUnits", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"install", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"prepare", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"watchBuildTree", boolean> | BaseCliParam<"test", boolean> | BaseCliParam<"testType", string[]> | BaseCliParam<"testFiles", string[]> | BaseCliParam<"testCases", string[]> | BaseCliParam<"testDebugPort", number> | BaseCliParam<"launch", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", boolean> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", PromoteType> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"includePackage", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean> | BaseCliParam<"checkCyclicImports", boolean>)[];
 export type BaiParams = CliParams<typeof AllBaiParams>;
 export {};

package/core/params/params.js

@@ -12,13 +12,6 @@ export const BaiParam_DependencyTree = {
     group: 'General',
     description: 'Will print the projects packages dependencies tree into the .trash folder'
 };
-export const BaiParam_CheckCyclicImports = {
-    keys: ['--check-cyclic-imports', '-cci'],
-    keyName: 'checkCyclicImports',
-    type: 'boolean',
-    group: 'General',
-    description: 'will check for cyclic imports and render an svg with the import graph'
-};
 export const BaiParam_continue = {
     keys: ['--continue', '-con'],
     keyName: 'continue',
@@ -34,13 +27,6 @@ export const BaiParam_SetEnv = {
     initialValue: 'local',
     description: 'Will set the .config-${environment}.json as the current .config.json and prepare it as base 64 for local usage \ninput required: envName(string)'
 };
-export const BaiParam_Setup = {
-    keys: ['--setup'],
-    keyName: 'setup',
-    type: 'boolean',
-    group: 'Build',
-    description: 'Setup local project for developer'
-};
 export const BaiParam_Install = {
     keys: ['--install', '-i'],
     keyName: 'install',
@@ -184,9 +170,15 @@ export const BaiParam_DebugBackend = {
 export const BaiParam_Deploy = {
     keys: ['--deploy', '-dep'],
     keyName: 'deploy',
-    type: 'string',
+    type: 'boolean',
     group: 'Apps',
-    description: 'Will add the provided App to the deploy list or all applications'
+    description: 'Will add the provided App to the deploy list or all applications',
+    dependencies: [
+        { param: BaiParam_Launch, value: false },
+        { param: BaiParam_Watch, value: false },
+        { param: BaiParam_WatchBuildTree, value: false },
+        { param: BaiParam_GenerateDocs, value: false },
+    ]
 };
 export const BaiParam_Debug = {
     keys: ['--debug', '-d'],
@@ -239,6 +231,19 @@ export const BaiParam_UsePackage = {
     },
     dependencies: [{ param: BaiParam_AllUnits, value: true }]
 };
+export const BaiParam_includePackage = {
+    keys: ['-in', '--include='],
+    keyName: 'includePackage',
+    type: 'string[]',
+    group: 'Other',
+    description: 'Will include the units to process',
+    process: (value) => {
+        if (!value)
+            return [];
+        return value.split(',').map(str => str.trim());
+    },
+    dependencies: []
+};
 export const BaiParam_ToESM = {
     keys: ['-tesm', '--to-esm'],
     keyName: 'toESM',
@@ -248,13 +253,29 @@ export const BaiParam_ToESM = {
     dependencies: [{ param: BaiParam_AllUnits, value: true }]
 };
 export const BaiParam_Simulate = {
-    keys: ['--simulate', '-sim'],
+    keys: ['--simulate', '-sim', '--simulation'],
     keyName: 'simulation',
     type: 'boolean',
     group: 'Other',
     description: 'In combination with other params, will not perform the outbound operation, but instead simulate it',
     dependencies: [{ param: BaiParam_AllUnits, value: true }]
 };
+export const BaiParam_CheckCyclicImports = {
+    keys: ['--check-cyclic-imports', '-cci'],
+    keyName: 'checkCyclicImports',
+    type: 'boolean',
+    group: 'General',
+    description: 'will check for cyclic imports and render an svg with the import graph',
+    dependencies: [
+        { param: BaiParam_NoBuild, value: true },
+        { param: BaiParam_Launch, value: false },
+        { param: BaiParam_Install, value: false },
+        { param: BaiParam_Deploy, value: false },
+        { param: BaiParam_Publish, value: false },
+        { param: BaiParam_Purge, value: false },
+        { param: BaiParam_Clean, value: false },
+    ]
+};
 export const AllBaiParams = [
     BaiParam_AllUnits,
     BaiParam_DependencyTree,
@@ -264,7 +285,6 @@ export const AllBaiParams = [
     BaiParam_continue,
     BaiParam_Prepare,
     BaiParam_SetEnv,
-    BaiParam_Setup,
     BaiParam_Install,
     BaiParam_Generate, // TODO: to implement
     BaiParam_GenerateDocs, // TODO: to implement
@@ -284,6 +304,7 @@ export const AllBaiParams = [
     BaiParam_Debug,
     BaiParam_Verbose,
     BaiParam_Publish,
+    BaiParam_includePackage,
     BaiParam_UsePackage,
     BaiParam_ToESM,
     BaiParam_Simulate,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.400.4",
+  "version": "0.400.6",
   "description": "",
   "type": "module",
   "keywords": [
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "chokidar": "^3.6.0",
-    "@nu-art/ts-common": "0.400.4",
-    "@nu-art/commando": "0.400.4"
+    "@nu-art/ts-common": "0.400.6",
+    "@nu-art/commando": "0.400.6"
   },
   "unitConfig": {
     "type": "typescript-lib"

package/v3/PhaseManager.js

@@ -1,4 +1,4 @@
-import { addItemToArray, exists, flatArray, Logger, removeItemFromArray, timeCounter } from '@nu-art/ts-common';
+import { addItemToArray, asArray, exists, flatArray, Logger, removeItemFromArray, timeCounter } from '@nu-art/ts-common';
 import { PhaseAggregatedException } from '../core/exceptions/PhaseAggregatedException.js';
 export class PhaseManager extends Logger {
     phases;
@@ -28,6 +28,12 @@ export class PhaseManager extends Logger {
             const regexMatchers = usePackageKeys.map(filter => new RegExp(`.*?${filter}.*?`, 'i'));
             this.activeUnits = allUnits.filter(unit => regexMatchers.some(matcher => matcher.test(unit.config.key))).map(unit => unit.config.key);
         }
+        const packagesToInclude = this.runningStatus.runtimeParams.includePackage;
+        if (packagesToInclude?.length) {
+            const regexMatchers = asArray(packagesToInclude).map(filter => new RegExp(`.*?${filter}.*?`, 'i'));
+            this.activeUnits.push(...allUnits.filter(unit => regexMatchers.some(matcher => matcher.test(unit.config.key))).map(unit => unit.config.key));
+            this.activeUnits = [...new Set(this.activeUnits)];
+        }
         this.keyToPhaseMap = flatArray(phases).reduce((acc, phase) => {
             acc[phase.key] = phase;
             return acc;
@@ -75,11 +81,15 @@ export class PhaseManager extends Logger {
                 break;
             const scheduledStep = _steps[i];
             const step = this.mapStep(scheduledStep);
+            await this.runningStatus.onStepStarted(i);
             this.logDebug(`Executing step #${i + 1}/${_steps.length}`);
             this.logVerbose(scheduledStep);
             const errors = [];
             let failedStep;
             await Promise.all(step.units.map(async (unit) => {
+                if (this.runningStatus.isCompleted(unit.config.key))
+                    return;
+                let failed = false;
                 for (const phase of step.phases) {
                     if (this.killed)
                         break;
@@ -103,16 +113,19 @@ export class PhaseManager extends Logger {
                         errors.push(error);
                         failedStep = scheduledStep;
                         this.killed = true;
+                        failed = true;
                         break;
                     }
                     finally {
                         removeItemFromArray(this.runningUnits, unit);
                     }
                 }
+                if (!failed)
+                    await this.runningStatus.onUnitCompleted(unit.config.key);
             }));
-            await this.runningStatus.update(i);
             if (failedStep && errors.length)
                 throw new PhaseAggregatedException(errors, failedStep);
+            await this.runningStatus.onStepEnded();
         }
         this.logInfo('All steps completed.');
     }

package/v3/RunningStatusHandler.d.ts

@@ -1,16 +1,18 @@
 import { Logger } from '@nu-art/ts-common';
-import { ScheduledStep } from './PhaseManager.js';
 import { BaiParams } from '../core/params/params.js';
 export declare class RunningStatusHandler extends Logger {
     private isolated;
-    private steps;
-    private outputFolder;
+    private readonly outputFolder;
+    private completedUnits;
     runtimeParams: BaiParams;
     startIndex: number;
     constructor(outputFolder: string, runtimeParams: BaiParams);
     init(): Promise<void>;
-    setSteps(steps: ScheduledStep[]): void;
     isolate(): RunningStatusHandler;
-    update(index: number): Promise<void>;
+    isCompleted(unitKey: string): boolean;
+    onUnitCompleted(unitKey: string): Promise<void>;
+    onStepEnded(): Promise<void>;
+    onStepStarted(index: number): Promise<void>;
+    private saveStatus;
     load(): Promise<any>;
 }

package/v3/RunningStatusHandler.js

@@ -2,8 +2,9 @@ import fs, { promises as _fs } from 'fs';
 import { __stringify, Logger } from '@nu-art/ts-common';
 export class RunningStatusHandler extends Logger {
     isolated = false;
-    steps = [];
     outputFolder;
+    // The completed units in the phase.. when running -con, these can be skipped
+    completedUnits = [];
     runtimeParams;
     startIndex = 0;
     constructor(outputFolder, runtimeParams) {
@@ -20,31 +21,41 @@ export class RunningStatusHandler extends Logger {
             this.runtimeParams = Object.assign(currentParams, this.runtimeParams);
         }
     }
-    setSteps(steps) {
-        if (this.runtimeParams.continue)
-            return;
-        this.steps = steps;
-    }
     isolate() {
         this.isolated = true;
         return this;
     }
-    async update(index) {
+    isCompleted(unitKey) {
+        return this.completedUnits.includes(unitKey);
+    }
+    async onUnitCompleted(unitKey) {
+        this.logDebug(`On unit completed: ${unitKey}`);
+        this.completedUnits.push(unitKey);
+        await this.saveStatus();
+    }
+    async onStepEnded() {
+        this.logDebug(`On step ended successfully #${this.startIndex}`);
+        this.completedUnits = [];
+    }
+    async onStepStarted(index) {
         this.startIndex = index;
+        this.logDebug(`Setting execution index to #${this.startIndex}`);
         if (this.isolated)
             return;
-        this.logVerbose(`Setting execution index to #${index}`, this.steps[index]);
+        await this.saveStatus();
+    }
+    async saveStatus() {
         await _fs.writeFile(`${this.outputFolder}/running-status.json`, __stringify({
             index: this.startIndex,
             runtimeParams: this.runtimeParams,
-            steps: this.steps
+            completedUnits: this.completedUnits
         }, true));
     }
     async load() {
         try {
             const data = JSON.parse(await _fs.readFile(`${this.outputFolder}/running-status.json`, { encoding: 'utf-8' }));
             this.startIndex = data.index;
-            this.steps = data.steps;
+            this.completedUnits = data.completedUnits ?? [];
             this.runtimeParams = data.runtimeParams;
             return data.index;
         }

package/v3/UnitsMapper/resolvers/UnitMapper_Node.js

@@ -19,40 +19,47 @@ export class UnitMapper_Node extends UnitMapper_Base {
         const pathToFile = `${path}/__package.json`;
         if (!await FileSystemUtils.file.exists(pathToFile))
             return;
-        let packageJson = await FilesCache.load.json(pathToFile);
-        if (!packageJson)
-            return;
-        if (!packageJson.unitConfig) {
-            this.logWarning(`Found a package.json without unitConfig at: ${pathToFile}`);
-            UnitMapper_Node.invalidPaths.push(path);
-            return;
+        let packageJson;
+        try {
+            packageJson = await FilesCache.load.json(pathToFile);
+            if (!packageJson)
+                return;
+            if (!packageJson.unitConfig) {
+                this.logWarning(`Found a package.json without unitConfig at: ${pathToFile}`);
+                UnitMapper_Node.invalidPaths.push(path);
+                return;
+            }
+            if (tsValidateResult(packageJson.unitConfig.type, this.validator.type))
+                return; // not the expected type for this mapper
+            packageJson = deepClone(packageJson);
+            tsValidate(packageJson.unitConfig, this.validator);
+            const dependencies = packageJson.dependencies;
+            if (dependencies)
+                packageJson.dependencies = _keys(dependencies).reduce((acc, key) => {
+                    acc[key] = dependencies[key] === '?' ? `{{${key}}}` : dependencies[key];
+                    return acc;
+                }, {});
+            const devDependencies = packageJson.devDependencies;
+            if (devDependencies)
+                packageJson.devDependencies = _keys(devDependencies).reduce((acc, key) => {
+                    acc[key] = devDependencies[key] === '?' ? `{{${key}}}` : devDependencies[key];
+                    return acc;
+                }, {});
+            Object.freeze(packageJson);
+            const baseConfig = {
+                key: packageJson.name,
+                fullPath: path,
+                relativePath: path.replace(root, '.'),
+                label: packageJson.unitConfig.label ?? packageJson.name,
+                dependencies: { ...dependencies, ...packageJson.devDependencies },
+            };
+            const customESLintConfig = packageJson.unitConfig.customESLintConfig ?? false;
+            const customTSConfig = packageJson.unitConfig.customTSConfig ?? false;
+            return this.resolveNodeUnit({ path, root, packageJson, baseConfig, customESLintConfig, customTSConfig });
+        }
+        catch (e) {
+            this.logError(`Failed to load package.json at: ${pathToFile}`, e);
+            throw e;
         }
-        if (tsValidateResult(packageJson.unitConfig.type, this.validator.type))
-            return; // not the expected type for this mapper
-        packageJson = deepClone(packageJson);
-        tsValidate(packageJson.unitConfig, this.validator);
-        const dependencies = packageJson.dependencies;
-        if (dependencies)
-            packageJson.dependencies = _keys(dependencies).reduce((acc, key) => {
-                acc[key] = dependencies[key] === '?' ? `{{${key}}}` : dependencies[key];
-                return acc;
-            }, {});
-        const devDependencies = packageJson.devDependencies;
-        if (devDependencies)
-            packageJson.devDependencies = _keys(devDependencies).reduce((acc, key) => {
-                acc[key] = devDependencies[key] === '?' ? `{{${key}}}` : devDependencies[key];
-                return acc;
-            }, {});
-        Object.freeze(packageJson);
-        const baseConfig = {
-            key: packageJson.name,
-            fullPath: path,
-            relativePath: path.replace(root, '.'),
-            label: packageJson.unitConfig.label ?? packageJson.name,
-            dependencies: { ...dependencies, ...packageJson.devDependencies },
-        };
-        const customESLintConfig = packageJson.unitConfig.customESLintConfig ?? false;
-        const customTSConfig = packageJson.unitConfig.customTSConfig ?? false;
-        return this.resolveNodeUnit({ path, root, packageJson, baseConfig, customESLintConfig, customTSConfig });
     }
 }

package/v3/core/Unit_HelpPrinter.d.ts

@@ -3,7 +3,7 @@ import { UnitPhaseImplementor } from './types.js';
 import { Phase } from '../phase/index.js';
 import { ProjectUnit } from '../units/index.js';
 export declare const BaiParam_Help: BaseCliParam<'help', boolean>;
-declare const AllBaiParams_Help: (BaseCliParam<"allUnits", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"setup", boolean> | BaseCliParam<"install", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"prepare", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"watchBuildTree", boolean> | BaseCliParam<"test", boolean> | BaseCliParam<"testType", string[]> | BaseCliParam<"testFiles", string[]> | BaseCliParam<"testCases", string[]> | BaseCliParam<"testDebugPort", number> | BaseCliParam<"launch", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", string> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", "patch" | "minor" | "major"> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean> | BaseCliParam<"help", boolean>)[];
+declare const AllBaiParams_Help: (BaseCliParam<"allUnits", boolean> | BaseCliParam<"dependencyTree", boolean> | BaseCliParam<"continue", boolean> | BaseCliParam<"environment", string> | BaseCliParam<"install", boolean> | BaseCliParam<"clean", boolean> | BaseCliParam<"purge", boolean> | BaseCliParam<"generate", boolean> | BaseCliParam<"generateDocs", boolean> | BaseCliParam<"noBuild", boolean> | BaseCliParam<"prepare", boolean> | BaseCliParam<"dryRun", boolean> | BaseCliParam<"lint", boolean> | BaseCliParam<"watch", boolean> | BaseCliParam<"watchBuildTree", boolean> | BaseCliParam<"test", boolean> | BaseCliParam<"testType", string[]> | BaseCliParam<"testFiles", string[]> | BaseCliParam<"testCases", string[]> | BaseCliParam<"testDebugPort", number> | BaseCliParam<"launch", boolean> | BaseCliParam<"debugBackend", boolean> | BaseCliParam<"deploy", boolean> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", "patch" | "minor" | "major"> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"includePackage", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"help", boolean>)[];
 export type Help_BaiParams = CliParams<typeof AllBaiParams_Help>;
 export type Phase_Help = typeof phase_Help;
 export declare const phaseKey_Help = "help";

package/v3/phase/consts.d.ts

@@ -8,6 +8,7 @@ export declare const phase_CheckCyclicImports: Phase<'checkCyclicImports'>;
 export type Phase_ToESM = typeof phase_ToESM;
 export declare const phaseKey_ToESM = "convertToESM";
 export declare const phase_ToESM: Phase<'convertToESM'>;
+export declare const phases_Terminating: Phase<string>[][];
 export type Phase_Purge = typeof phase_Purge;
 export declare const phaseKey_Purge = "purge";
 export declare const phase_Purge: Phase<'purge'>;

package/v3/phase/consts.js

@@ -19,8 +19,12 @@ export const phase_ToESM = {
     key: phaseKey_ToESM,
     name: 'ToESM',
     method: 'convertToESM',
-    filter: (baiParams) => !baiParams.noBuild,
+    filter: (baiParams) => baiParams.toESM,
 };
+export const phases_Terminating = [
+    [phase_PrintDependencyTree],
+    [phase_CheckCyclicImports],
+];
 export const phaseKey_Purge = 'purge';
 export const phase_Purge = {
     key: phaseKey_Purge,
@@ -88,6 +92,7 @@ export const phase_Watch = {
 };
 export const phases_Build = [
     [phase_Purge, phase_Prepare],
+    [phase_ToESM],
     [phase_Install],
     [phase_Lint, phase_PreCompile, phase_Compile, phase_Test,],
     [phase_Watch]

package/v3/units/Unit_TypescriptLib.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import { copyFileSync, existsSync, promises as _fs, readdirSync, statSync } from 'fs';
-import { __stringify, arrayToMap, BadImplementationException, exists, ImplementationMissingException, LogLevel, NotImplementedYetException } from '@nu-art/ts-common';
+import { __stringify, arrayToMap, BadImplementationException, ImplementationMissingException, LogLevel, NotImplementedYetException } from '@nu-art/ts-common';
 import { CONST_BaiConfig, CONST_FirebaseJSON, CONST_FirebaseRC, CONST_NodeModules, CONST_PackageJSON, CONST_PackageJSONTemplate, CONST_TS_CONFIG } from '../../core/consts.js';
 import { CommandoException } from '@nu-art/commando/shell/core/CliError';
 import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
@@ -259,15 +259,18 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
     }
     async checkCyclicImports() {
         this.logDebug(`Checking Cyclic Imports - ${this.config.label}`);
+        const pathToMain = pathResolve(this.config.fullPath, './src/main');
+        const pathToTsConfig = pathResolve(pathToMain, './tsconfig.json');
         await this.allocateCommando(Commando_Basic)
             .cd(this.config.fullPath)
             // .setStdErrorValidator(stderr => {
             // 	return !stderr.includes('Finding files') && !stderr.includes('Image created');
             // })
-            .append(`npx madge --no-spinner --image "./imports-${this.config.key}.svg" --circular ${this.config.output}`)
+            .append(`npx madge --no-spinner --ts-config ${pathToTsConfig} --image "./imports-${this.config.key}.svg" --extensions ts,tsx,mts,js,mjs --circular ${pathToMain} `)
             .append('echo $?')
             .execute();
     }
+    // npx madge --circular --ts-config ./tsconfig.json --extensions ts,tsx,mts,js,mjs ./src/main
     async lint() {
         // need to move the copy of the default eslint rules to here
         const pathToLint = pathResolve(this.config.fullPath, `src/main`);
@@ -383,55 +386,88 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
         const specificFiles = [CONST_PackageJSONTemplate];
         const fileExtensions = ['.ts', '.tsx', '.mts', '.js', '.jsx', '.mjs'];
         const units = arrayToMap(this.runtimeContext.childUnits, unit => unit.config.key);
-        const toESM = async (pathTofile, importPath) => {
-            importPath = importPath.replace(/\/+/g, '/');
-            if (importPath.endsWith('.js'))
-                return importPath;
+        const toESM = async (pathTofile, originImportPath) => {
+            originImportPath = originImportPath.replace(/\/+/g, '/');
+            if (originImportPath.endsWith('.js'))
+                return originImportPath;
+            if (originImportPath.endsWith('.json'))
+                return originImportPath;
             for (const extension of fileExtensions) {
-                if (!importPath.endsWith(extension))
+                if (!originImportPath.endsWith(extension))
                     continue;
-                importPath = importPath.replace(extension, '');
+                originImportPath = originImportPath.replace(extension, '');
                 break;
             }
-            let initialPath;
-            let relativePathToFile;
-            let extension = '';
-            if (importPath.startsWith('.') || importPath.startsWith('/')) {
-                initialPath = path.dirname(pathTofile);
-                relativePathToFile = importPath;
-                extension = '.js';
-            }
-            else {
-                const [part1, part2, ...relativePathParts] = importPath.split('/');
-                const unit = units[part1] ?? units[`${part1}/${part2}`];
-                if (unit) {
-                    initialPath = `${unit.config.fullPath}/src/main`;
-                    relativePathToFile = relativePathParts.join('/');
-                }
+            // this can be ./path/to/folder => ./path/to/folder/index.js
+            // this can be ./path/to/file   => ./path/to/file.js
+            if (originImportPath.startsWith('.') || originImportPath.startsWith('/')) {
+                const initialPath = path.dirname(pathTofile);
+                let relativePathToFile = originImportPath;
+                const fullPath = path.resolve(initialPath, relativePathToFile);
+                if (await FileSystemUtils.exists(fullPath) && await FileSystemUtils.folder.isFolder(fullPath))
+                    relativePathToFile = `${relativePathToFile}/index`;
+                // either way we need to add a .js
+                relativePathToFile += '.js';
+                relativePathToFile = relativePathToFile.replace(/\/+/g, '/');
+                return relativePathToFile;
             }
-            if (!exists(initialPath) || !exists(relativePathToFile))
+            const resolveImportPathFromUnit = async (packageName, relativePathToFile) => {
+                const unit = units[packageName];
+                if (!unit)
+                    return;
+                let initialPath = `${unit.config.fullPath}/src/main`;
+                const fullPath = path.resolve(initialPath, relativePathToFile);
+                if (await FileSystemUtils.exists(fullPath) && await FileSystemUtils.folder.isFolder(fullPath))
+                    relativePathToFile = `${relativePathToFile}/index`;
+                const importPath = `${packageName}/${relativePathToFile}`.replace(/\/+/g, '/');
+                if (importPath === `${packageName}/index`)
+                    return `${packageName}`;
                 return importPath;
-            const fullPath = path.resolve(initialPath, relativePathToFile);
-            if (await FileSystemUtils.exists(fullPath) && await FileSystemUtils.folder.isFolder(fullPath))
-                relativePathToFile = `${relativePathToFile}/index`;
-            // throw new BadImplementationException(`Expected file to exist: ${fullPath}`);
-            relativePathToFile += extension;
-            relativePathToFile = relativePathToFile.replace(/\/+/g, '/');
-            return relativePathToFile;
+            };
+            // this can be {{libName}}/path/to/file   => {{libName}}/path/to/file
+            let [libName1, ...rest1] = originImportPath.split('/');
+            let esmImportPath = await resolveImportPathFromUnit(libName1, rest1.join('/'));
+            if (esmImportPath)
+                return esmImportPath;
+            let [libOrg, libName2, ...rest2] = originImportPath.split('/');
+            esmImportPath = await resolveImportPathFromUnit(`${libOrg}/${libName2}`, rest2.join('/'));
+            if (esmImportPath)
+                return esmImportPath;
+            return originImportPath;
         };
         const importMatchers = [
             {
-                regex: /from\s+["']([^"']+)["']/g,
+                regex: /from\s+"(\S+)?"/g,
                 replacer: async (pathTofile, importPath) => `from "${await toESM(pathTofile, importPath)}"`
             },
             {
-                regex: /require\(\s*["']([^"']+)["']\s*\)/g,
-                replacer: async (pathTofile, importPath) => `await import("${await toESM(pathTofile, importPath)}")`
+                regex: /from\s+'(\S+)?'/g,
+                replacer: async (pathTofile, importPath) => `from '${await toESM(pathTofile, importPath)}'`
+            },
+            {
+                regex: /\srequire\((\S+)?\)/g,
+                replacer: async (pathTofile, importPath) => ` await import("${await toESM(pathTofile, importPath)}")`
+            },
+            {
+                regex: /\srequire\((\S+)?\)/g,
+                replacer: async (pathTofile, importPath) => ` await import('${await toESM(pathTofile, importPath)}')`
+            },
+            {
+                regex: /\srequire\(\s*"(\S+)?"\s*\)/g,
+                replacer: async (pathTofile, importPath) => ` await import("${await toESM(pathTofile, importPath)}")`
             },
             {
-                regex: /import\(\s*["']([^"']+)["']\s*\)/g,
+                regex: /\srequire\(\s*'(\S+)?'\s*\)/g,
+                replacer: async (pathTofile, importPath) => ` await import('${await toESM(pathTofile, importPath)}')`
+            },
+            {
+                regex: /import\(\s*"(\S+)?"\s*\)/g,
                 replacer: async (pathTofile, importPath) => `import("${await toESM(pathTofile, importPath)}")`
             },
+            {
+                regex: /import\(\s*'(\S+)?'\s*\)/g,
+                replacer: async (pathTofile, importPath) => `import('${await toESM(pathTofile, importPath)}')`
+            },
         ];
         const updateImports = async (pathToEntry) => {
             let content = await FileSystemUtils.file.read(pathToEntry);

package/v3/units/firebase/Unit_FirebaseFunctionsApp.d.ts

@@ -1,7 +1,8 @@
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../index.js';
 import { UnitPhaseImplementor } from '../../core/types.js';
 import { FirebasePackageConfig } from '../../../core/types/index.js';
+import { StringMap } from '@nu-art/ts-common';
 import { Phase_Deploy, Phase_Launch } from '../../phase/index.js';
+import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
 export declare const firebaseFunctionEmulator_ErrorStrings: string[];
 export declare const firebaseFunctionEmulator_WarningStrings: string[];
 type EnvConfig = {
@@ -23,6 +24,7 @@ export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
     sources?: string[];
 };
 export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_Launch, Phase_Deploy]> {
+    functions: StringMap;
     static staggerCount: number;
     static DefaultConfig_FirebaseFunction: {
         pathToFirebaseConfig: string;
@@ -48,11 +50,12 @@ export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsA
     private getEnvConfig;
     private resolveFunctionsRC;
     private resolveProxyFile;
+    private pathToProxy;
     private resolveConfigDir;
     private resolveFunctionsJSON;
     private resolveFunctionsRuntimeConfig;
     private createAppVersionFile;
-    protected deriveDistDependencies(): import("@nu-art/ts-common").StringMap;
+    protected deriveDistDependencies(): StringMap;
     private createDependenciesDir;
     private runProxy;
     private runEmulator;

package/v3/units/firebase/Unit_FirebaseFunctionsApp.js

@@ -1,11 +1,13 @@
-import { Unit_TypescriptLib } from '../index.js';
-import { CONST_FirebaseJSON, CONST_FirebaseRC, CONST_PackageJSON } from '../../../core/consts.js';
+import { CONST_FirebaseJSON, CONST_FirebaseRC, CONST_NodeModules, CONST_PackageJSON } from '../../../core/consts.js';
 import { promises as _fs } from 'fs';
 import { __stringify, _logger_logPrefixes, deepClone, ImplementationMissingException, LogLevel, reduceObject, Second, sleep } from '@nu-art/ts-common';
 import { Const_FirebaseConfigKeys, Const_FirebaseDefaultsKeyToFile } from '../../../defaults/consts.js';
 import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
 import { resolve } from 'path';
 import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { Unit_TypescriptLib } from '../Unit_TypescriptLib.js';
+import { CommandoException } from '@nu-art/commando/shell/core/CliError';
+import { deployLogFilter } from './common.js';
 export const firebaseFunctionEmulator_ErrorStrings = [
     'functions: Failed',
 ];
@@ -14,6 +16,7 @@ export const firebaseFunctionEmulator_WarningStrings = [
 ];
 // const CONST_VersionApp = 'version-app.json';
 export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
+    functions = {};
     static staggerCount = 0;
     static DefaultConfig_FirebaseFunction = {
         pathToFirebaseConfig: '.firebase_config',
@@ -59,6 +62,7 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
                 return await FileSystemUtils.folder.delete(path);
         });
         await FileSystemUtils.folder.create(resolve(this.config.fullPath, this.config.pathToEmulatorData));
+        await FileSystemUtils.file.delete(this.pathToProxy());
         await this.resolveConfigs();
     }
     async resolveConfigs() {
@@ -89,8 +93,18 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
             .ls()
             .cat('package.json')
             .cat('index.js')
-            .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, `firebase --debug deploy --only functions --force`);
+            .cd(this.config.fullPath)
+            .setLogLevelFilter(deployLogFilter)
+            // example: Function URL (hello(us-central1)): https://hello-kv65k7yylq-uc.a.run.app
+            .onLog(/.*Function URL.*?\((.*?)\(.*(https:\/\/.*?)$/, match => {
+            this.functions[match[1]] = match[2];
+        });
+        const debug = this.runtimeContext.runtimeParams.verbose ? ' --debug' : '';
+        await this.executeAsyncCommando(commando, `firebase${debug} deploy --only functions --force`, (stdout, stderr, exitCode) => {
+            if (exitCode !== 0)
+                throw new CommandoException('Failed to deploy function', stdout, stderr, exitCode);
+        });
+        this.logInfo(`Functions: `, this.functions);
     }
     //######################### ResolveConfig Logic #########################
     getEnvConfig() {
@@ -118,7 +132,7 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
     }
     async resolveProxyFile() {
         const envConfig = this.getEnvConfig();
-        const targetPath = `${this.config.fullPath}/src/main/proxy.ts`;
+        const targetPath = this.pathToProxy();
         const path = this.runtimeContext.baiConfig.files?.backend?.proxy;
         if (!path)
             return;
@@ -131,15 +145,13 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         };
         await FileSystemUtils.file.template.copy(path, targetPath, params);
     }
+    pathToProxy() {
+        return resolve(this.config.fullPath, 'src/main/proxy.ts');
+    }
     async resolveConfigDir() {
         //Create the dir if it doesn't exist
         const pathToFirebaseConfigFolder = `${this.config.fullPath}/${this.config.pathToFirebaseConfig}`;
-        try {
-            await _fs.access(pathToFirebaseConfigFolder);
-        }
-        catch (e) {
-            await _fs.mkdir(pathToFirebaseConfigFolder, { recursive: true });
-        }
+        await FileSystemUtils.folder.create(pathToFirebaseConfigFolder);
         //Fill config dir with relevant files for each file that doesn't exist
         const defaultFiles = this.runtimeContext.baiConfig.files?.firebase;
         if (!defaultFiles) {
@@ -148,11 +160,10 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         }
         await Promise.all(Const_FirebaseConfigKeys.map(async (firebaseConfigKey) => {
             const pathToConfigFile = `${pathToFirebaseConfigFolder}/${Const_FirebaseDefaultsKeyToFile[firebaseConfigKey]}`;
-            const path = defaultFiles[firebaseConfigKey];
-            if (!path)
+            if (!defaultFiles[firebaseConfigKey])
                 return;
-            const defaultFileContent = await _fs.readFile(path, { encoding: 'utf-8' });
-            await _fs.writeFile(pathToConfigFile, defaultFileContent, { encoding: 'utf-8' });
+            const path = resolve(this.runtimeContext.parentUnit.config.fullPath, defaultFiles[firebaseConfigKey]);
+            await FileSystemUtils.file.copy(path, pathToConfigFile);
         }));
     }
     async resolveFunctionsJSON() {
@@ -205,6 +216,7 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
                 functions: {
                     source: this.config.output.replace(`${this.config.fullPath}/`, ''),
                     ignore: this.config.ignore,
+                    runtime: 'nodejs22',
                 }
             };
         }
@@ -259,7 +271,8 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         await this.resolveProxyFile();
         const commando = this.allocateCommando(Commando_NVM).applyNVM()
             .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, 'tsx src/main/proxy.ts');
+        const command = `${this.runtimeContext.parentUnit.config.fullPath}/${CONST_NodeModules}/.bin/tsx`;
+        await this.executeAsyncCommando(commando, `${command} src/main/proxy.ts`);
         this.logWarning('PROXY TERMINATED');
     }
     async runEmulator() {

package/v3/units/firebase/Unit_FirebaseHostingApp.d.ts

@@ -1,9 +1,9 @@
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../index.js';
 import { FirebasePackageConfig } from '../../../core/types/index.js';
 import { UnitPhaseImplementor } from '../../core/types.js';
-import { TS_Object, TypedMap } from '@nu-art/ts-common';
+import { StringMap, TS_Object, TypedMap } from '@nu-art/ts-common';
 import { UnitConfigJSON_Node } from '../../UnitsMapper/resolvers/UnitMapper_Node.js';
 import { Phase_Deploy, Phase_Launch } from '../../phase/index.js';
+import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
 export type FirebaseHostingConfig = {
     public: string;
     rewrites: {
@@ -29,6 +29,7 @@ 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_Launch, Phase_Deploy]> {
+    hosting: StringMap;
     static DefaultConfig_FirebaseHosting: {
         servingPort: number;
         output: string;

package/v3/units/firebase/Unit_FirebaseHostingApp.js

@@ -1,12 +1,15 @@
-import { Unit_TypescriptLib } from '../index.js';
 import { ImplementationMissingException, LogLevel } from '@nu-art/ts-common';
 import { promises as _fs } from 'fs';
 import { CONST_FirebaseJSON, CONST_FirebaseRC } from '../../../core/consts.js';
 import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
 import { Commando_Basic } from '@nu-art/commando/shell/plugins/basic';
 import { resolve } from 'path';
+import { Unit_TypescriptLib } from '../Unit_TypescriptLib.js';
+import { CommandoException } from '@nu-art/commando/shell/core/CliError';
+import { deployLogFilter } from './common.js';
 const CONST_VersionApp = 'version-app.json';
 export class Unit_FirebaseHostingApp extends Unit_TypescriptLib {
+    hosting = {};
     static DefaultConfig_FirebaseHosting = {
         servingPort: 8100,
         output: 'dist',
@@ -38,8 +41,14 @@ export class Unit_FirebaseHostingApp extends Unit_TypescriptLib {
     }
     async deploy() {
         const commando = this.allocateCommando(Commando_NVM).applyNVM()
-            .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, `firebase --debug deploy --only hosting`);
+            .cd(this.config.fullPath)
+            .setLogLevelFilter(deployLogFilter)
+            // example: Function URL (hello(us-central1)): https://hello-kv65k7yylq-uc.a.run.app
+            .onLog(/.*Hosting URL.*(https:\/\/.*?)$/, match => {
+            this.hosting[match[1]] = match[2];
+        });
+        const debug = this.runtimeContext.runtimeParams.verbose ? ' --debug' : '';
+        await this.executeAsyncCommando(commando, `firebase${debug} deploy --only hosting`);
     }
     //######################### ResolveConfig Logic #########################
     getEnvConfig() {
@@ -74,7 +83,10 @@ export class Unit_FirebaseHostingApp extends Unit_TypescriptLib {
     async compileImpl() {
         const commando = this.allocateCommando(Commando_NVM, Commando_Basic).applyNVM()
             .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, `ENV=${this.runtimeContext.runtimeParams.environment} npm run build`);
+        await this.executeAsyncCommando(commando, `ENV=${this.runtimeContext.runtimeParams.environment} npm run build`, (stdout, stderr, exitCode) => {
+            if (exitCode > 0)
+                throw new CommandoException(`Error compiling`, stdout, stderr, exitCode);
+        });
     }
     async createAppVersionFile() {
         //Writing the file to the package source instead of the output is fine,

package/v3/units/firebase/common.d.ts

@@ -0,0 +1,3 @@
+import { LogTypes } from '@nu-art/commando/shell/types';
+import { LogLevel } from '@nu-art/ts-common';
+export declare const deployLogFilter: (log: string, std: LogTypes) => LogLevel.Debug | LogLevel.Info | LogLevel.Warning | LogLevel.Error;

package/v3/units/firebase/common.js

@@ -0,0 +1,13 @@
+import { LogLevel } from '@nu-art/ts-common';
+const warn = ['missing required API'];
+const info = ['=== Deploying', 'functions: Successfully deployed function'];
+const infoStartsWith = ['✔ ', 'i '];
+export const deployLogFilter = (log, std) => {
+    if (log.startsWith('⚠ ') || warn.find(str => log.includes(str)))
+        return LogLevel.Warning;
+    if (infoStartsWith.find(str => log.startsWith(str)) || info.find(str => log.includes(str)))
+        return LogLevel.Info;
+    if (log.includes('Error:'))
+        return LogLevel.Error;
+    return LogLevel.Debug;
+};