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

package/BuildAndInstall.d.ts

@@ -1,10 +1,10 @@
 import { Logger } from '@nu-art/ts-common';
 import { BaiParams } from './core/params.js';
-import { Phase } from './phases/definitions/index.js';
+import type { Phase } from './phases/definitions/types.js';
 import { UnitsMapper } from './units/discovery/UnitsMapper.js';
 import { ProjectUnit } from './units/base/ProjectUnit.js';
 import { PhaseManager } from './phases/PhaseManager.js';
-import { Unit_NodeProject } from './units/index.js';
+import { Unit_NodeProject } from './units/implementations/Unit_NodeProject.js';
 import { Workspace } from './workspace/Workspace.js';
 import { BaseCliParam } from '@nu-art/cli-params';
 import { RunningStatusHandler } from './runtime/RunningStatusHandler.js';

package/BuildAndInstall.js

@@ -1,6 +1,7 @@
 import { BeLogged, DebugFlag, filterDuplicates, ImplementationMissingException, LogClient_Terminal, Logger, LogLevel, merge } from '@nu-art/ts-common';
 import { AllBaiParams } from './core/params.js';
-import { phases_Build, phases_Deploy, phases_Launch, phases_Terminating } from './phases/definitions/index.js';
+import { phase_Help, Unit_HelpPrinter } from './core/Unit_HelpPrinter.js';
+import { phases_Build, phases_Deploy, phases_Launch, phases_Terminating } from './phases/definitions/consts.js';
 import { UnitsMapper } from './units/discovery/UnitsMapper.js';
 import { FilesCache } from './core/FilesCache.js';
 import { ProjectUnit } from './units/base/ProjectUnit.js';
@@ -8,11 +9,16 @@ import { PhaseManager } from './phases/PhaseManager.js';
 import { Workspace } from './workspace/Workspace.js';
 import { resolve } from 'path';
 import { CONST_BaiConfig, CONST_NodeModules, CONST_VersionApp } from './config/consts.js';
-import { UnitMapper_FirebaseFunction, UnitMapper_FirebaseHosting, UnitMapper_NodeLib, UnitMapper_NodeProject, UnitMapper_ViteHosting } from './units/discovery/resolvers/index.js';
+import { UnitMapper_FirebaseFunction } from './units/discovery/resolvers/UnitMapper_FirebaseFunction.js';
+import { UnitMapper_FirebaseHosting } from './units/discovery/resolvers/UnitMapper_FirebaseHosting.js';
+import { UnitMapper_NodeLib } from './units/discovery/resolvers/UnitMapper_NodeLib.js';
+import { UnitMapper_NodeProject } from './units/discovery/resolvers/UnitMapper_NodeProject.js';
+import { UnitMapper_ViteHosting } from './units/discovery/resolvers/UnitMapper_ViteHosting.js';
 import { CLIParamsResolver } from '@nu-art/cli-params';
 import { RunningStatusHandler } from './runtime/RunningStatusHandler.js';
 import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 export const DefaultPhases = [
+    [phase_Help],
     ...phases_Build,
     ...phases_Terminating,
     ...phases_Launch,
@@ -100,6 +106,7 @@ export class BuildAndInstall extends Logger {
     }
     async build() {
         await this.init();
+        this.workspace.addProjectUnits([Unit_HelpPrinter]);
         // Scan units from workspace
         await this.workspace.scanUnits(this.pathToProject, this.unitsMapper);
         const nodeProjectUnit = this.workspace.getNodeProjectUnit();

package/config/consts.d.ts

@@ -1,8 +1,8 @@
 /**
  * Constants for file names and configuration keys used throughout the build system.
  */
-import { MemKey } from '@nu-art/ts-common/mem-storage/index';
-import { RuntimeProjectConfig } from './types/index.js';
+import { MemKey } from '@nu-art/ts-common/mem-storage';
+import { RuntimeProjectConfig } from './types/project-config.js';
 /** Version file name (version-app.json) */
 export declare const CONST_VersionApp = "version-app.json";
 /** Package.json template file name (__package.json) */

package/config/consts.js

@@ -1,7 +1,7 @@
 /**
  * Constants for file names and configuration keys used throughout the build system.
  */
-import { MemKey } from '@nu-art/ts-common/mem-storage/index';
+import { MemKey } from '@nu-art/ts-common/mem-storage';
 /** Version file name (version-app.json) */
 export const CONST_VersionApp = 'version-app.json';
 /** Package.json template file name (__package.json) */

package/config/package/consts.d.ts

@@ -1,4 +1,4 @@
-import { FirebasePackageConfig } from '../types/index.js';
+import { FirebasePackageConfig } from '../types/package/package.js';
 export type DefaultType_ProjectEnvs = 'local' | 'dev' | 'staging' | 'prod';
 export declare const Default_ProjectEnvs: ("local" | "staging" | "dev" | "prod")[];
 export declare const Default_FunctionsIgnoreFiles: string[];

package/config/types/package/runtime-package.d.ts

@@ -1,4 +1,4 @@
-import { PackageJson } from '../configs/index.js';
+import { PackageJson } from '../configs/package-json.js';
 import { Package, Package_Sourceless } from './package.js';
 type WithPackageJson = {
     packageJsonTemplate: PackageJson;

package/config/types/project-config.d.ts

@@ -1,5 +1,6 @@
 import { StringMap, TypedMap } from '@nu-art/ts-common';
-import { Package, RuntimePackage } from './package/index.js';
+import type { Package } from './package/package.js';
+import type { RuntimePackage } from './package/runtime-package.js';
 export type ProjectConfig = {
     params: StringMap;
     packages: Package[];
@@ -28,6 +29,7 @@ export type BAI_Config = {
                 'firebase.json'?: string;
                 '.firebaserc'?: string;
                 baseEmulationPort?: number;
+                mongoPort?: number;
             };
             playwright?: {
                 browsers?: ('chromium' | 'firefox' | 'webkit')[];

package/core/FilesCache.d.ts

@@ -16,11 +16,15 @@
  */
 export declare const FilesCache: {
     /**
-     * Clears the file cache.
+     * Clears the entire file cache.
      *
      * Useful for tests or when files may have changed.
      */
     clear: () => {};
+    /**
+     * Invalidates a single cached entry so the next load re-reads from disk.
+     */
+    invalidate: (path: string) => void;
     load: {
         /**
          * Loads and caches a JSON file.

package/core/FilesCache.js

@@ -32,11 +32,15 @@ const readFile = async (path) => {
  */
 export const FilesCache = {
     /**
-     * Clears the file cache.
+     * Clears the entire file cache.
      *
      * Useful for tests or when files may have changed.
      */
     clear: () => cachedFiles = {},
+    /**
+     * Invalidates a single cached entry so the next load re-reads from disk.
+     */
+    invalidate: (path) => { delete cachedFiles[path]; },
     load: {
         /**
          * Loads and caches a JSON file.

package/core/Unit_HelpPrinter.d.ts

@@ -1,10 +1,8 @@
-import { BaseCliParam, CliParams } from '@nu-art/cli-params';
+import { BaiParam_Help } from './params.js';
 import { UnitPhaseImplementor } from './types.js';
-import { Phase } from '../phases/definitions/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<"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<"buildPushImage", string> | BaseCliParam<"deployImage", string> | BaseCliParam<"deployFunction", string> | BaseCliParam<"deleteFunctions", boolean> | BaseCliParam<"deleteFunction", string> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", "patch" | "minor" | "major"> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"buildTree", boolean> | BaseCliParam<"includeApps", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"extractDynamicDeps", boolean> | BaseCliParam<"mapExports", boolean> | BaseCliParam<"indicesMcpServer", boolean> | BaseCliParam<"indicesMcpPort", number> | BaseCliParam<"help", boolean>)[];
-export type Help_BaiParams = CliParams<typeof AllBaiParams_Help>;
+import type { Phase } from '../phases/definitions/types.js';
+import { ProjectUnit } from '../units/base/ProjectUnit.js';
+export { BaiParam_Help };
 export type Phase_Help = typeof phase_Help;
 export declare const phaseKey_Help = "help";
 export declare const phase_Help: Phase<'printHelp'>;
@@ -13,4 +11,3 @@ declare class _Unit_HelpPrinter extends ProjectUnit implements UnitPhaseImplemen
     printHelp(): Promise<void>;
 }
 export declare const Unit_HelpPrinter: _Unit_HelpPrinter;
-export {};

package/core/Unit_HelpPrinter.js

@@ -1,15 +1,7 @@
 import { _keys, LogLevel, reduceToMap } from '@nu-art/ts-common';
-import { AllBaiParams, BaiParam_AllUnits, BaiParam_NoBuild, BaiParam_Prepare } from './params.js';
-import { ProjectUnit } from '../units/index.js';
-export const BaiParam_Help = {
-    keys: ['--help', '-h'],
-    keyName: 'help',
-    type: 'boolean',
-    group: 'General',
-    description: 'This help menu',
-    dependencies: [{ param: BaiParam_NoBuild, value: true }, { param: BaiParam_Prepare, value: false }, { param: BaiParam_AllUnits, value: true }],
-};
-const AllBaiParams_Help = [...AllBaiParams, BaiParam_Help];
+import { AllBaiParams, BaiParam_Help } from './params.js';
+import { ProjectUnit } from '../units/base/ProjectUnit.js';
+export { BaiParam_Help };
 export const phaseKey_Help = 'help';
 export const phase_Help = {
     key: phaseKey_Help,

package/core/params.d.ts

@@ -45,6 +45,7 @@ export declare const BaiParam_ExtractDynamicDeps: BaseCliParam<'extractDynamicDe
 export declare const BaiParam_MapExports: BaseCliParam<'mapExports', boolean>;
 export declare const BaiParam_IndicesMcpServer: BaseCliParam<'indicesMcpServer', boolean>;
 export declare const BaiParam_IndicesMcpPort: BaseCliParam<'indicesMcpPort', number>;
-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<"buildPushImage", string> | BaseCliParam<"deployImage", string> | BaseCliParam<"deployFunction", string> | BaseCliParam<"deleteFunctions", boolean> | BaseCliParam<"deleteFunction", string> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", PromoteType> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"buildTree", boolean> | BaseCliParam<"includeApps", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"extractDynamicDeps", boolean> | BaseCliParam<"mapExports", boolean> | BaseCliParam<"indicesMcpServer", boolean> | BaseCliParam<"indicesMcpPort", number>)[];
+export declare const BaiParam_Help: BaseCliParam<'help', 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<"buildPushImage", string> | BaseCliParam<"deployImage", string> | BaseCliParam<"deployFunction", string> | BaseCliParam<"deleteFunctions", boolean> | BaseCliParam<"deleteFunction", string> | BaseCliParam<"debug", boolean> | BaseCliParam<"debugLifecycle", boolean> | BaseCliParam<"verbose", boolean> | BaseCliParam<"publish", PromoteType> | BaseCliParam<"usePackage", string[]> | BaseCliParam<"buildTree", boolean> | BaseCliParam<"includeApps", string[]> | BaseCliParam<"toESM", boolean> | BaseCliParam<"simulation", boolean> | BaseCliParam<"checkCyclicImports", boolean> | BaseCliParam<"extractDynamicDeps", boolean> | BaseCliParam<"mapExports", boolean> | BaseCliParam<"indicesMcpServer", boolean> | BaseCliParam<"indicesMcpPort", number> | BaseCliParam<"help", boolean>)[];
 export type BaiParams = CliParams<typeof AllBaiParams>;
 export {};

package/core/params.js

@@ -395,6 +395,14 @@ export const BaiParam_IndicesMcpPort = {
     description: 'Port for Export Indices MCP server (default: 3001)',
     dependencies: [{ param: BaiParam_IndicesMcpServer, value: true }]
 };
+export const BaiParam_Help = {
+    keys: ['--help', '-h'],
+    keyName: 'help',
+    type: 'boolean',
+    group: 'General',
+    description: 'This help menu',
+    dependencies: [{ param: BaiParam_NoBuild, value: true }, { param: BaiParam_Prepare, value: false }, { param: BaiParam_AllUnits, value: true }],
+};
 export const AllBaiParams = [
     BaiParam_AllUnits,
     BaiParam_DependencyTree,
@@ -437,5 +445,6 @@ export const AllBaiParams = [
     BaiParam_MapExports,
     BaiParam_IndicesMcpServer,
     BaiParam_IndicesMcpPort,
-    BaiParam_DebugLifecycle
+    BaiParam_DebugLifecycle,
+    BaiParam_Help,
 ];

package/core/types.d.ts

@@ -1,6 +1,6 @@
 import { AsyncVoidFunction } from '@nu-art/ts-common';
-import { BaseUnit } from '../units/index.js';
-import { Phase } from '../phases/definitions/index.js';
+import { BaseUnit } from '../units/base/BaseUnit.js';
+import type { Phase } from '../phases/definitions/types.js';
 export type Unit<P extends Phase<string>[]> = BaseUnit & UnitPhaseImplementor<P>;
 export type UnitPhaseImplementor<P extends Phase<string>[]> = {
     [K in P[number]['method']]: AsyncVoidFunction;

package/exceptions/UnitPhaseException.d.ts

@@ -1,5 +1,5 @@
 import { CustomException } from '@nu-art/ts-common';
-import { BaseUnit } from '../units/index.js';
+import { BaseUnit } from '../units/base/BaseUnit.js';
 /**
  * Exception thrown when a specific phase fails on a specific unit.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.500.0",
+  "version": "0.500.6",
   "description": "A build system for monorepos that orchestrates building, testing, and deploying units with dependency-aware phase execution",
   "type": "module",
   "keywords": [
@@ -39,12 +39,12 @@
   },
   "dependencies": {
     "chokidar": "^3.6.0",
-    "@nu-art/cli-params": "0.500.0",
-    "@nu-art/ts-common": "0.500.0",
-    "@nu-art/commando": "0.500.0"
+    "@nu-art/cli-params": "0.500.6",
+    "@nu-art/ts-common": "0.500.6",
+    "@nu-art/commando": "0.500.6"
   },
   "devDependencies": {
-    "@nu-art/testalot": "0.500.0"
+    "@nu-art/testalot": "0.500.6"
   },
   "unitConfig": {
     "type": "typescript-lib"

package/phases/PhaseManager.d.ts

@@ -1,7 +1,7 @@
 import { Logger } from '@nu-art/ts-common';
 import { RunningStatusHandler } from '../runtime/RunningStatusHandler.js';
-import { Phase } from './definitions/index.js';
-import { BaseUnit } from '../units/index.js';
+import type { Phase } from './definitions/types.js';
+import { BaseUnit } from '../units/base/BaseUnit.js';
 /**
  * Scheduled execution step (before mapping to actual phases/units).
  */

package/phases/definitions/consts.d.ts

@@ -57,6 +57,9 @@ export declare const phase_Compile: Phase<'compile'>;
 export type Phase_PrepareWatch = typeof phase_PrepareWatch;
 export declare const phaseKey_PrepareWatch = "watchPrepare";
 export declare const phase_PrepareWatch: Phase<'watchPrepare'>;
+export type Phase_InstallWatch = typeof phase_InstallWatch;
+export declare const phaseKey_InstallWatch = "watchInstall";
+export declare const phase_InstallWatch: Phase<'watchInstall'>;
 export type Phase_CompileWatch = typeof phase_CompileWatch;
 export declare const phaseKey_CompileWatch = "watchCompile";
 export declare const phase_CompileWatch: Phase<'watchCompile'>;

package/phases/definitions/consts.js

@@ -92,6 +92,13 @@ export const phase_PrepareWatch = {
     filter: (baiParams) => baiParams.prepare,
     unitCategory: 'project', // All project units need to be prepared
 };
+export const phaseKey_InstallWatch = 'watchInstall';
+export const phase_InstallWatch = {
+    key: phaseKey_InstallWatch,
+    name: 'Install Watch',
+    method: 'watchInstall',
+    dependencyPhase: [phase_PrepareWatch],
+};
 export const phaseKey_CompileWatch = 'watchCompile';
 export const phase_CompileWatch = {
     key: phaseKey_CompileWatch,

package/templates/firebase/functions/service.yaml

@@ -12,6 +12,8 @@ metadata:
     cloudfunctions.googleapis.com/function-id: {{FUNCTION_NAME}}
     run.googleapis.com/ingress: all
     run.googleapis.com/ingress-status: all
+    run.googleapis.com/invoker-iam-disabled: 'true'
+    run.googleapis.com/maxScale: '100'
 spec:
   template:
     metadata:

package/units/base/BaseUnit.d.ts

@@ -3,7 +3,7 @@ import { CommandoInteractive } from '@nu-art/commando';
 import { BaseCommando } from '@nu-art/commando';
 import { MergeTypes } from '@nu-art/commando';
 import { Commando_Basic } from '@nu-art/commando';
-import { BAI_Config } from '../../config/types/index.js';
+import { BAI_Config } from '../../config/types/project-config.js';
 import { UnitsDependencyMapper } from '../../dependencies/UnitsDependencyMapper.js';
 import { BaiParams } from '../../core/params.js';
 import { Workspace } from '../../workspace/Workspace.js';

package/units/discovery/UnitsMapper.d.ts

@@ -1,4 +1,5 @@
-import { BaseUnit, ProjectUnit } from '../index.js';
+import { BaseUnit } from '../base/BaseUnit.js';
+import { ProjectUnit } from '../base/ProjectUnit.js';
 import { Logger } from '@nu-art/ts-common';
 import { UnitMapper_Base } from './resolvers/UnitMapper_Base.js';
 import { BaiParams } from '../../core/params.js';
@@ -34,7 +35,7 @@ export declare class UnitsMapper extends Logger {
      * @param projectRoot - The path to the project root
      * @param units - The project units derived from the file system
      */
-    resolveUnits(path: string, projectRoot?: string, units?: BaseUnit<any>[]): Promise<BaseUnit<any, import("../index.js").UnitRuntimeContext>[]>;
+    resolveUnits(path: string, projectRoot?: string, units?: BaseUnit<any>[]): Promise<BaseUnit<any, import("../base/BaseUnit.js").UnitRuntimeContext>[]>;
     /**
      * Adds unit resolution rules.
      *

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

@@ -1,6 +1,6 @@
 import { AbsolutePath, Logger, RelativePath, StringMap, TypeValidator } from '@nu-art/ts-common';
-import { BaseUnit } from '../../index.js';
-import { BAI_Config } from '../../../config/types/index.js';
+import { BaseUnit } from '../../base/BaseUnit.js';
+import { BAI_Config } from '../../../config/types/project-config.js';
 import { BaiParams } from '../../../core/params.js';
 export type BaseUnitConfig = {
     fullPath: AbsolutePath;

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_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,4 +1,4 @@
-import { _keys, deepClone, 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';
@@ -32,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);
+            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,

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

@@ -2,7 +2,7 @@ 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).
  */
@@ -32,6 +32,11 @@ export type Unit_PackageJson_Config = Config_ProjectUnit & {
  */
 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,10 +1,11 @@
-import { CONST_NodeModules, CONST_PackageJSON } from '../../config/consts.js';
-import { __stringify, ValidationException } 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.
  *
@@ -28,6 +29,26 @@ import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common
  */
 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);
@@ -40,16 +61,15 @@ export class Unit_PackageJson extends ProjectUnit {
         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) => {
@@ -74,13 +94,20 @@ export class Unit_PackageJson extends ProjectUnit {
         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.

package/units/implementations/Unit_TypescriptLib.d.ts

@@ -1,7 +1,7 @@
 import { RecursivePartial, TypedMap } from '@nu-art/ts-common';
 import { UnitPhaseImplementor } from '../../core/types.js';
 import { Unit_PackageJson, Unit_PackageJson_Config } from './Unit_PackageJson.js';
-import { Phase_CheckCyclicImports, Phase_Compile, Phase_ExtractDynamicDeps, Phase_Lint, Phase_MapExports, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Publish, Phase_Test, Phase_ToESM } from '../../phases/definitions/index.js';
+import { Phase_CheckCyclicImports, Phase_Compile, Phase_ExtractDynamicDeps, Phase_Lint, Phase_MapExports, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Publish, Phase_Test, Phase_ToESM } from '../../phases/definitions/consts.js';
 import { TsConfig } from '../base/types.js';
 export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
     customESLintConfig: boolean;

package/units/implementations/Unit_TypescriptLib.js

@@ -7,7 +7,7 @@ import { resolve, resolve as pathResolve } from 'path';
 import { Unit_PackageJson } from './Unit_PackageJson.js';
 import { glob } from 'node:fs/promises';
 import { TestTypes } from '../../core/params.js';
-import { DEFAULT_OLD_TEMPLATE_PATTERN, DEFAULT_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { DEFAULT_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 import path from 'node:path';
 import { ExportMapper } from '../../exports/ExportMapper.js';
 const assets = [
@@ -156,6 +156,33 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
                 FIREBASE_FIRESTORE_INDICES: resolve(pathToProjectRoot, firebaseConfigFiles.firestoreIndexesRules),
             }, DEFAULT_TEMPLATE_PATTERN);
             await this.releasePorts(ports);
+            const mongoPort = runtimeContext.baiConfig.files?.tests?.firebase?.mongoPort;
+            if (mongoPort) {
+                const containerName = `mongo-test-${config.key.replace(/[^a-z0-9-]/gi, '-')}`;
+                this.logInfo(`Starting MongoDB test container on port ${mongoPort} (container: ${containerName})`);
+                await this.releasePorts([`${mongoPort}`]);
+                const commando = this.allocateCommando();
+                await this.executeAsyncCommando(commando, `docker rm -f ${containerName} 2>/dev/null; docker run -d --name ${containerName} -p ${mongoPort}:${mongoPort} mongo:7 --replSet rs0 --port ${mongoPort}`, (stdout, stderr, exitCode) => {
+                    if (exitCode !== 0)
+                        throw new CommandoException('Failed to start MongoDB test container', stdout, stderr, exitCode);
+                });
+                const initCommando = this.allocateCommando();
+                await this.executeAsyncCommando(initCommando, `sleep 3 && docker exec ${containerName} mongosh --port ${mongoPort} --quiet --eval "rs.initiate({_id:'rs0',members:[{_id:0,host:'localhost:${mongoPort}'}]}); while(!rs.status().members.some(m=>m.stateStr==='PRIMARY')){sleep(200)} print('PRIMARY ready')"`, (stdout, stderr, exitCode) => {
+                    if (exitCode !== 0)
+                        throw new CommandoException('Failed to initiate MongoDB test replica set', stdout, stderr, exitCode);
+                });
+                this.logInfo(`MongoDB test container started as replica set on port ${mongoPort}`);
+                this.registerTerminatable(async () => {
+                    try {
+                        const stopCommando = this.allocateCommando();
+                        await this.executeAsyncCommando(stopCommando, `docker rm -f ${containerName}`, () => {
+                        });
+                    }
+                    catch (e) {
+                        this.logWarning(`Failed to stop MongoDB test container: ${e.message}`);
+                    }
+                });
+            }
         },
         ui: async () => {
             throw new NotImplementedYetException('UI tests not implemented yet');
@@ -525,7 +552,7 @@ ${browserNames}
         const packageJson = FileSystemUtils.file.template.transform(__stringify(this.config.packageJson, true), params);
         this.logVerbose('Compiling params: ', params);
         this.logVerbose('Compiling from package.json: ', packageJson);
-        await FileSystemUtils.file.template.write(targetPath, packageJson, params, DEFAULT_OLD_TEMPLATE_PATTERN);
+        await FileSystemUtils.file.template.write(targetPath, packageJson, params, DEFAULT_TEMPLATE_PATTERN);
     }
     async purge() {
         await FileSystemUtils.folder.delete(this.config.output);

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

@@ -1,7 +1,7 @@
 import { UnitPhaseImplementor } from '../../../core/types.js';
-import { FirebasePackageConfig } from '../../../config/types/index.js';
+import { FirebasePackageConfig } from '../../../config/types/package/package.js';
 import { StringMap } from '@nu-art/ts-common';
-import { Phase_BuildPushImage, Phase_Deploy, Phase_DeployImage, Phase_Launch } from '../../../phases/definitions/index.js';
+import { Phase_BuildPushImage, Phase_Deploy, Phase_DeployImage, Phase_Launch } from '../../../phases/definitions/consts.js';
 import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
 export declare const firebaseFunctionEmulator_ErrorStrings: string[];
 export declare const firebaseFunctionEmulator_WarningStrings: string[];
@@ -27,6 +27,10 @@ export type FunctionConfig = {
     serviceAccountName?: string;
     resources?: FunctionResourceConfig;
 };
+export type MongoEmulatorConfig = {
+    port?: number;
+    dbName?: string;
+};
 export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
     firebaseConfig?: FirebasePackageConfig;
     pathToFirebaseConfig: string;
@@ -39,6 +43,7 @@ export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
     pathToEmulatorData: string;
     sources?: string[];
     functions: string[] | FunctionConfig[];
+    mongo?: MongoEmulatorConfig;
     containerDeployment?: {
         artifactRegistry: {
             region: string;
@@ -98,6 +103,11 @@ export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsA
     postCompile(): Promise<void>;
     launch(): Promise<void>;
     releaseEmulatorPorts(): Promise<void>;
+    private resolveMongoPort;
+    private resolveMongoContainerName;
+    private resolveMongoDataPath;
+    private startMongoEmulator;
+    private stopMongoEmulator;
     deploy(): Promise<void>;
     /**
      * Builds Docker container image using Google Cloud Build and pushes it to Artifact Registry.

package/units/implementations/firebase/Unit_FirebaseFunctionsApp.js

@@ -3,7 +3,7 @@ import { __stringify, _keys, _logger_logPrefixes, deepClone, ImplementationMissi
 import { Const_FirebaseConfigKeys, Const_FirebaseDefaultsKeyToFile, Default_Files, FunctionBuildTemplateFiles } from '../../../templates/consts.js';
 import { Commando_NVM, CommandoException } from '@nu-art/commando';
 import { resolve } from 'path';
-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 { Unit_TypescriptLib } from '../Unit_TypescriptLib.js';
 import { deployLogFilter, ensureArtifactRegistryRepository } from './common.js';
 export const firebaseFunctionEmulator_ErrorStrings = [
@@ -85,7 +85,7 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
             return dependencies;
         }, dependencies);
         packageJson.dependencies = dependencies;
-        await FileSystemUtils.file.template.write(targetPath, __stringify(packageJson, true), this.deriveDistDependencies(), DEFAULT_OLD_TEMPLATE_PATTERN);
+        await FileSystemUtils.file.template.write(targetPath, __stringify(packageJson, true), this.deriveDistDependencies(), DEFAULT_TEMPLATE_PATTERN);
     }
     async prepare() {
         await super.prepare();
@@ -113,6 +113,8 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
     async launch() {
         await sleep(2 * Second * Unit_FirebaseFunctionsApp.staggerCount++);
         await this.releaseEmulatorPorts();
+        if (this.config.mongo)
+            await this.startMongoEmulator();
         let emulatorPromise;
         const proxyPromise = this.runProxy(() => {
             emulatorPromise = this.runEmulator();
@@ -123,8 +125,51 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
     }
     async releaseEmulatorPorts() {
         const allPorts = Array.from({ length: 11 }, (_, i) => `${this.config.basePort + i}`);
+        if (this.config.mongo)
+            allPorts.push(`${this.resolveMongoPort()}`);
         return this.releasePorts(allPorts);
     }
+    //######################### MongoDB Emulator #########################
+    resolveMongoPort() {
+        return this.config.mongo?.port ?? this.config.basePort + 11;
+    }
+    resolveMongoContainerName() {
+        return `mongo-emu-${this.config.key.replace(/[^a-z0-9-]/gi, '-')}`;
+    }
+    resolveMongoDataPath() {
+        return resolve(this.config.fullPath, CONST_TrashDir, 'mongo-data');
+    }
+    async startMongoEmulator() {
+        const port = this.resolveMongoPort();
+        const containerName = this.resolveMongoContainerName();
+        const mongoDataPath = this.resolveMongoDataPath();
+        await FileSystemUtils.folder.create(mongoDataPath);
+        this.logInfo(`Starting MongoDB emulator on port ${port} (container: ${containerName}, data: ${mongoDataPath})`);
+        const stopAction = async () => this.stopMongoEmulator();
+        this.registerTerminatable(stopAction);
+        const commando = this.allocateCommando();
+        await this.executeAsyncCommando(commando, `docker rm -f ${containerName} 2>/dev/null; docker run -d --name ${containerName} -p ${port}:${port} -v ${mongoDataPath}:/data/db mongo:7 --replSet rs0 --port ${port}`, (stdout, stderr, exitCode) => {
+            if (exitCode !== 0)
+                throw new CommandoException(`Failed to start MongoDB emulator container`, stdout, stderr, exitCode);
+        });
+        const initCommando = this.allocateCommando();
+        await this.executeAsyncCommando(initCommando, `sleep 3 && docker exec ${containerName} mongosh --port ${port} --quiet --eval "try{rs.status()}catch(e){rs.initiate({_id:'rs0',members:[{_id:0,host:'localhost:${port}'}]})} while(!rs.status().members.some(m=>m.stateStr==='PRIMARY')){sleep(200)} print('PRIMARY ready')"`, (stdout, stderr, exitCode) => {
+            if (exitCode !== 0)
+                throw new CommandoException(`Failed to initiate MongoDB replica set`, stdout, stderr, exitCode);
+        });
+        this.logInfo(`MongoDB emulator started as replica set on port ${port}`);
+    }
+    async stopMongoEmulator() {
+        const containerName = this.resolveMongoContainerName();
+        this.logInfo(`Stopping MongoDB emulator (container: ${containerName})`);
+        try {
+            const commando = this.allocateCommando();
+            await this.executeAsyncCommando(commando, `docker rm -f ${containerName}`, () => { });
+        }
+        catch (e) {
+            this.logWarning(`Failed to stop MongoDB emulator container: ${e.message}`);
+        }
+    }
     async deploy() {
         const commando = this.allocateCommando(Commando_NVM).applyNVM()
             .cd(this.config.output)
@@ -806,6 +851,8 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
                 return LogLevel.Warning;
         })
             .onLog(/.*Emulator Hub running.*/, () => this.setStatus('Launch Complete'));
+        if (this.config.mongo)
+            commando.custom(`export MONGODB_EMULATOR_HOST=localhost:${this.resolveMongoPort()}`);
         await this.executeAsyncCommando(commando, `${this.npmCommand('firebase')} emulators:start --project ${this.config.envConfig.projectId} --export-on-exit --import=${this.config.pathToEmulatorData} ${this.runtimeContext.runtimeParams.debugBackend
             ? `--inspect-functions ${this.config.debugPort}` : ''}`);
         this.logWarning('EMULATORS TERMINATED');

package/units/implementations/firebase/Unit_HostingApp.d.ts

@@ -1,7 +1,7 @@
-import { FirebasePackageConfig } from '../../../config/types/index.js';
+import { FirebasePackageConfig } from '../../../config/types/package/package.js';
 import { UnitPhaseImplementor } from '../../../core/types.js';
 import { StringMap, TS_Object } from '@nu-art/ts-common';
-import { Phase_BuildPushImage, Phase_Deploy, Phase_DeployImage, Phase_Launch } from '../../../phases/definitions/index.js';
+import { Phase_BuildPushImage, Phase_Deploy, Phase_DeployImage, Phase_Launch } from '../../../phases/definitions/consts.js';
 import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
 export type FirebaseHostingConfig = {
     public: string;

package/workspace/Workspace.d.ts

@@ -2,7 +2,9 @@ import { AnyConstructor, Logger } from '@nu-art/ts-common';
 import { BaiParams } from '../core/params.js';
 import { UnitsMapper } from '../units/discovery/UnitsMapper.js';
 import { UnitsDependencyMapper } from '../dependencies/UnitsDependencyMapper.js';
-import { BaseUnit, ProjectUnit, Unit_NodeProject } from '../units/index.js';
+import { BaseUnit } from '../units/base/BaseUnit.js';
+import { ProjectUnit } from '../units/base/ProjectUnit.js';
+import { Unit_NodeProject } from '../units/implementations/Unit_NodeProject.js';
 /**
  * Central workspace manager for all units in the build system.
  *

package/workspace/Workspace.js

@@ -1,6 +1,7 @@
 import { _keys, arrayToMap, BadImplementationException, flatArray, ImplementationMissingException, Logger } from '@nu-art/ts-common';
 import { UnitsDependencyMapper } from '../dependencies/UnitsDependencyMapper.js';
-import { ProjectUnit, Unit_NodeProject } from '../units/index.js';
+import { ProjectUnit } from '../units/base/ProjectUnit.js';
+import { Unit_NodeProject } from '../units/implementations/Unit_NodeProject.js';
 /**
  * Central workspace manager for all units in the build system.
  *

package/config/types/configs/index.d.ts

@@ -1,3 +0,0 @@
-export * from './firebasejson.js';
-export * from './firebaserc.js';
-export * from './package-json.js';

package/config/types/configs/index.js

@@ -1,3 +0,0 @@
-export * from './firebasejson.js';
-export * from './firebaserc.js';
-export * from './package-json.js';

package/config/types/index.d.ts

@@ -1,4 +0,0 @@
-export * from './core.js';
-export * from './configs/index.js';
-export * from './package/index.js';
-export * from './project-config.js';

package/config/types/index.js

@@ -1,4 +0,0 @@
-export * from './core.js';
-export * from './configs/index.js';
-export * from './package/index.js';
-export * from './project-config.js';

package/config/types/package/index.d.ts

@@ -1,2 +0,0 @@
-export * from './package.js';
-export * from './runtime-package.js';

package/config/types/package/index.js

@@ -1,2 +0,0 @@
-export * from './package.js';
-export * from './runtime-package.js';

package/phases/definitions/index.d.ts

@@ -1,2 +0,0 @@
-export * from './types.js';
-export * from './consts.js';

package/phases/definitions/index.js

@@ -1,2 +0,0 @@
-export * from './types.js';
-export * from './consts.js';

package/phases/index.d.ts

@@ -1,2 +0,0 @@
-export * from './definitions/index.js';
-export * from './PhaseManager.js';

package/phases/index.js

@@ -1,2 +0,0 @@
-export * from './definitions/index.js';
-export * from './PhaseManager.js';

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

@@ -1,5 +0,0 @@
-export * from './UnitMapper_NodeLib.js';
-export * from './UnitMapper_NodeProject.js';
-export * from './UnitMapper_FirebaseFunction.js';
-export * from './UnitMapper_FirebaseHosting.js';
-export * from './UnitMapper_ViteHosting.js';

package/units/discovery/resolvers/index.js

@@ -1,5 +0,0 @@
-export * from './UnitMapper_NodeLib.js';
-export * from './UnitMapper_NodeProject.js';
-export * from './UnitMapper_FirebaseFunction.js';
-export * from './UnitMapper_FirebaseHosting.js';
-export * from './UnitMapper_ViteHosting.js';

package/units/index.d.ts

@@ -1,6 +0,0 @@
-export * from './base/BaseUnit.js';
-export * from './base/ProjectUnit.js';
-export * from './implementations/Unit_TypescriptLib.js';
-export * from './implementations/Unit_PackageJson.js';
-export * from './implementations/Unit_NodeProject.js';
-export * from './base/types.js';

package/units/index.js

@@ -1,6 +0,0 @@
-export * from './base/BaseUnit.js';
-export * from './base/ProjectUnit.js';
-export * from './implementations/Unit_TypescriptLib.js';
-export * from './implementations/Unit_PackageJson.js';
-export * from './implementations/Unit_NodeProject.js';
-export * from './base/types.js';