@orxataguy/tyr 1.0.0

package/src/lib/DockerManager.ts

@@ -0,0 +1,108 @@
+import { ShellManager } from './ShellManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+export interface DockerRunOptions {
+    image: string;
+    name: string;
+    port?: string;
+    env?: string[];
+}
+
+/**
+ * @class DockerManager
+ * @description Low-level manager for interacting with the Docker Daemon.
+ * Allows starting individual containers, checking states, and managing Docker Compose stacks.
+ */
+export class DockerManager {
+    private shell: ShellManager;
+    private logger: Logger;
+
+    constructor(shell: ShellManager, logger: Logger) {
+        this.shell = shell;
+        this.logger = logger;
+    }
+
+    /**
+     * @method isRunning
+     * @description Checks whether the Docker service is active and responding on the host system.
+     * @returns {Promise<boolean>} True if Docker is running.
+     * @example
+     * const active = await docker.isRunning();
+     * if (!active) fail('Start Docker first.');
+     */
+    public async isRunning(): Promise<boolean> {
+        try {
+            await this.shell.exec('docker info');
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * @method run
+     * @description Deploys an individual container in detached mode. If it already exists, restarts it.
+     * @param {DockerRunOptions} config - Deployment configuration.
+     * @example
+     * await docker.run({ name: 'my-db', image: 'mongo:latest', port: '27017:27017' });
+     */
+    public async run({ image, name, port, env = [] }: DockerRunOptions): Promise<void> {
+        this.logger.info(`Starting container: ${name} (${image})...`);
+        try {
+            if (await this.containerExists(name)) {
+                this.logger.warn(`Container ${name} already exists. Restarting...`);
+                await this.shell.exec(`docker rm -f ${name}`);
+            }
+
+            const envFlags = env.map(e => `-e ${e}`).join(' ');
+            const portMapping = port ? `-p ${port}` : '';
+            const containerId = await this.shell.exec(`docker run -d --name ${name} ${portMapping} ${envFlags} ${image}`);
+            this.logger.success(`Container active. ID: ${containerId.substring(0, 12)}`);
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not start container: ${name}`, e, 'Check that Docker is running and the image exists.');
+        }
+    }
+
+    /**
+     * @method containerExists
+     * @description Checks whether a specific container exists (running or stopped).
+     * @param {string} name - The container name to look for.
+     * @returns {Promise<boolean>} True if it exists.
+     * @example
+     * if (await docker.containerExists('my-app')) { ... }
+     */
+    public async containerExists(name: string): Promise<boolean> {
+        try {
+            await this.shell.exec(`docker inspect ${name}`);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * @method composeUp
+     * @description Starts a full stack using a docker-compose file.
+     * @param {string} file - Relative path to the compose file.
+     * @example
+     * await docker.composeUp('infrastructure/db-compose.yml');
+     */
+    public async composeUp(file: string = 'docker-compose.yml'): Promise<void> {
+        this.logger.info(`Starting stack from ${file}...`);
+        try {
+            await this.shell.exec(`docker-compose -f ${file} up -d`);
+            this.logger.success('Stack deployed successfully.');
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not start Docker Compose stack from: ${file}`, e, 'Check that the compose file exists and is valid.');
+        }
+    }
+}
+
+export const DockerManagerTests = {
+    // isRunning: {},
+    // run: { image: 'alpine:latest', name: 'tyr-test-container', env: [] },
+    // containerExists: { name: 'tyr-test-container' },
+};

package/src/lib/FileSystemManager.ts

@@ -0,0 +1,152 @@
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class FileSystemManager
+ * @description Abstraction layer over the file system (fs).
+ * Includes safety utilities such as automatic backups when overwriting and idempotent writes.
+ */
+export class FileSystemManager {
+    private logger: Logger;
+
+    constructor(logger: Logger) {
+        this.logger = logger;
+    }
+
+    private resolvePath(filePath: string): string {
+        return filePath.startsWith('~/')
+            ? path.join(homedir(), filePath.slice(2))
+            : filePath;
+    }
+
+    /**
+     * @method exists
+     * @description Synchronously checks whether a file or directory exists at the given path.
+     * @param {string} filePath - Relative or absolute path to check.
+     * @returns {boolean} True if the file exists.
+     * @example
+     * if (fs.exists('./config.json')) {
+     *   logger.info('Config found.');
+     * }
+     */
+    public exists(filePath: string): boolean {
+        const resolvedPath = this.resolvePath(filePath);
+        return existsSync(resolvedPath);
+    }
+
+    /**
+     * @method read
+     * @description Reads the content of a file in UTF-8 format. Returns null if the file does not exist.
+     * @param {string} filePath - Path to the file.
+     * @returns {Promise<string|null>} File content or null if it does not exist.
+     * @example
+     * const content = await fs.read('.env');
+     */
+    public async read(filePath: string): Promise<string | null> {
+        const resolvedPath = this.resolvePath(filePath);
+        try {
+            return await fs.readFile(resolvedPath, 'utf-8');
+        } catch (e) {
+            if ((e as NodeJS.ErrnoException).code === 'ENOENT') return null;
+            throw new TyrError(`Could not read file: ${filePath}`, e, 'Check that the file exists and has read permissions.');
+        }
+    }
+
+    /**
+     * @method delete
+     * @description Deletes a file if it exists.
+     * @param {string} filePath - Path to the file to delete.
+     * @example
+     * await fs.delete('./temp/cache.log');
+     */
+    public async delete(filePath: string): Promise<void> {
+        const resolvedPath = this.resolvePath(filePath);
+        if (!this.exists(resolvedPath)) {
+            throw new TyrError(`Cannot delete: file not found: ${filePath}`, null, 'Check that the path is correct.');
+        }
+        try {
+            await fs.unlink(resolvedPath);
+            this.logger.success(`File deleted: ${filePath}`);
+        } catch (e) {
+            throw new TyrError(`Could not delete file: ${filePath}`, e);
+        }
+    }
+
+    /**
+     * @method write
+     * @description Writes content to a file. If the file already exists, creates a .bak backup before overwriting.
+     * @param {string} filePath - Destination path.
+     * @param {string} content - Text content to write.
+     * @example
+     * await fs.write('src/config.js', 'export const port = 3000;');
+     */
+    public async write(filePath: string, content: string): Promise<void> {
+        const resolvedPath = this.resolvePath(filePath);
+        try {
+            const dir = path.dirname(resolvedPath);
+            await fs.mkdir(dir, { recursive: true });
+
+            if (this.exists(resolvedPath)) {
+                const backupPath = `${resolvedPath}.bak`;
+                await fs.copyFile(resolvedPath, backupPath);
+                this.logger.info(`Backup created at: ${backupPath}`);
+            }
+
+            await fs.writeFile(resolvedPath, content, 'utf-8');
+            this.logger.success(`File written: ${filePath}`);
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not write file: ${filePath}`, e, 'Check write permissions on the destination directory.');
+        }
+    }
+
+    /**
+     * @method createDir
+     * @description Creates a directory recursively (like mkdir -p). Does nothing if it already exists.
+     * @param {string} dirPath - Path of the directory to create.
+     * @example
+     * await fs.createDir('src/controllers/api/v1');
+     */
+    public async createDir(dirPath: string): Promise<void> {
+        const resolvedPath = this.resolvePath(dirPath);
+        if (this.exists(resolvedPath)) return;
+        try {
+            await fs.mkdir(resolvedPath, { recursive: true });
+            this.logger.info(`Directory created: ${dirPath}`);
+        } catch (e) {
+            throw new TyrError(`Could not create directory: ${dirPath}`, e, 'Check write permissions on the parent directory.');
+        }
+    }
+
+    /**
+     * @method ensureLine
+     * @description Ensures that a specific line exists in a file. Useful for adding environment variables or config entries without duplicating them.
+     * @param {string} filePath - Path to the file.
+     * @param {string} line - The exact line to ensure.
+     * @example
+     * await fs.ensureLine('.env', 'PORT=8080');
+     */
+    public async ensureLine(filePath: string, line: string): Promise<void> {
+        const resolvedPath = this.resolvePath(filePath);
+        const content = (await this.read(resolvedPath)) || '';
+        if (content.includes(line)) {
+            this.logger.info(`Line already present in ${filePath}. Skipping.`);
+            return;
+        }
+        const newContent = content.endsWith('\n') ? content + line : content + '\n' + line;
+        await this.write(filePath, newContent);
+    }
+}
+
+export const FileSystemManagerTests = {
+    exists: { filePath: '~/Projects/TyrFramework/package.json' },
+    read:   { filePath: '~/Projects/TyrFramework/package.json' },
+    write:  { filePath: '~/Projects/TyrFramework/tests/foo.test.txt', content: 'Test content from TyrFramework' },
+    delete: { filePath: '~/Projects/TyrFramework/tests/foo.test.txt' },
+    ensureLine: { filePath: '~/Projects/TyrFramework/package.json', line: '"type": "module",' },
+};

package/src/lib/GitManager.ts

@@ -0,0 +1,76 @@
+import { ShellManager } from './ShellManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class GitManager
+ * @description Wrapper for common Git operations. Automates repository initialization, commits and cloning.
+ */
+export class GitManager {
+    private shell: ShellManager;
+    private logger: Logger;
+
+    constructor(shell: ShellManager, logger: Logger) {
+        this.shell = shell;
+        this.logger = logger;
+    }
+
+    /**
+     * @method init
+     * @description Initializes a Git repository in the current directory and renames the default branch to 'main'.
+     * @example
+     * await git.init();
+     */
+    public async init(): Promise<void> {
+        try { await this.shell.exec('git init'); await this.shell.exec('git branch -M main'); } catch (e) {
+            throw new TyrError(`Could not init git repository`, e, 'Check if the current directory still exists.');
+        }
+    }
+
+    /**
+     * @method addAll
+     * @description Stages all files in the current directory (git add .).
+     * @example
+     * await git.addAll();
+     */
+    public async addAll(): Promise<void> {
+        await this.shell.exec('git add .');
+    }
+
+    /**
+     * @method commit
+     * @description Creates a commit with the provided message.
+     * @param {string} message - The commit message.
+     * @example
+     * await git.commit("feat: initial project structure");
+     */
+    public async commit(message: string): Promise<void> {
+        await this.shell.exec(`git commit -m "${message}"`);
+        this.logger.success(`Commit created: "${message}"`);
+    }
+
+    /**
+     * @method clone
+     * @description Clones a remote repository into the current directory.
+     * @param {string} repoUrl - The HTTPS or SSH URL of the repository.
+     * @example
+     * await git.clone('https://github.com/user/repo.git');
+     */
+    public async clone(repoUrl: string): Promise<void> {
+        this.logger.info(`Cloning ${repoUrl}...`);
+        try {
+            await this.shell.exec(`git clone ${repoUrl}`);
+        } catch (e) {
+            throw new TyrError(`Could not find the repository ` + repoUrl, e, 'Check if the repository exists or if you have the right permissions to clone it.');
+        }
+    }
+}
+
+/**
+ * @object GitManagerTests
+ * @description Test parameters to validate GitManager functionality.
+ */
+export const GitManagerTests = {
+    init: { directory: '/tmp/tyr-git-test' },
+    addAll: { directory: '/tmp/tyr-git-test' },
+};

package/src/lib/PackageManager.ts

@@ -0,0 +1,87 @@
+import { ShellManager } from './ShellManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class PackageManager
+ * @description OS-agnostic package manager. Automatically detects whether the system uses apt, brew or dnf and installs native software.
+ */
+export class PackageManager {
+    private shell: ShellManager;
+    private logger: Logger;
+    private manager: string | null;
+
+    constructor(shell: ShellManager, logger: Logger) {
+        this.shell = shell;
+        this.logger = logger;
+        this.manager = null;
+    }
+
+    /**
+     * @method detect
+     * @description Attempts to identify the package manager installed on the host system.
+     * @returns {Promise<string>} The name of the detected binary ('apt', 'brew', 'dnf').
+     * @example
+     * const mgr = await pkg.detect();
+     * logger.info(`Using: ${mgr}`);
+     */
+    public async detect(): Promise<string> {
+        if (this.manager) return this.manager;
+
+        const isWindows = process.platform === 'win32';
+        const checkCmd = isWindows ? 'where' : 'which';
+
+        const candidates: [string, string][] = isWindows
+            ? [['winget', 'winget'], ['choco', 'choco'], ['scoop', 'scoop']]
+            : [['apt-get', 'apt'], ['brew', 'brew'], ['dnf', 'dnf']];
+
+        for (const [bin, name] of candidates) {
+            try {
+                await this.shell.exec(`${checkCmd} ${bin}`);
+                this.manager = name;
+                return name;
+            } catch (e) {}
+        }
+
+        throw new TyrError(
+            'No supported package manager detected.',
+            null,
+            isWindows
+                ? 'Install winget (Windows Package Manager), Chocolatey, or Scoop.'
+                : 'Make sure apt, brew or dnf is installed on your system.'
+        );
+    }
+
+    /**
+     * @method install
+     * @description Installs a system package using the detected package manager.
+     * @param {string} packageName - Name of the package to install (e.g. 'nginx', 'python3').
+     * @example
+     * await pkg.install('nginx');
+     */
+    public async install(packageName: string): Promise<void> {
+        const mgr = await this.detect();
+        this.logger.info(`Installing ${packageName} using ${mgr}...`);
+
+        const commands: Record<string, string> = {
+            apt: `sudo apt-get install -y ${packageName}`,
+            brew: `brew install ${packageName}`,
+            dnf: `sudo dnf install -y ${packageName}`,
+            winget: `winget install ${packageName}`,
+            choco: `choco install -y ${packageName}`,
+            scoop: `scoop install ${packageName}`,
+        };
+
+        try {
+            await this.shell.exec(commands[mgr]);
+            this.logger.success(`Package ${packageName} installed.`);
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not install package: ${packageName}`, e, `Try running the install command manually with ${mgr}.`);
+        }
+    }
+}
+
+export const PackageManagerTests = {
+    detect: {},
+};

package/src/lib/SQLManager.ts

@@ -0,0 +1,121 @@
+import 'dotenv/config';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import sql, { config as SQLConfig } from 'mssql';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+dotenv.config({ path: path.resolve(__dirname, '../../.env') });
+
+/**
+ * @class SQLManager
+ * @description Conector con la base de datos SQL Server.
+ */
+export class SQLManager {
+  private pool!: sql.ConnectionPool;
+  private connected = false;
+
+  constructor() {
+  }
+
+  private async init(): Promise<void> {
+    if (!this.connected) {
+
+      const db_config: SQLConfig = {
+        user: process.env.MSSQL_USER,
+        password: process.env.MSSQL_PASSWORD,
+        server: process.env.MSSQL_SERVER || '',
+        database: process.env.MSSQL_DATABASE,
+        options: {
+          encrypt: false,
+          trustServerCertificate: true
+        }
+      };
+
+      this.pool = await sql.connect(db_config);
+      this.connected = true;
+    }
+  }
+
+  /**
+   * @method select
+   * @description Ejecuta un comando SELECT en SQL Server y devuelve el resultado como JSON.
+   * @param {string} query - El comando SELECT completo.
+   * @returns {Promise<any[]>} Los registros del resultado.
+   * @example
+   * await dbManager.init();
+   * const data = await dbManager.select('SELECT * FROM tabla');
+   */
+  public async select(query: string): Promise<any[]> {
+    await this.init();
+
+    const result = await this.pool.request().query(query);
+
+    await this.close();
+    return result.recordset;
+  }
+
+  /**
+   * @method searchBrokerOnDB
+   * @description Busca broker por hostname usando la query encoded.
+   * @param {string | URL} url - URL o string para extraer hostname.
+   * @returns {Promise<string>} Nombre del broker.
+   * @example
+   * const broker = await db.searchBrokerOnDB('https://www.foo.com');
+   */
+  public async searchBrokerOnDB(url: string | URL): Promise<string> {
+    let urlString = url.toString();
+
+    if (!urlString.startsWith("http://") && !urlString.startsWith("https://")) {
+      urlString = "https://" + urlString;
+    }
+    let urlObj = new URL(urlString).hostname;
+
+    if (urlObj.split('.').length < 3) {
+      urlObj = ['www', urlObj].join('.');
+    }
+
+    const isWeb = urlObj.startsWith('www') ||
+      urlObj.startsWith('horizon') ||
+      urlObj.startsWith('ambiance') ||
+      urlObj.startsWith('panorama') ||
+      urlObj.startsWith('flow') ||
+      urlObj.startsWith('panorama') ||
+      urlObj.startsWith('avantio') ||
+      urlObj.startsWith('demo');
+
+
+    const query = isWeb ? `SELECT basedir as BROKER from ftpUsers where CONCAT(prefijo, '.', dominio) = '${urlObj}'` : `SELECT LOGIN_DS AS BROKER from CR_CANALVENTAS WHERE WEB_DS = '${urlObj}'`;
+
+    await this.init();
+
+    const result = await this.pool.request().query(query);
+
+    await this.close();
+
+    if (!result.recordset[0] || !result.recordset[0].BROKER) {
+      throw new Error(`No se encontró broker para ${urlObj}`);
+    }
+
+    return result.recordset[0].BROKER as string;
+  }
+
+  private async close(): Promise<void> {
+    if (this.connected && this.pool) {
+      await this.pool.close();
+      this.connected = false;
+    }
+  }
+}
+
+/**
+ * @object SQLManagerTests
+ * @description Parámetros de pruebas para validar la funcionalidad de SQLManager.
+ */
+export const SQLManagerTests = {
+    // init: {},
+    // select: { query: 'SELECT 1 as test_value' },
+    // connectionPool: { queries: ['SELECT 1 as q1', 'SELECT 2 as q2', 'SELECT 3 as q3'] }
+};

package/src/lib/ShellManager.ts

@@ -0,0 +1,118 @@
+import { execa } from 'execa';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import inquirer from 'inquirer';
+
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class ShellManager
+ * @description Terminal command executor. Maintains the working directory (CWD) state to chain commands in specific folders.
+ */
+export class ShellManager {
+    private cwd: string;
+
+    constructor() {
+        this.cwd = process.cwd();
+    }
+
+    /**
+     * @method exec
+     * @description Executes a command in the system shell and returns the standard output.
+     * @param {string} command - The full command to execute.
+     * @returns {Promise<string>} The command output (stdout) trimmed of extra whitespace.
+     * @example
+     * const version = await shell.exec('node -v');
+     */
+    public async exec(command: string): Promise<string> {
+        try {
+            const result = await execa(command, { shell: true, cwd: this.cwd });
+            return result.stdout.trim();
+        } catch (e) {
+            throw new TyrError(`An error occurred while executing the command: ${command}`, e);
+        }
+    }
+
+    /**
+    * @method showLoader
+    * @description Displays a spinner loader in the terminal.
+    * @param {string} message - Informational text to show alongside the spinner.
+    * @returns {void}
+    * @example
+    * shell.showLoader('Loading...');
+    */
+    public showLoader = (message: string): { stop: () => void } => {
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let i = 0;
+        let stopped = false;
+
+        const interval = setInterval(() => {
+            if (!stopped) {
+                process.stdout.write(`\r${frames[i]} ${message}`);
+                i = (i + 1) % frames.length;
+            }
+        }, 80);
+
+        return {
+            stop: () => {
+                stopped = true;
+                clearInterval(interval);
+                process.stdout.write('\r');
+            }
+        };
+    };
+
+    /**
+     * @method input
+     * @description Prompts the user for a value via CLI.
+     * @param {string} question - Informational text shown as the prompt.
+     * @returns {Promise<string>} The value entered by the user.
+     * @example
+     * const name = await shell.input("What's your name?");
+     */
+    public async input(question: string): Promise<string> {
+        try {
+            const result = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'value',
+                    message: question,
+                },
+            ]);
+
+            return result.value.trim();
+        } catch (e) {
+            throw new TyrError(`An error occurred while prompting the question: ${question}`, e);
+        }
+    }
+
+    /**
+     * @method cd
+     * @description Changes the internal working directory for subsequent commands executed by this instance.
+     * @param {string} path - Absolute or relative path to change to.
+     * @example
+     * shell.cd('./backend');
+     * await shell.exec('npm install'); // Runs inside /backend
+     */
+    public cd(path: string): void {
+        let expandedPath = path;
+        if (path.startsWith('~/')) {
+            expandedPath = path.replace('~', homedir());
+        } else if (path === '~') {
+            expandedPath = homedir();
+        }
+
+        this.cwd = resolve(this.cwd, expandedPath);
+    }
+}
+
+/**
+ * @object ShellManagerTests
+ * @description Test parameters to validate ShellManager functionality.
+ */
+export const ShellManagerTests = {
+    exec: { command: 'node -v' },
+    cd: { path: '/tmp' },
+    input: { question: 'Enter a test value:' },
+    showLoader: { message: 'Loading test...' }
+};