Mixins em TypeScript

1. Introdução aos Mixins

Mixins são um padrão de design que permite reutilizar comportamentos entre classes sem herança múltipla. Em TypeScript, mixins combinam funcionalidades de múltiplas fontes em uma única classe, resolvendo a limitação da herança única do JavaScript.

Diferentemente das interfaces, que apenas definem contratos, mixins fornecem implementações concretas. Enquanto a herança única cria uma hierarquia rígida, mixins oferecem composição flexível de comportamentos. Problemas como duplicação de código e rigidez hierárquica são resolvidos com mixins, permitindo que classes compartilhem funcionalidades sem acoplamento forte.

2. Fundamentos: Funções Construtoras e Classes

A base dos mixins em TypeScript são funções construtoras e a capacidade de classes como expressões. O padrão fundamental envolve criar funções que recebem uma classe base e retornam uma nova classe estendida.

type Constructor<T = {}> = new (...args: any[]) => T;

function TimestampMixin<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    createdAt: Date = new Date();

    getTimestamp(): string {
      return this.createdAt.toISOString();
    }
  };
}

Aqui, TimestampMixin é uma função que recebe qualquer classe construtora e retorna uma nova classe com propriedades adicionais.

3. Implementando Mixins com TypeScript

Para implementar mixins de forma tipada, usamos a assinatura Constructor<T>:

type Constructor<T = {}> = new (...args: any[]) => T;

function Loggable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    log(message: string): void {
      console.log(`[${new Date().toISOString()}] ${message}`);
    }
  };
}

function Serializable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    toJSON(): string {
      return JSON.stringify(this);
    }
  };
}

class Person {
  constructor(public name: string, public age: number) {}
}

const LoggableSerializablePerson = Loggable(Serializable(Person));
const person = new LoggableSerializablePerson("Alice", 30);
person.log("Person created");
console.log(person.toJSON());

Aplicamos múltiplos mixins compondo as funções, criando uma classe com todos os comportamentos desejados.

4. Tipagem e Restrições com TypeScript

TypeScript permite restringir tipos de mixins para garantir compatibilidade:

type Constructor<T = {}> = new (...args: any[]) => T;

interface HasName {
  name: string;
}

function NamedMixin<TBase extends Constructor<HasName>>(Base: TBase) {
  return class extends Base {
    greet(): string {
      return `Hello, my name is ${this.name}`;
    }
  };
}

class Employee {
  constructor(public name: string, public salary: number) {}
}

const NamedEmployee = NamedMixin(Employee);
// Funciona porque Employee tem a propriedade 'name'

// class Animal {
//   constructor(public species: string) {}
// }
// const NamedAnimal = NamedMixin(Animal); // Erro: falta 'name'

A interface NewableFunction não é necessária para mixins básicos; o tipo abstract new (...args: any[]) => any permite criar mixins para classes abstratas:

type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;

function AbstractMixin<TBase extends AbstractConstructor>(Base: TBase) {
  return abstract class extends Base {
    abstract execute(): void;
  };
}

5. Mixins com Métodos e Propriedades Conflitantes

Quando mixins definem métodos com mesmo nome, a ordem de aplicação determina a precedência:

function MixinA<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    doSomething(): string {
      return "A";
    }
  };
}

function MixinB<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    doSomething(): string {
      return "B";
    }
  };
}

// MixinB sobrescreve MixinA
const Combined = MixinB(MixinA(Base));
// combined.doSomething() retorna "B"

Para usar super em mixins, acessamos o protótipo da classe base:

function SuperMixin<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    doSomething(): string {
      const baseResult = super.doSomething?.() || "";
      return baseResult + " extended";
    }
  };
}

6. Mixins Abstratos e Parciais

Mixins podem exigir implementações específicas da classe base:

interface Validatable {
  validate(): boolean;
}

function ValidationMixin<TBase extends Constructor<Validatable>>(Base: TBase) {
  return class extends Base {
    isValid(): boolean {
      return this.validate();
    }
  };
}

abstract class FormField {
  abstract validate(): boolean;
}

class EmailField extends FormField {
  validate(): boolean {
    return this.value.includes("@");
  }
  constructor(public value: string) {
    super();
  }
}

const ValidatableEmail = ValidationMixin(EmailField);

Propriedades privadas em mixins são encapsuladas usando WeakMap:

const privateState = new WeakMap<object, Map<string, any>>();

function StatefulMixin<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    setState(key: string, value: any): void {
      if (!privateState.has(this)) {
        privateState.set(this, new Map());
      }
      privateState.get(this)!.set(key, value);
    }

    getState(key: string): any {
      return privateState.get(this)?.get(key);
    }
  };
}

7. Padrões Avançados e Boas Práticas

Mixins com estado podem usar factory functions para parametrização:

function ConfigurableMixin<TBase extends Constructor>(config: { prefix: string }) {
  return function <TBase extends Constructor>(Base: TBase) {
    return class extends Base {
      log(message: string): void {
        console.log(`${config.prefix}: ${message}`);
      }
    };
  };
}

const ProductionLogger = ConfigurableMixin({ prefix: "PROD" });
const DevLogger = ConfigurableMixin({ prefix: "DEV" });

Boas práticas:
- Prefira composição sobre herança quando possível
- Mantenha mixins focados em uma única responsabilidade
- Evite mixins que dependem de estado interno complexo
- Documente claramente os requisitos da classe base

Quando evitar mixins:
- Para comportamentos simples, use funções utilitárias
- Quando a hierarquia é clara, herança é mais adequada
- Para contratos sem implementação, use interfaces

8. Exemplo Prático: Sistema de Log e Validação

Vamos criar um sistema completo combinando mixins de log e validação:

type Constructor<T = {}> = new (...args: any[]) => T;

// Mixin Loggable
function Loggable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    private logHistory: string[] = [];

    log(level: string, message: string): void {
      const entry = `[${level.toUpperCase()}] ${new Date().toISOString()}: ${message}`;
      this.logHistory.push(entry);
      console.log(entry);
    }

    getLogs(): string[] {
      return [...this.logHistory];
    }
  };
}

// Mixin Validatable
interface HasEmail {
  email: string;
}

function Validatable<TBase extends Constructor<HasEmail>>(Base: TBase) {
  return class extends Base {
    validateEmail(): boolean {
      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      return emailRegex.test(this.email);
    }

    validateRequired(fields: string[]): boolean {
      return fields.every(field => (this as any)[field] !== undefined && (this as any)[field] !== null);
    }
  };
}

// Classe base
class User {
  constructor(
    public name: string,
    public email: string,
    public age: number
  ) {}
}

// Combinando mixins
const LoggableValidatableUser = Loggable(Validatable(User));

class UserService {
  createUser(name: string, email: string, age: number): LoggableValidatableUser {
    const user = new LoggableValidatableUser(name, email, age);

    user.log("info", `Creating user: ${name}`);

    if (!user.validateEmail()) {
      user.log("error", `Invalid email: ${email}`);
      throw new Error("Invalid email format");
    }

    if (!user.validateRequired(["name", "email", "age"])) {
      user.log("error", "Required fields missing");
      throw new Error("Required fields missing");
    }

    user.log("success", `User ${name} created successfully`);
    return user;
  }
}

// Uso
const service = new UserService();
try {
  const user = service.createUser("Alice", "alice@example.com", 30);
  console.log(user.getLogs());
} catch (error) {
  console.error(error);
}

Este exemplo demonstra como mixins permitem compor comportamentos complexos de forma modular e reutilizável, mantendo a tipagem forte do TypeScript.

Referências