mfer 1.0.0 → 1.0.1

package/README.md

@@ -1,5 +1,7 @@
 # mfer (Micro Frontend Runner)
 
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 A powerful CLI tool designed to simplify the management and execution of multiple micro frontend applications. mfer helps developers run, update, and organize their micro frontend projects with minimal configuration and maximum efficiency.
 
 ## 🚀 Features
@@ -24,8 +26,8 @@ npm install -g mfer
 
 ### Install from source
 ```bash
-git clone https://github.com/srimel/run-mfs.git
-cd run-mfs
+git clone https://github.com/srimel/mfer.git
+cd mfer
 npm install
 npm run build
 npm install -g .
@@ -248,8 +250,8 @@ mfer config edit
 For local development of mfer itself:
 
 ```bash
-git clone https://github.com/srimel/run-mfs.git
-cd run-mfs
+git clone https://github.com/srimel/mfer.git
+cd mfer
 npm install
 npm run build
 npm install -g .

package/dist/index.js

@@ -10,7 +10,7 @@ import { loadConfig } from "./utils/config-utils.js";
 program
     .name("mfer")
     .description("Micro Frontend Runner (mfer) - A CLI for running your project's micro frontends.")
-    .version("1.0.0", "-v, --version", "mfer CLI version")
+    .version("1.0.1", "-v, --version", "mfer CLI version")
     .hook("preAction", (thisCommand, actionCommand) => {
     console.log();
 })

package/dist/utils/__tests__/config-utils.test.js

@@ -0,0 +1,250 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { spawn } from 'child_process';
+import YAML from 'yaml';
+vi.mock('fs');
+vi.mock('path');
+vi.mock('os');
+vi.mock('child_process');
+vi.mock('yaml');
+vi.mock('chalk', () => {
+    const mockChalk = {
+        red: vi.fn((text) => text),
+        blue: { bold: vi.fn((text) => text) },
+        green: vi.fn((text) => text)
+    };
+    return Object.assign({ default: mockChalk }, mockChalk);
+});
+describe('config-utils', () => {
+    const mockFs = vi.mocked(fs);
+    const mockPath = vi.mocked(path);
+    const mockOs = vi.mocked(os);
+    const mockSpawn = vi.mocked(spawn);
+    const mockYaml = vi.mocked(YAML);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockOs.homedir.mockReturnValue('/mock/home');
+        mockPath.join.mockReturnValue('/mock/home/.mfer/config.yaml');
+        mockPath.dirname.mockReturnValue('/mock/home/.mfer');
+    });
+    describe('loadConfig', () => {
+        it('should load config when file exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConfig = {
+                base_github_url: 'https://github.com',
+                mfe_directory: '/path/to/mfe',
+                groups: {
+                    all: ['app1', 'app2']
+                }
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue('mock yaml content');
+            mockYaml.parse.mockReturnValue(mockConfig);
+            const { loadConfig } = yield import('../config-utils.js');
+            loadConfig();
+            expect(mockFs.readFileSync).toHaveBeenCalledWith('/mock/home/.mfer/config.yaml', 'utf8');
+            expect(mockYaml.parse).toHaveBeenCalledWith('mock yaml content');
+        }));
+        it('should not load config when file does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockFs.existsSync.mockReturnValue(false);
+            const { loadConfig } = yield import('../config-utils.js');
+            loadConfig();
+            expect(loadConfig).toBeDefined();
+        }));
+    });
+    describe('warnOfMissingConfig', () => {
+        it('should display warning when config does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockFs.existsSync.mockReturnValue(false);
+            const { warnOfMissingConfig } = yield import('../config-utils.js');
+            warnOfMissingConfig();
+            expect(warnOfMissingConfig).toBeDefined();
+        }));
+        it('should not display warning when config exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockFs.existsSync.mockReturnValue(true);
+            const { warnOfMissingConfig } = yield import('../config-utils.js');
+            warnOfMissingConfig();
+            expect(warnOfMissingConfig).toBeDefined();
+        }));
+    });
+    describe('isConfigValid', () => {
+        it('should return false when config file does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockFs.existsSync.mockReturnValue(false);
+            const { isConfigValid } = yield import('../config-utils.js');
+            const result = isConfigValid();
+            expect(typeof result).toBe('boolean');
+        }));
+        it('should return false when YAML parsing fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue('invalid yaml');
+            mockYaml.parse.mockImplementation(() => {
+                throw new Error('Invalid YAML');
+            });
+            const { isConfigValid } = yield import('../config-utils.js');
+            const result = isConfigValid();
+            expect(result).toBe(false);
+        }));
+        it('should return false when config is missing required fields', () => __awaiter(void 0, void 0, void 0, function* () {
+            const invalidConfigs = [
+                null,
+                undefined,
+                {},
+                { base_github_url: 'https://github.com' },
+                { base_github_url: 'https://github.com', mfe_directory: '/path' },
+                { base_github_url: 'https://github.com', mfe_directory: '/path', groups: {} },
+                { base_github_url: 'https://github.com', mfe_directory: '/path', groups: { all: [] } }
+            ];
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue('mock yaml content');
+            const { isConfigValid } = yield import('../config-utils.js');
+            for (const config of invalidConfigs) {
+                mockYaml.parse.mockReturnValue(config);
+                const result = isConfigValid();
+                expect(result).toBeFalsy();
+                mockYaml.parse.mockClear();
+            }
+        }));
+        it('should return true when config has all required fields', () => __awaiter(void 0, void 0, void 0, function* () {
+            const validConfig = {
+                base_github_url: 'https://github.com',
+                mfe_directory: '/path/to/mfe',
+                groups: {
+                    all: ['app1', 'app2'],
+                    frontend: ['app1'],
+                    backend: ['app2']
+                }
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue('mock yaml content');
+            mockYaml.parse.mockReturnValue(validConfig);
+            const { isConfigValid } = yield import('../config-utils.js');
+            const result = isConfigValid();
+            expect(result).toBe(true);
+        }));
+    });
+    describe('saveConfig', () => {
+        it('should save config successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConfig = {
+                base_github_url: 'https://github.com',
+                mfe_directory: '/path/to/mfe',
+                groups: {
+                    all: ['app1', 'app2']
+                }
+            };
+            mockFs.existsSync.mockReturnValue(false);
+            mockYaml.stringify.mockReturnValue('mock yaml string');
+            const { saveConfig } = yield import('../config-utils.js');
+            saveConfig(mockConfig);
+            expect(mockPath.dirname).toHaveBeenCalledWith('/mock/home/.mfer/config.yaml');
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith('/mock/home/.mfer', { recursive: true });
+            expect(mockYaml.stringify).toHaveBeenCalledWith(mockConfig);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith('/mock/home/.mfer/config.yaml', 'mock yaml string');
+        }));
+        it('should create directory if it does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConfig = {
+                base_github_url: 'https://github.com',
+                mfe_directory: '/path/to/mfe',
+                groups: {
+                    all: ['app1', 'app2']
+                }
+            };
+            mockFs.existsSync.mockReturnValue(false);
+            mockYaml.stringify.mockReturnValue('mock yaml string');
+            const { saveConfig } = yield import('../config-utils.js');
+            saveConfig(mockConfig);
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith('/mock/home/.mfer', { recursive: true });
+        }));
+        it('should handle errors when saving config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConfig = {
+                base_github_url: 'https://github.com',
+                mfe_directory: '/path/to/mfe',
+                groups: {
+                    all: ['app1', 'app2']
+                }
+            };
+            const mockError = new Error('Write error');
+            mockFs.writeFileSync.mockImplementation(() => {
+                throw mockError;
+            });
+            const { saveConfig } = yield import('../config-utils.js');
+            saveConfig(mockConfig);
+            expect(saveConfig).toBeDefined();
+        }));
+    });
+    describe('editConfig', () => {
+        it('should open config file with default editor on Windows', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockOs.platform.mockReturnValue('win32');
+            const mockProcess = { env: {} };
+            vi.stubGlobal('process', mockProcess);
+            const mockSpawnInstance = {
+                unref: vi.fn()
+            };
+            mockSpawn.mockReturnValue(mockSpawnInstance);
+            const { editConfig } = yield import('../config-utils.js');
+            editConfig();
+            expect(mockSpawn).toHaveBeenCalledWith('notepad', ['/mock/home/.mfer/config.yaml'], {
+                stdio: 'ignore',
+                detached: true,
+                shell: true
+            });
+            expect(mockSpawnInstance.unref).toHaveBeenCalled();
+        }));
+        it('should use EDITOR environment variable when available', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockOs.platform.mockReturnValue('linux');
+            const mockProcess = { env: { EDITOR: 'vim' } };
+            vi.stubGlobal('process', mockProcess);
+            const mockSpawnInstance = {
+                unref: vi.fn()
+            };
+            mockSpawn.mockReturnValue(mockSpawnInstance);
+            const { editConfig } = yield import('../config-utils.js');
+            editConfig();
+            expect(mockSpawn).toHaveBeenCalledWith('vim', ['/mock/home/.mfer/config.yaml'], {
+                stdio: 'ignore',
+                detached: true,
+                shell: true
+            });
+        }));
+        it('should use VISUAL environment variable when EDITOR is not available', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockOs.platform.mockReturnValue('linux');
+            const mockProcess = { env: { VISUAL: 'code' } };
+            vi.stubGlobal('process', mockProcess);
+            const mockSpawnInstance = {
+                unref: vi.fn()
+            };
+            mockSpawn.mockReturnValue(mockSpawnInstance);
+            const { editConfig } = yield import('../config-utils.js');
+            editConfig();
+            expect(mockSpawn).toHaveBeenCalledWith('code', ['/mock/home/.mfer/config.yaml'], {
+                stdio: 'ignore',
+                detached: true,
+                shell: true
+            });
+        }));
+        it('should use vi as fallback on non-Windows platforms', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockOs.platform.mockReturnValue('linux');
+            const mockProcess = { env: {} };
+            vi.stubGlobal('process', mockProcess);
+            const mockSpawnInstance = {
+                unref: vi.fn()
+            };
+            mockSpawn.mockReturnValue(mockSpawnInstance);
+            const { editConfig } = yield import('../config-utils.js');
+            editConfig();
+            expect(mockSpawn).toHaveBeenCalledWith('vi', ['/mock/home/.mfer/config.yaml'], {
+                stdio: 'ignore',
+                detached: true,
+                shell: true
+            });
+        }));
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mfer",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "CLI tool designed to sensibly run micro-frontends from the terminal.",
   "bin": {
     "mfer": "dist/index.js"
@@ -9,7 +9,9 @@
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
-    "watch": "tsc --watch"
+    "watch": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "keywords": [
     "micro frontends",
@@ -38,7 +40,8 @@
   "devDependencies": {
     "@types/node": "^24.0.3",
     "rimraf": "^6.0.1",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.5.3",