@simplens/onboard 1.0.9 → 1.0.11

package/src/__tests__/utils.test.ts

@@ -1,142 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'fs';
-import os from 'os';
-import path from 'path';
-import {
-    fileExists,
-    writeFile,
-    readFile,
-    appendFile,
-} from '../utils.js';
-
-describe('utils - file operations', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-        // Create a temporary directory for tests
-        tempDir = path.join(os.tmpdir(), `onboard-test-${Date.now()}`);
-        await fs.mkdir(tempDir, { recursive: true });
-    });
-
-    afterEach(async () => {
-        // Clean up temporary directory
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        } catch (error) {
-            // Ignore cleanup errors
-        }
-    });
-
-    describe('fileExists', () => {
-        it('should return true for existing file', async () => {
-            const filePath = path.join(tempDir, 'test.txt');
-            await fs.writeFile(filePath, 'content');
-
-            expect(await fileExists(filePath)).toBe(true);
-        });
-
-        it('should return false for non-existing file', async () => {
-            const filePath = path.join(tempDir, 'nonexistent.txt');
-
-            expect(await fileExists(filePath)).toBe(false);
-        });
-
-        it('should return true for existing directory', async () => {
-            expect(await fileExists(tempDir)).toBe(true);
-        });
-    });
-
-    describe('writeFile', () => {
-        it('should write content to file', async () => {
-            const filePath = path.join(tempDir, 'write-test.txt');
-            const content = 'Hello, World!';
-
-            await writeFile(filePath, content);
-
-            const written = await fs.readFile(filePath, 'utf-8');
-            expect(written).toBe(content);
-        });
-
-        it('should create parent directories if they do not exist', async () => {
-            const filePath = path.join(tempDir, 'nested', 'dir', 'file.txt');
-            const content = 'Nested content';
-
-            await writeFile(filePath, content);
-
-            expect(await fileExists(filePath)).toBe(true);
-            const written = await fs.readFile(filePath, 'utf-8');
-            expect(written).toBe(content);
-        });
-
-        it('should overwrite existing file', async () => {
-            const filePath = path.join(tempDir, 'overwrite.txt');
-            
-            await fs.writeFile(filePath, 'original');
-            await writeFile(filePath, 'new content');
-
-            const written = await fs.readFile(filePath, 'utf-8');
-            expect(written).toBe('new content');
-        });
-    });
-
-    describe('readFile', () => {
-        it('should read file content', async () => {
-            const filePath = path.join(tempDir, 'read-test.txt');
-            const content = 'File content to read';
-            await fs.writeFile(filePath, content);
-
-            const read = await readFile(filePath);
-
-            expect(read).toBe(content);
-        });
-
-        it('should throw error for non-existing file', async () => {
-            const filePath = path.join(tempDir, 'nonexistent.txt');
-
-            await expect(readFile(filePath)).rejects.toThrow();
-        });
-
-        it('should handle UTF-8 content', async () => {
-            const filePath = path.join(tempDir, 'utf8.txt');
-            const content = 'Hello 世界 🌍';
-            await fs.writeFile(filePath, content);
-
-            const read = await readFile(filePath);
-
-            expect(read).toBe(content);
-        });
-    });
-
-    describe('appendFile', () => {
-        it('should append content to existing file', async () => {
-            const filePath = path.join(tempDir, 'append-test.txt');
-            await fs.writeFile(filePath, 'Line 1\n');
-
-            await appendFile(filePath, 'Line 2\n');
-
-            const content = await fs.readFile(filePath, 'utf-8');
-            expect(content).toBe('Line 1\nLine 2\n');
-        });
-
-        it('should create file if it does not exist', async () => {
-            const filePath = path.join(tempDir, 'new-append.txt');
-
-            await appendFile(filePath, 'First line\n');
-
-            expect(await fileExists(filePath)).toBe(true);
-            const content = await fs.readFile(filePath, 'utf-8');
-            expect(content).toBe('First line\n');
-        });
-
-        it('should handle multiple appends', async () => {
-            const filePath = path.join(tempDir, 'multi-append.txt');
-
-            await appendFile(filePath, 'Line 1\n');
-            await appendFile(filePath, 'Line 2\n');
-            await appendFile(filePath, 'Line 3\n');
-
-            const content = await fs.readFile(filePath, 'utf-8');
-            expect(content).toBe('Line 1\nLine 2\nLine 3\n');
-        });
-    });
-});

package/src/__tests__/validators.test.ts

@@ -1,221 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { 
-    checkDockerInstalled, 
-    checkDockerRunning,
-    detectOS,
-    validatePrerequisites,
-    validateEnvValue,
-    validatePublicDomain,
-    validateEmailAddress
-} from '../validators.js';
-import {
-    DockerNotInstalledError,
-    DockerNotRunningError,
-    DockerPermissionError
-} from '../types/errors.js';
-
-// Mock execa
-vi.mock('execa', () => ({
-    execa: vi.fn(),
-}));
-
-// Mock utils
-vi.mock('../utils.js', () => ({
-    logError: vi.fn(),
-    logSuccess: vi.fn(),
-    logWarning: vi.fn(),
-}));
-
-import { execa } from 'execa';
-
-describe('validators', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    describe('checkDockerInstalled', () => {
-        it('should not throw when docker is installed', async () => {
-            vi.mocked(execa).mockResolvedValueOnce({
-                stdout: 'Docker version 24.0.0',
-                stderr: '',
-            } as any);
-
-            await expect(checkDockerInstalled()).resolves.not.toThrow();
-        });
-
-        it('should throw DockerNotInstalledError when docker is not installed', async () => {
-            vi.mocked(execa).mockRejectedValueOnce(new Error('Command not found'));
-
-            await expect(checkDockerInstalled()).rejects.toThrow(DockerNotInstalledError);
-        });
-    });
-
-    describe('checkDockerRunning', () => {
-        it('should not throw when docker daemon is running', async () => {
-            vi.mocked(execa).mockResolvedValueOnce({
-                stdout: 'CONTAINER ID   IMAGE',
-                stderr: '',
-            } as any);
-
-            await expect(checkDockerRunning()).resolves.not.toThrow();
-        });
-
-        it('should throw DockerPermissionError on permission denied', async () => {
-            const error = new Error('permission denied while trying to connect');
-            vi.mocked(execa).mockRejectedValueOnce(error);
-
-            await expect(checkDockerRunning()).rejects.toThrow(DockerPermissionError);
-        });
-
-        it('should throw DockerNotRunningError when daemon is not running', async () => {
-            const error = new Error('Cannot connect to the Docker daemon');
-            vi.mocked(execa).mockRejectedValueOnce(error);
-
-            await expect(checkDockerRunning()).rejects.toThrow(DockerNotRunningError);
-        });
-
-        it('should throw DockerNotRunningError on generic docker error', async () => {
-            const error = new Error('Some other docker error');
-            vi.mocked(execa).mockRejectedValueOnce(error);
-
-            await expect(checkDockerRunning()).rejects.toThrow(DockerNotRunningError);
-        });
-    });
-
-    describe('detectOS', () => {
-        const originalPlatform = process.platform;
-
-        afterEach(() => {
-            Object.defineProperty(process, 'platform', {
-                value: originalPlatform
-            });
-        });
-
-        it('should detect Windows', () => {
-            Object.defineProperty(process, 'platform', {
-                value: 'win32'
-            });
-            expect(detectOS()).toBe('windows');
-        });
-
-        it('should detect macOS', () => {
-            Object.defineProperty(process, 'platform', {
-                value: 'darwin'
-            });
-            expect(detectOS()).toBe('darwin');
-        });
-
-        it('should detect Linux', () => {
-            Object.defineProperty(process, 'platform', {
-                value: 'linux'
-            });
-            expect(detectOS()).toBe('linux');
-        });
-
-        it('should default to Linux for unknown platforms', () => {
-            Object.defineProperty(process, 'platform', {
-                value: 'freebsd'
-            });
-            expect(detectOS()).toBe('linux');
-        });
-    });
-
-    describe('validateEnvValue', () => {
-        describe('URL validation', () => {
-            it('should reject empty MongoDB URI', () => {
-                expect(validateEnvValue('MONGO_URI', '')).toBe(false);
-            });
-
-            it('should reject MongoDB URI without proper format', () => {
-                expect(validateEnvValue('MONGO_URI', 'localhost:27017')).toBe(false);
-            });
-
-            it('should accept valid MongoDB URI', () => {
-                expect(validateEnvValue('MONGO_URI', 'mongodb://localhost:27017')).toBe(true);
-            });
-
-            it('should reject Redis URL without proper format', () => {
-                expect(validateEnvValue('REDIS_URL', 'localhost:6379')).toBe(false);
-            });
-
-            it('should accept valid Redis URL', () => {
-                expect(validateEnvValue('REDIS_URL', 'redis://localhost:6379')).toBe(true);
-            });
-        });
-
-        describe('Port validation', () => {
-            it('should reject negative ports', () => {
-                expect(validateEnvValue('PORT', '-1')).toBe(false);
-            });
-
-            it('should reject zero port', () => {
-                expect(validateEnvValue('PORT', '0')).toBe(false);
-            });
-
-            it('should reject ports > 65535', () => {
-                expect(validateEnvValue('PORT', '65536')).toBe(false);
-            });
-
-            it('should accept valid ports', () => {
-                expect(validateEnvValue('PORT', '3000')).toBe(true);
-                expect(validateEnvValue('API_PORT', '8080')).toBe(true);
-            });
-
-            it('should reject non-numeric ports', () => {
-                expect(validateEnvValue('PORT', 'abc')).toBe(false);
-            });
-        });
-
-        describe('Security fields validation', () => {
-            it('should reject short API keys', () => {
-                expect(validateEnvValue('API_KEY', 'short')).toBe(false);
-            });
-
-            it('should reject short passwords', () => {
-                expect(validateEnvValue('PASSWORD', '1234567')).toBe(false);
-            });
-
-            it('should reject short secrets', () => {
-                expect(validateEnvValue('AUTH_SECRET', 'abc')).toBe(false);
-            });
-
-            it('should accept API keys with 8+ characters', () => {
-                expect(validateEnvValue('API_KEY', 'verylongapikey123')).toBe(true);
-            });
-
-            it('should accept passwords with 8+ characters', () => {
-                expect(validateEnvValue('PASSWORD', 'password123')).toBe(true);
-            });
-        });
-
-        describe('General validation', () => {
-            it('should accept valid non-special values', () => {
-                expect(validateEnvValue('SOME_VAR', 'some-value')).toBe(true);
-            });
-        });
-    });
-
-    describe('validatePublicDomain', () => {
-        it('accepts valid public domains', () => {
-            expect(validatePublicDomain('example.com')).toBe(true);
-            expect(validatePublicDomain('app.example.com')).toBe(true);
-        });
-
-        it('rejects urls or malformed values', () => {
-            expect(validatePublicDomain('https://example.com')).not.toBe(true);
-            expect(validatePublicDomain('example')).not.toBe(true);
-            expect(validatePublicDomain('example.com/path')).not.toBe(true);
-        });
-    });
-
-    describe('validateEmailAddress', () => {
-        it('accepts valid email addresses', () => {
-            expect(validateEmailAddress('admin@example.com')).toBe(true);
-        });
-
-        it('rejects invalid email values', () => {
-            expect(validateEmailAddress('admin@')).not.toBe(true);
-            expect(validateEmailAddress('not-an-email')).not.toBe(true);
-        });
-    });
-});

package/src/config/constants.ts

@@ -1,87 +0,0 @@
-/**
- * Application configuration constants
- */
-
-/**
- * Service port mappings
- */
-export const SERVICE_PORTS = {
-    API: 3000,
-    DASHBOARD: 3002,
-    GRAFANA: 3001,
-    KAFKA_UI: 8080,
-    MONGO: 27017,
-    KAFKA: 9092,
-    REDIS: 6379,
-    LOKI: 3100,
-} as const;
-
-/**
- * Health check configuration
- */
-export const HEALTH_CHECK = {
-    MAX_RETRIES: 30,
-    RETRY_DELAY_MS: 2000,
-    TIMEOUT_MS: 60000,
-} as const;
-
-/**
- * Docker command timeouts
- */
-export const DOCKER_TIMEOUTS = {
-    START_MS: 30000,
-    STOP_MS: 15000,
-    BUILD_MS: 300000,
-} as const;
-
-/**
- * Critical environment variables that always need user input
- */
-export const CRITICAL_ENV_KEYS = [
-    'NS_API_KEY',
-    'MONGO_URI',
-    'BROKERS',
-    'REDIS_URL',
-    'AUTH_SECRET',
-    'ADMIN_PASSWORD',
-    'CORE_VERSION',
-    'DASHBOARD_VERSION',
-];
-
-/**
- * Validation constraints
- */
-export const VALIDATION = {
-    MIN_PASSWORD_LENGTH: 8,
-    MIN_API_KEY_LENGTH: 8,
-    PORT_MIN: 1,
-    PORT_MAX: 65535,
-} as const;
-
-/**
- * File paths
- */
-export const FILES = {
-    DOCKER_COMPOSE_INFRA: 'docker-compose.infra.yaml',
-    DOCKER_COMPOSE_APP: 'docker-compose.yaml',
-    ENV_FILE: '.env',
-    CONFIG_FILE: 'simplens.config.yaml',
-    ERROR_LOG: 'onboard-error.log',
-} as const;
-
-/**
- * URL templates for service access
- */
-export function getServiceURL(service: keyof typeof SERVICE_PORTS, host: string = 'localhost'): string {
-    return `http://${host}:${SERVICE_PORTS[service]}`;
-}
-
-/**
- * Docker compose file paths
- */
-export const DOCKER_COMPOSE_COMMANDS = {
-    UP: ['up', '-d'],
-    DOWN: ['down'],
-    LOGS: ['logs', '-f'],
-    PS: ['ps'],
-} as const;

package/src/config/index.ts

@@ -1 +0,0 @@
-export * from './constants.js';