¿Qué es TypeORM en los Frameworks Backend?

by | Mar 11, 2026 | Full Stack Web Developer, PHP, SQL, TypeScript | 0 comments

Introducción

Cuando comencé en el desarrollo de aplicaciones, mi primer lenguaje de programación fue PHP. En esa época, al trabajar con bases de datos, el proceso consistía en escribir manualmente las consultas en SQL, establecer las conexiones, preparar los parámetros y ejecutar cada operación directamente en el código. Al inicio esto era bastante interesante, ya que me permitía entender claramente cómo funcionaban las consultas y cómo interactuaba la aplicación con la base de datos.

<?php
require_once "models/dbconnection.php";

class Datos extends Connection {
    /*Accounts Registration*/
    public static function AccountsRegistrationsModel($name, $email, $phone, $password) {
        $db = Connection::MarbustDBConnect();
        $sql = 'INSERT INTO marbust_accounts (accountName, accountEmail, accountPhone, accountPassword) VALUES (:accountName, :accountEmail, :accountPhone, :accountPassword)';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':accountName', $name, PDO::PARAM_STR);
        $stmt->bindValue(':accountEmail', $email, PDO::PARAM_STR);
        $stmt->bindValue(':accountPhone', $phone, PDO::PARAM_STR);
        $stmt->bindValue(':accountPassword', $password, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
    public static function checkExistingEmail($email) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT accountEmail FROM marbust_accounts WHERE accountEmail = :email';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':email', $email, PDO::PARAM_STR);
        $stmt->execute();
        $matchEmail = $stmt->fetch(PDO::FETCH_NUM);
        $stmt->closeCursor();
        if(empty($matchEmail)){
         return 0;
        } else {
         return 1;
        }
    }
    public static function checkExistingPhone($phone) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT accountPhone FROM marbust_accounts WHERE accountPhone = :phone';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':phone', $phone, PDO::PARAM_STR);
        $stmt->execute();
        $matchPhone = $stmt->fetch(PDO::FETCH_NUM);
        $stmt->closeCursor();
        if(empty($matchPhone)){
         return 0;
        } else {
         return 1;
        }
    }
    
    public static function checkExistingId($idtotransfer) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT MarbustAccountId FROM marbust_accounts WHERE MarbustAccountId = :id';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':id', $idtotransfer, PDO::PARAM_STR);
        $stmt->execute();
        $matchId = $stmt->fetch(PDO::FETCH_NUM);
        $stmt->closeCursor();
        if(empty($matchId)){
         return 0;
        } else {
         return 1;
        }
    }
    
    public static function getUser($email) {
    $db = Connection::MarbustDBConnect();
    $sql = 'SELECT MarbustAccountId, accountName, accountEmail, accountPhone, accountPassword FROM marbust_accounts WHERE accountEmail = :email';
    $stmt = $db->prepare($sql);
    $stmt->bindValue(':email', $email, PDO::PARAM_STR);
    $stmt->execute();
    $userData = $stmt->fetch(PDO::FETCH_ASSOC);
    $stmt->closeCursor();
    return $userData;
    }
    
    public static function AccountsChangeDataModel($id, $name, $email, $phone) {
        $db = Connection::MarbustDBConnect();
        $sql = 'UPDATE marbust_accounts SET accountName = :accountName, accountEmail = :accountEmail, accountPhone = :accountPhone WHERE MarbustAccountId = :MarbustAccountId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':accountName', $name, PDO::PARAM_STR);
        $stmt->bindValue(':accountEmail', $email, PDO::PARAM_STR);
        $stmt->bindValue(':accountPhone', $phone, PDO::PARAM_STR);
        $stmt->bindValue(':MarbustAccountId', $id, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
    
    public static function getUserInfo($id) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbust_accounts WHERE MarbustAccountId = :MarbustAccountId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $id, PDO::PARAM_INT);
        $stmt->execute();
        $userInfo = $stmt->fetch(PDO::FETCH_ASSOC);
        $stmt->closeCursor();
        return $userInfo;
    }
	
    public static function AccountsChangePasswordModel($id, $password) {
        $db = Connection::MarbustDBConnect();
        $sql = 'UPDATE marbust_accounts SET accountPassword = :accountPassword WHERE MarbustAccountId = :MarbustAccountId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':accountPassword', $password, PDO::PARAM_STR);
        $stmt->bindValue(':MarbustAccountId', $id, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
    
    public static function GetAllAccountsModel() {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbust_accounts ORDER BY MarbustAccountId ASC';
        $stmt = $db->prepare($sql);
        $stmt->execute();
        $accountsData = $stmt->fetchAll(); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
	
	public static function GetAllAccountsModelOBN() {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbust_accounts ORDER BY accountName ASC';
        $stmt = $db->prepare($sql);
        $stmt->execute();
        $accountsData = $stmt->fetchAll(); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
	
	public static function GetTotalAccountsModel() {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT COUNT(*) FROM marbust_accounts';
        $stmt = $db->prepare($sql);
        $stmt->execute();
       	$total = $stmt->fetchColumn();
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $total;
    }
	
	public static function DeleteUserModel($userIDtoDelete) {
    $db = Connection::MarbustDBConnect();
    $sql = 'DELETE FROM marbust_accounts WHERE MarbustAccountId = :MarbustAccountId';
    $stmt = $db->prepare($sql);
    $stmt->bindValue(':MarbustAccountId', $userIDtoDelete, PDO::PARAM_STR);
    $stmt->execute();
	$rowsChanged = $stmt->rowCount();
    // Close the database interaction
    $stmt->closeCursor();
    // Return the indication of success (rows changed)
    return $rowsChanged;
    }
	
	public static function DeleteComputerModel($ComputerIDtoDelete) {
    $db = Connection::MarbustDBConnect();
    $sql = 'DELETE FROM marbustcomputers_customerscomputers WHERE maintancecomputerId = :maintancecomputerId';
    $stmt = $db->prepare($sql);
    $stmt->bindValue(':maintancecomputerId', $ComputerIDtoDelete, PDO::PARAM_STR);
    $stmt->execute();
	$rowsChanged = $stmt->rowCount();
    // Close the database interaction
    $stmt->closeCursor();
    // Return the indication of success (rows changed)
    return $rowsChanged;
    }

    public static function DeleteMaintanceModel( $MaintanceIDtoDelete ) {
        $db = Connection::MarbustDBConnect();
        $sql = 'DELETE FROM marbustcomputers_maintances WHERE maintanceId = :maintanceId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintanceId', $MaintanceIDtoDelete, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
        }
	
	//Marbust Computers Models
	public static function GetTotalUserComputersModel($id) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT COUNT(*) FROM marbustcomputers_customerscomputers WHERE MarbustAccountId = :MarbustAccountId';
        $stmt = $db->prepare($sql);
		$stmt->bindValue(':MarbustAccountId', $id, PDO::PARAM_STR);
        $stmt->execute();
       	$total = $stmt->fetchColumn();
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $total;
    }
	public static function GetTotalCountComputersModel() {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT COUNT(*) FROM marbustcomputers_customerscomputers';
        $stmt = $db->prepare($sql);
        $stmt->execute();
       	$total = $stmt->fetchColumn();
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $total;
    }
	
	public static function GetTotalCountComputersMaintancesModel() {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT COUNT(*) FROM marbustcomputers_maintances';
        $stmt = $db->prepare($sql);
        $stmt->execute();
       	$total = $stmt->fetchColumn();
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $total;
    }
	
	public static function GetMyComputersModel($userId) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_customerscomputers WHERE MarbustAccountId = :MarbustAccountId ORDER BY maintancenextYear ASC, maintancenextMonth ASC, maintancenextDay ASC';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $userId, PDO::PARAM_STR);
        $stmt->execute();
        $accountsData = $stmt->fetchAll(); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
	
	public static function GetAllComputersModel() {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_customerscomputers 
        JOIN marbust_accounts
            ON marbustcomputers_customerscomputers.MarbustAccountId = marbust_accounts.MarbustAccountId
        ORDER BY maintancenextYear DESC, maintancenextMonth DESC, maintancenextDay DESC';
        $stmt = $db->prepare($sql);
        $stmt->execute();
        $accountsData = $stmt->fetchAll(); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
    
    public static function GetAllMaintancesModel() {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_maintances
        JOIN marbust_accounts
             ON marbustcomputers_maintances.MarbustAccountId = marbust_accounts.MarbustAccountId
        JOIN marbustcomputers_customerscomputers
            ON marbustcomputers_maintances.maintancecomputerId = marbustcomputers_customerscomputers.maintancecomputerId
        JOIN marbustcomputers_types
             ON marbustcomputers_maintances.maintancetypeId = marbustcomputers_types.maintancetypeId
        JOIN marbustcomputers_techs
             ON marbustcomputers_maintances.maintancetechId = marbustcomputers_techs.maintancetechId
       ORDER BY maintanceId DESC';
        $stmt = $db->prepare($sql);
        $stmt->execute();
        $accountsData = $stmt->fetchAll(); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
	
	public static function GetSpecificTechNameModel($techId) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_techs
        JOIN marbust_accounts
             ON marbustcomputers_techs.MarbustAccountId = marbust_accounts.MarbustAccountId
             WHERE maintancetechId = :maintancetechId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintancetechId', $techId, PDO::PARAM_STR);
        $stmt->execute();
        $accountsData = $stmt->fetch(PDO::FETCH_ASSOC); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
	
	public static function GetMyMaintancesCountModel($id) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT COUNT(*) FROM marbustcomputers_maintances WHERE MarbustAccountId = :MarbustAccountId';
        $stmt = $db->prepare($sql);
		$stmt->bindValue(':MarbustAccountId', $id, PDO::PARAM_STR);
        $stmt->execute();
       	$total = $stmt->fetchColumn();
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $total;
    }
	
	public static function GetMyMaintancesModel($id) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_maintances
        JOIN marbustcomputers_customerscomputers
            ON marbustcomputers_maintances.maintancecomputerId = marbustcomputers_customerscomputers.maintancecomputerId
        JOIN marbustcomputers_types
             ON marbustcomputers_maintances.maintancetypeId = marbustcomputers_types.maintancetypeId
        JOIN marbustcomputers_techs
             ON marbustcomputers_maintances.maintancetechId = marbustcomputers_techs.maintancetechId
       WHERE marbustcomputers_maintances.MarbustAccountId = :MarbustAccountId
	   ORDER BY maintanceId DESC';
        $stmt = $db->prepare($sql);
		$stmt->bindValue(':MarbustAccountId', $id, PDO::PARAM_STR);
        $stmt->execute();
        $accountsData = $stmt->fetchAll(); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
  
	public static function checkExistingPC($ComputerName) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT maintancecomputerName FROM marbustcomputers_customerscomputers WHERE maintancecomputerName = :maintancecomputerName';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintancecomputerName', $ComputerName, PDO::PARAM_STR);
        $stmt->execute();
        $matchPC = $stmt->fetch(PDO::FETCH_NUM);
        $stmt->closeCursor();
        if(empty($matchPC)){
         return 0;
        } else {
         return 1;
        }
    }
	
	public static function PCRegistrationModel($MarbustAccountId, $ComputerName, $day, $month, $year) {
        $db = Connection::MarbustDBConnect();
        $sql = 'INSERT INTO marbustcomputers_customerscomputers (MarbustAccountId, maintancecomputerName, 	maintancenextDay, maintancenextMonth, maintancenextYear) VALUES (:MarbustAccountId, :maintancecomputerName, :maintancenextDay, :maintancenextMonth, :maintancenextYear)';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $MarbustAccountId, PDO::PARAM_STR);
        $stmt->bindValue(':maintancecomputerName', $ComputerName, PDO::PARAM_STR);
        $stmt->bindValue(':maintancenextDay', $day, PDO::PARAM_STR);
        $stmt->bindValue(':maintancenextMonth', $month, PDO::PARAM_STR);
        $stmt->bindValue(':maintancenextYear', $year, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
	
	public static function checkMaintanceType($KindName) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT maintancetypeName FROM marbustcomputers_types WHERE maintancetypeName = :maintancetypeName';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintancetypeName', $KindName, PDO::PARAM_STR);
        $stmt->execute();
        $matchMaintance = $stmt->fetch(PDO::FETCH_NUM);
        $stmt->closeCursor();
        if(empty($matchMaintance)){
         return 0;
        } else {
         return 1;
        }
    }
	
	public static function MaintanceTypeRegistryModel($KindName, $points, $time) {
        $db = Connection::MarbustDBConnect();
        $sql = 'INSERT INTO marbustcomputers_types (maintancetypeName, maintancetypePoints,  maintancetypeextraTime) VALUES (:maintancetypeName, :maintancetypePoints, :maintancetypeextraTime)';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintancetypeName', $KindName, PDO::PARAM_STR);
        $stmt->bindValue(':maintancetypePoints', $points, PDO::PARAM_STR);
        $stmt->bindValue(':maintancetypeextraTime', $time, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
	
	public static function checkExistingTechAccount($idtoverify) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT MarbustAccountId FROM marbustcomputers_techs WHERE MarbustAccountId = :MarbustAccountId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $idtoverify, PDO::PARAM_STR);
        $stmt->execute();
        $matchEmail = $stmt->fetch(PDO::FETCH_NUM);
        $stmt->closeCursor();
        if(empty($matchEmail)){
         return 0;
        } else {
         return 1;
        }
    }
	
	public static function getTechInfo($userId) {
    $db = Connection::MarbustDBConnect();
    $sql = 'SELECT * FROM marbustcomputers_techs WHERE MarbustAccountId = :MarbustAccountId';
    $stmt = $db->prepare($sql);
    $stmt->bindValue(':MarbustAccountId', $userId, PDO::PARAM_STR);
    $stmt->execute();
    $userData = $stmt->fetch(PDO::FETCH_ASSOC);
    $stmt->closeCursor();
    return $userData;
    }
	
	public static function MaintanceTechRegistryModel($MarbustAccountId, $active) {
        $db = Connection::MarbustDBConnect();
        $sql = 'INSERT INTO marbustcomputers_techs (MarbustAccountId, maintancetechActive) VALUES (:MarbustAccountId, :maintancetechActive)';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $MarbustAccountId, PDO::PARAM_STR);
        $stmt->bindValue(':maintancetechActive', $active, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
	
	public static function checkExistingComputersAccount($idtoverify) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT MarbustAccountId FROM marbustcomputers_customerscomputers WHERE MarbustAccountId = :MarbustAccountId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $idtoverify, PDO::PARAM_STR);
        $stmt->execute();
        $matchEmail = $stmt->fetch(PDO::FETCH_NUM);
        $stmt->closeCursor();
        if(empty($matchEmail)){
         return 0;
        } else {
         return 1;
        }
    }
	
	public static function getUserName($id) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT accountName, accountEmail FROM marbust_accounts WHERE MarbustAccountId = :MarbustAccountId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $id, PDO::PARAM_INT);
        $stmt->execute();
        $userInfo = $stmt->fetch(PDO::FETCH_ASSOC);
        $stmt->closeCursor();
        return $userInfo;
    }
	
	public static function GetCustomerComputersModel($userId) {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_customerscomputers WHERE MarbustAccountId = :MarbustAccountId ORDER BY maintancecomputerName ASC';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $userId, PDO::PARAM_STR);
        $stmt->execute();
        $accountsData = $stmt->fetchAll(); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
	
	public static function GetMaintancesKindsModel() {
        $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_types ORDER BY maintancetypeName ASC';
        $stmt = $db->prepare($sql);
        $stmt->execute();
        $accountsData = $stmt->fetchAll(); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    }
	
	public static function MonthsforNextMaintanceModel($KindId) {
    $db = Connection::MarbustDBConnect();
    $sql = 'SELECT maintancetypeextraTime FROM marbustcomputers_types WHERE maintancetypeId = :maintancetypeId';
    $stmt = $db->prepare($sql);
    $stmt->bindValue(':maintancetypeId', $KindId, PDO::PARAM_STR);
    $stmt->execute();
    $userData = $stmt->fetch(PDO::FETCH_ASSOC);
    $stmt->closeCursor();
    return $userData;
    }
    
    public static function MaintanceUpdateNextDateModel($ComputerId, $month, $day, $year) {
        $db = Connection::MarbustDBConnect();
        $sql = 'UPDATE marbustcomputers_customerscomputers SET maintancenextMonth = :maintancenextMonth, maintancenextDay = :maintancenextDay, maintancenextYear = :maintancenextYear WHERE maintancecomputerId = :maintancecomputerId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintancenextMonth', $month, PDO::PARAM_STR);
        $stmt->bindValue(':maintancenextDay', $day, PDO::PARAM_STR);
        $stmt->bindValue(':maintancenextYear', $year, PDO::PARAM_STR);
        $stmt->bindValue(':maintancecomputerId', $ComputerId, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
	
	public static function MaintanceRegistryModel($MarbustAccountId, $TechId, $ComputerId, $KindId, $day, $month, $year, $description, $promotion) {
        $db = Connection::MarbustDBConnect();
        $sql = 'INSERT INTO marbustcomputers_maintances (MarbustAccountId, maintancecomputerId, maintancedoneDay, maintancedoneMonth, maintancedoneYear, maintanceDescription, maintancetypeId, maintancePromo, maintancetechId) VALUES (:MarbustAccountId, :maintancecomputerId, :maintancedoneDay, :maintancedoneMonth, :maintancedoneYear, :maintanceDescription, :maintancetypeId, :maintancePromo, :maintancetechId)';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':MarbustAccountId', $MarbustAccountId, PDO::PARAM_STR);
        $stmt->bindValue(':maintancetechId', $TechId, PDO::PARAM_STR);
        $stmt->bindValue(':maintancecomputerId', $ComputerId, PDO::PARAM_STR);
        $stmt->bindValue(':maintancetypeId', $KindId, PDO::PARAM_STR);
        $stmt->bindValue(':maintancedoneDay', $day, PDO::PARAM_STR);
        $stmt->bindValue(':maintancedoneMonth', $month, PDO::PARAM_STR);
        $stmt->bindValue(':maintancedoneYear', $year, PDO::PARAM_STR);
        $stmt->bindValue(':maintanceDescription', $description, PDO::PARAM_STR);
        $stmt->bindValue(':maintancePromo', $promotion, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
    
	public static function MaintanceEditModel($MaintanceId, $description) {
        $db = Connection::MarbustDBConnect();
        $sql = 'UPDATE marbustcomputers_maintances SET maintanceDescription = :maintanceDescription WHERE maintanceId = :maintanceId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintanceDescription', $description, PDO::PARAM_STR);
        $stmt->bindValue(':maintanceId', $MaintanceId, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
	public static function GetComputerData($ComputerId) {
		$db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_customerscomputers WHERE maintancecomputerId = :maintancecomputerId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintancecomputerId', $ComputerId, PDO::PARAM_STR);
        $stmt->execute();
        $accountsData = $stmt->fetch(PDO::FETCH_ASSOC);
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData; 
	}
	
	public static function GetSpecificMaintanceModel($MaintanceId) {
		    $db = Connection::MarbustDBConnect();
        $sql = 'SELECT * FROM marbustcomputers_maintances
        JOIN marbust_accounts
             ON marbustcomputers_maintances.MarbustAccountId = marbust_accounts.MarbustAccountId
        JOIN marbustcomputers_customerscomputers
            ON marbustcomputers_maintances.maintancecomputerId = marbustcomputers_customerscomputers.maintancecomputerId
        JOIN marbustcomputers_types
             ON marbustcomputers_maintances.maintancetypeId = marbustcomputers_types.maintancetypeId
       WHERE marbustcomputers_maintances.maintanceId =:maintanceId';
        $stmt = $db->prepare($sql);
		$stmt->bindValue(':maintanceId', $MaintanceId, PDO::PARAM_STR);
        $stmt->execute();
        $accountsData = $stmt->fetch(PDO::FETCH_ASSOC); 
        // Close the database interaction
        $stmt->closeCursor();
        
        // Return the indication of success (rows changed)
        return $accountsData;
    
	}
	
	
	public static function PCChangeNameModel($selectedComputerIDtoChange, $ComputerName) {
        $db = Connection::MarbustDBConnect();
        $sql = 'UPDATE marbustcomputers_customerscomputers SET maintancecomputerName = :maintancecomputerName WHERE maintancecomputerId = :maintancecomputerId';
        $stmt = $db->prepare($sql);
        $stmt->bindValue(':maintancecomputerId', $selectedComputerIDtoChange, PDO::PARAM_STR);
        $stmt->bindValue(':maintancecomputerName', $ComputerName, PDO::PARAM_STR);
        $stmt->execute();
        $rowsChanged = $stmt->rowCount();
        // Close the database interaction
        $stmt->closeCursor();
        // Return the indication of success (rows changed)
        return $rowsChanged;
    }
    
}

https://github.com/MarbustTechnologyCompany/marbust-accounts-backend/blob/V1/models/models.php#L9

Sin embargo, con el tiempo, a medida que los proyectos crecían, mantener todo ese código SQL dentro de los archivos del proyecto comenzó a volverse más complicado. Gestionar consultas, relaciones entre tablas y cambios en la estructura de la base de datos requería cada vez más esfuerzo.

Todo cambió cuando comencé a trabajar como desarrollador backend utilizando Node.js y TypeScript. En ese entorno conocí TypeORM, una herramienta que facilita enormemente la forma en que interactuamos con las bases de datos dentro de aplicaciones modernas.

En este artículo quiero explicarte qué es TypeORM, cómo se utiliza dentro de los frameworks backend y cuáles son sus principales ventajas.

¿Qué es TypeORM?

TypeORM es un ORM (Object Relational Mapper) diseñado principalmente para aplicaciones desarrolladas con TypeScript y JavaScript.

Un ORM es una herramienta que permite trabajar con bases de datos utilizando objetos y clases dentro del código en lugar de escribir consultas SQL directamente. En otras palabras, convierte las tablas de la base de datos en modelos de programación que pueden manipularse desde el código.

Esto significa que, en lugar de escribir algo como:

SELECT * FROM users WHERE id = 1;

podemos trabajar con código similar a:

const user = await userRepository.findOneBy({ id: 1 });

El ORM se encarga de traducir ese código a consultas SQL que luego se ejecutan en la base de datos.

Una de las grandes ventajas de TypeORM es que soporta múltiples motores de base de datos como:

  • MySQL
  • PostgreSQL
  • MariaDB
  • SQLite
  • Microsoft SQL Server

Esto permite que el desarrollador trabaje con una misma estructura de código independientemente del motor de base de datos utilizado.

¿Cómo se usa TypeORM normalmente?

El uso de TypeORM generalmente se basa en tres elementos principales:

Entidades (Entities)
Representan las tablas dentro de la base de datos.

Repositorios (Repositories)
Permiten interactuar con las entidades para consultar, insertar, actualizar o eliminar registros.

Fuentes de datos (Data Sources)
Definen la conexión hacia la base de datos.

Por ejemplo, una entidad simple podría verse así:

@Entity()
export class User {

  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;

}


En este caso, la clase User representa una tabla en la base de datos y cada propiedad corresponde a una columna.

Cuando el proyecto se ejecuta, TypeORM interpreta estas clases y genera las consultas necesarias para interactuar con la base de datos.

Esto permite trabajar principalmente con código TypeScript, mientras que el ORM se encarga de convertir esas instrucciones en comandos SQL.

TypeORM en frameworks de Node.js

En mi experiencia trabajando con desarrollo backend, he utilizado TypeORM principalmente dentro de dos frameworks populares del ecosistema de Node.js.

Uso en LoopBack 4

Uno de los frameworks donde he trabajado con TypeORM es LoopBack 4.

Dentro de este framework, el flujo de trabajo generalmente consiste en:

  1. Crear un modelo que represente la estructura de datos.
  2. Crear un repositorio que conecte ese modelo con una fuente de datos.
  3. Utilizar ese repositorio dentro de los controladores o servicios para realizar operaciones con la base de datos.

Este enfoque sigue una arquitectura bastante estructurada, donde cada componente tiene una responsabilidad clara dentro de la aplicación.

Uso en NestJS

typeorm

También he trabajado con TypeORM dentro de NestJS, donde la integración resulta bastante directa.

En este caso, el flujo suele ser más sencillo:

  1. Se define la entidad (modelo).
  2. Se importa dentro del módulo correspondiente.
  3. Luego puede utilizarse directamente dentro de los servicios o controladores.

Esto permite trabajar de forma muy rápida al desarrollar APIs o servicios backend.

Ventajas principales de usar TypeORM

Existen varias ventajas importantes al trabajar con un ORM como TypeORM dentro de proyectos backend modernos.

Una de las más importantes es que permite trabajar completamente con código TypeScript, lo que mejora la legibilidad y el mantenimiento del proyecto.

También facilita la portabilidad entre bases de datos, ya que el mismo código puede funcionar con distintos motores sin necesidad de reescribir consultas SQL.

Otra ventaja es la organización del proyecto. Al separar entidades, repositorios y servicios, el código se vuelve más limpio y fácil de mantener a largo plazo.

Además, TypeORM ofrece funcionalidades adicionales como:

  • manejo de relaciones entre tablas
  • migraciones de base de datos
  • consultas personalizadas
  • validaciones y decoradores
  • integración directa con frameworks modernos

Todo esto contribuye a que el desarrollo backend sea más estructurado y escalable.

Posibles desventajas

Aunque TypeORM ofrece muchas ventajas, también existen algunos puntos a considerar.

Desde mi experiencia personal, uno de los efectos secundarios de usar un ORM durante mucho tiempo es que el desarrollador puede dejar de escribir consultas SQL manualmente con tanta frecuencia. Esto puede hacer que, con el tiempo, se pierda cierta práctica con la sintaxis directa de motores como MySQL.

Por esta razón, considero que es importante mantener un buen conocimiento de SQL incluso cuando se utilizan herramientas que abstraen el acceso a la base de datos.

Conclusión

TypeORM se ha convertido en una herramienta muy importante dentro del desarrollo backend moderno, especialmente en proyectos construidos con Node.js y TypeScript. Su capacidad para transformar la interacción con bases de datos en un modelo basado en objetos permite desarrollar aplicaciones de manera más organizada y escalable.

En mi experiencia como desarrollador, pasar de escribir consultas SQL manuales a trabajar con un ORM como TypeORM fue un cambio significativo que simplificó mucho la forma en que construyo aplicaciones backend.

Espero que este artículo te ayude a entender qué es TypeORM y por qué es una herramienta tan utilizada dentro del desarrollo de software actual.

Sobre el Autor:

MarAntBQ.dev

Marco Antonio Bustillos Quiroz
Bachelor of Science in Web Design and Development (BYU-Idaho)
Full Stack Web Developer con más de 8 años de experiencia en desarrollo Front End y Back End. Mis proyectos incluyen sitios web, landing pages, aplicaciones web, REST APIs, e-commerce, y mucho más. Mi pasión es crear experiencias digitales impactantes y compartir conocimientos con otros desarrolladores.