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

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;
@@ -14,7 +14,7 @@ export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
  *
  * **Key Responsibilities**:
  * - Compiles TypeScript to JavaScript
- * - Runs tests (pure, firebase, ui, mobile)
+ * - Runs tests (pure, firebase, ui, mobile, playwright)
  * - Lints code
  * - Publishes packages
  * - Manages assets (JSON, SCSS, SVG, images)
@@ -36,6 +36,11 @@ export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
  * - **firebase**: Tests with Firebase emulators
  * - **ui**: UI tests (not implemented)
  * - **mobile**: Mobile tests (not implemented)
+ * - **playwright**: Playwright test runner (@playwright/test)
+ *   - Automatic browser instance management (one per worker)
+ *   - Better performance with shared browser instances across test files
+ *   - Built-in fixtures and test isolation
+ *   - Pattern: **\/*.test.playwright.ts
  *
  * **Asset Management**: Automatically copies non-TypeScript files (JSON, SCSS, SVG, images)
  * to output directory during compilation.
@@ -45,6 +50,7 @@ export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
 export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Unit_TypescriptLib_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_PreCompile, Phase_Compile, Phase_PrintDependencyTree, Phase_CheckCyclicImports, Phase_Lint, Phase_Test, Phase_Publish, Phase_ToESM, Phase_ExtractDynamicDeps, Phase_MapExports]> {
     private TestTypeWorkspaceSetup;
     runTests(): Promise<void>;
+    private generatePlaywrightConfig;
     protected dependencyUnits: Unit_TypescriptLib[];
     constructor(config: Unit_TypescriptLib<C>['config']);
     protected clearOutputDir(): Promise<void>;

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 = [
@@ -28,7 +28,8 @@ const defaultTestPatterns = {
     pure: '**/*.test.ts',
     firebase: '**/*.test.firebase.ts',
     ui: '**/*.test.ui.ts',
-    mobile: '**/*.test.mobile.ts'
+    mobile: '**/*.test.mobile.ts',
+    playwright: '**/*.test.playwright.ts'
 };
 const CONST_ESM_PREFIX = 'export NODE_OPTIONS=\'--import data:text/javascript,import%20%7B%20register%20%7D%20from%20%22node%3Amodule%22%3B%20import%20%7B%20pathToFileURL%20%7D%20from%20%22node%3Aurl%22%3B%20register%28%22ts-node%2Fesm%22%2C%20pathToFileURL%28%22.%2F%22%29%29%3B\'';
 const TestsCommandComposer = {
@@ -62,13 +63,35 @@ const TestsCommandComposer = {
     mobile: async () => {
         throw new NotImplementedYetException('Mobile tests not implemented yet');
     },
+    playwright: async (config, runtimeContext) => {
+        const command = resolve(runtimeContext.parentUnit.config.fullPath, 'node_modules/.bin/playwright');
+        // Playwright accepts file paths as arguments (not glob patterns)
+        // If testFiles not explicitly provided, discover them via glob and convert to relative paths
+        let testFiles = runtimeContext.runtimeParams.testFiles;
+        if (!testFiles) {
+            const pattern = resolve(config.fullPath, 'src/test', defaultTestPatterns.playwright);
+            const fileIterator = glob(pattern, {});
+            const absoluteFiles = [];
+            for await (const file of fileIterator)
+                absoluteFiles.push(file);
+            testFiles = absoluteFiles.map(file => path.relative(config.fullPath, file));
+        }
+        const cli_testFiles = testFiles.length > 0 ? ` ${testFiles.join(' ')}` : '';
+        // Map test cases to Playwright's --grep option
+        const testCases = runtimeContext.runtimeParams.testCases;
+        const cli_testCases = testCases ? ` --grep '${testCases.join('|')}'` : '';
+        // Map debug port to Playwright's --debug option
+        const debugPort = runtimeContext.runtimeParams.testDebugPort;
+        const cli_debug = debugPort ? ` --debug=${debugPort}` : '';
+        return `${command} test${cli_testFiles}${cli_testCases}${cli_debug}`;
+    },
 };
 /**
  * TypeScript library unit for building TypeScript packages.
  *
  * **Key Responsibilities**:
  * - Compiles TypeScript to JavaScript
- * - Runs tests (pure, firebase, ui, mobile)
+ * - Runs tests (pure, firebase, ui, mobile, playwright)
  * - Lints code
  * - Publishes packages
  * - Manages assets (JSON, SCSS, SVG, images)
@@ -90,6 +113,11 @@ const TestsCommandComposer = {
  * - **firebase**: Tests with Firebase emulators
  * - **ui**: UI tests (not implemented)
  * - **mobile**: Mobile tests (not implemented)
+ * - **playwright**: Playwright test runner (@playwright/test)
+ *   - Automatic browser instance management (one per worker)
+ *   - Better performance with shared browser instances across test files
+ *   - Built-in fixtures and test isolation
+ *   - Pattern: **\/*.test.playwright.ts
  *
  * **Asset Management**: Automatically copies non-TypeScript files (JSON, SCSS, SVG, images)
  * to output directory during compilation.
@@ -128,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');
@@ -135,6 +190,48 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
         mobile: async () => {
             throw new NotImplementedYetException('Mobile tests not implemented yet');
         },
+        playwright: async (config, runtimeContext) => {
+            const playwrightConfigPath = resolve(config.fullPath, 'playwright.config.ts');
+            // Generate playwright.config.ts if missing
+            if (!await FileSystemUtils.file.exists(playwrightConfigPath)) {
+                const playwrightConfig = runtimeContext.baiConfig.files?.tests?.playwright;
+                const browsers = playwrightConfig?.browsers ?? ['chromium'];
+                const headless = playwrightConfig?.headless ?? true;
+                const baseURL = playwrightConfig?.baseURL;
+                const viewport = playwrightConfig?.viewport ?? { width: 1280, height: 720 };
+                // Vite config: from bai-config, or default to shared _thunderstorm/vite.config.ts when package is under _thunderstorm
+                const projectRoot = runtimeContext.parentUnit.config.fullPath;
+                const viteConfigPathFromConfig = playwrightConfig?.vite?.configPath;
+                const defaultThunderstormVitePath = '_thunderstorm/vite.config.ts';
+                const viteConfigPath = viteConfigPathFromConfig ?? (config.fullPath.includes('_thunderstorm') ? defaultThunderstormVitePath : undefined);
+                const vitePort = playwrightConfig?.vite?.port ?? 5173;
+                const viteOptions = viteConfigPath ? {
+                    port: vitePort,
+                    configPath: path.relative(config.fullPath, resolve(projectRoot, viteConfigPath))
+                } : undefined;
+                const configContent = this.generatePlaywrightConfig({
+                    browsers,
+                    headless,
+                    baseURL,
+                    viewport,
+                    vite: viteOptions
+                });
+                await FileSystemUtils.file.write(playwrightConfigPath, configContent);
+                this.logInfo(`Generated playwright.config.ts for ${config.key}`);
+            }
+            // Ensure browser binaries are installed
+            const commando = this.allocateCommando(Commando_NVM)
+                .cd(config.fullPath);
+            const playwrightConfig = runtimeContext.baiConfig.files?.tests?.playwright;
+            const browsersToInstall = playwrightConfig?.browsers ?? ['chromium'];
+            for (const browser of browsersToInstall) {
+                await this.executeAsyncCommando(commando, `npx playwright install ${browser}`, (stdout, stderr, exitCode) => {
+                    if (exitCode !== 0) {
+                        this.logWarning(`Failed to install ${browser} browser, tests may fail`);
+                    }
+                });
+            }
+        },
     };
     async runTests() {
         const testsFolder = resolve(this.config.fullPath, 'src/test');
@@ -165,6 +262,60 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
             });
         }
     }
+    generatePlaywrightConfig(options) {
+        const browserNames = options.browsers.map(browser => {
+            const deviceName = browser === 'webkit' ? 'Safari' : browser.charAt(0).toUpperCase() + browser.slice(1);
+            return `    {
+      name: '${browser}',
+      use: { ...devices['Desktop ${deviceName}'] },
+    }`;
+        }).join(',\n');
+        // Build webServer block if vite config is provided
+        const viteConfig = options.vite;
+        const webServerBlock = viteConfig ? `
+  webServer: {
+    command: \`npx vite --config \${resolve(__dirname, '${viteConfig.configPath}')} --port \${vitePort} --host 127.0.0.1\`,
+    url: \`http://127.0.0.1:\${vitePort}/src/test/index.html\`,
+    reuseExistingServer: true,
+    timeout: 60000,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  },
+` : '';
+        // Use vite URL as baseURL when vite is configured, otherwise use provided baseURL
+        const baseURL = viteConfig
+            ? '`http://127.0.0.1:${vitePort}`'
+            : options.baseURL ? `'${options.baseURL}'` : undefined;
+        const baseURLConfig = baseURL ? `    baseURL: ${baseURL},` : '';
+        // Add imports based on whether vite is used
+        const imports = viteConfig
+            ? `import {defineConfig, devices} from '@playwright/test';
+import {resolve} from 'path';
+import {fileURLToPath} from 'url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const vitePort = process.env.VITE_PORT || '${viteConfig.port}';
+`
+            : `import {defineConfig, devices} from '@playwright/test';
+`;
+        return `${imports}
+export default defineConfig({
+  testDir: './src/test',
+  testMatch: '**/*.test.playwright.ts',
+${webServerBlock}
+  use: {
+    headless: ${options.headless},
+${baseURLConfig ? baseURLConfig + '\n' : ''}    viewport: { width: ${options.viewport.width}, height: ${options.viewport.height} },
+  },
+
+  projects: [
+${browserNames}
+  ],
+
+  timeout: 30000,
+});
+`;
+    }
     dependencyUnits;
     constructor(config) {
         super(config);
@@ -401,7 +552,7 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
         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

@@ -1,11 +1,10 @@
 import { CONST_BuildImageDir, CONST_FirebaseJSON, CONST_FirebaseRC, CONST_LatestTag, CONST_PackageJSON, CONST_TrashDir, CONST_VersionApp } from '../../../config/consts.js';
 import { __stringify, _keys, _logger_logPrefixes, deepClone, ImplementationMissingException, LogLevel, Second, sleep } from '@nu-art/ts-common';
-import { Const_FirebaseConfigKeys, Const_FirebaseDefaultsKeyToFile, FunctionBuildTemplateFiles } from '../../../templates/consts.js';
-import { Commando_NVM } from '@nu-art/commando';
+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 { CommandoException } from '@nu-art/commando';
 import { deployLogFilter, ensureArtifactRegistryRepository } from './common.js';
 export const firebaseFunctionEmulator_ErrorStrings = [
     'functions: Failed',
@@ -86,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();
@@ -114,15 +113,63 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
     async launch() {
         await sleep(2 * Second * Unit_FirebaseFunctionsApp.staggerCount++);
         await this.releaseEmulatorPorts();
-        await Promise.all([
-            this.runProxy(),
-            this.runEmulator(),
-        ]);
+        if (this.config.mongo)
+            await this.startMongoEmulator();
+        let emulatorPromise;
+        const proxyPromise = this.runProxy(() => {
+            emulatorPromise = this.runEmulator();
+        });
+        await proxyPromise;
+        if (emulatorPromise)
+            await emulatorPromise;
     }
     async releaseEmulatorPorts() {
-        const allPorts = Array.from({ length: 10 }, (_, i) => `${this.config.basePort + i}`);
+        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)
@@ -635,9 +682,8 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
     async resolveProxyFile() {
         const envConfig = this.getEnvConfig();
         const targetPath = this.pathToProxy();
-        const path = this.runtimeContext.baiConfig.files?.backend?.proxy;
-        if (!path)
-            return;
+        const templatePath = this.runtimeContext.baiConfig.files?.backend?.proxy ?? Default_Files.backend.proxy;
+        await FileSystemUtils.folder.create(resolve(this.config.fullPath, '.trash/proxy'));
         const params = {
             PROJECT_ID: `${envConfig.projectId}`,
             PROXY_PORT: `${this.config.basePort}`,
@@ -645,10 +691,10 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
             PATH_TO_SSL_KEY: `${this.config.sslKey}`,
             PATH_TO_SSL_CERTIFICATE: `${this.config.sslCert}`,
         };
-        await FileSystemUtils.file.template.copy(path, targetPath, params);
+        await FileSystemUtils.file.template.copy(templatePath, targetPath, params);
     }
     pathToProxy() {
-        return resolve(this.config.fullPath, 'src/main/proxy.ts');
+        return resolve(this.config.fullPath, '.trash/proxy/proxy.ts');
     }
     async resolveConfigDir() {
         //Create the dir if it doesn't exist
@@ -779,11 +825,19 @@ export class Unit_FirebaseFunctionsApp extends Unit_TypescriptLib {
         }));
     }
     //######################### Launch Logic #########################
-    async runProxy() {
+    async runProxy(onReady) {
         await this.resolveProxyFile();
         const commando = this.allocateCommando(Commando_NVM).applyNVM()
             .cd(this.config.fullPath);
-        await this.executeAsyncCommando(commando, `${this.npmCommand('tsx')} src/main/proxy.ts`);
+        let readyFired = false;
+        commando.addLogProcessor((log) => {
+            if (!readyFired && log.includes('SSL proxy started at port')) {
+                readyFired = true;
+                onReady?.();
+            }
+            return true;
+        });
+        await this.executeAsyncCommando(commando, `${this.npmCommand('tsx')} .trash/proxy/proxy.ts`);
         this.logWarning('PROXY TERMINATED');
     }
     async runEmulator() {
@@ -797,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_FirebaseHostingApp.d.ts

@@ -1,115 +1,37 @@
-import { FirebasePackageConfig } from '../../../config/types/index.js';
-import { UnitPhaseImplementor } from '../../../core/types.js';
-import { StringMap, TS_Object, TypedMap } from '@nu-art/ts-common';
+import { TypedMap } from '@nu-art/ts-common';
 import { UnitConfigJSON_Node } from '../../discovery/resolvers/UnitMapper_Node.js';
-import { Phase_BuildPushImage, Phase_Deploy, Phase_DeployImage, Phase_Launch } from '../../../phases/definitions/index.js';
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
-export type FirebaseHostingConfig = {
-    public: string;
-    rewrites: {
-        source: string;
-        destination: string;
-    }[];
+import { FirebaseHosting_EnvConfig, FirebaseHostingConfig, Unit_HostingApp, Unit_HostingApp_Config } from './Unit_HostingApp.js';
+export type { FirebaseHostingConfig, FirebaseHosting_EnvConfig };
+export type WebpackEnvConfig = {
+    minifyHtml?: boolean;
+    devServerSSL?: boolean;
+    devServerPort?: number;
+    sslKey?: string;
+    sslCert?: string;
 };
-export type FirebaseHosting_EnvConfig = {
-    config: TS_Object;
-    projectId: string;
-    isLocal?: boolean;
+export type WebpackHosting_EnvConfig = FirebaseHosting_EnvConfig & {
+    webpackConfig?: WebpackEnvConfig;
 };
 export type UnitConfigJSON_FirebaseHosting = UnitConfigJSON_Node & {
     servingPort?: number;
     hostingConfig?: FirebaseHostingConfig;
-    envs: TypedMap<FirebaseHosting_EnvConfig>;
+    envs: TypedMap<WebpackHosting_EnvConfig>;
 };
-export type Unit_FirebaseHostingApp_Config = Unit_TypescriptLib_Config & {
-    firebaseConfig?: FirebasePackageConfig;
-    servingPort: number;
-    hostingConfig?: FirebaseHostingConfig;
-    envConfig: FirebaseHosting_EnvConfig;
-    sources?: string[];
-    hostingDeployment?: {
-        artifactRegistry: {
-            region: string;
-            repository: string;
-            projectId: string;
-        };
-        packageName: string;
-    };
+export type Unit_FirebaseHostingApp_Config = Unit_HostingApp_Config & {
+    envConfig: WebpackHosting_EnvConfig;
 };
 /**
- * Firebase Hosting application unit.
- *
- * **Key Features**:
- * - Extends Unit_TypescriptLib (compiles TypeScript)
- * - Manages Firebase hosting configuration (firebase.json, .firebaserc)
- * - Supports multiple environments (local, staging, production)
- * - Implements launch and deploy phases
- *
- * **Phases Implemented**:
- * - `prepare()`: Resolves Firebase hosting config files
- * - `compile()`: Compiles TypeScript (without declarations)
- * - `launch()`: Starts Firebase hosting emulator
- * - `deploy()`: Deploys to Firebase hosting
- *
- * **Configuration**:
- * - `servingPort`: Port for local hosting server
- * - `hostingConfig`: Firebase hosting configuration (public folder, rewrites)
- * - `envConfig`: Environment-specific config (projectId, isLocal)
+ * Firebase Hosting application unit (webpack bundler).
+ * Extends Unit_HostingApp; implements compile via npm run build, launch via npm run start.
  */
-export declare class Unit_FirebaseHostingApp<C extends Unit_FirebaseHostingApp_Config = Unit_FirebaseHostingApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_Launch, Phase_Deploy, Phase_BuildPushImage, Phase_DeployImage]> {
-    hosting: StringMap;
-    injectedMetadata: StringMap;
+export declare class Unit_FirebaseHostingApp<C extends Unit_FirebaseHostingApp_Config = Unit_FirebaseHostingApp_Config> extends Unit_HostingApp<C> {
     static DefaultConfig_FirebaseHosting: {
         servingPort: number;
         output: string;
     };
     constructor(config: Unit_FirebaseHostingApp<C>['config']);
     prepare(): Promise<void>;
-    compile(): Promise<void>;
-    launch(): Promise<void>;
-    releaseWebpackPorts(): Promise<void>;
-    deploy(): Promise<void>;
-    private getEnvConfig;
-    private resolveHostingRC;
-    private resolveHostingJSON;
-    private resolveHostingRuntimeConfig;
+    private resolveWebpackEnvConfig;
     protected compileImpl(): Promise<void>;
-    private createAppVersionFile;
-    private runApp;
-    /**
-     * Builds hosting output and uploads it to Artifact Registry as a generic package.
-     *
-     * **Process**:
-     * 1. Validates hostingDeployment config exists
-     * 2. Creates deployment-metadata.json with build information
-     * 3. Creates tarball of hosting output directory
-     * 4. Uploads to Artifact Registry as generic package
-     *
-     * **Requirements**:
-     * - `--build-push-image <tag>` CLI flag with tag value
-     * - `hostingDeployment` config in unit config with `packageName` field
-     * - `packageName` must comply with Artifact Registry naming restrictions
-     * - gcloud CLI installed and authenticated
-     * - Artifact Registry API enabled in GCP project
-     */
-    buildPushImage(): Promise<void>;
-    /**
-     * Deploys hosting build from Artifact Registry to Firebase Hosting.
-     *
-     * **Process**:
-     * 1. Validates hostingDeployment config exists
-     * 2. Downloads tarball from Artifact Registry
-     * 3. Extracts to temp directory
-     * 4. Sets up Firebase tools (package.json + npm install)
-     * 5. Deploys to Firebase Hosting
-     * 6. Validates deployment by fetching deployment-metadata.json
-     *
-     * **Requirements**:
-     * - `--deploy-image <tag>` CLI flag with tag value
-     * - `hostingDeployment` config in unit config with `packageName` field
-     * - Package must already exist in Artifact Registry (built via buildPushImage)
-     * - gcloud CLI installed and authenticated
-     * - Firebase CLI (installed via npm in temp directory)
-     */
-    deployImage(): Promise<void>;
+    protected runApp(): Promise<void>;
 }