feat(patterns): added abstract factory and factory method pattern

Author: 4lessandrodev

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+/node_modules

README.md

@@ -0,0 +1,11 @@
+# Design Patterns with typescript
+
+## Extracted from books: 
+* Typescript Design Patterns - Vilic Vane
+* Mergulho nos padrões de projeto - Alexander Shvets
+* Refactoring Guru - refactoring.guru
+
+### Patterns
+
+- Factory Method
+- Abstract Factory

abstract-factory/abstract-factory.spec.ts

@@ -0,0 +1,16 @@
+import { ConcreteFactory1, ConcreteFactory2, clientCode} from './index'
+
+describe('abstract-factory', (): void => {
+it('should execute abstract factory', (): void => {
+/**
+ * The client code can work with any concrete factory class.
+ */
+console.log('Client: Testing client code with the first factory type...');
+clientCode(new ConcreteFactory1());
+
+console.log('');
+
+console.log('Client: Testing the same client code with the second factory type...');
+clientCode(new ConcreteFactory2());
+})
+})

abstract-factory/index.ts

@@ -0,0 +1,137 @@
+// https://refactoring.guru/pt-br/design-patterns/abstract-factory/typescript/example
+/**
+ * The Abstract Factory interface declares a set of methods that return
+ * different abstract products. These products are called a family and are
+ * related by a high-level theme or concept. Products of one family are usually
+ * able to collaborate among themselves. A family of products may have several
+ * variants, but the products of one variant are incompatible with products of
+ * another.
+ */
+ interface AbstractFactory {
+ createProductA(): AbstractProductA;
+
+ createProductB(): AbstractProductB;
+}
+
+/**
+ * Concrete Factories produce a family of products that belong to a single
+ * variant. The factory guarantees that resulting products are compatible. Note
+ * that signatures of the Concrete Factory's methods return an abstract product,
+ * while inside the method a concrete product is instantiated.
+ */
+export class ConcreteFactory1 implements AbstractFactory {
+ public createProductA(): AbstractProductA {
+ return new ConcreteProductA1();
+ }
+
+ public createProductB(): AbstractProductB {
+ return new ConcreteProductB1();
+ }
+}
+
+/**
+ * Each Concrete Factory has a corresponding product variant.
+ */
+export class ConcreteFactory2 implements AbstractFactory {
+ public createProductA(): AbstractProductA {
+ return new ConcreteProductA2();
+ }
+
+ public createProductB(): AbstractProductB {
+ return new ConcreteProductB2();
+ }
+}
+
+/**
+ * Each distinct product of a product family should have a base interface. All
+ * variants of the product must implement this interface.
+ */
+interface AbstractProductA {
+ usefulFunctionA(): string;
+}
+
+/**
+ * These Concrete Products are created by corresponding Concrete Factories.
+ */
+class ConcreteProductA1 implements AbstractProductA {
+ public usefulFunctionA(): string {
+ return 'The result of the product A1.';
+ }
+}
+
+class ConcreteProductA2 implements AbstractProductA {
+ public usefulFunctionA(): string {
+ return 'The result of the product A2.';
+ }
+}
+
+/**
+ * Here's the the base interface of another product. All products can interact
+ * with each other, but proper interaction is possible only between products of
+ * the same concrete variant.
+ */
+interface AbstractProductB {
+ /**
+ * Product B is able to do its own thing...
+ */
+ usefulFunctionB(): string;
+
+ /**
+ * ...but it also can collaborate with the ProductA.
+ *
+ * The Abstract Factory makes sure that all products it creates are of the
+ * same variant and thus, compatible.
+ */
+ anotherUsefulFunctionB(collaborator: AbstractProductA): string;
+}
+
+/**
+ * These Concrete Products are created by corresponding Concrete Factories.
+ */
+class ConcreteProductB1 implements AbstractProductB {
+
+ public usefulFunctionB(): string {
+ return 'The result of the product B1.';
+ }
+
+ /**
+ * The variant, Product B1, is only able to work correctly with the variant,
+ * Product A1. Nevertheless, it accepts any instance of AbstractProductA as
+ * an argument.
+ */
+ public anotherUsefulFunctionB(collaborator: AbstractProductA): string {
+ const result = collaborator.usefulFunctionA();
+ return `The result of the B1 collaborating with the (${result})`;
+ }
+}
+
+class ConcreteProductB2 implements AbstractProductB {
+
+ public usefulFunctionB(): string {
+ return 'The result of the product B2.';
+ }
+
+ /**
+ * The variant, Product B2, is only able to work correctly with the variant,
+ * Product A2. Nevertheless, it accepts any instance of AbstractProductA as
+ * an argument.
+ */
+ public anotherUsefulFunctionB(collaborator: AbstractProductA): string {
+ const result = collaborator.usefulFunctionA();
+ return `The result of the B2 collaborating with the (${result})`;
+ }
+}
+
+/**
+ * The client code works with factories and products only through abstract
+ * types: AbstractFactory and AbstractProduct. This lets you pass any factory or
+ * product subclass to the client code without breaking it.
+ */
+export function clientCode(factory: AbstractFactory) {
+ const productA = factory.createProductA();
+ const productB = factory.createProductB();
+
+ console.log(productB.usefulFunctionB());
+ console.log(productB.anotherUsefulFunctionB(productA));
+}
+

factory-method/factory-method.spec.ts

@@ -0,0 +1,22 @@
+import { clientCode, ConcreteCreator1, ConcreteCreator2 } from "./index";
+import { clientDelivery, BikeCreator, TruckCreator } from './my-factory-method';
+
+describe('factory-method', (): void => {
+it('should create a valid instance', (): void => {
+/**
+ * The Application picks a creator's type depending on the configuration or
+ * environment.
+ */
+console.log('App: Launched with the ConcreteCreator1.');
+clientCode(new ConcreteCreator1());
+console.log('');
+
+console.log('App: Launched with the ConcreteCreator2.');
+clientCode(new ConcreteCreator2());
+})
+
+it('should create car delivery', () => {
+clientDelivery(new BikeCreator()); // Delivery by bike
+clientDelivery(new TruckCreator()); // Delivery by truck
+})
+})

factory-method/index.ts

@@ -0,0 +1,85 @@
+// https://refactoring.guru/pt-br/design-patterns/factory-method/typescript/example
+/**
+ * The Creator class declares the factory method that is supposed to return an
+ * object of a Product class. The Creator's subclasses usually provide the
+ * implementation of this method.
+ */
+ abstract class Creator {
+ /**
+ * Note that the Creator may also provide some default implementation of the
+ * factory method.
+ */
+ public abstract factoryMethod(): Product;
+
+ /**
+ * Also note that, despite its name, the Creator's primary responsibility is
+ * not creating products. Usually, it contains some core business logic that
+ * relies on Product objects, returned by the factory method. Subclasses can
+ * indirectly change that business logic by overriding the factory method
+ * and returning a different type of product from it.
+ */
+ public someOperation(): string {
+ // Call the factory method to create a Product object.
+ const product = this.factoryMethod();
+ // Now, use the product.
+ return `Creator: The same creator's code has just worked with ${product.operation()}`;
+ }
+}
+
+/**
+ * Concrete Creators override the factory method in order to change the
+ * resulting product's type.
+ */
+export class ConcreteCreator1 extends Creator {
+ /**
+ * Note that the signature of the method still uses the abstract product
+ * type, even though the concrete product is actually returned from the
+ * method. This way the Creator can stay independent of concrete product
+ * classes.
+ */
+ public factoryMethod(): Product {
+ return new ConcreteProduct1();
+ }
+}
+
+export class ConcreteCreator2 extends Creator {
+ public factoryMethod(): Product {
+ return new ConcreteProduct2();
+ }
+}
+
+/**
+ * The Product interface declares the operations that all concrete products must
+ * implement.
+ */
+interface Product {
+ operation(): string;
+}
+
+/**
+ * Concrete Products provide various implementations of the Product interface.
+ */
+class ConcreteProduct1 implements Product {
+ public operation(): string {
+ return '{Result of the ConcreteProduct1}';
+ }
+}
+
+class ConcreteProduct2 implements Product {
+ public operation(): string {
+ return '{Result of the ConcreteProduct2}';
+ }
+}
+
+/**
+ * The client code works with an instance of a concrete creator, albeit through
+ * its base interface. As long as the client keeps working with the creator via
+ * the base interface, you can pass it any creator's subclass.
+ */
+export function clientCode(creator: Creator): void {
+ // ...
+ console.log('Client: I\'m not aware of the creator\'s class, but it still works.');
+ console.log(creator.someOperation());
+ // ...
+}
+

factory-method/my-factory-method.ts

@@ -0,0 +1,41 @@
+interface Delivery {
+operation(): void
+}
+
+abstract class Factory {
+public abstract create(): Delivery;
+
+public DoDelivery(): void {
+const vehicle = this.create();
+vehicle.operation();
+}
+}
+
+export class TruckCreator extends Factory {
+
+public create(): Delivery {
+return new Truck()
+}
+}
+
+export class BikeCreator extends Factory {
+public create(): Delivery {
+return new Bike()
+}
+}
+
+export class Bike implements Delivery {
+operation(): void {
+console.log('A item was delivered by bike')
+}
+}
+
+export class Truck implements Delivery {
+operation(): void {
+console.log('A item was delivered by truck');
+}
+}
+
+export const clientDelivery = (factory: Factory): void => {
+factory.DoDelivery();
+}