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

package/build-and-install-v3.js

@@ -1,4 +1,4 @@
-import { _keys, arrayToMap, BeLogged, DebugFlag, filterDuplicates, LogClient_Terminal, Logger, LogLevel, merge } from '@nu-art/ts-common';
+import { _keys, arrayToMap, BeLogged, DebugFlag, filterDuplicates, ImplementationMissingException, LogClient_Terminal, Logger, LogLevel, merge } from '@nu-art/ts-common';
 import { AllBaiParams } from './core/params/params.js';
 import { phases_Build, phases_Deploy, phases_Launch, phases_Terminating } from './v3/phase/index.js';
 import { UnitsMapper } from './v3/UnitsMapper/UnitsMapper.js';
@@ -8,7 +8,7 @@ import { ProjectUnit } from './v3/units/ProjectUnit.js';
 import { PhaseManager } from './v3/PhaseManager.js';
 import { Unit_NodeProject } from './v3/units/index.js';
 import { resolve } from 'path';
-import { CONST_BaiConfig, CONST_NodeModules } from './core/consts.js';
+import { CONST_BaiConfig, CONST_NodeModules, CONST_VersionApp } from './core/consts.js';
 import { UnitMapper_FirebaseFunction, UnitMapper_FirebaseHosting, UnitMapper_NodeLib, UnitMapper_NodeProject } from './v3/UnitsMapper/resolvers/index.js';
 import { CLIParamsResolver } from '@nu-art/commando/cli-params/CLIParamsResolver';
 import { RunningStatusHandler } from './v3/RunningStatusHandler.js';
@@ -76,6 +76,8 @@ export class BuildAndInstall extends Logger {
         const nodeProjectUnit = allProjectUnits.find(unit => unit.isInstanceOf(Unit_NodeProject));
         // @ts-ignore
         this['nodeProjectUnit'] = nodeProjectUnit;
+        if (!this.nodeProjectUnit)
+            throw new ImplementationMissingException('NodeProject unit not found. Make sure you have a Unit_NodeProject in your project.');
         this.nodeProjectUnit.assignUnit(allProjectUnits);
         this.logDebug(`Parent unit: ${this.nodeProjectUnit.config.key}`);
         this.logDebug(`Child units: ${allProjectUnits.map(unit => unit.config.key).join(', ')}`);
@@ -91,8 +93,11 @@ export class BuildAndInstall extends Logger {
         }));
         const globalOutputFolder = resolve(this.pathToProject, '.trash/output');
         this.unitsDependencyMapper = new UnitsDependencyMapper(unitsDependencies, globalOutputFolder);
+        const versionFilePath = resolve(this.pathToProject, CONST_VersionApp);
+        this.logInfo('loading version from: ', versionFilePath);
+        const version = await FileSystemUtils.file.read.json(versionFilePath, { version: '1.0.0' });
         const runtimeContext = ({
-            version: '',
+            version: version.version,
             parentUnit: this.nodeProjectUnit,
             childUnits: allProjectUnits,
             baiConfig,
@@ -129,8 +134,15 @@ export class BuildAndInstall extends Logger {
             if (killCounter > 5)
                 process.exit(1);
         });
-        await phaseManager.execute(executionPlan);
-        this.logInfo('Completed successfully');
-        this.logInfo('---------------------------------- Process Completed successfully ----------------------------------');
+        try {
+            await phaseManager.execute(executionPlan);
+            this.logInfo('Completed successfully');
+            this.logInfo('---------------------------------- Process Completed successfully ----------------------------------');
+        }
+        catch (e) {
+            this.logInfo('Process Failed');
+            this.logInfo('---------------------------------- Process Failed ----------------------------------');
+            throw e;
+        }
     }
 }

package/core/consts.d.ts

@@ -1,5 +1,6 @@
 import { MemKey } from '@nu-art/ts-common/mem-storage/index';
 import { RuntimeProjectConfig } from './types/index.js';
+export declare const CONST_VersionApp = "version-app.json";
 export declare const CONST_PackageJSONTemplate = "__package.json";
 export declare const CONST_PackageJSON = "package.json";
 export declare const CONST_NodeModules = "node_modules";

package/core/consts.js

@@ -1,4 +1,5 @@
 import { MemKey } from '@nu-art/ts-common/mem-storage/index';
+export const CONST_VersionApp = 'version-app.json';
 export const CONST_PackageJSONTemplate = '__package.json';
 export const CONST_PackageJSON = 'package.json';
 export const CONST_NodeModules = 'node_modules';

package/core/exceptions/PhaseAggregatedException.d.ts

@@ -1,5 +1,8 @@
-import { CustomException } from '@nu-art/ts-common';
+import { CustomException, Logger } from '@nu-art/ts-common';
 import { ScheduledStep } from '../../v3/PhaseManager.js';
+import { UnitPhaseException } from './UnitPhaseException.js';
 export declare class PhaseAggregatedException extends CustomException {
-    constructor(errors: Error[], step: ScheduledStep);
+    errors: UnitPhaseException[];
+    constructor(errors: UnitPhaseException[], step: ScheduledStep);
+    print(logger: Logger): void;
 }

package/core/exceptions/PhaseAggregatedException.js

@@ -1,8 +1,24 @@
-import { CustomException } from '@nu-art/ts-common';
+import { CustomException, isErrorOfType } from '@nu-art/ts-common';
+import { CommandoException } from '@nu-art/commando/shell/core/CliError';
 export class PhaseAggregatedException extends CustomException {
+    errors;
     constructor(errors, step) {
         super(PhaseAggregatedException, `One or more errors occurred in step execution: ${JSON.stringify(step)}`);
         // @ts-ignore
-        this.cause = errors;
+        this.errors = errors;
+    }
+    print(logger) {
+        logger.logError(this.message);
+        this.errors.forEach(error => {
+            const commandoError = isErrorOfType(error, CommandoException);
+            if (commandoError) {
+                logger.logWarning(`message: ${commandoError.message}`);
+                commandoError.cause && logger.logWarning('caused by: ', commandoError.cause);
+                logger.logError('stdout: ', commandoError.stdout);
+                logger.logError('stderr', commandoError.stderr);
+                return;
+            }
+            logger.logWarning('error: ', error);
+        });
     }
 }

package/core/exceptions/UnitPhaseException.d.ts

@@ -0,0 +1,5 @@
+import { CustomException } from '@nu-art/ts-common';
+import { BaseUnit } from '../../v3/units/index.js';
+export declare class UnitPhaseException extends CustomException {
+    constructor(cause: Error, unit: BaseUnit, phase: string);
+}

package/core/exceptions/UnitPhaseException.js

@@ -0,0 +1,6 @@
+import { CustomException } from '@nu-art/ts-common';
+export class UnitPhaseException extends CustomException {
+    constructor(cause, unit, phase) {
+        super(UnitPhaseException, `Error in ${unit.config.key} (${phase})`, cause);
+    }
+}

package/core/params/params.d.ts

@@ -1,7 +1,6 @@
 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_continue: BaseCliParam<'continue', boolean>;
 export declare const BaiParam_SetEnv: BaseCliParam<'environment', string>;
 export declare const BaiParam_Install: BaseCliParam<'install', boolean>;
 export declare const BaiParam_Clean: BaseCliParam<'clean', boolean>;
@@ -14,6 +13,7 @@ export declare const BaiParam_DryRun: BaseCliParam<'dryRun', boolean>;
 export declare const BaiParam_Lint: BaseCliParam<'lint', boolean>;
 export declare const BaiParam_Watch: BaseCliParam<'watch', boolean>;
 export declare const BaiParam_WatchBuildTree: BaseCliParam<'watchBuildTree', boolean>;
+export declare const BaiParam_continue: BaseCliParam<'continue', boolean>;
 export declare const BaiParam_Test: BaseCliParam<'test', boolean>;
 export declare const TestTypes: string[];
 export type TestType = typeof TestTypes[number];
@@ -35,6 +35,6 @@ export declare const BaiParam_includePackage: BaseCliParam<'includePackage', str
 export declare const BaiParam_ToESM: BaseCliParam<'toESM', boolean>;
 export declare const BaiParam_Simulate: 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 declare const AllBaiParams: (BaseCliParam<"allUnits", boolean> | BaseCliParam<"dependencyTree", 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<"continue", 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_continue = {
-    keys: ['--continue', '-con'],
-    keyName: 'continue',
-    type: 'boolean',
-    group: 'Build',
-    description: 'Will pick up where last build process failed'
-};
 export const BaiParam_SetEnv = {
     keys: ['--set-env', '-se'],
     keyName: 'environment',
@@ -108,6 +101,14 @@ export const BaiParam_WatchBuildTree = {
     description: 'Once watch triggers, will build the entire tree that depends on the libs that changed',
     dependencies: [{ param: BaiParam_Watch, value: true }, { param: BaiParam_NoBuild, value: true }, { param: BaiParam_Prepare, value: false }]
 };
+export const BaiParam_continue = {
+    keys: ['--continue', '-con'],
+    keyName: 'continue',
+    type: 'boolean',
+    group: 'Build',
+    description: 'Will pick up where last build process failed',
+    dependencies: [{ param: BaiParam_Watch, value: false }]
+};
 export const BaiParam_Test = {
     keys: ['--test', '-t'],
     keyName: 'test',
@@ -158,7 +159,7 @@ export const BaiParam_Launch = {
     keyName: 'launch',
     type: 'boolean',
     group: 'Apps',
-    description: 'It will add the provided App to the launch list \nrequired input: path-to-app-to-launch(string)'
+    description: 'Will perform the launch phast on packages that supports it. use the --use-package flag to filter out for specific packages'
 };
 export const BaiParam_DebugBackend = {
     keys: ['--debug-backend', '-lbd'],
@@ -172,7 +173,7 @@ export const BaiParam_Deploy = {
     keyName: 'deploy',
     type: 'boolean',
     group: 'Apps',
-    description: 'Will add the provided App to the deploy list or all applications',
+    description: 'Will perform the deploy phast on packages that supports it. use the --use-package flag to filter out for specific packages',
     dependencies: [
         { param: BaiParam_Launch, value: false },
         { param: BaiParam_Watch, value: false },
@@ -195,7 +196,7 @@ export const BaiParam_DebugLifecycle = {
     description: 'Will only print the run config and die'
 };
 export const BaiParam_Verbose = {
-    keys: ['--verbose', '-d'],
+    keys: ['--verbose', '-v'],
     keyName: 'verbose',
     group: 'Other',
     type: 'boolean',
@@ -206,7 +207,14 @@ export const BaiParam_QuickDeploy = {
     keyName: 'quickDeploy',
     type: 'boolean',
     group: 'Other',
-    description: 'Will deploy both frontend & backend, without any other lifecycle action'
+    description: 'Will perform the deploy phase without other lifecycle options',
+    dependencies: [
+        ...BaiParam_Deploy.dependencies,
+        { param: BaiParam_Purge, value: false },
+        { param: BaiParam_Lint, value: false },
+        { param: BaiParam_Test, value: false },
+        { param: BaiParam_NoBuild, value: true },
+    ]
 };
 export const BaiParam_Publish = {
     keys: ['--publish'],

package/package.json

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

package/v3/PhaseManager.js

@@ -1,5 +1,6 @@
 import { addItemToArray, asArray, exists, flatArray, Logger, removeItemFromArray, timeCounter } from '@nu-art/ts-common';
 import { PhaseAggregatedException } from '../core/exceptions/PhaseAggregatedException.js';
+import { UnitPhaseException } from '../core/exceptions/UnitPhaseException.js';
 export class PhaseManager extends Logger {
     phases;
     units;
@@ -110,7 +111,7 @@ export class PhaseManager extends Logger {
                     }
                     catch (error) {
                         this.logError(`Phase(${phase.name}) - Error - ${unit.config.key}`, error);
-                        errors.push(error);
+                        errors.push(new UnitPhaseException(error, unit, phase.key));
                         failedStep = scheduledStep;
                         this.killed = true;
                         failed = true;
@@ -123,8 +124,9 @@ export class PhaseManager extends Logger {
                 if (!failed)
                     await this.runningStatus.onUnitCompleted(unit.config.key);
             }));
-            if (failedStep && errors.length)
+            if (failedStep && errors.length) {
                 throw new PhaseAggregatedException(errors, failedStep);
+            }
             await this.runningStatus.onStepEnded();
         }
         this.logInfo('All steps completed.');

package/v3/UnitsMapper/resolvers/UnitMapper_FirebaseHosting.js

@@ -23,8 +23,10 @@ export class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node {
         const outputDir = context.packageJson.publishConfig?.directory;
         const env = this.runtimeParams[BaiParam_SetEnv.keyName];
         const envUnitConfig = context.packageJson.unitConfig.envs[env];
-        if (!envUnitConfig)
+        if (!envUnitConfig) {
+            this.logWarning('Package Json config:', context.packageJson.unitConfig);
             throw new ImplementationMissingException(`Missing configuration for env: ${env}`);
+        }
         const envConfig = {
             config: envUnitConfig.config,
             projectId: envUnitConfig.projectId,

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<"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>)[];
+declare const AllBaiParams_Help: (BaseCliParam<"allUnits", boolean> | BaseCliParam<"dependencyTree", 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<"continue", 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/units/Unit_TypescriptLib.d.ts

@@ -11,6 +11,7 @@ export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
 export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Unit_TypescriptLib_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_PreCompile, Phase_Compile, Phase_PrintDependencyTree, Phase_CheckCyclicImports, Phase_Lint, Phase_Test, Phase_Publish, Phase_ToESM]> {
     private TestTypeWorkspaceSetup;
     runTests(): Promise<void>;
+    protected dependencyUnits: Unit_TypescriptLib[];
     constructor(config: Unit_TypescriptLib<C>['config']);
     protected clearOutputDir(): Promise<void>;
     protected clearOutputDirImpl(): Promise<void>;

package/v3/units/Unit_TypescriptLib.js

@@ -126,6 +126,7 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
             });
         }
     }
+    dependencyUnits;
     constructor(config) {
         super(config);
         this.addToClassStack(Unit_TypescriptLib);
@@ -147,6 +148,8 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
             // @ts-ignore
             this.publish = undefined;
         }
+        const unitKeys = this.runtimeContext.unitsMapper.getTransitiveDependencies([this.config.key]);
+        this.dependencyUnits = this.runtimeContext.unitsResolver(unitKeys, Unit_TypescriptLib);
     }
     async compileImpl() {
         const pathToCompile = `${this.config.fullPath}/src/main`;
@@ -228,6 +231,8 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
             .execute();
     }
     async compile() {
+        if (!this.dependencyUnits)
+            await this.prepare();
         await this.clearOutputDirImpl();
         await this.compileImpl();
         await this.copyAssetsToOutput();

package/v3/units/firebase/Unit_FirebaseFunctionsApp.js

@@ -1,6 +1,5 @@
-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_FirebaseJSON, CONST_FirebaseRC, CONST_NodeModules, CONST_PackageJSON, CONST_VersionApp } from '../../../core/consts.js';
+import { __stringify, _keys, _logger_logPrefixes, deepClone, ImplementationMissingException, LogLevel, 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';
@@ -48,11 +47,20 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         const distDependencies = this.deriveDistDependencies();
         packageJson.main = 'index.js';
         packageJson.types = 'index.d.ts';
-        if (packageJson.dependencies)
-            packageJson.dependencies = reduceObject(packageJson.dependencies, packageJson.dependencies, (acc, key, value) => {
-                acc[key] = distDependencies[key] ?? value;
-                return acc;
-            });
+        const dependencies = packageJson.dependencies ?? {};
+        // First, update existing dependencies (replace workspace:* with file: paths where applicable)
+        _keys(dependencies).reduce((dependencies, packageName) => {
+            if (distDependencies[packageName])
+                dependencies[packageName] = distDependencies[packageName];
+            return dependencies;
+        }, dependencies);
+        // Then, add ALL dependencyUnits to the dependencies (this includes transitive dependencies)
+        // This ensures the entire dependency tree is referenced in the main package.json
+        this.dependencyUnits.reduce((dependencies, unit) => {
+            dependencies[unit.config.key] = distDependencies[unit.config.key];
+            return dependencies;
+        }, dependencies);
+        packageJson.dependencies = dependencies;
         await FileSystemUtils.file.template.write(targetPath, __stringify(packageJson, true), this.deriveDistDependencies(), DEFAULT_OLD_TEMPLATE_PATTERN);
     }
     async prepare() {
@@ -101,8 +109,9 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         });
         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);
+            if (exitCode === 0)
+                return;
+            throw new CommandoException(`Failed to deploy function with exit code ${exitCode}`, stdout, stderr, exitCode);
         });
         this.logInfo(`Functions: `, this.functions);
     }
@@ -127,8 +136,8 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
                 }
             }
         };
-        const targetPath = `${this.config.fullPath}/${CONST_FirebaseRC}`;
-        await _fs.writeFile(targetPath, JSON.stringify(rcConfig, null, 2), { encoding: 'utf-8' });
+        const targetPath = resolve(this.config.fullPath, CONST_FirebaseRC);
+        await FileSystemUtils.file.write.json(targetPath, rcConfig);
     }
     async resolveProxyFile() {
         const envConfig = this.getEnvConfig();
@@ -220,7 +229,7 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
                 }
             };
         }
-        await _fs.writeFile(targetPath, JSON.stringify(fileContent, null, 2), { encoding: 'utf-8' });
+        await FileSystemUtils.file.write.json(targetPath, fileContent);
     }
     async resolveFunctionsRuntimeConfig() {
         const envConfig = this.getEnvConfig();
@@ -233,30 +242,25 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         };
         const inLocalIgnoreTLS = `${envConfig.isLocal ? '// @ts-ignore\nprocess.env[\'NODE_TLS_REJECT_UNAUTHORIZED\'] = 0;\n\n' : ''}`;
         const fileContent = `${inLocalIgnoreTLS}export const Environment = ${JSON.stringify(beConfig)};`;
-        await _fs.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
+        await FileSystemUtils.file.write(targetPath, fileContent);
     }
     //######################### Compile Logic #########################
     async createAppVersionFile() {
         //Writing the file to the package source instead of the output is fine,
         //copyAssetsToOutput will move the file to output
-        // const targetPath = `${this.config.fullPath}/src/main/${CONST_VersionApp}`;
-        // const appVersion = MemKey_ProjectConfig.get().projectVersion;
-        // const fileContent = JSON.stringify({version: appVersion}, null, 2);
-        // await _fs.writeFile(targetPath, fileContent, {encoding: 'utf-8'});
+        const targetPath = `${this.config.fullPath}/src/main/${CONST_VersionApp}`;
+        const appVersion = this.runtimeContext.version;
+        await FileSystemUtils.file.write.json(targetPath, { version: appVersion });
     }
     deriveDistDependencies() {
-        const unitKeys = this.runtimeContext.unitsMapper.getTransitiveDependencies([this.config.key]);
-        const dependencyUnits = this.runtimeContext.unitsResolver(unitKeys, Unit_TypescriptLib);
-        return dependencyUnits.reduce((dependencies, unit) => {
+        return this.dependencyUnits.reduce((dependencies, unit) => {
             dependencies[unit.config.key] = `file:.dependencies/${unit.config.key}`;
             return dependencies;
         }, super.deriveDistDependencies());
     }
     async createDependenciesDir() {
         //Gather units that are dependencies of this unit
-        const unitKeys = this.runtimeContext.unitsMapper.getTransitiveDependencies([this.config.key]);
-        const dependencyUnits = this.runtimeContext.unitsResolver(unitKeys, Unit_TypescriptLib);
-        await Promise.all(dependencyUnits.map(async (unit) => {
+        await Promise.all(this.dependencyUnits.map(async (unit) => {
             //Copy dependency unit output into this units output/.dependency dir
             const dependencyOutputPath = `${unit.config.output}/`;
             const targetPath = `${this.config.output}/.dependencies/${unit.config.key}/`;

package/v3/units/firebase/Unit_FirebaseHostingApp.js

@@ -1,13 +1,12 @@
 import { ImplementationMissingException, LogLevel } from '@nu-art/ts-common';
-import { promises as _fs } from 'fs';
-import { CONST_FirebaseJSON, CONST_FirebaseRC } from '../../../core/consts.js';
+import { CONST_FirebaseJSON, CONST_FirebaseRC, CONST_VersionApp } 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';
+import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 export class Unit_FirebaseHostingApp extends Unit_TypescriptLib {
     hosting = {};
     static DefaultConfig_FirebaseHosting = {
@@ -61,7 +60,7 @@ export class Unit_FirebaseHostingApp extends Unit_TypescriptLib {
         const envConfig = this.getEnvConfig();
         const rcConfig = { projects: { default: envConfig.projectId } };
         const targetPath = `${this.config.fullPath}/${CONST_FirebaseRC}`;
-        await _fs.writeFile(targetPath, JSON.stringify(rcConfig, null, 2), { encoding: 'utf-8' });
+        await FileSystemUtils.file.write.json(targetPath, rcConfig);
     }
     async resolveHostingJSON() {
         const envConfig = this.getEnvConfig();
@@ -70,14 +69,21 @@ export class Unit_FirebaseHostingApp extends Unit_TypescriptLib {
         if (envConfig.isLocal)
             fileContent = {};
         else
-            fileContent = { hosting: this.config.hostingConfig };
-        await _fs.writeFile(targetPath, JSON.stringify(fileContent, null, 2), { encoding: 'utf-8' });
+            fileContent = {
+                hosting: this.config.hostingConfig ?? {
+                    'public': 'dist',
+                    'rewrites': [
+                        { 'source': '**', 'destination': '/index.html' }
+                    ]
+                }
+            };
+        await FileSystemUtils.file.write.json(targetPath, fileContent);
     }
     async resolveHostingRuntimeConfig() {
         const envConfig = this.getEnvConfig().config;
         const targetPath = resolve(this.config.fullPath, `./src/main/config.ts`);
         const fileContent = `export const config = ${JSON.stringify(envConfig, null, 2)};`;
-        await _fs.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
+        await FileSystemUtils.file.write(targetPath, fileContent);
     }
     //######################### Compile Logic #########################
     async compileImpl() {
@@ -93,8 +99,7 @@ export class Unit_FirebaseHostingApp extends Unit_TypescriptLib {
         //Webpack bundles files into the output automatically!
         const targetPath = `${this.config.fullPath}/src/main/${CONST_VersionApp}`;
         const appVersion = this.runtimeContext.version;
-        const fileContent = JSON.stringify({ version: appVersion }, null, 2);
-        await _fs.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
+        await FileSystemUtils.file.write.json(targetPath, { version: appVersion });
     }
     //######################### Launch Logic #########################
     async runApp() {