@mbc-cqrs-serverless/cli 0.1.69-beta.0 → 0.1.71-beta.0

package/dist/actions/generate.action.spec.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_action_1 = __importDefault(require("./generate.action"));
+describe('Generate Action', () => {
+    const mockCommand = {
+        name: () => 'generate',
+        opts: () => ({
+            dryRun: false,
+            mode: 'async',
+            schema: true
+        })
+    };
+    const mockOptions = {
+        dryRun: false,
+        mode: 'async',
+        schema: true
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('Overview: Schematic generation functionality', () => {
+        describe('Purpose: Test basic generate action execution', () => {
+            it('should execute generate action without errors', async () => {
+                await expect((0, generate_action_1.default)('service', 'test-service', mockOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle different schematic types', async () => {
+                const schematicTypes = ['service', 'controller', 'entity', 'dto', 'module'];
+                for (const type of schematicTypes) {
+                    await expect((0, generate_action_1.default)(type, `test-${type}`, mockOptions, mockCommand)).resolves.not.toThrow();
+                }
+            });
+            it('should handle generate action with custom command options', async () => {
+                const customCommand = {
+                    ...mockCommand,
+                    opts: () => ({
+                        dryRun: true,
+                        mode: 'sync',
+                        schema: false
+                    })
+                };
+                await expect((0, generate_action_1.default)('service', 'custom-service', mockOptions, customCommand)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test dry-run functionality', () => {
+            it('should execute dry-run without making actual changes', async () => {
+                const dryRunCommand = {
+                    ...mockCommand,
+                    opts: () => ({
+                        dryRun: true,
+                        mode: 'async',
+                        schema: true
+                    })
+                };
+                await expect((0, generate_action_1.default)('service', 'test-service', mockOptions, dryRunCommand)).resolves.not.toThrow();
+            });
+            it('should handle dry-run with different modes', async () => {
+                const syncDryRunCommand = {
+                    ...mockCommand,
+                    opts: () => ({
+                        dryRun: true,
+                        mode: 'sync',
+                        schema: false
+                    })
+                };
+                await expect((0, generate_action_1.default)('controller', 'test-controller', mockOptions, syncDryRunCommand)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test error handling scenarios', () => {
+            it('should handle missing schematic name', async () => {
+                await expect((0, generate_action_1.default)('service', '', mockOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle undefined schematic name', async () => {
+                await expect((0, generate_action_1.default)('service', undefined, mockOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle invalid schematic type', async () => {
+                await expect((0, generate_action_1.default)('invalid-type', 'test-name', mockOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle undefined command', async () => {
+                await expect((0, generate_action_1.default)('service', 'test-service', mockOptions, undefined)).rejects.toThrow();
+            });
+        });
+        describe('Purpose: Test mode and schema options', () => {
+            it('should handle async mode with schema', async () => {
+                const asyncCommand = {
+                    ...mockCommand,
+                    opts: () => ({
+                        dryRun: false,
+                        mode: 'async',
+                        schema: true
+                    })
+                };
+                await expect((0, generate_action_1.default)('service', 'async-service', mockOptions, asyncCommand)).resolves.not.toThrow();
+            });
+            it('should handle sync mode without schema', async () => {
+                const syncCommand = {
+                    ...mockCommand,
+                    opts: () => ({
+                        dryRun: false,
+                        mode: 'sync',
+                        schema: false
+                    })
+                };
+                await expect((0, generate_action_1.default)('entity', 'sync-entity', mockOptions, syncCommand)).resolves.not.toThrow();
+            });
+            it('should handle noSchema option', async () => {
+                const noSchemaCommand = {
+                    ...mockCommand,
+                    opts: () => ({
+                        dryRun: false,
+                        mode: 'async',
+                        noSchema: true
+                    })
+                };
+                await expect((0, generate_action_1.default)('dto', 'no-schema-dto', mockOptions, noSchemaCommand)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test special characters and edge cases', () => {
+            it('should handle special characters in schematic names', async () => {
+                await expect((0, generate_action_1.default)('service', 'test-service_with-special.chars', mockOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle very long schematic names', async () => {
+                const longName = 'very-long-schematic-name-that-exceeds-normal-length-limits';
+                await expect((0, generate_action_1.default)('service', longName, mockOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle numeric schematic names', async () => {
+                await expect((0, generate_action_1.default)('service', '123-numeric-service', mockOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle empty command options', async () => {
+                const emptyCommand = {
+                    ...mockCommand,
+                    opts: () => ({})
+                };
+                await expect((0, generate_action_1.default)('service', 'test-service', mockOptions, emptyCommand)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test concurrent generation scenarios', () => {
+            it('should handle multiple concurrent generation requests', async () => {
+                const promises = [
+                    (0, generate_action_1.default)('service', 'service1', mockOptions, mockCommand),
+                    (0, generate_action_1.default)('controller', 'controller1', mockOptions, mockCommand),
+                    (0, generate_action_1.default)('entity', 'entity1', mockOptions, mockCommand)
+                ];
+                await expect(Promise.all(promises)).resolves.not.toThrow();
+            });
+            it('should maintain consistency across multiple calls', async () => {
+                const results = await Promise.all([
+                    (0, generate_action_1.default)('service', 'test-service', mockOptions, mockCommand),
+                    (0, generate_action_1.default)('service', 'test-service', mockOptions, mockCommand),
+                    (0, generate_action_1.default)('service', 'test-service', mockOptions, mockCommand)
+                ]);
+                results.forEach(result => {
+                    expect(result).toBeUndefined();
+                });
+            });
+        });
+    });
+});

package/dist/actions/start.action.spec.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const start_action_1 = __importDefault(require("./start.action"));
+describe('Start Action', () => {
+    describe('Overview: Application start functionality', () => {
+        describe('Purpose: Test basic start action execution', () => {
+            it('should execute start action without errors', async () => {
+                await expect((0, start_action_1.default)()).resolves.not.toThrow();
+            });
+            it('should handle start action consistently', async () => {
+                const result = await (0, start_action_1.default)();
+                expect(result).toBeUndefined();
+            });
+        });
+        describe('Purpose: Test start action behavior consistency', () => {
+            it('should maintain consistent behavior across multiple calls', async () => {
+                const results = await Promise.all([
+                    (0, start_action_1.default)(),
+                    (0, start_action_1.default)(),
+                    (0, start_action_1.default)()
+                ]);
+                results.forEach(result => {
+                    expect(result).toBeUndefined();
+                });
+            });
+            it('should handle concurrent start action calls', async () => {
+                const promises = Array(5).fill(null).map(() => (0, start_action_1.default)());
+                await expect(Promise.all(promises)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test start action error scenarios', () => {
+            it('should handle unexpected errors gracefully', async () => {
+                const originalConsoleError = console.error;
+                console.error = jest.fn();
+                try {
+                    await (0, start_action_1.default)();
+                    expect(console.error).not.toHaveBeenCalled();
+                }
+                finally {
+                    console.error = originalConsoleError;
+                }
+            });
+            it('should handle multiple rapid calls', async () => {
+                for (let i = 0; i < 10; i++) {
+                    await expect((0, start_action_1.default)()).resolves.not.toThrow();
+                }
+            });
+            it('should handle start action in different execution contexts', async () => {
+                await expect((0, start_action_1.default)()).resolves.not.toThrow();
+                setTimeout(async () => {
+                    await expect((0, start_action_1.default)()).resolves.not.toThrow();
+                }, 0);
+                setImmediate(async () => {
+                    await expect((0, start_action_1.default)()).resolves.not.toThrow();
+                });
+            });
+        });
+    });
+});

package/dist/actions/ui.action.spec.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ui_action_1 = __importDefault(require("./ui.action"));
+jest.mock('child_process');
+jest.mock('fs');
+jest.mock('path');
+describe('UI Action', () => {
+    const mockCommand = {
+        name: () => 'ui-common',
+        opts: () => ({})
+    };
+    const mockOptions = {
+        pathDir: './src/common',
+        branch: 'main',
+        auth: 'SSH',
+        component: 'all',
+        alias: false,
+        token: undefined
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('Overview: UI common component installation functionality', () => {
+        describe('Purpose: Test basic UI action execution', () => {
+            it('should execute UI action without errors', async () => {
+                await expect((0, ui_action_1.default)(mockOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle UI action with different command names', async () => {
+                const customCommand = { ...mockCommand, name: () => 'ui' };
+                await expect((0, ui_action_1.default)(mockOptions, customCommand)).resolves.not.toThrow();
+            });
+            it('should handle UI action with custom options', async () => {
+                const customOptions = {
+                    ...mockOptions,
+                    component: 'appsync',
+                    branch: 'develop'
+                };
+                await expect((0, ui_action_1.default)(customOptions, mockCommand)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test error handling scenarios', () => {
+            it('should handle invalid component option', async () => {
+                const invalidComponentOptions = {
+                    ...mockOptions,
+                    component: 'invalid-component'
+                };
+                await expect((0, ui_action_1.default)(invalidComponentOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle missing options', async () => {
+                await expect((0, ui_action_1.default)({}, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle undefined command', async () => {
+                await expect((0, ui_action_1.default)(mockOptions, undefined)).rejects.toThrow();
+            });
+        });
+        describe('Purpose: Test authentication options', () => {
+            it('should handle HTTPS authentication', async () => {
+                const httpsOptions = {
+                    ...mockOptions,
+                    auth: 'HTTPS',
+                    token: 'user:token123'
+                };
+                await expect((0, ui_action_1.default)(httpsOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle SSH authentication', async () => {
+                const sshOptions = {
+                    ...mockOptions,
+                    auth: 'SSH'
+                };
+                await expect((0, ui_action_1.default)(sshOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle HTTPS - Token authentication', async () => {
+                const httpsTokenOptions = {
+                    ...mockOptions,
+                    auth: 'HTTPS - Token',
+                    token: 'user:token123'
+                };
+                await expect((0, ui_action_1.default)(httpsTokenOptions, mockCommand)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test component installation options', () => {
+            it('should handle all components installation', async () => {
+                const allOptions = {
+                    ...mockOptions,
+                    component: 'all'
+                };
+                await expect((0, ui_action_1.default)(allOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle specific component installation', async () => {
+                const componentOptions = {
+                    ...mockOptions,
+                    component: 'component'
+                };
+                await expect((0, ui_action_1.default)(componentOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle appsync component installation', async () => {
+                const appsyncOptions = {
+                    ...mockOptions,
+                    component: 'appsync'
+                };
+                await expect((0, ui_action_1.default)(appsyncOptions, mockCommand)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test branch and path handling', () => {
+            it('should handle custom branch', async () => {
+                const customBranchOptions = {
+                    ...mockOptions,
+                    branch: 'develop'
+                };
+                await expect((0, ui_action_1.default)(customBranchOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle custom path directory', async () => {
+                const customPathOptions = {
+                    ...mockOptions,
+                    pathDir: './custom/path'
+                };
+                await expect((0, ui_action_1.default)(customPathOptions, mockCommand)).resolves.not.toThrow();
+            });
+            it('should handle alias option', async () => {
+                const aliasOptions = {
+                    ...mockOptions,
+                    alias: true
+                };
+                await expect((0, ui_action_1.default)(aliasOptions, mockCommand)).resolves.not.toThrow();
+            });
+        });
+        describe('Purpose: Test concurrent execution scenarios', () => {
+            it('should handle multiple concurrent UI action calls', async () => {
+                const promises = [
+                    (0, ui_action_1.default)(mockOptions, mockCommand),
+                    (0, ui_action_1.default)(mockOptions, mockCommand),
+                    (0, ui_action_1.default)(mockOptions, mockCommand)
+                ];
+                await expect(Promise.all(promises)).resolves.not.toThrow();
+            });
+            it('should maintain consistency across multiple calls', async () => {
+                const results = await Promise.all([
+                    (0, ui_action_1.default)(mockOptions, mockCommand),
+                    (0, ui_action_1.default)(mockOptions, mockCommand),
+                    (0, ui_action_1.default)(mockOptions, mockCommand)
+                ]);
+                results.forEach(result => {
+                    expect(result).toBeUndefined();
+                });
+            });
+        });
+    });
+});

package/dist/runners/abstract.runner.spec.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const events_1 = require("events");
+const abstract_runner_1 = require("./abstract.runner");
+jest.mock('child_process');
+describe('Abstract Runner', () => {
+    const mockSpawn = child_process_1.spawn;
+    let mockChildProcess;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockChildProcess = new events_1.EventEmitter();
+        mockChildProcess.stdout = new events_1.EventEmitter();
+        mockChildProcess.stderr = new events_1.EventEmitter();
+        mockSpawn.mockReturnValue(mockChildProcess);
+    });
+    describe('Overview: Base runner functionality for command execution', () => {
+        describe('Purpose: Test successful command execution', () => {
+            it('should execute command successfully with default options', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('npm', ['--version']);
+                const runPromise = runner.run('install');
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 0);
+                }, 10);
+                await expect(runPromise).resolves.toBeNull();
+                expect(mockSpawn).toHaveBeenCalledWith('npm', ['--version', 'install'], expect.any(Object));
+            });
+            it('should execute command with custom arguments', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('node', ['-v']);
+                const runPromise = runner.run('--help');
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 0);
+                }, 10);
+                await expect(runPromise).resolves.toBeNull();
+                expect(mockSpawn).toHaveBeenCalledWith('node', ['-v', '--help'], expect.any(Object));
+            });
+            it('should collect output when collectResult is true', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('echo', ['hello']);
+                const runPromise = runner.run('world', true);
+                setTimeout(() => {
+                    mockChildProcess.stdout.emit('data', Buffer.from('hello\n'));
+                }, 10);
+                const result = await runPromise;
+                expect(result).toBe('hello');
+            });
+        });
+        describe('Purpose: Test error handling scenarios', () => {
+            it('should handle command execution failure', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('invalid-command', []);
+                const runPromise = runner.run('test');
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 1);
+                }, 10);
+                await expect(runPromise).rejects.toBeUndefined();
+            });
+            it('should handle spawn errors', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('invalid-command', []);
+                const runPromise = runner.run('test');
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 1);
+                }, 10);
+                await expect(runPromise).rejects.toBeUndefined();
+            });
+            it('should handle stderr output as error', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('test-command', []);
+                const runPromise = runner.run('test');
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 1);
+                }, 10);
+                await expect(runPromise).rejects.toBeUndefined();
+            });
+        });
+        describe('Purpose: Test command string generation', () => {
+            it('should generate correct command string with binary and arguments', () => {
+                const runner = new abstract_runner_1.AbstractRunner('npm', ['install', '--save']);
+                const commandString = runner.rawFullCommand('test');
+                expect(commandString).toBe('npm install --save test');
+            });
+            it('should generate command string with empty arguments', () => {
+                const runner = new abstract_runner_1.AbstractRunner('node', []);
+                const commandString = runner.rawFullCommand('test');
+                expect(commandString).toBe('node test');
+            });
+            it('should handle arguments with spaces', () => {
+                const runner = new abstract_runner_1.AbstractRunner('echo', ['hello world', 'test']);
+                const commandString = runner.rawFullCommand('command');
+                expect(commandString).toBe('echo hello world test command');
+            });
+        });
+        describe('Purpose: Test output collection functionality', () => {
+            it('should collect stdout when collectResult is enabled', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('cat', ['file.txt']);
+                const runPromise = runner.run('test', true);
+                setTimeout(() => {
+                    mockChildProcess.stdout.emit('data', Buffer.from('line 1\n'));
+                }, 10);
+                const result = await runPromise;
+                expect(result).toBe('line 1');
+            });
+            it('should not collect output when collectResult is false', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('echo', ['test']);
+                const runPromise = runner.run('command', false);
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 0);
+                }, 10);
+                const result = await runPromise;
+                expect(result).toBeNull();
+            });
+            it('should handle empty stdout output', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('true', []);
+                const runPromise = runner.run('test', false);
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 0);
+                }, 10);
+                const result = await runPromise;
+                expect(result).toBeNull();
+            });
+        });
+        describe('Purpose: Test edge cases and error scenarios', () => {
+            it('should handle process exit with signal', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('test-command', []);
+                const runPromise = runner.run('test');
+                setTimeout(() => {
+                    mockChildProcess.emit('close', null, 'SIGTERM');
+                }, 10);
+                await expect(runPromise).rejects.toBeUndefined();
+            });
+            it('should handle multiple stderr chunks', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('test-command', []);
+                const runPromise = runner.run('test');
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 1);
+                }, 10);
+                await expect(runPromise).rejects.toBeUndefined();
+            });
+            it('should handle very long command arguments', async () => {
+                const longArgs = Array(100).fill('very-long-argument-name');
+                const runner = new abstract_runner_1.AbstractRunner('test-command', longArgs);
+                const commandString = runner.rawFullCommand('test');
+                expect(commandString).toContain('test-command');
+                expect(commandString.split(' ')).toHaveLength(102);
+            });
+        });
+        describe('Purpose: Test concurrent execution scenarios', () => {
+            it('should handle multiple runner instances', async () => {
+                const runner1 = new abstract_runner_1.AbstractRunner('echo', ['test1']);
+                const runner2 = new abstract_runner_1.AbstractRunner('echo', ['test2']);
+                const promise1 = runner1.run('command1');
+                const promise2 = runner2.run('command2');
+                setTimeout(() => {
+                    mockChildProcess.emit('close', 0);
+                }, 10);
+                const results = await Promise.all([promise1, promise2]);
+                expect(results).toEqual([null, null]);
+            });
+            it('should handle rapid successive runs', async () => {
+                const runner = new abstract_runner_1.AbstractRunner('echo', ['test']);
+                const promises = Array(5).fill(null).map((_, i) => {
+                    const promise = runner.run(`command${i}`);
+                    setTimeout(() => {
+                        mockChildProcess.emit('close', 0);
+                    }, 10 + i);
+                    return promise;
+                });
+                const results = await Promise.all(promises);
+                expect(results).toEqual([null, null, null, null, null]);
+            });
+        });
+    });
+});

package/dist/runners/schematic.runner.spec.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematic_runner_1 = require("./schematic.runner");
+const abstract_runner_1 = require("./abstract.runner");
+jest.mock('./abstract.runner');
+describe('Schematic Runner', () => {
+    const mockAbstractRunner = abstract_runner_1.AbstractRunner;
+    const mockRunnerInstance = {
+        run: jest.fn(),
+        rawFullCommand: jest.fn()
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockAbstractRunner.mockImplementation(() => mockRunnerInstance);
+    });
+    describe('Overview: Schematic execution runner functionality', () => {
+        describe('Purpose: Test basic schematic runner initialization', () => {
+            it('should create schematic runner without errors', () => {
+                expect(() => new schematic_runner_1.SchematicRunner()).not.toThrow();
+            });
+            it('should create schematic runner with default settings', () => {
+                expect(() => new schematic_runner_1.SchematicRunner()).not.toThrow();
+            });
+            it('should initialize AbstractRunner with correct binary path', () => {
+                new schematic_runner_1.SchematicRunner();
+                expect(mockAbstractRunner).toHaveBeenCalledWith('node', expect.arrayContaining([expect.stringContaining('schematics.js')]));
+            });
+        });
+        describe('Purpose: Test schematic command execution', () => {
+            it('should execute schematic command successfully', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                await runner.run('@mbc-cqrs-serverless/cli:service --name=test-service');
+                expect(mockRunnerInstance.run).toHaveBeenCalledWith('@mbc-cqrs-serverless/cli:service --name=test-service');
+            });
+            it('should handle complex schematic commands with multiple options', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                const command = '@mbc-cqrs-serverless/cli:service --name=test-service --mode=async --schema --dry-run';
+                await runner.run(command);
+                expect(mockRunnerInstance.run).toHaveBeenCalledWith(command);
+            });
+            it('should handle schematic commands with quoted arguments', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                const command = '@mbc-cqrs-serverless/cli:service --name="test service" --description="A test service"';
+                await runner.run(command);
+                expect(mockRunnerInstance.run).toHaveBeenCalledWith(command);
+            });
+        });
+        describe('Purpose: Test error handling scenarios', () => {
+            it('should handle schematic execution failure', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockRejectedValue(new Error('Schematic execution failed'));
+                await expect(runner.run('@mbc-cqrs-serverless/cli:service --name=test'))
+                    .rejects.toThrow('Schematic execution failed');
+            });
+            it('should handle empty command string', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                await runner.run('');
+                expect(mockRunnerInstance.run).toHaveBeenCalledWith('');
+            });
+            it('should handle undefined command', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                await runner.run(undefined);
+                expect(mockRunnerInstance.run).toHaveBeenCalledWith(undefined);
+            });
+        });
+        describe('Purpose: Test collection name handling', () => {
+            it('should use node binary with schematics path', () => {
+                new schematic_runner_1.SchematicRunner();
+                expect(mockAbstractRunner).toHaveBeenCalledWith('node', expect.arrayContaining([expect.stringContaining('schematics.js')]));
+            });
+            it('should initialize with node binary and schematics path', () => {
+                new schematic_runner_1.SchematicRunner();
+                expect(mockAbstractRunner).toHaveBeenCalledWith('node', expect.arrayContaining([expect.stringContaining('schematics.js')]));
+            });
+            it('should handle binary path resolution', () => {
+                new schematic_runner_1.SchematicRunner();
+                expect(mockAbstractRunner).toHaveBeenCalled();
+            });
+        });
+        describe('Purpose: Test binary path resolution', () => {
+            it('should resolve schematics binary path correctly', () => {
+                new schematic_runner_1.SchematicRunner();
+                const binaryPath = mockAbstractRunner.mock.calls[0][0];
+                expect(binaryPath).toBe('node');
+                const args = mockAbstractRunner.mock.calls[0][1];
+                expect(args[0]).toContain('schematics.js');
+            });
+            it('should handle different working directories', () => {
+                const originalCwd = process.cwd;
+                process.cwd = jest.fn().mockReturnValue('/custom/working/directory');
+                new schematic_runner_1.SchematicRunner();
+                expect(mockAbstractRunner).toHaveBeenCalled();
+                process.cwd = originalCwd;
+            });
+        });
+        describe('Purpose: Test command parsing and formatting', () => {
+            it('should handle command string correctly', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                await runner.run('collection:schematic --option1=value1 --option2 --option3=value3');
+                expect(mockRunnerInstance.run).toHaveBeenCalledWith('collection:schematic --option1=value1 --option2 --option3=value3');
+            });
+            it('should handle commands with no options', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                await runner.run('collection:schematic');
+                expect(mockRunnerInstance.run).toHaveBeenCalledWith('collection:schematic');
+            });
+            it('should handle commands with special characters', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                await runner.run('collection:schematic --name=test-service_v2.0');
+                expect(mockRunnerInstance.run).toHaveBeenCalledWith('collection:schematic --name=test-service_v2.0');
+            });
+        });
+        describe('Purpose: Test concurrent execution scenarios', () => {
+            it('should handle multiple concurrent schematic runs', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run.mockResolvedValue(undefined);
+                const promises = [
+                    runner.run('@mbc-cqrs-serverless/cli:service --name=service1'),
+                    runner.run('@mbc-cqrs-serverless/cli:controller --name=controller1'),
+                    runner.run('@mbc-cqrs-serverless/cli:entity --name=entity1')
+                ];
+                await Promise.all(promises);
+                expect(mockRunnerInstance.run).toHaveBeenCalledTimes(3);
+            });
+            it('should handle partial failure in concurrent runs', async () => {
+                const runner = new schematic_runner_1.SchematicRunner();
+                mockRunnerInstance.run
+                    .mockResolvedValueOnce(undefined)
+                    .mockRejectedValueOnce(new Error('Execution failed'))
+                    .mockResolvedValueOnce(undefined);
+                const promises = [
+                    runner.run('@mbc-cqrs-serverless/cli:service --name=service1'),
+                    runner.run('@mbc-cqrs-serverless/cli:controller --name=controller1'),
+                    runner.run('@mbc-cqrs-serverless/cli:entity --name=entity1')
+                ];
+                const results = await Promise.allSettled(promises);
+                expect(results[0].status).toBe('fulfilled');
+                expect(results[1].status).toBe('rejected');
+                expect(results[2].status).toBe('fulfilled');
+            });
+        });
+    });
+});

package/dist/schematics/schematic.option.spec.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematic_option_1 = require("./schematic.option");
+describe('Schematic Option', () => {
+    describe('Overview: Command option handling and formatting functionality', () => {
+        describe('Purpose: Test basic option creation and formatting', () => {
+            it('should create string option and format correctly', () => {
+                const option = new schematic_option_1.SchematicOption('name', 'test-service');
+                expect(option.toCommandString()).toBe('--name=test-service');
+            });
+            it('should create boolean option and format correctly', () => {
+                const option = new schematic_option_1.SchematicOption('dry-run', true);
+                expect(option.toCommandString()).toBe('--dry-run');
+            });
+            it('should create false boolean option and format correctly', () => {
+                const option = new schematic_option_1.SchematicOption('schema', false);
+                expect(option.toCommandString()).toBe('--no-schema');
+            });
+        });
+        describe('Purpose: Test name normalization functionality', () => {
+            it('should normalize camelCase names to kebab-case', () => {
+                const option = new schematic_option_1.SchematicOption('dryRun', true);
+                expect(option.normalizedName).toBe('dry-run');
+                expect(option.toCommandString()).toBe('--dry-run');
+            });
+            it('should normalize snake_case names correctly', () => {
+                const option = new schematic_option_1.SchematicOption('spec_file_suffix', 'spec');
+                expect(option.normalizedName).toBe('spec_file_suffix');
+            });
+            it('should handle already normalized names', () => {
+                const option = new schematic_option_1.SchematicOption('dry-run', true);
+                expect(option.normalizedName).toBe('dry-run');
+            });
+        });
+        describe('Purpose: Test special option handling', () => {
+            it('should handle name option with special formatting', () => {
+                const option = new schematic_option_1.SchematicOption('name', 'TestService');
+                expect(option.toCommandString()).toBe('--name=test-service');
+            });
+            it('should handle version option without quotes', () => {
+                const option = new schematic_option_1.SchematicOption('version', '1.0.0');
+                expect(option.toCommandString()).toBe('--version=1.0.0');
+            });
+            it('should handle path option without quotes', () => {
+                const option = new schematic_option_1.SchematicOption('path', './src/services');
+                expect(option.toCommandString()).toBe('--path=./src/services');
+            });
+            it('should handle other string options with quotes', () => {
+                const option = new schematic_option_1.SchematicOption('description', 'A test service');
+                expect(option.toCommandString()).toBe('--description="A test service"');
+            });
+        });
+        describe('Purpose: Test special character escaping', () => {
+            it('should escape parentheses in name values', () => {
+                const option = new schematic_option_1.SchematicOption('name', 'test(service)');
+                expect(option.toCommandString()).toBe('--name=test\\(service\\)');
+            });
+            it('should escape brackets in name values', () => {
+                const option = new schematic_option_1.SchematicOption('name', 'test[service]');
+                expect(option.toCommandString()).toBe('--name=test\\[service\\]');
+            });
+            it('should handle mixed special characters', () => {
+                const option = new schematic_option_1.SchematicOption('name', 'test(service)[v1]');
+                expect(option.toCommandString()).toBe('--name=test\\(service\\)\\[v1\\]');
+            });
+        });
+        describe('Purpose: Test edge cases and boundary conditions', () => {
+            it('should handle empty string values', () => {
+                const option = new schematic_option_1.SchematicOption('name', '');
+                expect(option.toCommandString()).toBe('--name=');
+            });
+            it('should handle numeric values', () => {
+                const option = new schematic_option_1.SchematicOption('port', 3000);
+                expect(option.toCommandString()).toBe('--port=3000');
+            });
+            it('should handle null values', () => {
+                const option = new schematic_option_1.SchematicOption('test', null);
+                expect(option.toCommandString()).toBe('--test=null');
+            });
+            it('should handle undefined values', () => {
+                const option = new schematic_option_1.SchematicOption('test', undefined);
+                expect(option.toCommandString()).toBe('--test=undefined');
+            });
+        });
+        describe('Purpose: Test complex option scenarios', () => {
+            it('should handle options with spaces in values', () => {
+                const option = new schematic_option_1.SchematicOption('description', 'A complex service description');
+                expect(option.toCommandString()).toBe('--description="A complex service description"');
+            });
+            it('should handle options with quotes in values', () => {
+                const option = new schematic_option_1.SchematicOption('description', 'A "quoted" description');
+                expect(option.toCommandString()).toBe('--description="A "quoted" description"');
+            });
+            it('should handle very long option names', () => {
+                const longName = 'veryLongOptionNameThatExceedsNormalLengthLimits';
+                const option = new schematic_option_1.SchematicOption(longName, 'value');
+                expect(option.normalizedName).toBe('very-long-option-name-that-exceeds-normal-length-limits');
+            });
+            it('should handle very long option values', () => {
+                const longValue = 'A'.repeat(1000);
+                const option = new schematic_option_1.SchematicOption('description', longValue);
+                expect(option.toCommandString()).toBe(`--description="${longValue}"`);
+            });
+        });
+        describe('Purpose: Test option type consistency', () => {
+            it('should maintain consistent formatting across multiple calls', () => {
+                const option = new schematic_option_1.SchematicOption('dry-run', true);
+                const result1 = option.toCommandString();
+                const result2 = option.toCommandString();
+                expect(result1).toBe(result2);
+                expect(result1).toBe('--dry-run');
+            });
+            it('should handle boolean toggle scenarios', () => {
+                const trueOption = new schematic_option_1.SchematicOption('feature', true);
+                const falseOption = new schematic_option_1.SchematicOption('feature', false);
+                expect(trueOption.toCommandString()).toBe('--feature');
+                expect(falseOption.toCommandString()).toBe('--no-feature');
+            });
+            it('should handle string vs boolean distinction', () => {
+                const stringOption = new schematic_option_1.SchematicOption('value', 'true');
+                const booleanOption = new schematic_option_1.SchematicOption('value', true);
+                expect(stringOption.toCommandString()).toBe('--value="true"');
+                expect(booleanOption.toCommandString()).toBe('--value');
+            });
+        });
+    });
+});

package/dist/ui/logger.spec.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./logger");
+describe('Logger Utilities', () => {
+    let originalConsole;
+    beforeEach(() => {
+        originalConsole = { ...console };
+        console.info = jest.fn();
+        console.log = jest.fn();
+        console.error = jest.fn();
+        console.warn = jest.fn();
+    });
+    afterEach(() => {
+        console.info = originalConsole.info;
+        console.log = originalConsole.log;
+        console.error = originalConsole.error;
+        console.warn = originalConsole.warn;
+    });
+    describe('Overview: CLI logging functionality', () => {
+        describe('Purpose: Test info logging methods', () => {
+            it('should log info messages with proper formatting', () => {
+                logger_1.logger.info('Test info message');
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Test info message'));
+            });
+            it('should handle multiple info messages', () => {
+                logger_1.logger.info('First message');
+                logger_1.logger.info('Second message');
+                expect(console.log).toHaveBeenCalledTimes(2);
+                expect(console.log).toHaveBeenNthCalledWith(1, expect.stringContaining('First message'));
+                expect(console.log).toHaveBeenNthCalledWith(2, expect.stringContaining('Second message'));
+            });
+            it('should handle empty info messages', () => {
+                logger_1.logger.info('');
+                expect(console.log).toHaveBeenCalledWith(expect.any(String));
+            });
+        });
+        describe('Purpose: Test error logging methods', () => {
+            it('should log error messages with proper formatting', () => {
+                logger_1.logger.error('Test error message');
+                expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Test error message'));
+            });
+            it('should handle error objects', () => {
+                const error = new Error('Test error');
+                logger_1.logger.error(error.message);
+                expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Test error'));
+            });
+            it('should handle multiple error messages', () => {
+                logger_1.logger.error('First error');
+                logger_1.logger.error('Second error');
+                expect(console.error).toHaveBeenCalledTimes(2);
+            });
+        });
+        describe('Purpose: Test warning logging methods', () => {
+            it('should log warning messages with proper formatting', () => {
+                logger_1.logger.warn('Test warning message');
+                expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Test warning message'));
+            });
+            it('should handle multiple warning messages', () => {
+                logger_1.logger.warn('First warning');
+                logger_1.logger.warn('Second warning');
+                expect(console.warn).toHaveBeenCalledTimes(2);
+            });
+        });
+        describe('Purpose: Test success and status logging methods', () => {
+            it('should log success messages with proper formatting', () => {
+                logger_1.logger.success('Operation completed successfully');
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Operation completed successfully'));
+            });
+            it('should log title messages with proper formatting', () => {
+                logger_1.logger.title('test', 'Processing...');
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Processing...'));
+            });
+        });
+        describe('Purpose: Test message formatting and special characters', () => {
+            it('should handle messages with special characters', () => {
+                const specialMessage = 'Message with @#$%^&*() characters';
+                logger_1.logger.info(specialMessage);
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining(specialMessage));
+            });
+            it('should handle messages with newlines', () => {
+                const multilineMessage = 'Line 1\nLine 2\nLine 3';
+                logger_1.logger.info(multilineMessage);
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining(multilineMessage));
+            });
+            it('should handle very long messages', () => {
+                const longMessage = 'A'.repeat(1000);
+                logger_1.logger.info(longMessage);
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining(longMessage));
+            });
+        });
+        describe('Purpose: Test logging with different data types', () => {
+            it('should handle string conversion of undefined messages', () => {
+                logger_1.logger.info(String(undefined));
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining('undefined'));
+            });
+            it('should handle string conversion of null messages', () => {
+                logger_1.logger.info(String(null));
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining('null'));
+            });
+            it('should handle string conversion of numeric messages', () => {
+                logger_1.logger.info(String(123));
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining('123'));
+            });
+            it('should handle string conversion of boolean messages', () => {
+                logger_1.logger.info(String(true));
+                expect(console.log).toHaveBeenCalledWith(expect.stringContaining('true'));
+            });
+        });
+        describe('Purpose: Test concurrent logging scenarios', () => {
+            it('should handle multiple concurrent log calls', () => {
+                const promises = [
+                    Promise.resolve(logger_1.logger.info('Concurrent message 1')),
+                    Promise.resolve(logger_1.logger.error('Concurrent error 1')),
+                    Promise.resolve(logger_1.logger.warn('Concurrent warning 1')),
+                    Promise.resolve(logger_1.logger.success('Concurrent success 1'))
+                ];
+                return Promise.all(promises).then(() => {
+                    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Concurrent message 1'));
+                    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Concurrent error 1'));
+                    expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Concurrent warning 1'));
+                    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Concurrent success 1'));
+                });
+            });
+            it('should maintain message order in rapid succession', () => {
+                logger_1.logger.info('Message 1');
+                logger_1.logger.info('Message 2');
+                logger_1.logger.info('Message 3');
+                expect(console.log).toHaveBeenCalledTimes(3);
+                expect(console.log).toHaveBeenNthCalledWith(1, expect.stringContaining('Message 1'));
+                expect(console.log).toHaveBeenNthCalledWith(2, expect.stringContaining('Message 2'));
+                expect(console.log).toHaveBeenNthCalledWith(3, expect.stringContaining('Message 3'));
+            });
+        });
+        describe('Purpose: Test error handling in logging methods', () => {
+            it('should handle console method failures gracefully', () => {
+                console.log = jest.fn().mockImplementation(() => {
+                    throw new Error('Console error');
+                });
+                expect(() => logger_1.logger.info('Test message')).toThrow('Console error');
+            });
+            it('should handle console method unavailability', () => {
+                const originalLog = console.log;
+                delete console.log;
+                expect(() => logger_1.logger.info('Test message')).not.toThrow();
+                console.log = originalLog;
+            });
+        });
+    });
+});

package/dist/utils/formatting.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatting_1 = require("./formatting");
+describe('Formatting Utilities', () => {
+    describe('Overview: String normalization functionality', () => {
+        describe('Purpose: Test normalizeToKebabOrSnakeCase with various input formats', () => {
+            it('should convert camelCase to kebab-case', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('camelCaseString')).toBe('camel-case-string');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('myTestVariable')).toBe('my-test-variable');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('XMLHttpRequest')).toBe('xmlhttp-request');
+            });
+            it('should convert PascalCase to kebab-case', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('PascalCaseString')).toBe('pascal-case-string');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('MyTestClass')).toBe('my-test-class');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('HTTPSConnection')).toBe('httpsconnection');
+            });
+            it('should handle strings with spaces', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('string with spaces')).toBe('string-with-spaces');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('Multiple   spaces   here')).toBe('multiple---spaces---here');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)(' leading and trailing spaces ')).toBe('-leading-and-trailing-spaces-');
+            });
+            it('should handle strings with underscores', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('snake_case_string')).toBe('snake_case_string');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('mixed_snake_camelCase')).toBe('mixed_snake_camel-case');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('__double__underscores__')).toBe('__double__underscores__');
+            });
+            it('should handle already kebab-case strings', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('kebab-case-string')).toBe('kebab-case-string');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('already-formatted')).toBe('already-formatted');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('single')).toBe('single');
+            });
+        });
+        describe('Purpose: Test edge cases and special characters', () => {
+            it('should handle empty inputs', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('')).toBe('');
+            });
+            it('should handle null and undefined inputs with error', () => {
+                expect(() => (0, formatting_1.normalizeToKebabOrSnakeCase)(null)).toThrow();
+                expect(() => (0, formatting_1.normalizeToKebabOrSnakeCase)(undefined)).toThrow();
+            });
+            it('should handle numeric strings', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('123')).toBe('123');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('version2')).toBe('version2');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('test123Variable')).toBe('test123-variable');
+            });
+            it('should handle special characters', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('test@email.com')).toBe('test@email.com');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('file.name.extension')).toBe('file.name.extension');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('path/to/file')).toBe('path/to/file');
+            });
+            it('should handle mixed case with numbers', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('HTML5Parser')).toBe('html5-parser');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('CSS3Styles')).toBe('css3-styles');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('API2Client')).toBe('api2-client');
+            });
+            it('should handle consecutive uppercase letters', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('XMLParser')).toBe('xmlparser');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('HTTPSRequest')).toBe('httpsrequest');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('JSONData')).toBe('jsondata');
+            });
+        });
+        describe('Purpose: Test boundary conditions', () => {
+            it('should handle very long strings', () => {
+                const longString = 'thisIsAVeryLongCamelCaseStringThatShouldBeConvertedToKebabCase';
+                const expected = 'this-is-avery-long-camel-case-string-that-should-be-converted-to-kebab-case';
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)(longString)).toBe(expected);
+            });
+            it('should handle single character strings', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('a')).toBe('a');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('A')).toBe('a');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('1')).toBe('1');
+            });
+            it('should handle strings with only special characters', () => {
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('___')).toBe('___');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('---')).toBe('---');
+                expect((0, formatting_1.normalizeToKebabOrSnakeCase)('...')).toBe('...');
+            });
+        });
+        describe('Purpose: Test performance with various input sizes', () => {
+            it('should handle repeated transformations consistently', () => {
+                const input = 'testCamelCaseString';
+                const expected = 'test-camel-case-string';
+                for (let i = 0; i < 100; i++) {
+                    expect((0, formatting_1.normalizeToKebabOrSnakeCase)(input)).toBe(expected);
+                }
+            });
+            it('should handle array of different string formats', () => {
+                const inputs = [
+                    'camelCase',
+                    'PascalCase',
+                    'snake_case',
+                    'kebab-case',
+                    'UPPERCASE',
+                    'lowercase',
+                    'Mixed_Format-String'
+                ];
+                const results = inputs.map(input => (0, formatting_1.normalizeToKebabOrSnakeCase)(input));
+                expect(results).toEqual([
+                    'camel-case',
+                    'pascal-case',
+                    'snake_case',
+                    'kebab-case',
+                    'uppercase',
+                    'lowercase',
+                    'mixed_format-string'
+                ]);
+            });
+        });
+    });
+});

package/dist/utils/local-binaries.spec.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const local_binaries_1 = require("./local-binaries");
+jest.mock('fs');
+jest.mock('path');
+describe('Local Binaries Utilities', () => {
+    const mockExistsSync = fs_1.existsSync;
+    const mockJoin = path_1.join;
+    const mockPosixJoin = path_1.posix.join;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockJoin.mockImplementation((...args) => args.join('/'));
+        mockPosixJoin.mockImplementation((...args) => args.join('/'));
+    });
+    describe('Overview: Local binary detection and loading functionality', () => {
+        describe('Purpose: Test localBinExists function', () => {
+            it('should return true when local binary exists', () => {
+                mockExistsSync.mockReturnValue(true);
+                const result = (0, local_binaries_1.localBinExists)();
+                expect(result).toBe(true);
+                expect(mockExistsSync).toHaveBeenCalledWith(expect.stringContaining('node_modules/@mbc-cqrs-serverless/cli'));
+            });
+            it('should return false when local binary does not exist', () => {
+                mockExistsSync.mockReturnValue(false);
+                const result = (0, local_binaries_1.localBinExists)();
+                expect(result).toBe(false);
+                expect(mockExistsSync).toHaveBeenCalledWith(expect.stringContaining('node_modules/@mbc-cqrs-serverless/cli'));
+            });
+            it('should handle file system errors gracefully', () => {
+                mockExistsSync.mockImplementation(() => {
+                    throw new Error('File system error');
+                });
+                expect(() => (0, local_binaries_1.localBinExists)()).toThrow('File system error');
+            });
+        });
+        describe('Purpose: Test loadLocalBinCommandLoader function', () => {
+            it('should successfully load command loader when binary exists', () => {
+                const mockCommandLoader = {
+                    loadCommands: jest.fn(),
+                    getCommand: jest.fn()
+                };
+                jest.doMock('node_modules/@mbc-cqrs-serverless/cli/dist/commands', () => mockCommandLoader, { virtual: true });
+                const result = (0, local_binaries_1.loadLocalBinCommandLoader)();
+                expect(result).toBeDefined();
+                expect(mockPosixJoin).toHaveBeenCalledWith(expect.any(String), 'node_modules', '@mbc-cqrs-serverless', 'cli', 'dist', 'commands');
+            });
+            it('should handle missing command loader module', () => {
+                jest.doMock('node_modules/@mbc-cqrs-serverless/cli/dist/commands', () => {
+                    throw new Error('Module not found');
+                }, { virtual: true });
+                expect(() => (0, local_binaries_1.loadLocalBinCommandLoader)()).not.toThrow();
+            });
+            it('should handle corrupted command loader module', () => {
+                jest.doMock('node_modules/@mbc-cqrs-serverless/cli/dist/commands', () => null, { virtual: true });
+                const result = (0, local_binaries_1.loadLocalBinCommandLoader)();
+                expect(result).toBeDefined();
+            });
+        });
+        describe('Purpose: Test path construction and resolution', () => {
+            it('should construct correct path segments for binary detection', () => {
+                mockExistsSync.mockReturnValue(true);
+                (0, local_binaries_1.localBinExists)();
+                expect(mockJoin).toHaveBeenCalledWith(process.cwd(), 'node_modules', '@mbc-cqrs-serverless', 'cli');
+            });
+            it('should construct correct posix path for command loader', () => {
+                const mockCommandLoader = {};
+                jest.doMock('node_modules/@mbc-cqrs-serverless/cli/dist/commands', () => mockCommandLoader, { virtual: true });
+                (0, local_binaries_1.loadLocalBinCommandLoader)();
+                expect(mockPosixJoin).toHaveBeenCalledWith(expect.any(String), 'node_modules', '@mbc-cqrs-serverless', 'cli', 'dist', 'commands');
+            });
+            it('should handle different working directories', () => {
+                const originalCwd = process.cwd;
+                process.cwd = jest.fn().mockReturnValue('/custom/working/directory');
+                mockExistsSync.mockReturnValue(true);
+                (0, local_binaries_1.localBinExists)();
+                expect(mockJoin).toHaveBeenCalledWith(expect.any(String), 'node_modules', '@mbc-cqrs-serverless', 'cli');
+                process.cwd = originalCwd;
+            });
+        });
+        describe('Purpose: Test error scenarios and edge cases', () => {
+            it('should handle permission denied errors', () => {
+                mockExistsSync.mockImplementation(() => {
+                    throw new Error('EACCES: permission denied');
+                });
+                expect(() => (0, local_binaries_1.localBinExists)()).toThrow('EACCES: permission denied');
+            });
+            it('should handle network drive or symlink issues', () => {
+                mockExistsSync.mockImplementation(() => {
+                    throw new Error('ENOTDIR: not a directory');
+                });
+                expect(() => (0, local_binaries_1.localBinExists)()).toThrow('ENOTDIR: not a directory');
+            });
+            it('should handle require cache issues in command loader', () => {
+                const mockCommandLoader = { cached: true };
+                jest.doMock('node_modules/@mbc-cqrs-serverless/cli/dist/commands', () => mockCommandLoader, { virtual: true });
+                const result1 = (0, local_binaries_1.loadLocalBinCommandLoader)();
+                const result2 = (0, local_binaries_1.loadLocalBinCommandLoader)();
+                expect(result1).toBe(result2);
+            });
+        });
+        describe('Purpose: Test integration scenarios', () => {
+            it('should work correctly when binary exists and command loader is available', () => {
+                mockExistsSync.mockReturnValue(true);
+                const mockCommandLoader = {
+                    loadCommands: jest.fn(),
+                    getCommand: jest.fn()
+                };
+                jest.doMock('node_modules/@mbc-cqrs-serverless/cli/dist/commands', () => mockCommandLoader, { virtual: true });
+                const binaryExists = (0, local_binaries_1.localBinExists)();
+                const commandLoader = (0, local_binaries_1.loadLocalBinCommandLoader)();
+                expect(binaryExists).toBe(true);
+                expect(commandLoader).toBeDefined();
+                expect(typeof commandLoader).toBe('object');
+            });
+            it('should handle scenario where binary exists but command loader fails', () => {
+                mockExistsSync.mockReturnValue(true);
+                jest.doMock('node_modules/@mbc-cqrs-serverless/cli/dist/commands', () => {
+                    throw new Error('Command loader initialization failed');
+                }, { virtual: true });
+                const binaryExists = (0, local_binaries_1.localBinExists)();
+                expect(binaryExists).toBe(true);
+                expect(() => (0, local_binaries_1.loadLocalBinCommandLoader)()).not.toThrow();
+            });
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mbc-cqrs-serverless/cli",
-  "version": "0.1.69-beta.0",
+  "version": "0.1.71-beta.0",
   "description": "a CLI to get started with MBC CQRS serverless framework",
   "keywords": [
     "mbc",
@@ -58,5 +58,5 @@
     "@faker-js/faker": "^8.3.1",
     "copyfiles": "^2.4.1"
   },
-  "gitHead": "0e61e7c464af48b5717bbbd0fb0c42acca7ac310"
+  "gitHead": "1af676f97241bb111fc56b8435e29e9b2c62e105"
 }