Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura

Wzorce zarządzania stanem w JavaScript/TypeScript

18 min czytania ·
W tej lekcji5

W centrum dowodzenia parku stan zmienia się co sekundę: otwarte bramy, nakarmione dinozaury, alarmy. Gdy każdy moduł zmienia te dane po swojemu, po awarii nikt nie wie, kto i kiedy otworzył bramę wybiegu Velociraptorów. Pomogą w tym wzorce zarządzania stanem. Poznasz trzy: Flux, Event Sourcing i maszyny stanów (State Machines).

Flux Architecture - Jednokierunkowy przepływ danych

Flux to wzorzec architektury aplikacji, który wprowadza jednokierunkowy przepływ danych, co czyni stan aplikacji bardziej przewidywalnym i łatwiejszym do debugowania. Zaproponował go Facebook: akcja trafia do dispatchera, ten przekazuje ją do store'ów, a widok odświeża się po zmianie.

Podstawowe składniki Flux

Akcja (Action) to obiekt z polem type i opcjonalnym payload, dispatcher rozsyła akcje, store przechowuje stan i powiadamia subskrybentów, a action creators to funkcje tworzące akcje:

// Typy dla Flux
type Action<T = any> = {
  type: string;
  payload?: T;
};

type Listener = () => void;

// Store - przechowuje stan aplikacji
class Store<T> {
  private state: T;
  private listeners: Listener[] = [];

  constructor(initialState: T) {
    this.state = initialState;
  }

  getState(): T {
    return this.state;
  }

  protected setState(newState: T): void {
    this.state = newState;
    this.emitChange();
  }

  subscribe(listener: Listener): () => void {
    this.listeners.push(listener);

    // Zwracamy funkcję do unsubscribe
    return () => {
      const index = this.listeners.indexOf(listener);
      if (index > -1) {
        this.listeners.splice(index, 1);
      }
    };
  }

  private emitChange(): void {
    this.listeners.forEach(listener => listener());
  }
}

// Dispatcher - centralny hub dla wszystkich akcji
class Dispatcher {
  private callbacks: Array<(action: Action) => void> = [];

  register(callback: (action: Action) => void): string {
    const id = Math.random().toString(36).slice(2, 11);
    this.callbacks.push(callback);
    return id;
  }

  dispatch(action: Action): void {
    console.log('Dispatching action:', action);
    this.callbacks.forEach(callback => {
      callback(action);
    });
  }
}

// Action Creators - funkcje tworzące akcje
const TodoActions = {
  addTodo: (text: string): Action<{ text: string }> => ({
    type: 'ADD_TODO',
    payload: { text }
  }),

  toggleTodo: (id: string): Action<{ id: string }> => ({
    type: 'TOGGLE_TODO',
    payload: { id }
  }),

  deleteTodo: (id: string): Action<{ id: string }> => ({
    type: 'DELETE_TODO',
    payload: { id }
  }),

  setFilter: (filter: 'all' | 'active' | 'completed'): Action<{ filter: string }> => ({
    type: 'SET_FILTER',
    payload: { filter }
  })
};

// Stan aplikacji
interface Todo {
  id: string;
  text: string;
  completed: boolean;
  createdAt: Date;
}

interface TodoState {
  todos: Todo[];
  filter: 'all' | 'active' | 'completed';
}

// Implementacja TodoStore
class TodoStore extends Store<TodoState> {
  constructor(dispatcher: Dispatcher) {
    super({
      todos: [],
      filter: 'all'
    });

    // Rejestracja w dispatcherze
    dispatcher.register((action: Action) => {
      this.handleAction(action);
    });
  }

  private handleAction(action: Action): void {
    const currentState = this.getState();

    switch (action.type) {
      case 'ADD_TODO':
        this.setState({
          ...currentState,
          todos: [
            ...currentState.todos,
            {
              id: Math.random().toString(36).slice(2, 11),
              text: action.payload.text,
              completed: false,
              createdAt: new Date()
            }
          ]
        });
        break;

      case 'TOGGLE_TODO':
        this.setState({
          ...currentState,
          todos: currentState.todos.map(todo =>
            todo.id === action.payload.id
              ? { ...todo, completed: !todo.completed }
              : todo
          )
        });
        break;

      case 'DELETE_TODO':
        this.setState({
          ...currentState,
          todos: currentState.todos.filter(todo => todo.id !== action.payload.id)
        });
        break;

      case 'SET_FILTER':
        this.setState({
          ...currentState,
          filter: action.payload.filter
        });
        break;

      case 'LOAD_TODOS_SUCCESS':
        this.setState({
          ...currentState,
          todos: action.payload.todos
        });
        break;

      default:
        // Brak zmian stanu dla nieznanych akcji
        break;
    }
  }

  // Selektory - funkcje do pobierania przetworzonych danych
  getFilteredTodos(): Todo[] {
    const { todos, filter } = this.getState();

    switch (filter) {
      case 'active':
        return todos.filter(todo => !todo.completed);
      case 'completed':
        return todos.filter(todo => todo.completed);
      default:
        return todos;
    }
  }

  getStats() {
    const todos = this.getState().todos;
    return {
      total: todos.length,
      completed: todos.filter(todo => todo.completed).length,
      active: todos.filter(todo => !todo.completed).length
    };
  }
}

// Użycie Flux
const dispatcher = new Dispatcher();
const todoStore = new TodoStore(dispatcher);

// Subskrypcja na zmiany
const unsubscribe = todoStore.subscribe(() => {
  console.log('Stan się zmienił:', {
    todos: todoStore.getFilteredTodos(),
    stats: todoStore.getStats(),
    filter: todoStore.getState().filter
  });
});

// Wykonywanie akcji
dispatcher.dispatch(TodoActions.addTodo('Nauka Flux'));
dispatcher.dispatch(TodoActions.addTodo('Implementacja TodoApp'));
dispatcher.dispatch(TodoActions.toggleTodo(todoStore.getState().todos[0].id));
dispatcher.dispatch(TodoActions.setFilter('active'));

Metoda setState jest chroniona, więc nowy stan ustawia wyłącznie akcja przepuszczona przez dispatcher. getState zwraca jednak referencję do obiektu stanu, przez którą da się go zmienić z pominięciem dispatchera. Dlatego nowy stan warto zamrozić, zanim store powiadomi subskrybentów: Object.freeze działa płytko, więc zamraża się też zagnieżdżone tablice, takie jak todos. Każdy element ma jedną odpowiedzialność (SRP), a store zwykle istnieje w jednej instancji, jak Singleton. W Reduxie logikę z handleAction przenosi się do reducera: czystej funkcji, która z obecnego stanu i akcji tworzy nowy stan.

Zaawansowany Flux z Middleware

Middleware to warstwa, przez którą każda akcja przechodzi przed dotarciem do store'a, jak śluza przed wybiegiem. Tu dodaje logowanie, debugowanie i obsługę akcji asynchronicznych:

// Middleware dla Flux
type Middleware = (action: Action, next: (action: Action) => void) => void;

class EnhancedDispatcher extends Dispatcher {
  private middlewares: Middleware[] = [];

  use(middleware: Middleware): void {
    this.middlewares.push(middleware);
  }

  dispatch(action: Action): void {
    let index = 0;

    const next = (currentAction: Action) => {
      if (index < this.middlewares.length) {
        const middleware = this.middlewares[index++];
        middleware(currentAction, next);
      } else {
        super.dispatch(currentAction);
      }
    };

    next(action);
  }
}

// Middleware do logowania
const loggingMiddleware: Middleware = (action, next) => {
  console.group(`Action: ${action.type}`);
  console.log('Payload:', action.payload);
  console.time('Action Duration');

  next(action);

  console.timeEnd('Action Duration');
  console.groupEnd();
};

// Middleware do debugowania
const debugMiddleware: Middleware = (action, next) => {
  if (process.env.NODE_ENV === 'development') {
    console.log('Debug: Before action', action);
  }

  next(action);

  if (process.env.NODE_ENV === 'development') {
    console.log('Debug: After action', action);
  }
};

// Middleware do obsługi akcji asynchronicznych
const asyncMiddleware: Middleware = (action, next) => {
  if (typeof action.payload === 'function') {
    // To jest akcja asynchroniczna
    action.payload((asyncAction: Action) => {
      next(asyncAction);
    });
  } else {
    next(action);
  }
};

// Async Action Creator
const AsyncTodoActions = {
  loadTodos: () => ({
    type: 'ASYNC_ACTION',
    payload: (dispatch: (action: Action) => void) => {
      // Symulacja wywołania API
      setTimeout(() => {
        dispatch({
          type: 'LOAD_TODOS_SUCCESS',
          payload: {
            todos: [
              { id: '1', text: 'Todo z API', completed: false, createdAt: new Date() }
            ]
          }
        });
      }, 1000);
    }
  })
};

// Użycie Enhanced Dispatcher
const enhancedDispatcher = new EnhancedDispatcher();
enhancedDispatcher.use(loggingMiddleware);
enhancedDispatcher.use(debugMiddleware);
enhancedDispatcher.use(asyncMiddleware);

const enhancedTodoStore = new TodoStore(enhancedDispatcher);

Każdy middleware decyduje, czy wywołać next, więc może przerwać, opóźnić albo wzbogacić akcję. Nowe zachowanie dopisujesz przez use, bez edycji klasy, zgodnie z zasadą otwarte/zamknięte.

Event Sourcing - Historia zdarzeń jako źródło prawdy

Event Sourcing to wzorzec, w którym stan aplikacji jest określany przez sekwencję zdarzeń, zamiast przechowywania aktualnego stanu bezpośrednio. To jak dziennik strażnika: nie nadpisujesz tablicy ze stanem wybiegu, tylko zapisujesz każde zdarzenie, a stan odtwarzasz, czytając dziennik od początku.

Podstawowa implementacja Event Sourcing

Agregat (Aggregate) to obiekt, którego stan budujemy z eventów, tutaj User. Metody takie jak changeEmail nie zmieniają stanu, tylko zwracają nowe eventy, a zmianę wykonuje dopiero apply:

// Typy dla Event Sourcing
interface Event {
  id: string;
  type: string;
  data: any;
  timestamp: Date;
  version: number;
}

interface Aggregate {
  id: string;
  version: number;
  apply(event: Event): void;
}

// Event Store - przechowuje wszystkie eventy
class EventStore {
  private events: Map<string, Event[]> = new Map();

  async saveEvents(aggregateId: string, events: Event[], expectedVersion: number): Promise<void> {
    const existingEvents = this.events.get(aggregateId) || [];

    if (existingEvents.length !== expectedVersion) {
      throw new Error('Concurrency conflict: unexpected version');
    }

    // Dodawanie nowych eventów
    const newEvents = events.map((event, index) => ({
      ...event,
      version: expectedVersion + index + 1,
      timestamp: new Date()
    }));

    this.events.set(aggregateId, [...existingEvents, ...newEvents]);
    console.log(`Saved ${newEvents.length} events for aggregate ${aggregateId}`);
  }

  async getEvents(aggregateId: string, fromVersion: number = 0): Promise<Event[]> {
    const events = this.events.get(aggregateId) || [];
    return events.filter(event => event.version > fromVersion);
  }

  async getAllEvents(): Promise<Event[]> {
    const allEvents: Event[] = [];
    for (const events of this.events.values()) {
      allEvents.push(...events);
    }
    return allEvents.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
  }
}

// Definicje eventów
const UserEvents = {
  UserCreated: (data: { name: string; email: string }) => ({
    type: 'UserCreated',
    data
  }),

  UserEmailChanged: (data: { email: string }) => ({
    type: 'UserEmailChanged',
    data
  }),

  UserDeactivated: (data: { reason: string }) => ({
    type: 'UserDeactivated',
    data
  }),

  UserReactivated: () => ({
    type: 'UserReactivated',
    data: {}
  })
};

// User Aggregate
class User implements Aggregate {
  id: string;
  version: number = 0;
  name: string = '';
  email: string = '';
  isActive: boolean = true;
  createdAt?: Date;
  deactivatedAt?: Date;

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

  // Metody do tworzenia eventów (commands)
  static create(id: string, name: string, email: string): { user: User; events: any[] } {
    const user = new User(id);
    const events = [UserEvents.UserCreated({ name, email })];
    return { user, events };
  }

  changeEmail(newEmail: string): any[] {
    if (this.email === newEmail) {
      return []; // Brak zmian
    }

    if (!this.isActive) {
      throw new Error('Cannot change email for deactivated user');
    }

    return [UserEvents.UserEmailChanged({ email: newEmail })];
  }

  deactivate(reason: string): any[] {
    if (!this.isActive) {
      return []; // Już nieaktywny
    }

    return [UserEvents.UserDeactivated({ reason })];
  }

  reactivate(): any[] {
    if (this.isActive) {
      return []; // Już aktywny
    }

    return [UserEvents.UserReactivated()];
  }

  // Aplikowanie eventów do zmiany stanu
  apply(event: Event): void {
    switch (event.type) {
      case 'UserCreated':
        this.name = event.data.name;
        this.email = event.data.email;
        this.createdAt = event.timestamp;
        this.isActive = true;
        break;

      case 'UserEmailChanged':
        this.email = event.data.email;
        break;

      case 'UserDeactivated':
        this.isActive = false;
        this.deactivatedAt = event.timestamp;
        break;

      case 'UserReactivated':
        this.isActive = true;
        this.deactivatedAt = undefined;
        break;

      default:
        throw new Error(`Unknown event type: ${event.type}`);
    }

    this.version = event.version;
  }

  // Odtwarzanie stanu z eventów
  static fromHistory(id: string, events: Event[]): User {
    const user = new User(id);
    events.forEach(event => user.apply(event));
    return user;
  }
}

// Repository dla User Aggregate
class UserRepository {
  constructor(private eventStore: EventStore) {}

  async save(user: User, newEvents: any[]): Promise<void> {
    if (newEvents.length === 0) return;

    const events = newEvents.map(eventData => ({
      id: Math.random().toString(36).slice(2, 11),
      type: eventData.type,
      data: eventData.data,
      timestamp: new Date(),
      version: 0 // Zostanie ustawiona w EventStore
    }));

    await this.eventStore.saveEvents(user.id, events, user.version);

    // Aplikowanie zapisanych eventów (z wersjami nadanymi przez EventStore) do aggregate
    const savedEvents = await this.eventStore.getEvents(user.id, user.version);
    savedEvents.forEach(event => user.apply(event));
  }

  async getById(id: string): Promise<User | null> {
    const events = await this.eventStore.getEvents(id);

    if (events.length === 0) {
      return null;
    }

    return User.fromHistory(id, events);
  }
}

// Użycie Event Sourcing
async function demonstrateEventSourcing() {
  const eventStore = new EventStore();
  const userRepository = new UserRepository(eventStore);

  // Tworzenie użytkownika
  const { user, events } = User.create('user1', 'Jan Kowalski', 'jan@example.com');
  await userRepository.save(user, events);

  console.log('Użytkownik po utworzeniu:', user);

  // Zmiana emaila
  const emailChangeEvents = user.changeEmail('jan.kowalski@example.com');
  await userRepository.save(user, emailChangeEvents);

  console.log('Użytkownik po zmianie emaila:', user);

  // Dezaktywacja
  const deactivateEvents = user.deactivate('User requested account deletion');
  await userRepository.save(user, deactivateEvents);

  console.log('Użytkownik po dezaktywacji:', user);

  // Reaktywacja
  const reactivateEvents = user.reactivate();
  await userRepository.save(user, reactivateEvents);

  console.log('Użytkownik po reaktywacji:', user);

  // Odtworzenie stanu z eventów
  const reconstructedUser = await userRepository.getById('user1');
  console.log('Odtworzony użytkownik:', reconstructedUser);

  // Historia wszystkich eventów
  const allEvents = await eventStore.getAllEvents();
  console.log('Historia eventów:', allEvents);
}

demonstrateEventSourcing();

EventStore pilnuje wersji: jeśli ktoś w międzyczasie dopisał event, zapis kończy się konfliktem (optymistyczna kontrola współbieżności). Dlatego repozytorium aplikuje eventy z wersjami nadanymi przez magazyn, a fromHistory odtwarza użytkownika z samej historii.

Projektory i Read Models

Czytanie całej historii przy każdym pytaniu byłoby wolne. Projektor słucha eventów i buduje z nich model gotowy do odczytu (read model), na przykład statystyki:

// Projektor - tworzy read modele z eventów
abstract class Projector {
  abstract getProjectionName(): string;
  abstract handle(event: Event): Promise<void>;
}

// Read Model dla statystyk użytkowników
interface UserStats {
  totalUsers: number;
  activeUsers: number;
  deactivatedUsers: number;
  emailChanges: number;
}

class UserStatsProjector extends Projector {
  private stats: UserStats = {
    totalUsers: 0,
    activeUsers: 0,
    deactivatedUsers: 0,
    emailChanges: 0
  };

  getProjectionName(): string {
    return 'UserStats';
  }

  async handle(event: Event): Promise<void> {
    switch (event.type) {
      case 'UserCreated':
        this.stats.totalUsers++;
        this.stats.activeUsers++;
        break;

      case 'UserEmailChanged':
        this.stats.emailChanges++;
        break;

      case 'UserDeactivated':
        this.stats.activeUsers--;
        this.stats.deactivatedUsers++;
        break;

      case 'UserReactivated':
        this.stats.activeUsers++;
        this.stats.deactivatedUsers--;
        break;
    }

    console.log(`[UserStatsProjector] Updated stats:`, this.stats);
  }

  getStats(): UserStats {
    return { ...this.stats };
  }
}

// Event Bus dla projektorów
class EventBus {
  private projectors: Projector[] = [];

  registerProjector(projector: Projector): void {
    this.projectors.push(projector);
  }

  async publishEvent(event: Event): Promise<void> {
    console.log(`Publishing event: ${event.type}`);

    const promises = this.projectors.map(projector =>
      projector.handle(event).catch(error => {
        console.error(`Error in projector ${projector.getProjectionName()}:`, error);
      })
    );

    await Promise.all(promises);
  }
}

// Enhanced Event Store z Event Bus
class EnhancedEventStore extends EventStore {
  constructor(private eventBus: EventBus) {
    super();
  }

  async saveEvents(aggregateId: string, events: Event[], expectedVersion: number): Promise<void> {
    await super.saveEvents(aggregateId, events, expectedVersion);

    // Publikowanie eventów do projektorów
    const savedEvents = await this.getEvents(aggregateId, expectedVersion);
    for (const event of savedEvents) {
      await this.eventBus.publishEvent(event);
    }
  }
}

// Użycie z projektorami
async function demonstrateProjectors() {
  const eventBus = new EventBus();
  const userStatsProjector = new UserStatsProjector();

  eventBus.registerProjector(userStatsProjector);

  const enhancedEventStore = new EnhancedEventStore(eventBus);
  const userRepository = new UserRepository(enhancedEventStore);

  // Wykonanie operacji - projektory będą automatycznie aktualizowane
  const { user, events } = User.create('user2', 'Anna Nowak', 'anna@example.com');
  await userRepository.save(user, events);

  const emailChangeEvents = user.changeEmail('anna.nowak@example.com');
  await userRepository.save(user, emailChangeEvents);

  console.log('Finalne statystyki:', userStatsProjector.getStats());
}

demonstrateProjectors();

Projektor nie zmienia historii, tylko ją streszcza, więc nowy możesz dodać w dowolnej chwili i zasilić istniejącymi eventami.

State Machines (Maszyny stanów) z XState

Maszyny stanów pozwalają na modelowanie złożonych przepływów stanów w sposób deklaratywny i przewidywalny. Maszyna jest zawsze w dokładnie jednym stanie, a przejście następuje tylko po zdarzeniu dozwolonym w tym stanie, jak brama, której nie otworzysz w trakcie karmienia.

Podstawowa maszyna stanów

Najpierw własna maszyna. Każdy stan ma mapę on, w której zdarzenie wskazuje kolejny stan, oraz opcjonalne entry i exit, uruchamiane przy wejściu i wyjściu:

// Implementacja prostej maszyny stanów (bez XState)
interface StateDefinition {
  on: Record<string, string>;
  entry?: () => void;
  exit?: () => void;
}

interface MachineConfig {
  id: string;
  initial: string;
  states: Record<string, StateDefinition>;
}

class StateMachine {
  private currentState: string;
  private config: MachineConfig;
  private listeners: Array<(state: string) => void> = [];

  constructor(config: MachineConfig) {
    this.config = config;
    this.currentState = config.initial;
    this.executeEntry();
  }

  getCurrentState(): string {
    return this.currentState;
  }

  send(event: string): void {
    const currentStateConfig = this.config.states[this.currentState];
    const nextState = currentStateConfig.on[event];

    if (!nextState) {
      console.warn(`Event "${event}" not handled in state "${this.currentState}"`);
      return;
    }

    this.transition(nextState);
  }

  private transition(nextState: string): void {
    if (!this.config.states[nextState]) {
      throw new Error(`State "${nextState}" not defined`);
    }

    console.log(`Transition: ${this.currentState} -> ${nextState}`);

    // Wyjście z bieżącego stanu
    this.executeExit();

    // Zmiana stanu
    const previousState = this.currentState;
    this.currentState = nextState;

    // Wejście do nowego stanu
    this.executeEntry();

    // Powiadomienie subskrybentów
    this.listeners.forEach(listener => listener(this.currentState));
  }

  private executeEntry(): void {
    const stateConfig = this.config.states[this.currentState];
    if (stateConfig.entry) {
      stateConfig.entry();
    }
  }

  private executeExit(): void {
    const stateConfig = this.config.states[this.currentState];
    if (stateConfig.exit) {
      stateConfig.exit();
    }
  }

  subscribe(listener: (state: string) => void): () => void {
    this.listeners.push(listener);
    return () => {
      const index = this.listeners.indexOf(listener);
      if (index > -1) {
        this.listeners.splice(index, 1);
      }
    };
  }
}

// Przykład: Maszyna stanów dla procesu zamówienia
const orderMachine = new StateMachine({
  id: 'order',
  initial: 'cart',
  states: {
    cart: {
      on: {
        CHECKOUT: 'checkout'
      },
      entry: () => console.log('Entered cart state'),
      exit: () => console.log('Exited cart state')
    },
    checkout: {
      on: {
        PAYMENT: 'payment',
        BACK_TO_CART: 'cart'
      },
      entry: () => console.log('Entered checkout state')
    },
    payment: {
      on: {
        SUCCESS: 'confirmed',
        FAILURE: 'payment_failed',
        BACK_TO_CHECKOUT: 'checkout'
      },
      entry: () => console.log('Processing payment...')
    },
    payment_failed: {
      on: {
        RETRY: 'payment',
        BACK_TO_CHECKOUT: 'checkout'
      },
      entry: () => console.log('Payment failed!')
    },
    confirmed: {
      on: {
        FULFILL: 'shipped'
      },
      entry: () => console.log('Order confirmed!')
    },
    shipped: {
      on: {
        DELIVER: 'delivered'
      },
      entry: () => console.log('Order shipped!')
    },
    delivered: {
      on: {},
      entry: () => console.log('Order delivered!')
    }
  }
});

// Subskrypcja na zmiany stanu
orderMachine.subscribe((state) => {
  console.log(`Current state: ${state}`);
});

// Symulacja przepływu zamówienia
console.log('=== Order Flow Simulation ===');
orderMachine.send('CHECKOUT');
orderMachine.send('PAYMENT');
orderMachine.send('SUCCESS');
orderMachine.send('FULFILL');
orderMachine.send('DELIVER');

Zdarzenie niedozwolone w bieżącym stanie, na przykład DELIVER w koszyku, jest ignorowane z ostrzeżeniem, więc nieprawidłowe przejście jest niemożliwe.

Integracja z XState (konceptualna)

XState to popularna biblioteka maszyn stanów. Dokłada kontekst (dane obok stanu), strażników (guards) blokujących przejścia i wywoływanie usług, takich jak płatność:

// Przykład jak wyglądałaby maszyna stanów z XState
// (kod konceptualny - wymaga instalacji XState)

/*
import { createMachine, interpret } from 'xstate';

const orderMachineXState = createMachine({
  id: 'order',
  initial: 'cart',
  context: {
    items: [],
    total: 0,
    customer: null
  },
  states: {
    cart: {
      on: {
        ADD_ITEM: {
          actions: 'addItem'
        },
        REMOVE_ITEM: {
          actions: 'removeItem'
        },
        CHECKOUT: {
          target: 'checkout',
          cond: 'hasItems'
        }
      }
    },
    checkout: {
      entry: 'calculateTotal',
      on: {
        PAYMENT: 'payment',
        BACK_TO_CART: 'cart'
      }
    },
    payment: {
      invoke: {
        id: 'paymentService',
        src: 'processPayment',
        onDone: {
          target: 'confirmed',
          actions: 'savePaymentInfo'
        },
        onError: {
          target: 'payment_failed',
          actions: 'savePaymentError'
        }
      },
      on: {
        BACK_TO_CHECKOUT: 'checkout'
      }
    },
    payment_failed: {
      on: {
        RETRY: 'payment',
        BACK_TO_CHECKOUT: 'checkout'
      }
    },
    confirmed: {
      entry: 'sendConfirmationEmail',
      on: {
        FULFILL: 'shipped'
      }
    },
    shipped: {
      entry: 'sendShippingNotification',
      on: {
        DELIVER: 'delivered'
      }
    },
    delivered: {
      entry: 'sendDeliveryConfirmation',
      type: 'final'
    }
  }
}, {
  actions: {
    addItem: (context, event) => {
      // Dodaj produkt do koszyka
    },
    removeItem: (context, event) => {
      // Usuń item z koszyka
    },
    calculateTotal: (context) => {
      // Oblicz sumę
    },
    savePaymentInfo: (context, event) => {
      // Zapisz info o płatności
    }
  },
  guards: {
    hasItems: (context) => context.items.length > 0
  },
  services: {
    processPayment: (context) => {
      // Zwraca Promise z procesem płatności
      return fetch('/api/payment', {
        method: 'POST',
        body: JSON.stringify(context)
      });
    }
  }
});
*/

Kod jest w komentarzu, bo wymaga instalacji biblioteki, i używa API XState 4. W wersji 5 funkcję interpret zastąpiło createActor, cond nazywa się guard, services to actors, akcje i strażnicy dostają jeden obiekt ({ context, event }), a usługę zwracającą Promise trzeba opakować w fromPromise.

Zaawansowane maszyny stanów z hierarchią

Maszyna może też przechowywać kontekst, jak odtwarzacz muzyki z głośnością i playlistą:

// Hierarchiczna maszyna stanów dla odtwarzacza muzyki
interface PlayerContext {
  currentTrack: string | null;
  volume: number;
  position: number;
  playlist: string[];
}

class HierarchicalStateMachine extends StateMachine {
  private context: any = {};

  constructor(config: MachineConfig, initialContext: any = {}) {
    super(config);
    this.context = { ...initialContext };
  }

  getContext(): any {
    return { ...this.context };
  }

  updateContext(updates: any): void {
    this.context = { ...this.context, ...updates };
  }
}

const musicPlayerMachine = new HierarchicalStateMachine({
  id: 'musicPlayer',
  initial: 'stopped',
  states: {
    stopped: {
      on: {
        PLAY: 'playing',
        LOAD: 'loading'
      },
      entry: () => console.log('Player stopped')
    },
    loading: {
      on: {
        LOADED: 'playing',
        ERROR: 'error'
      },
      entry: () => console.log('Loading track...')
    },
    playing: {
      on: {
        PAUSE: 'paused',
        STOP: 'stopped',
        NEXT: 'loading',
        PREVIOUS: 'loading'
      },
      entry: () => console.log('Playing music'),
      exit: () => console.log('Stopped playing')
    },
    paused: {
      on: {
        PLAY: 'playing',
        STOP: 'stopped'
      },
      entry: () => console.log('Music paused')
    },
    error: {
      on: {
        RETRY: 'loading',
        STOP: 'stopped'
      },
      entry: () => console.log('Error loading track')
    }
  }
}, {
  currentTrack: null,
  volume: 50,
  position: 0,
  playlist: ['track1.mp3', 'track2.mp3']
});

// Symulacja odtwarzacza
console.log('=== Music Player Simulation ===');
musicPlayerMachine.send('LOAD');
musicPlayerMachine.send('LOADED');
musicPlayerMachine.send('PAUSE');
musicPlayerMachine.send('PLAY');
musicPlayerMachine.send('NEXT');

Nazwa klasy jest na wyrost: to wciąż płaska maszyna rozszerzona o kontekst. Prawdziwa hierarchia oznacza stany zagnieżdżone, na przykład playing z podstanami normal i shuffle, co XState obsługuje natywnie.

Porównanie wzorców zarządzania stanem

Kiedy używać którego wzorca?

W dużej aplikacji wzorce często współpracują, a każdy odpowiada za inny rodzaj stanu:

// Przykład aplikacji używającej wszystkich trzech wzorców

// 1. Flux - do prostego zarządzania stanem UI
class UIStateManager {
  // Zarządzanie stanem komponentów UI, formularzy, modali
}

// 2. Event Sourcing - do logiki biznesowej z historią
class OrderEventStore {
  // Zarządzanie zamówieniami z pełną historią zmian
}

// 3. State Machines - dla złożonych przepływów
class WorkflowStateMachine extends StateMachine {
  // Zarządzanie przepływami biznesowymi (np. procesami akceptacji)
}

// Kombinacja wzorców w jednej aplikacji
class ApplicationStateManager {
  private uiState: UIStateManager;
  private orderEvents: OrderEventStore;
  private workflows: Map<string, WorkflowStateMachine>;

  constructor() {
    this.uiState = new UIStateManager();
    this.orderEvents = new OrderEventStore();
    this.workflows = new Map();
  }

  // Flux dla UI
  updateUI(action: Action): void {
    // this.uiState.dispatch(action);
  }

  // Event Sourcing dla zdarzeń biznesowych
  processBusinessEvent(event: Event): void {
    // this.orderEvents.append(event);
  }

  // State Machines dla przepływów pracy
  advanceWorkflow(workflowId: string, event: string): void {
    const workflow = this.workflows.get(workflowId);
    if (workflow) {
      workflow.send(event);
    }
  }
}

Flux obsługuje stan interfejsu, Event Sourcing dane biznesowe z historią, a maszyny stanów przepływy, takie jak akceptacja zamówienia.

Najlepsze praktyki

Trzy zasady porządkują pracę: rozdziel rodzaje stanu, testuj każdy wzorzec osobno i dbaj o wydajność:

// 1. Separation of Concerns - rozdzielenie odpowiedzialności
interface StatePattern {
  // UI State - Flux/Redux
  uiState: {
    loading: boolean;
    errors: string[];
    notifications: any[];
  };

  // Business State - Event Sourcing
  businessEvents: Event[];

  // Workflow State - State Machines
  workflows: Record<string, string>; // workflowId -> currentState
}

// 2. Testowanie wzorców
class StatePatternTests {
  testFluxActions(): void {
    // Testy action creators, reducerów i store'ów
  }

  testEventSourcing(): void {
    // Testy aplikowania eventów i projektorów
  }

  testStateMachines(): void {
    // Testy przejść stanów, strażników i akcji
  }
}

// 3. Wydajność
class PerformanceOptimizations {
  // Memoizacja selektorów Flux
  memoizedSelectors = new Map();

  // Snapshotting dla Event Sourcing
  snapshots = new Map();

  // Cache instancji maszyn stanów
  machineInstances = new Map();
}

Memoizacja selektorów oszczędza obliczeń we Fluksie, a snapshoty w Event Sourcing pozwalają odtwarzać stan od ostatniej migawki zamiast od pierwszego eventu.

Podsumowanie wzorców zarządzania stanem

Flux daje prosty jednokierunkowy przepływ, łatwe debugowanie i śledzenie zmian, więc pasuje do stanu UI, choć w prostych aplikacjach bywa przerostem formy. Event Sourcing daje pełną historię, odtworzenie stanu z dowolnego momentu i naturalny audyt, kosztem złożoności i miejsca na dysku. Maszyny stanów jasno modelują złożone przepływy, wykluczają nieprawidłowe stany i łatwo je wizualizować oraz testować, choć wymagają nauki i bywają przesadą dla prostych stanów.

Moja rekomendacja: w małej aplikacji wystarczy podstawowy stan (useState, signals), w średniej Flux/Redux dla UI, w dużej kombinacja wzorców, a w systemach klasy enterprise Event Sourcing i maszyny stanów dla krytycznych procesów. W edytorze poniżej zbudujesz system bezpieczeństwa parku, a w kolejnej lekcji zajmiemy się code splittingiem i tree shakingiem.

Pamiętaj: stan parku to jego pamięć, więc zmieniaj go tylko przez jedną, dobrze pilnowaną bramę.

Kod do tej lekcji: index.js
// System Bezpieczeństwa Parku
// Ćwiczenie: Zaimplementuj system monitoringu sensorów

class SecuritySystem {
  constructor() {
    this.sensors = new Map();
    this.alerts = [];
    this.securityLevel = "GREEN";
  }

  // Zaimplementuj metody:
  // addSensor(zone, type) - dodaj sensor do strefy
  // triggerAlert(zone, severity) - wyzwól alert
  // getStatus() - zwróć status bezpieczeństwa

  addSensor(zone, type) {
    // Twój kod tutaj
  }

  triggerAlert(zone, severity) {
    // Twój kod tutaj
  }

  getStatus() {
    // Twój kod tutaj
  }
}

const security = new SecuritySystem();
security.addSensor("Sektor A", "motion");
console.log("System bezpieczeństwa aktywny");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co oznacza zasada Single Responsibility Principle (SRP)?

  2. 2. Co oznacza zasada Open/Closed Principle?

Zadania praktyczne w grze

  • Edytor kodu

    W pliku index.js jest klasa VisitorManagementSystem, która trzyma odwiedzających w Map pod numerem biletu. Uzupełnij luki: ___BLANK1___ to metoda Map, która zwraca odwiedzającego dla numeru biletu, ___BLANK2___ to metoda tablicy, która z listy odwiedzających buduje jeden obiekt z liczbą osób w każdej strefie (startuje od pustego obiektu {}), a ___BLANK3___ to właściwość Map z liczbą zapisanych odwiedzających. trackVisitorLocation ma zwrócić false dla nieznanego biletu, a getStats() zwrócić { total, byZone }, np. { total: 2, byZone: { entrance: 1, raptors: 1 } }.

  • Układanie w pionie

    Uporządkuj etapy implementacji wzorca Singleton:

  • Edytor kodu

    W pliku index.js jest klasa GeneticLaboratory. Uzupełnij luki: ___BLANK1___ to metoda wyrażenia regularnego, która sprawdza, czy napis pasuje do wzorca (sekwencja zawiera tylko litery A, C, G i T), i zwraca true albo false, ___BLANK2___ to pole wyniku analyzeDNA, które mówi, czy DNA jest poprawne, a ___BLANK3___ to wyrażenie, które zwraca nową tablicę ze wszystkimi gatunkami zapisanymi w Map this.species. analyzeDNA ma zwrócić { valid, length, gcContent }, synthesize nie może utworzyć gatunku z niepoprawnego DNA (zwraca wtedy null), a getSpeciesDatabase zwraca tablicę gatunków.

  1. PytanieZasada Single Responsibility
  2. PytanieZasada Open/Closed
  3. Zadanie z kodemĆwiczenie: System odwiedzających
  4. Ułóż w kolejnościEtapy implementacji wzorca Singleton
  5. Zadanie z kodemĆwiczenie: Laboratorium genetyczne

Przydatne artykuły