Principiile SOLID

SOLID.js

/*
const person = {
	nane:"john",
	age: 20,
}

for(const item in person ){

	console.log(item); //key

}
*/

//OOP

//Principiile OOP

//1. Abstractizare
//2. Incapsulare
//3. Mostenire
//4. Polimorfism


// Pricipiile SOLID

//S: Single Responsability Principle (Principiul responsabilitatii unice)

//WRONG
class User {

	  constructor(name, email) {

	     this.name = name;
	     this.email = email;
	  }
	  
	  savetodatabase() //logica DB
	  sendWelcomeEmail()  //logica pentru email
	  
}

//CORECT fiecare CLASA are o singura responsabilitate

class User {


	  constructor(name, email) {

	  	   this.name = name;
	  	   this.email = email;
	  }
}

class UserRepository {

	save(user) {

		console.log(`Salvez ${user.name} in Baza de date');
	}
};

class EmailService {

        console.log(``trimit email la ${user.name}`);
}



//O: Open/closed Principle (Principiul deschis/inchis)

//Entitatile trebuie sa fie deschise pentru extindere, dar inchise pentru modificare

//gresit, de fiecare data cand apare o forma noua , modificam functia
function area(shape) {

	   if(shape.type === 'circle') return Math.PI * shape.r ** 2;

	   if(shape.type === 'square') return shape.side ** 2;

	   //trebuie modificat de fiecare data pentru fiecare forma noua
}

//corect , adauga clase noi fara sa modificam codul existent

class Circle {

	constructor(r) {this.r = r}
	area() {return MAth.pi * this.r * 2}
}


class Square {

	constructor(side) {this.side = side}
	area() {return Math.side ** 2};
}


class Trriangle {

	constructor(base, height){  //extindere fara modificarea codului existent

		  this.base = base; this.height = height;
	}	

	area(){return this.base * this.height /  2}
	
}

const totalArea = (shapes) => shapes.reduce((sum, s) => sum + s.area(), 0)

console.log(totalArea[new Circle(2), new Square(3), new Trriangle(2,3))


//L:Liskov Substitution PRinciplae (Principiul Substitutiei Liskov)

//OBiectele unei clase derivate trebuie sa poata inlocui obiectele clasei de baza fara a strica comportamentul programului


//gresit

class Bird {

	fly() {
		console.log('zbor')
	}
}

class Pinguin extends Bird {

	fly() {throw new Error('Pinguinii nu pot zbura')}
}

//CORRECT este

class Bird {

	eat() {console.log("mananca");}
}


class FlyingBird extends Bird {

	fly() {console.log("zboara")}
}

class A extends FlyingBird {


}

//I: Interface Segragation PRinciple (Principiul segragarii interfetelor)


//gresit, interfata prea mare
class Machine {

	print() {
		throw new Error("Neimplementat")
	}

	scans() {

		throw new Error("Neimplementat")
	}

	fax() {
		throw new Error("Neimplementat")
	}
}

class SimplePRinter extends Machine {

	 print() {
	 	//implementez metoda
	 	console.log("Printez");
	 }
}

//
const Printable = (Base) => class extends Base {

	print() {
		console.log("printez")
	}
}

const Scannable = (Base) => class extends Base {

	scan() {
		console.log("Scanez")
	}
}

class Device {}


class SimplePRinter extends Printable(Device) {

} 

class MultiFunctonPRinter extends Scannable(Printable(Device)) {}


//D: Dependency Inverstion PRinciple (Principiul inversarii dependentelor)

//modulele de nivel inalt nu trebuie sa depinde de cele de nivel jos. Ambele trebuie sa depinda de abstractiune

//gresit . dependenta directa de implementarea concreata
class MySQLDAtabase {


	save(data) {
		 console.log("Salvat in MySQL", data)
	}
}

class OrderService {

	constructor() {

		this.db = new MySQLDatabase() //cuplare stransa
	}

	createOrder(order) {
		this.db.save(order)
	}
}

//corect

class MySQLDAtabase {

	save(data) {
		console.log("Salvat in MySQL", data)
	}
}

class MongoDatabase {

	save(data) {
		console.log("Salvat in MongoDB", data)
	}
}


class RedisDatabase {

	save(data) {
		console.log("Salvat in Redis", data)
	}
}

class PostresQLDatabase {

	save(data) {
		console.log("Salvat in postgres", data)
	}
}

class OrderService {

     constructor(database) {//depinde de o abstractiune (orice are .save)

     	this.db = database
     }

     createOrder(order) {
     	this.db.save(order)
     }

}

new ORderService(new MySQLDatabase()).createOrder({id: 1})
new ORderService(new MongoDatabase()).createOrder({id: 2})
new ORderService(new PostGresDatabase()).createOrder({id: 3})
new ORderService(new REdisDatabase()).createOrder({id: 4})


//concluzie
/*
SRP ..schimbare per clasa

OCP ..extinzi , nu modifici

LSP ..subclasele pot inlocui clasa de baza

ISP ....interfete mici si specifice

DIP...depinzi  de abstractiuni, nu de implementari
*/