Factory: pros y contras

No estoy seguro si asi consistia el reto pero ahi va mi solucion

/** STEP 1 */
class HttpAdapter {
    constructor(type) {
        this._type = type;
    }
    get() {
        throw new Error('Methor not implemented')
    }
    post() {
        throw new Error('Methor not implemented')
    }
    put() {
        throw new Error('Methor not implemented')
    }
    delete() {
        throw new Error('Methor not implemented')
    }
    getType() {
        return this._type;
    }
}

class Express extends HttpAdapter {
    constructor() {
        super('Express');
    }
    get() {
        console.log(`get Method for ${this._type} adapter`);
    }
    post() {
        console.log(`post Method for ${this._type} adapter`);
    }
    put() {
        console.log(`put Method for ${this._type} adapter`);
    }
    delete() {
        console.log(`delete Method for ${this._type} adapter`);
    }
}
class NestJs extends HttpAdapter {
    constructor() {
        super('NestJs');
    }
    get() {
        console.log(`get Method for ${this._type} adapter`);
    }
    post() {
        console.log(`post Method for ${this._type} adapter`);
    }
    put() {
        console.log(`put Method for ${this._type} adapter`);
    }
    delete() {
        console.log(`delete Method for ${this._type} adapter`);
    }
}

class HttpAdaptrFactory {
    makeAdapter() {
        throw new Error('Method not implement')
    }
}

class ExpressFactory extends HttpAdaptrFactory {
    makeAdapter() {
        return new Express();
    }
}

class NestJsFactory extends HttpAdaptrFactory {
    makeAdapter() {
        return new NestJs();
    }
}

function appAdapter (adapter) {
    const httpAdapter = adapter.makeAdapter()
    httpAdapter.get();
    httpAdapter.post();
    httpAdapter.put();
    httpAdapter.delete();
    console.log(httpAdapter.getType())
}

function createAdaper(type) {
    const adapters = {
        'express': ExpressFactory,
        'nestjs': NestJsFactory
    }
    
    const Adapters = adapters[type]
    return new Adapters()
}

appAdapter(createAdaper('express'))
appAdapter(createAdaper('nestjs'))

¡Hola! He dejado en mi repositorio en github el código del reto en typescript y en python, les dejo el link por si quieren echar un vistazo.

Aqui mi solución 😄

// STEP 1:
abstract class HttpAdapter {
    public constructor(type: string) {}

    public abstract get(): void;
    public abstract post(): void;
    public abstract put(): void;
    public abstract delete(): void;
}

// STEP 2:
class ExpressHttpAdapter extends HttpAdapter {
    constructor() {
        super("Express");
    }

    get() {
        console.log("Express get method");
    }
    post() {
        console.log("Express post method");
    }
    put() {
        console.log("Express put method");
    }
    delete() {
        console.log("Express delete method");
    }
}

// STEP 3:
interface HttpAdapterFactory {
    makeAdapter(): HttpAdapter;
}

// STEP 4:
class ExpressHttpAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new ExpressHttpAdapter();
    }
}

function clientApp() {
    const expressHttpAdapter = new ExpressHttpAdapter();
    expressHttpAdapter.get();
    expressHttpAdapter.post();
    expressHttpAdapter.put();
    expressHttpAdapter.delete();
}
clientApp();

interface HttpAdapterFactory {
    makeAdapter(): HttpAdapter
}

interface HttpAdapter {
    get(): void
    post(): void
    put(): void
    delete(): void
}

class ExpressAdapter implements HttpAdapter {
    get(): void {
        console.log('Express método get')
    }

    post(): void {
        console.log('Express método post')
    }

    put(): void {
        console.log('Express método put')
    }

    delete(): void {
        console.log('Express método delete')
    }
}

class FastifyAdapter implements HttpAdapter {
    get(): void {
        console.log('Fastify método get')
    }

    post(): void {
        console.log('Fastify método post')
    }

    put(): void {
        console.log('Fastify método put')
    }

    delete(): void {
        console.log('Fastify método delete')
    }
}

class ExpressFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new ExpressAdapter()
    }
}

class FastifyFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new FastifyAdapter()
    }
}

function appFactory(factory: HttpAdapterFactory): void {
    const adapter = factory.makeAdapter()
    adapter.get()
    adapter.post()
    adapter.delete()
}

function createFactory(type: 'express' | 'fastify'): HttpAdapterFactory {
    const factories = {
        express: ExpressFactory,
        fastify: FastifyFactory
    }

    const Factory = new factories[type]
    return Factory
}

appFactory(createFactory('express'))
appFactory(createFactory('fastify'))

Les dejo mi codigo en TypeScript por si les es de ayuda:

// creo la interface para los http adapter
interface IHttpAdapter {
  get(): void;
  post(): void;
  put(): void;
  delete(): void;
  getType(): void;
}

// implemento la interface para las class de http adapters
class RestHttpAdapter implements IHttpAdapter {
  private type: string = "REST";

  get() {
    console.log("Method get in " + this.type);
  }
  post() {
    console.log("Method post in " + this.type);
  }
  put() {
    console.log("Method put in " + this.type);
  }
  delete() {
    console.log("Method delete in " + this.type);
  }
  getType(): void {
    console.log(this.type);
  }
}

class SoapHttpAdapter implements IHttpAdapter {
  private type: string = "SOAP";

  get() {
    console.log("Method get in " + this.type);
  }
  post() {
    console.log("Method post in " + this.type);
  }
  put() {
    console.log("Method put in " + this.type);
  }
  delete() {
    console.log("Method delete in " + this.type);
  }
  getType(): void {
    console.log(this.type);
  }
}

// creo la interface factory
interface IHttpAdapterFactory {
  makeAdapter(): IHttpAdapter;
}

// implemento la interface factory para las class factory
class RestHttpAdapterFactory implements IHttpAdapterFactory {
  makeAdapter(): IHttpAdapter {
    return new RestHttpAdapter();
  }
}

class SoapHttpAdapterFactory implements IHttpAdapterFactory {
  makeAdapter(): IHttpAdapter {
    return new SoapHttpAdapter();
  }
}

// funciones para instanciar factories y http adapters
const appFactory2 = (factory: IHttpAdapterFactory) => {
  const httpAdapter = factory.makeAdapter();
  httpAdapter.getType();
  httpAdapter.get();
  httpAdapter.post();
  httpAdapter.put();
  httpAdapter.delete();
};

type HttpAdapterType = "rest" | "soap";

const createFactory2 = (type: HttpAdapterType) => {
  const factories = { rest: RestHttpAdapterFactory, soap: SoapHttpAdapterFactory };
  const Factory = factories[type];
  return new Factory();
};

appFactory2(createFactory2("rest"));
appFactory2(createFactory2("soap"));

Mi solucion a la actividad

/*
    Creamos nuestra clase principal HTTPAdapter que será la encargada de 
    definir los métodos que se utilizarán en los adapters
*/

class HttpAdapter {
    type = undefined;

    constructor(type) {
        this.type = type;
    }

    getType() {
        throw new Error('Method not implemented');
    }

    get(url) {
        return `${this.type} Method GET: ${url}`;
    }

    post(url) {
        return `${this.type} Method POST: ${url}`;
    }

    put(url) {
        return `${this.type} Method PUT: ${url}`;
    }

    delete(url) {
        return `${this.type} Method DELETE: ${url}`;
    }

}

// Definimos nuestros adapters que heredarán de la clase principal
class ExpressAdapter extends HttpAdapter {
    getType() {
        return this.type;
    }
}

class NestJsAdapter extends HttpAdapter {
    getType() {
        return this.type;
    }
}

// Creamos nuestro factory que será el encargado de crear los adapters

const Adapter = {
    // Definimos los adapters disponibles
    factory : {
        Express : NestJsAdapter,
        NestJs: ExpressAdapter,
    },
    // Creamos un método para registrar los adapters
    register : function(type) {
        const NewAdapter = this.factory[type];

        if(!NewAdapter) {
            return "Adapter not found"
        }

        return new NewAdapter(type);
    }
}

const Express = Adapter.register('Express');
const NestJs = Adapter.register('NestJs');

console.log(Express.get('platzi.com')); //output: Express Method GET: platzi.com
console.log(NestJs.delete()); //output: NestJs Method DELETE: undefined

Comparto mi Ts

abstract class HttpAdapter {

    constructor(private _type: string) {

    }
    abstract get(): void;
    abstract post(): void;
    abstract put(): void;
    abstract delete(): void;

   get type(): string {
        return this._type;
    }
}

// adapters concretos 
class AdapterExpress extends HttpAdapter {

    constructor() {
        super('Express');
    }

    get(): void {
        console.log(`get method for ${this.type} adapter`);
    }
    post(): void {
        console.log(`post method for ${this.type} adapter`);
    }
    put(): void {
        console.log(`put method for ${this.type} adapter`);
    }
    delete(): void {
        console.log(`delete method for ${this.type} adapter`);
    }
};


class AdapterNextJs extends HttpAdapter {

    constructor() {
        super('NestJs');
    }

    get(): void {
        console.log(`get method for ${this.type} adapter`);
    }
    post(): void {
        console.log(`post method for ${this.type} adapter`);
    }
    put(): void {
        console.log(`put method for ${this.type} adapter`);
    }
    delete(): void {
        console.log(`delete method for ${this.type} adapter`);
    }
};

// Interface para la abstracion de la fabrica de adapters
interface HttpAdapterFactory {
    makeAdapter(): HttpAdapter
}

// fabricas concretas para cada adapter
class ExpressAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new AdapterExpress;
    };
};

class NextJsAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new AdapterNextJs;
    };
};

// aplicaciones
type HttpAdapterType = 'express' | 'nextjs';

function createFactory(type: HttpAdapterType): HttpAdapterFactory  {
    const factories = {
        'express': ExpressAdapterFactory,
        'nextjs': NextJsAdapterFactory
    };
    const Factory = new factories[type];

    return Factory;
};

function createAdapter(factory: HttpAdapterFactory) {
    const adapter = factory.makeAdapter()
    adapter.get();
    adapter.post();
    adapter.put();
    adapter.delete()
}

createAdapter(createFactory('express'));
createAdapter(createFactory('nextjs'));

Ahí humildemente, si tengo algo malo, diganme xd

/**
 * Como implementar factory?
 * 1. Declara una clase/interface de producto base, que será devuelta por la clase de la fábrica y sus subclases.
 * 2. Implementa subclases de productos concretos que hereden/implementen la clase/interface de producto base.
 * 3. Declara una clase/interface de fábrica que devuelva objetos que coincidan con el producto base, no con los productos concretos.
 * 4. Implementa subclases de fábricas concretas que hereden/implementen la clase/interface de fábrica base. Estas clases devolverán productos
 * concretos en su método de fábrica.
 */

/** Paso 1 */
class HttpAdapter {

    constructor(type){
        this.type = type;
    }

    get() {
        throw new Error('Method not implemented!');
    }

    post() {
        throw new Error('Method not implemented!');
    }

    put() {
        throw new Error('Method not implemented!');
    }

    delete() {
        throw new Error('Method not implemented!');
    }
}

/** Paso 2 */
class ExpressHttpAdapter extends HttpAdapter {

    constructor() {
        super('express');
    }

    get() {
        console.log('Get desde Express');
    }

    post() {
        console.log('Post desde Express');
    }

    put() {
        console.log('Put desde Express');
    }

    delete() {
        console.log('Delete desde Express');
    }
}

class FastifyHttpAdapter extends HttpAdapter {
    constructor() {
        super('fastify');
    }

    get() {
        console.log('Get desde Fastify');
    }

    post() {
        console.log('Post desde Fastify');
    }

    put() {
        console.log('Put desde Fastify');
    }

    delete() {
        console.log('Delete desde Fastify');
    }
}

/** Paso 3 */
class HttpAdapterFactory {
    makeAdapter() {
        throw new Error('Method not implemented!');
    }
}

/** Paso 4 */
class ExpressHttpAdapterFactory extends HttpAdapterFactory {
    makeAdapter() {
        return new ExpressHttpAdapter('express');
    }
}

class FastifyHttpAdapterFactory extends HttpAdapterFactory {
    makeAdapter() {
        return new FastifyHttpAdapter('fastify');
    }
}

/* Client App */

function clienteApp(factory) {
    const adapter = factory.makeAdapter();
    adapter.get();
    console.log(adapter.type);
}

clienteApp(new ExpressHttpAdapterFactory());
clienteApp(new FastifyHttpAdapterFactory());

Solución 😄…

.
.
.
.

interface HttpAdapterFactory {
  makeAdapter(): HttpAdapter;
}

class ExpressHttpAdapterFactory implements HttpAdapterFactory {
  makeAdapter() {
    return new ExpressHttpAdapter("express");
  }
}

class FastifyHttpAdapterFactory implements HttpAdapterFactory {
  makeAdapter() {
    return new FastifyHttpAdapter("fastify");
  }
}

class NestJsHttpAdapterFactory implements HttpAdapterFactory {
  makeAdapter() {
    return new NestJsHttpAdapter("nest-js");
  }
}

interface HttpAdapter {
  get(): void;
  post(): void;
  put(): void;
  delete(): void;
}

class ExpressHttpAdapter implements HttpAdapter {
  private type: string;

  constructor(type: string) {
    this.type = type;
  }

  get() {
    console.log(`${this.type} get implementation`);
  }
  post() {
    console.log(`${this.type} post implementation`);
  }
  put() {
    console.log(`${this.type} put implementation`);
  }
  delete() {
    console.log(`${this.type} delete implementation`);
  }
}

class FastifyHttpAdapter implements HttpAdapter {
  private type: string;

  constructor(type: string) {
    this.type = type;
  }

  get() {
    console.log(`${this.type} get implementation`);
  }
  post() {
    console.log(`${this.type} post implementation`);
  }
  put() {
    console.log(`${this.type} put implementation`);
  }
  delete() {
    console.log(`${this.type} delete implementation`);
  }
}

class NestJsHttpAdapter implements HttpAdapter {
  private type: string;

  constructor(type: string) {
    this.type = type;
  }

  get() {
    console.log(`${this.type} get implementation`);
  }
  post() {
    console.log(`${this.type} post implementation`);
  }
  put() {
    console.log(`${this.type} put implementation`);
  }
  delete() {
    console.log(`${this.type} delete implementation`);
  }
}

function appHttpAdapaterFactory(factory: HttpAdapterFactory) {
  const adapter: HttpAdapter = factory.makeAdapter();
  adapter.get();
  adapter.post();
  adapter.put();
  adapter.delete();
}

// appHttpAdapaterFactory(new ExpressHttpAdapterFactory());
// appHttpAdapaterFactory(new FastifyHttpAdapterFactory());
// appHttpAdapaterFactory(new NestJsHttpAdapterFactory());

type HttpAdapterFactoryType = "express" | "fastify" | "nest-js";
function createHttpAdapterFactory(type: HttpAdapterFactoryType) {
  const adapters = {
    express: ExpressHttpAdapterFactory,
    fastify: FastifyHttpAdapterFactory,
    "nest-js": NestJsHttpAdapterFactory,
  };
  const factoryClass = adapters[type];
  return new factoryClass();
}

appHttpAdapaterFactory(createHttpAdapterFactory("express"));
appHttpAdapaterFactory(createHttpAdapterFactory("fastify"));
appHttpAdapaterFactory(createHttpAdapterFactory("nest-js"));

Este reto me tuvo muy entretenido y me pareció muy didáctico. Comparto mi código, creando dos Productos Concretos para ejemplificar:

//PRODUCTOS ADAPTERS

class HttpAdapter {
    get(){
        throw new Error("Metodo get no implementado");
    }

    post(){
        throw new Error('Metodo post no implementado');
    }

    put(){
        throw new Error('Metodo put no implementado');
    }

    delete(){
        throw new Error('Metodo delete no implementado');
    }
}


class HttpAdapterHiro extends HttpAdapter{
    get(){
        console.log("Hiro getMethod");
    }

    post(){
        console.log("Hiro postMethod");
    }

    put(){
        console.log('Hiro putMethod');
    }

    delete(){
        console.log('Hiro deleteMethod');
    }
}

class HttpAdapterAurel extends HttpAdapter{
    get(){
        console.log('Aurel getMethod');
    }

    post(){
        console.log('Aurel postMethod');
    }

    put(){
        console.log('Aurel putMethod');
    }

    delete(){
        console.log('Aurel deleteMethod');
    }
}



//Fabricas

class HttpAdapterFactory{
    makeAdapter() {
        throw new Error('Metodo makeAdapter no implementado');
    }
}

class HttpAdapterHiroFactory extends HttpAdapterFactory{
    makeAdapter() {
        return new HttpAdapterHiro();
    }
}

class HttpAdapterAurelFactory extends HttpAdapterFactory{
    makeAdapter() {
        return new HttpAdapterAurel();
    }
}


//IMPLEMENTACIÓN
function createAdapter(factory){
    const connectAdapter = factory.makeAdapter();
    return connectAdapter;
}

function createFactory(adapter){
    const adapters = {
        hiro: HttpAdapterHiroFactory,
        aurel: HttpAdapterAurelFactory,
    };
    const Factory = adapters[adapter];
    return new Factory();
}