@nu-art/build-and-install 0.401.9 → 0.500.6

package/units/discovery/resolvers/UnitMapper_FirebaseFunction.d.ts

@@ -1,11 +1,13 @@
 import { TypedMap } from '@nu-art/ts-common';
 import { UnitConfigJSON_Node, UnitMapper_Node, UnitMapper_NodeContext } from './UnitMapper_Node.js';
 import { FunctionConfig, Unit_FirebaseFunctionsApp } from '../../implementations/firebase/Unit_FirebaseFunctionsApp.js';
+type EnvFunctionOverride = Pick<FunctionConfig, 'name'> & Partial<Omit<FunctionConfig, 'name'>>;
 type EnvConfig = {
     defaultConfig?: string;
     envConfig?: string;
     projectId: string;
     isLocal?: boolean;
+    functions?: EnvFunctionOverride[];
 };
 type UnitConfigJSON_FirebaseFunction = UnitConfigJSON_Node & {
     debugPort?: number;
@@ -15,6 +17,10 @@ type UnitConfigJSON_FirebaseFunction = UnitConfigJSON_Node & {
     sslKey?: string;
     sslCert?: string;
     functions: string[] | FunctionConfig[];
+    mongo?: {
+        port?: number;
+        dbName?: string;
+    };
 };
 export declare class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node<Unit_FirebaseFunctionsApp, UnitConfigJSON_FirebaseFunction> {
     static tsValidator_FirebaseFunction: {
@@ -30,10 +36,12 @@ export declare class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node<U
         sslKey: import("@nu-art/ts-common").Validator<string>;
         sslCert: import("@nu-art/ts-common").Validator<string>;
         functions: import("@nu-art/ts-common").Validator<FunctionConfig[]>;
+        mongo: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: object | undefined) => string | object | undefined))[];
         containerDeployment: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: object | undefined) => string | object | undefined))[];
     };
     constructor();
     protected resolveNodeUnit(context: UnitMapper_NodeContext<UnitConfigJSON_FirebaseFunction>): Promise<Unit_FirebaseFunctionsApp<{
+        functions: FunctionConfig[];
         envConfig: {
             defaultConfig: string | undefined;
             envConfig: string | undefined;
@@ -53,7 +61,10 @@ export declare class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node<U
         basePort: number;
         envs: TypedMap<EnvConfig>;
         ignore?: string[] | undefined;
-        functions: string[] | FunctionConfig[];
+        mongo?: {
+            port?: number;
+            dbName?: string;
+        } | undefined;
         pathToFirebaseConfig: string;
         pathToEmulatorData: string;
         fullPath: import("@nu-art/ts-common").AbsolutePath;

package/units/discovery/resolvers/UnitMapper_FirebaseFunction.js

@@ -1,14 +1,8 @@
-import { ImplementationMissingException, tsValidate_OptionalArray, tsValidateAnyNumber, tsValidateAnyString, tsValidateBoolean, tsValidateDynamicObject, tsValidateOptionalAnyNumber, tsValidateOptionalAnyString, tsValidateOptionalObject, tsValidateRegexp, tsValidateResult, tsValidateValue } from '@nu-art/ts-common';
+import { ImplementationMissingException, mergeObject, tsValidate_OptionalArray, tsValidateAnyNumber, tsValidateAnyString, tsValidateBoolean, tsValidateDynamicObject, tsValidateOptionalAnyNumber, tsValidateOptionalAnyString, tsValidateOptionalObject, tsValidateRegexp, tsValidateResult, tsValidateValue } from '@nu-art/ts-common';
 import { UnitMapper_Node } from './UnitMapper_Node.js';
 import { Unit_FirebaseFunctionsApp } from '../../implementations/firebase/Unit_FirebaseFunctionsApp.js';
 import { resolve } from 'path';
 import { BaiParam_SetEnv } from '../../../core/params.js';
-const valuesValidator = {
-    defaultConfig: tsValidateOptionalAnyString,
-    envConfig: tsValidateOptionalAnyString,
-    projectId: tsValidateAnyString,
-    isLocal: tsValidateBoolean(false),
-};
 // Docker image name validation: lowercase, alphanumeric with dots, underscores, hyphens
 // Cannot start/end with separators, no consecutive separators
 // Pattern: starts with alphanumeric, optionally followed by (separator + alphanumeric) groups
@@ -40,19 +34,54 @@ const functionConfigValidator = {
     resources: tsValidateOptionalObject(functionResourceConfigValidator),
 };
 // Validator for functions array: accepts either string[] or FunctionConfig[]
-// Uses custom validator to check type first, then validate accordingly
 const functionItemValidator = (input) => {
-    if (typeof input === 'string') {
-        // Legacy format: just a string (function name)
+    if (typeof input === 'string')
         return tsValidateResult(input, tsValidateAnyString);
-    }
-    if (typeof input === 'object' && input !== null) {
-        // New format: FunctionConfig object
+    if (typeof input === 'object' && input !== null)
         return tsValidateResult(input, tsValidateOptionalObject(functionConfigValidator));
-    }
     return 'Function item must be either a string (function name) or an object (FunctionConfig)';
 };
 const functionsArrayValidator = tsValidate_OptionalArray(functionItemValidator);
+// Env override validators — all fields optional except name
+const envFunctionResourceValidator = {
+    ...functionResourceConfigValidator,
+    cpu: tsValidateOptionalAnyNumber,
+};
+const envFunctionOverrideValidator = {
+    name: tsValidateAnyString,
+    trigger: tsValidateOptionalAnyString,
+    schedule: tsValidateOptionalAnyString,
+    serviceAccountName: tsValidateOptionalAnyString,
+    resources: tsValidateOptionalObject(envFunctionResourceValidator),
+};
+const envFunctionsValidator = tsValidate_OptionalArray((input) => {
+    if (typeof input === 'object' && input !== null)
+        return tsValidateResult(input, tsValidateOptionalObject(envFunctionOverrideValidator));
+    return 'Env function override must be an object with a name property';
+});
+const valuesValidator = {
+    defaultConfig: tsValidateOptionalAnyString,
+    envConfig: tsValidateOptionalAnyString,
+    projectId: tsValidateAnyString,
+    isLocal: tsValidateBoolean(false),
+    functions: envFunctionsValidator,
+};
+const mongoEmulatorValidator = {
+    port: tsValidateOptionalAnyNumber,
+    dbName: tsValidateOptionalAnyString,
+};
+function mergeFunctionConfigs(defaults, overrides) {
+    const normalized = defaults.map(f => typeof f === 'string' ? { name: f, trigger: 'http' } : f);
+    if (!overrides || overrides.length === 0)
+        return normalized;
+    for (const override of overrides) {
+        const index = normalized.findIndex(f => f.name === override.name);
+        if (index === -1)
+            throw new ImplementationMissingException(`Env function override references unknown function '${override.name}'. Available: ${normalized.map(f => f.name).join(', ')}`);
+        normalized[index] = mergeObject(normalized[index], override);
+    }
+    return normalized;
+}
 export class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node {
     static tsValidator_FirebaseFunction = {
         type: tsValidateValue(['firebase-function']),
@@ -62,7 +91,8 @@ export class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node {
         basePort: tsValidateOptionalAnyNumber,
         sslKey: tsValidateOptionalAnyString,
         sslCert: tsValidateOptionalAnyString,
-        functions: functionsArrayValidator, // Required: non-empty array validated in process, accepts string[] or FunctionConfig[]
+        functions: functionsArrayValidator,
+        mongo: tsValidateOptionalObject(mongoEmulatorValidator),
         containerDeployment: tsValidateOptionalObject(containerDeploymentValidator),
         ...UnitMapper_Node.tsValidator_Node,
     };
@@ -82,14 +112,14 @@ export class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node {
             isLocal: envUnitConfig?.isLocal ?? env === 'local'
         };
         const { type, ...unitConfig } = context.packageJson.unitConfig;
-        // Validate functions array is required and non-empty
-        if (!unitConfig.functions || !Array.isArray(unitConfig.functions) || unitConfig.functions.length === 0) {
+        if (!unitConfig.functions || !Array.isArray(unitConfig.functions) || unitConfig.functions.length === 0)
             throw new ImplementationMissingException(`Missing or empty 'functions' array in unit config for ${context.baseConfig.key}. Functions must be explicitly declared.`);
-        }
+        const functions = mergeFunctionConfigs(unitConfig.functions, envUnitConfig?.functions);
         return new Unit_FirebaseFunctionsApp({
             ...context.baseConfig,
             ...Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction,
             ...unitConfig,
+            functions,
             envConfig,
             isTopLevelApp: true,
             hasSelfHotReload: unitConfig.hasSelfHotReload ?? false,

package/units/discovery/resolvers/UnitMapper_FirebaseHosting.d.ts

@@ -1,6 +1,6 @@
 import { TypedMap } from '@nu-art/ts-common';
 import { UnitMapper_Node, UnitMapper_NodeContext } from './UnitMapper_Node.js';
-import { FirebaseHosting_EnvConfig, Unit_FirebaseHostingApp, UnitConfigJSON_FirebaseHosting } from '../../implementations/firebase/Unit_FirebaseHostingApp.js';
+import { Unit_FirebaseHostingApp, UnitConfigJSON_FirebaseHosting, WebpackHosting_EnvConfig } from '../../implementations/firebase/Unit_FirebaseHostingApp.js';
 export declare class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node<Unit_FirebaseHostingApp, UnitConfigJSON_FirebaseHosting> {
     static tsValidator_FirebaseHosting: {
         label: import("@nu-art/ts-common").Validator<string>;
@@ -9,17 +9,13 @@ export declare class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node<Un
         hasSelfHotReload: import("@nu-art/ts-common").Validator<boolean>;
         type: import("@nu-art/ts-common").Validator<any>;
         servingPort: import("@nu-art/ts-common").Validator<number>;
-        envs: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: TypedMap<FirebaseHosting_EnvConfig> | undefined) => import("@nu-art/ts-common").InvalidResultObject<TypedMap<FirebaseHosting_EnvConfig>> | undefined))[];
+        envs: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: TypedMap<WebpackHosting_EnvConfig> | undefined) => import("@nu-art/ts-common").InvalidResultObject<TypedMap<WebpackHosting_EnvConfig>> | undefined))[];
         hostingConfig: import("@nu-art/ts-common").ValidatorImpl<any>;
         hostingDeployment: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: object | undefined) => string | object | undefined))[];
     };
     constructor();
     protected resolveNodeUnit(context: UnitMapper_NodeContext<UnitConfigJSON_FirebaseHosting>): Promise<Unit_FirebaseHostingApp<{
-        envConfig: {
-            config: import("@nu-art/ts-common").TS_Object;
-            projectId: string;
-            isLocal: boolean;
-        };
+        envConfig: WebpackHosting_EnvConfig;
         isTopLevelApp: true;
         hasSelfHotReload: boolean;
         customESLintConfig: boolean;
@@ -28,8 +24,8 @@ export declare class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node<Un
         packageJson: import("../types.js").TS_PackageJSON<UnitConfigJSON_FirebaseHosting>;
         label: string;
         servingPort: number;
-        hostingConfig?: import("../../implementations/firebase/Unit_FirebaseHostingApp.js").FirebaseHostingConfig | undefined;
-        envs: TypedMap<FirebaseHosting_EnvConfig>;
+        hostingConfig?: import("../../implementations/firebase/Unit_HostingApp.js").FirebaseHostingConfig | undefined;
+        envs: TypedMap<WebpackHosting_EnvConfig>;
         fullPath: import("@nu-art/ts-common").AbsolutePath;
         relativePath: import("@nu-art/ts-common").RelativePath;
         key: string;

package/units/discovery/resolvers/UnitMapper_FirebaseHosting.js

@@ -7,6 +7,7 @@ const valuesValidator = {
     config: tsValidateMustExist,
     projectId: tsValidateAnyString,
     isLocal: tsValidateBoolean(false),
+    webpackConfig: tsValidateOptional
 };
 // Artifact Registry generic package name validation: lowercase, alphanumeric with dots, underscores, hyphens
 // Cannot start/end with separators, no consecutive separators
@@ -41,7 +42,8 @@ export class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node {
         const envConfig = {
             config: envUnitConfig?.config,
             projectId: envUnitConfig?.projectId,
-            isLocal: envUnitConfig?.isLocal ?? env === 'local'
+            isLocal: envUnitConfig?.isLocal ?? env === 'local',
+            webpackConfig: envUnitConfig?.webpackConfig,
         };
         const { type, ...unitConfig } = context.packageJson.unitConfig;
         return new Unit_FirebaseHostingApp({

package/units/discovery/resolvers/UnitMapper_Node.d.ts

@@ -1,6 +1,6 @@
 import { TS_PackageJSON } from '../types.js';
 import { TypeValidator } from '@nu-art/ts-common';
-import { BaseUnit } from '../../index.js';
+import { BaseUnit } from '../../base/BaseUnit.js';
 import { BaseUnitConfig, UnitConfigJSON_Base, UnitMapper_Base } from './UnitMapper_Base.js';
 export type UnitConfigJSON_Node = UnitConfigJSON_Base & {
     label: string;

package/units/discovery/resolvers/UnitMapper_Node.js

@@ -1,7 +1,8 @@
-import { _keys, deepClone, tsValidate, tsValidateBoolean, tsValidateOptionalAnyString, tsValidateResult } from '@nu-art/ts-common';
+import { tsValidateBoolean, tsValidateOptionalAnyString, tsValidateResult } from '@nu-art/ts-common';
 import { FilesCache } from '../../../core/FilesCache.js';
 import { UnitMapper_Base } from './UnitMapper_Base.js';
 import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { Unit_PackageJson } from '../../implementations/Unit_PackageJson.js';
 export class UnitMapper_Node extends UnitMapper_Base {
     static invalidPaths = [];
     static tsValidator_Node = {
@@ -31,20 +32,9 @@ export class UnitMapper_Node extends UnitMapper_Base {
             }
             if (tsValidateResult(packageJson.unitConfig.type, this.validator.type))
                 return; // not the expected type for this mapper
-            packageJson = deepClone(packageJson);
-            tsValidate(packageJson.unitConfig, this.validator);
+            packageJson = Unit_PackageJson.transformDependencyPlaceholders(packageJson);
+            const configValidationResult = tsValidateResult(packageJson.unitConfig, this.validator, undefined, false);
             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,
@@ -55,7 +45,10 @@ export class UnitMapper_Node extends UnitMapper_Base {
             };
             const customESLintConfig = packageJson.unitConfig.customESLintConfig ?? false;
             const customTSConfig = packageJson.unitConfig.customTSConfig ?? false;
-            return this.resolveNodeUnit({ path, root, packageJson, baseConfig, customESLintConfig, customTSConfig });
+            const unit = await this.resolveNodeUnit({ path, root, packageJson, baseConfig, customESLintConfig, customTSConfig });
+            if (unit instanceof Unit_PackageJson)
+                unit.configValidationResult = configValidationResult;
+            return unit;
         }
         catch (e) {
             this.logError(`Failed to load package.json at: ${pathToFile}`, e);

package/units/discovery/resolvers/UnitMapper_ViteHosting.d.ts

@@ -0,0 +1,46 @@
+import { TypedMap } from '@nu-art/ts-common';
+import { UnitMapper_Node, UnitMapper_NodeContext } from './UnitMapper_Node.js';
+import { FirebaseHosting_EnvConfig } from '../../implementations/firebase/Unit_HostingApp.js';
+import { Unit_ViteHostingApp } from '../../implementations/firebase/Unit_ViteHostingApp.js';
+type UnitConfigJSON_ViteHosting_Node = import('../../discovery/resolvers/UnitMapper_Node.js').UnitConfigJSON_Node & {
+    servingPort?: number;
+    hostingConfig?: import('../../implementations/firebase/Unit_HostingApp.js').FirebaseHostingConfig;
+    envs: TypedMap<FirebaseHosting_EnvConfig>;
+};
+export declare class UnitMapper_ViteHosting_Class extends UnitMapper_Node<Unit_ViteHostingApp, UnitConfigJSON_ViteHosting_Node> {
+    static tsValidator_ViteHosting: {
+        label: import("@nu-art/ts-common").Validator<string>;
+        customESLintConfig: import("@nu-art/ts-common").Validator<boolean>;
+        customTSConfig: import("@nu-art/ts-common").Validator<boolean>;
+        hasSelfHotReload: import("@nu-art/ts-common").Validator<boolean>;
+        type: import("@nu-art/ts-common").Validator<any>;
+        servingPort: import("@nu-art/ts-common").Validator<number>;
+        envs: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: TypedMap<FirebaseHosting_EnvConfig> | undefined) => import("@nu-art/ts-common").InvalidResultObject<TypedMap<FirebaseHosting_EnvConfig>> | undefined))[];
+        hostingConfig: import("@nu-art/ts-common").ValidatorImpl<any>;
+        hostingDeployment: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: object | undefined) => string | object | undefined))[];
+    };
+    constructor();
+    protected resolveNodeUnit(context: UnitMapper_NodeContext<UnitConfigJSON_ViteHosting_Node>): Promise<Unit_ViteHostingApp<{
+        envConfig: {
+            config: import("@nu-art/ts-common").TS_Object;
+            projectId: string;
+            isLocal: boolean;
+        };
+        isTopLevelApp: true;
+        hasSelfHotReload: boolean;
+        customESLintConfig: boolean;
+        customTSConfig: boolean;
+        output: string;
+        packageJson: import("../types.js").TS_PackageJSON<UnitConfigJSON_ViteHosting_Node>;
+        label: string;
+        servingPort: number;
+        hostingConfig?: import("../../implementations/firebase/Unit_HostingApp.js").FirebaseHostingConfig | undefined;
+        envs: TypedMap<FirebaseHosting_EnvConfig>;
+        fullPath: import("@nu-art/ts-common").AbsolutePath;
+        relativePath: import("@nu-art/ts-common").RelativePath;
+        key: string;
+        dependencies: import("@nu-art/ts-common").StringMap;
+    }>>;
+}
+export declare const UnitMapper_ViteHosting: UnitMapper_ViteHosting_Class;
+export {};

package/units/discovery/resolvers/UnitMapper_ViteHosting.js

@@ -0,0 +1,59 @@
+import { tsValidateAnyString, tsValidateBoolean, tsValidateDynamicObject, tsValidateMustExist, tsValidateOptional, tsValidateOptionalAnyNumber, tsValidateOptionalObject, tsValidateRegexp, tsValidateValue } from '@nu-art/ts-common';
+import { UnitMapper_Node } from './UnitMapper_Node.js';
+import { Unit_HostingApp } from '../../implementations/firebase/Unit_HostingApp.js';
+import { Unit_ViteHostingApp } from '../../implementations/firebase/Unit_ViteHostingApp.js';
+import { resolve } from 'path';
+import { BaiParam_SetEnv } from '../../../core/params.js';
+const valuesValidator = {
+    config: tsValidateMustExist,
+    projectId: tsValidateAnyString,
+    isLocal: tsValidateBoolean(false),
+};
+const packageNameRegex = /^[a-z0-9]+([._-][a-z0-9]+)*$/;
+const hostingDeploymentValidator = {
+    artifactRegistry: {
+        region: tsValidateAnyString,
+        repository: tsValidateAnyString,
+        projectId: tsValidateAnyString,
+    },
+    packageName: tsValidateRegexp(packageNameRegex, true),
+};
+export class UnitMapper_ViteHosting_Class extends UnitMapper_Node {
+    static tsValidator_ViteHosting = {
+        type: tsValidateValue(['vite-hosting']),
+        servingPort: tsValidateOptionalAnyNumber,
+        envs: tsValidateDynamicObject(valuesValidator, tsValidateAnyString),
+        hostingConfig: tsValidateOptional,
+        hostingDeployment: tsValidateOptionalObject(hostingDeploymentValidator),
+        ...UnitMapper_Node.tsValidator_Node,
+    };
+    constructor() {
+        super(UnitMapper_ViteHosting_Class.tsValidator_ViteHosting);
+    }
+    async resolveNodeUnit(context) {
+        const outputDir = context.packageJson.publishConfig?.directory;
+        const env = this.runtimeParams[BaiParam_SetEnv.keyName];
+        const envUnitConfig = context.packageJson.unitConfig.envs[env];
+        if (!envUnitConfig)
+            this.logWarning('Package Json config:', context.packageJson.unitConfig);
+        const envConfig = {
+            config: envUnitConfig?.config,
+            projectId: envUnitConfig?.projectId,
+            isLocal: envUnitConfig?.isLocal ?? env === 'local'
+        };
+        const { type, ...unitConfig } = context.packageJson.unitConfig;
+        return new Unit_ViteHostingApp({
+            ...context.baseConfig,
+            ...Unit_HostingApp.DefaultConfig_Hosting,
+            ...unitConfig,
+            envConfig,
+            isTopLevelApp: true,
+            hasSelfHotReload: unitConfig.hasSelfHotReload ?? false,
+            customESLintConfig: context.customESLintConfig,
+            customTSConfig: context.customTSConfig,
+            output: resolve(context.baseConfig.fullPath, outputDir ?? Unit_HostingApp.DefaultConfig_Hosting.output),
+            packageJson: context.packageJson,
+        });
+    }
+}
+export const UnitMapper_ViteHosting = new UnitMapper_ViteHosting_Class();

package/units/implementations/Unit_NodeProject.d.ts

@@ -2,7 +2,7 @@ import { UnitPhaseImplementor } from '../../core/types.js';
 import { StringMap } from '@nu-art/ts-common/utils/types';
 import { Unit_PackageJson, Unit_PackageJson_Config } from './Unit_PackageJson.js';
 import { ProjectUnit } from '../base/ProjectUnit.js';
-import { Phase_IndicesMcpServer, Phase_Install, Phase_PostPublish, Phase_Watch } from '../../phases/definitions/index.js';
+import { Phase_IndicesMcpServer, Phase_Install, Phase_InstallWatch, Phase_PostPublish, Phase_Watch } from '../../phases/definitions/consts.js';
 /**
  * Configuration for NodeProject (root project unit).
  */
@@ -35,7 +35,7 @@ type Unit_TypescriptProject_Config = Unit_PackageJson_Config & {
  * - Manages global packages installation
  * - Handles dependency tree for watch compilation
  */
-export declare class Unit_NodeProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_Install, Phase_Watch, Phase_PostPublish, Phase_IndicesMcpServer]> {
+export declare class Unit_NodeProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_Install, Phase_InstallWatch, Phase_Watch, Phase_PostPublish, Phase_IndicesMcpServer]> {
     private watcher?;
     readonly innerUnits: Unit_PackageJson[];
     private readonly suffixesToWatch;
@@ -51,6 +51,7 @@ export declare class Unit_NodeProject<C extends Unit_TypescriptProject_Config =
     stopWatch(): Promise<void | undefined>;
     private findUnit;
     install(): Promise<void>;
+    watchInstall(): Promise<void>;
     watch(timeout?: number, maxTimeout?: number): Promise<void>;
     purge(): Promise<void>;
     postPublish(): Promise<void>;

package/units/implementations/Unit_NodeProject.js

@@ -5,9 +5,9 @@ import { Commando_NVM, Commando_PNPM, CommandoException, PNPM } from '@nu-art/co
 import { Unit_PackageJson } from './Unit_PackageJson.js';
 import { resolve } from 'path';
 import { PhaseManager } from '../../phases/PhaseManager.js';
-import { phase_CompileWatch, phase_PrepareWatch } from '../../phases/definitions/index.js';
+import { phase_CompileWatch, phase_InstallWatch, phase_PrepareWatch } from '../../phases/definitions/consts.js';
 import { UnitsDependencyMapper } from '../../dependencies/UnitsDependencyMapper.js';
-import { CONST_PNPM_LOCK, CONST_PNPM_WORKSPACE } from '../../config/consts.js';
+import { CONST_PackageJSONTemplate, CONST_PNPM_LOCK, CONST_PNPM_WORKSPACE } from '../../config/consts.js';
 import { RunningStatusHandler } from '../../runtime/RunningStatusHandler.js';
 import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 import { IndicesMcpServer } from '../../exports/IndicesMcpServer.js';
@@ -71,11 +71,13 @@ export class Unit_NodeProject extends Unit_PackageJson {
     prepareWatchPaths() {
         // Using phase runner instance to resolve all project libs to watch
         const projectLibs = this.innerUnits.filter(unit => unit.isInstanceOf(Unit_TypescriptLib) && !unit.config.hasSelfHotReload);
-        //return all paths to watch
         return projectLibs.map(lib => {
             const sourceFolder = `${lib.config.fullPath}/src/main`;
             return {
-                paths: this.suffixesToWatch.map(suffix => `${sourceFolder}/**/*.${suffix}`),
+                paths: [
+                    ...this.suffixesToWatch.map(suffix => `${sourceFolder}/**/*.${suffix}`),
+                    `${lib.config.fullPath}/${CONST_PackageJSONTemplate}`,
+                ],
                 unit: lib,
                 fullPath: lib.config.fullPath
             };
@@ -106,6 +108,18 @@ export class Unit_NodeProject extends Unit_PackageJson {
                 throw new CommandoException(`Error installing packages`, stdout, stderr, exitCode);
         });
     }
+    async watchInstall() {
+        const units = this.innerUnits.filter(unit => unit.isInstanceOf(Unit_TypescriptLib));
+        const packages = units.map(unit => unit.config.relativePath);
+        if (packages.length > 0)
+            await PNPM.createWorkspace(packages, this.config.fullPath);
+        const commando = this.allocateCommando(Commando_NVM, Commando_PNPM)
+            .cd(this.config.fullPath);
+        await this.executeAsyncCommando(commando, 'pnpm i --no-frozen-lockfile', (stdout, stderr, exitCode) => {
+            if (exitCode !== 0)
+                throw new CommandoException('Error installing packages during watch', stdout, stderr, exitCode);
+        });
+    }
     async watch(timeout = 2 * Second, maxTimeout = 10 * Second) {
         if (this.watcher)
             throw new BadImplementationException('Watcher already initialized, MUST call stopWatch() before calling watch()');
@@ -121,14 +135,16 @@ export class Unit_NodeProject extends Unit_PackageJson {
             this.logInfo('Starting the watcher...');
             const units = new Set();
             const pathsToDelete = [];
+            let needsInstall = false;
             const onUnitChange = (path) => {
                 const unit = this.findUnit(pathDeclarations, path);
                 const filesToIgnore = unit.ignoreWatchFiles();
                 if (path.match(new RegExp(filesToIgnore.join('|'))))
                     return;
+                if (path.endsWith(CONST_PackageJSONTemplate))
+                    needsInstall = true;
                 // @ts-ignore - FIXME: should be a better way
                 unit.setStatus('Dirty');
-                //add unit to set
                 units.add(unit);
                 return unit;
             };
@@ -152,9 +168,11 @@ export class Unit_NodeProject extends Unit_PackageJson {
                 const _pathsToDelete = [...pathsToDelete];
                 const unitsToCompile = Array.from(units.values());
                 let unitDependencyTree = [unitsToCompile];
+                const _needsInstall = needsInstall;
                 // clear values in order to start collecting values for next debounce
                 pathsToDelete.length = 0;
                 units.clear();
+                needsInstall = false;
                 // fire all delete events
                 await Promise_all_sequentially(_pathsToDelete.map(path => {
                     return async () => path.unit.removeSpecificFileFromDist(path.path);
@@ -188,7 +206,13 @@ export class Unit_NodeProject extends Unit_PackageJson {
                     continue: false
                 };
                 const activeUnitKeys = this.runtimeContext.childUnits.map(unit => unit.config.key);
-                const phaseManager = new PhaseManager(new RunningStatusHandler(this.config.fullPath, watchRuntimeParams).isolate(), [[phase_PrepareWatch], [phase_CompileWatch]], unitDependencyTree, activeUnitKeys, activeUnitKeys);
+                const phases = _needsInstall
+                    ? [[phase_PrepareWatch], [phase_InstallWatch], [phase_CompileWatch]]
+                    : [[phase_PrepareWatch], [phase_CompileWatch]];
+                if (_needsInstall)
+                    unitDependencyTree.push([this]);
+                const allUnitKeys = _needsInstall ? [...activeUnitKeys, this.config.key] : activeUnitKeys;
+                const phaseManager = new PhaseManager(new RunningStatusHandler(this.config.fullPath, watchRuntimeParams).isolate(), phases, unitDependencyTree, allUnitKeys, allUnitKeys);
                 // @ts-ignore
                 phaseManager.setTag('PhaseManager-Watcher');
                 const executionPlan = await phaseManager.calculateExecutionSteps();

package/units/implementations/Unit_PackageJson.d.ts

@@ -1,8 +1,8 @@
-import { StringMap } from '@nu-art/ts-common';
+import { InvalidResult, StringMap } from '@nu-art/ts-common';
 import { UnitPhaseImplementor } from '../../core/types.js';
 import { Config_ProjectUnit, ProjectUnit } from '../base/ProjectUnit.js';
 import { TS_PackageJSON } from '../discovery/types.js';
-import { Phase_Prepare, Phase_PrepareWatch, Phase_Purge } from '../../phases/definitions/index.js';
+import { Phase_Prepare, Phase_PrepareWatch, Phase_Purge } from '../../phases/definitions/consts.js';
 /**
  * Configuration for PackageJson units (units with package.json).
  */
@@ -31,6 +31,12 @@ export type Unit_PackageJson_Config = Config_ProjectUnit & {
  * **Base For**: Unit_NodeProject, Unit_TypescriptLib, Unit_FirebaseHosting, etc.
  */
 export declare class Unit_PackageJson<C extends Unit_PackageJson_Config = Unit_PackageJson_Config> extends ProjectUnit<C> implements UnitPhaseImplementor<[Phase_Purge, Phase_Prepare, Phase_PrepareWatch]> {
+    configValidationResult?: InvalidResult<any>;
+    /**
+     * Clones a raw __package.json and replaces '?' dependency values with template
+     * placeholders '{{key}}' so template-transform can resolve them later.
+     */
+    static transformDependencyPlaceholders<T extends TS_PackageJSON>(packageJson: T): T;
     constructor(config: C);
     protected npmCommand(command: string): string;
     protected deriveDistDependencies(): StringMap;

package/units/implementations/Unit_PackageJson.js

@@ -1,9 +1,11 @@
-import { CONST_NodeModules, CONST_PackageJSON } from '../../config/consts.js';
-import { __stringify } from '@nu-art/ts-common';
+import { CONST_NodeModules, CONST_PackageJSON, CONST_PackageJSONTemplate } from '../../config/consts.js';
+import { __stringify, _keys, deepClone, ValidationException } from '@nu-art/ts-common';
 import { ProjectUnit } from '../base/ProjectUnit.js';
 import { resolve } from 'path';
+import { existsSync } from 'fs';
 import { Commando_NVM } from '@nu-art/commando';
-import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { DEFAULT_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { FilesCache } from '../../core/FilesCache.js';
 /**
  * Base class for all units that have a package.json file.
  *
@@ -26,25 +28,48 @@ import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common
  * **Base For**: Unit_NodeProject, Unit_TypescriptLib, Unit_FirebaseHosting, etc.
  */
 export class Unit_PackageJson extends ProjectUnit {
+    configValidationResult;
+    /**
+     * Clones a raw __package.json and replaces '?' dependency values with template
+     * placeholders '{{key}}' so template-transform can resolve them later.
+     */
+    static transformDependencyPlaceholders(packageJson) {
+        const result = deepClone(packageJson);
+        const dependencies = result.dependencies;
+        if (dependencies)
+            result.dependencies = _keys(dependencies).reduce((acc, key) => {
+                acc[key] = dependencies[key] === '?' ? `{{${key}}}` : dependencies[key];
+                return acc;
+            }, {});
+        const devDependencies = result.devDependencies;
+        if (devDependencies)
+            result.devDependencies = _keys(devDependencies).reduce((acc, key) => {
+                acc[key] = devDependencies[key] === '?' ? `{{${key}}}` : devDependencies[key];
+                return acc;
+            }, {});
+        return result;
+    }
     constructor(config) {
         super(config);
         this.addToClassStack(Unit_PackageJson);
     }
     //######################### Internal Logic #########################
     npmCommand(command) {
+        const packageBin = resolve(this.config.fullPath, './node_modules/.bin', command);
+        if (existsSync(packageBin))
+            return packageBin;
         return resolve(this.runtimeContext.parentUnit.config.fullPath, './node_modules/.bin', command);
     }
     deriveDistDependencies() {
+        const baseParams = this.runtimeContext.baiConfig.templateParams?.packageJson ?? {};
         const params = this.runtimeContext.parentUnit.innerUnits.reduce((dependencies, unit) => {
-            dependencies[unit.config.key] = unit.config.packageJson.version;
+            const rawVersion = unit.config.packageJson.version;
+            dependencies[unit.config.key] = FileSystemUtils.file.template.transform(rawVersion, baseParams);
             return dependencies;
         }, {
-            ...this.runtimeContext.baiConfig.templateParams?.packageJson,
+            ...baseParams,
         });
-        return {
-            ...params,
-            THUNDERSTORM_DEP_VERSION: this.runtimeContext.baiConfig.templateParams?.packageJson?.['THUNDERSTORM_VERSION'] ?? ''
-        };
+        return params;
     }
     deriveLibDependencies() {
         return this.runtimeContext.childUnits.reduce((dependencies, unit) => {
@@ -64,16 +89,25 @@ export class Unit_PackageJson extends ProjectUnit {
      * **Template Params**: Includes THUNDERSTORM_VERSION, __ENV__, and child unit versions.
      */
     async prepare() {
+        if (this.configValidationResult)
+            throw new ValidationException(`Invalid unit config for '${this.config.key}'`, undefined, this.configValidationResult);
         await this._sharedPrepare();
     }
     async watchPrepare() {
-        await this._sharedPrepare();
+        const pathToFile = resolve(this.config.fullPath, CONST_PackageJSONTemplate);
+        FilesCache.invalidate(pathToFile);
+        const raw = await FilesCache.load.json(pathToFile);
+        const freshPackageJson = Unit_PackageJson.transformDependencyPlaceholders(raw);
+        const targetPath = resolve(this.config.fullPath, CONST_PackageJSON);
+        const params = this.deriveLibDependencies();
+        const content = FileSystemUtils.file.template.transform(__stringify(freshPackageJson, true), params);
+        await FileSystemUtils.file.template.write(targetPath, content, params, DEFAULT_TEMPLATE_PATTERN);
     }
     async _sharedPrepare() {
         const targetPath = resolve(this.config.fullPath, CONST_PackageJSON);
         const params = this.deriveLibDependencies();
         const packageJson = FileSystemUtils.file.template.transform(__stringify(this.config.packageJson, true), params);
-        await FileSystemUtils.file.template.write(targetPath, packageJson, params, DEFAULT_OLD_TEMPLATE_PATTERN);
+        await FileSystemUtils.file.template.write(targetPath, packageJson, params, DEFAULT_TEMPLATE_PATTERN);
     }
     /**
      * Purges package.json and node_modules folder.
@@ -86,6 +120,7 @@ export class Unit_PackageJson extends ProjectUnit {
     }
     async releasePorts(allPorts) {
         const commando = this.allocateCommando(Commando_NVM).applyNVM();
+        this.logInfo('Releasing ports: ', allPorts);
         await commando.setUID(this.config.key)
             .append(`array=($(lsof -ti:${allPorts.join(',')}))`)
             .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)