awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
bespoyasov avatar

bespoyasov/frontend-clean-architecture

0
View on GitHub↗
2,575 stars·292 forks·TypeScript·28 viewsbespoyasov.me/blog/clean-architecture-on-frontend↗

Frontend Clean Architecture

This project provides a structural pattern for organizing React and TypeScript applications by decoupling business logic from user interface components and external infrastructure. It implements a layered architecture that isolates core domain rules, ensuring that the application remains independent of specific frameworks, libraries, or external service implementations.

The architecture relies on dependency injection and inversion principles to manage service implementations, allowing for modularity and easier testing. By utilizing a functional core and imperative shell, the system separates side effects from pure business logic, while shared type contracts and strict type safety ensure consistent data structures across all application modules.

The approach facilitates the creation of framework-agnostic use cases and domain entities that can be tested and maintained in isolation. By defining abstract interfaces for external services and implementing data translation layers, the project ensures that infrastructure-specific code does not leak into the primary business logic.

Features

  • Frontend Application Architectures - Structures complex React applications by separating business logic from user interface components and external infrastructure.
  • Pure Functional Cores - Encapsulates business logic in pure functions while isolating side effects to the boundary layer.
  • Business Entities - Encapsulates core business data and transformation logic into independent, framework-agnostic modules.
  • Business Logic Isolation - Decouples business entities from external dependencies by requiring data to be passed in during instantiation.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • Cross-Stack Type Contracts - Centralizes shared type definitions to ensure consistent data flow across application modules.
  • Data Adapters - Translates external service data into internal formats to maintain decoupling between infrastructure and business logic.
  • Dependency Injection Hooks - Uses component hooks to provide service implementations, facilitating modularity and easier testing.
  • Type Safety - Enforces strict type safety and consistent code patterns to prevent runtime errors during development.
  • Purely Functional Derivations - Organizes application logic using pure functions and immutable data patterns to improve testability.
  • TypeScript Dependency Injection Libraries - Manages service implementations through modular interfaces specifically for TypeScript applications.
  • Decoupled Logic Layers - Separates core business logic from UI components and infrastructure requirements through layered design.
  • Dependency Injection Containers - Manages service lifecycles and dependency resolution to facilitate modularity and testing.
  • Dependency Injection Patterns - Manages service implementations and external dependencies through modular interfaces to ensure portability.
  • External Service Integrations - Defines behavioral contracts for external services to ensure they remain interchangeable without modifying core logic.
  • Frontend Architecture Patterns - Provides a structural approach for organizing React and TypeScript applications into decoupled layers.
  • Fullstack Type Sharing - Shares type definitions across the application to ensure end-to-end type safety.
  • Functional Application Structuring - Structures application code using functional patterns to enhance predictability and testability.
  • Functional Programming - Methodology for building software using pure functions and immutable data patterns to improve maintainability.
  • Service Injection Patterns - Passes required services into business logic functions through dependency injection patterns to maintain modularity.
  • Clean Architecture Implementations - Implements layered architecture principles to decouple business logic from infrastructure and delivery mechanisms.
  • Dependency Inversion Patterns - Ensures high-level business logic depends on abstractions rather than concrete infrastructure implementations.
  • Service Layers - Uses service layers to decouple business logic from external data sources and API interactions.
  • Domain-Driven Designs - Aligns software architecture with business domains to ensure rules remain independent of UI and frameworks.
  • Layered Architectures - Organizes code into distinct functional layers to separate business rules from external concerns.
  • Logic Decoupling - Separates business rules from side effects and transport layers to ensure core logic remains testable.
  • Type-Safe Interface Architectures - Centralizes shared data structures and enforces strict type definitions to ensure consistency across large codebases.
  • TypeScript Architectural Patterns - Applies design principles for enforcing strict type safety and modularity across distinct application layers.
  • Shared Realtime Type Definitions - Centralizes TypeScript type definitions to ensure consistent data structures across all application modules.
  • Use Case Orchestrators - Coordinates interactions between external interfaces and domain entities through dedicated use case services.
  • Transport-Agnostic Use Cases - Extracts business logic into transport-agnostic functions that execute in isolation from UI or library hooks.
  • Side Effect Isolation - Separates external system interactions from pure business logic to ensure determinism.
  • External API Integrations - Connects web applications to external services while isolating infrastructure-specific data translation.

    • Star history

    Star history chart for bespoyasov/frontend-clean-architectureStar history chart for bespoyasov/frontend-clean-architecture

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does bespoyasov/frontend-clean-architecture do?

    This project provides a structural pattern for organizing React and TypeScript applications by decoupling business logic from user interface components and external infrastructure. It implements a layered architecture that isolates core domain rules, ensuring that the application remains independent of specific frameworks, libraries, or external service implementations.

    What are the main features of bespoyasov/frontend-clean-architecture?

    The main features of bespoyasov/frontend-clean-architecture are: Frontend Application Architectures, Pure Functional Cores, Business Entities, Business Logic Isolation, Cross-Stack Type Contracts, Data Adapters, Dependency Injection Hooks, Type Safety.

    Which projects share features with bespoyasov/frontend-clean-architecture?

    Projects with overlapping indexed features include: mattia-battiston/clean-architecture-example — This project is a reference implementation for structuring Java applications using clean architecture and… matthewrenze/clean-architecture-demo — This project serves as a reference implementation for applying clean architecture principles within a C# environment.… alexeymezenin/laravel-best-practices — This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable… sergdort/cleanarchitecturerxswift — This project is a Swift iOS architecture template that implements the Clean Architecture pattern. It organizes… cosmicpython/book — This project is a technical resource and pattern library for building enterprise applications with Python. It serves… day8/re-frame — re-frame is a functional framework for building single-page applications in ClojureScript. It provides a centralized,…

    Projects sharing features with Frontend Clean Architecture

    These projects share indexed features with Frontend Clean Architecture. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • mattia-battiston/clean-architecture-examplemattia-battiston avatar

      mattia-battiston/clean-architecture-example

      1,776View on GitHub↗

      This project is a reference implementation for structuring Java applications using clean architecture and domain-driven design principles. It provides a template for organizing code into concentric layers, ensuring that core business rules and domain entities remain entirely independent of external frameworks, databases, and delivery mechanisms. The architecture relies on the dependency inversion principle to decouple business logic from infrastructure. By defining abstract interfaces for data access and external services, the system allows for the replacement of underlying technologies witho

      Java
      View on GitHub↗1,776
    • matthewrenze/clean-architecture-demomatthewrenze avatar

      matthewrenze/clean-architecture-demo

      1,217View on GitHub↗

      This project serves as a reference implementation for applying clean architecture principles within a C# environment. It demonstrates how to structure enterprise applications by organizing code into concentric, independent layers that isolate core business logic from external infrastructure, frameworks, and database concerns. The codebase illustrates the application of domain-driven design to center software logic around business entities and rules. It utilizes interface-based decoupling and dependency inversion to ensure that high-level policies remain unaware of low-level implementation det

      C#
      View on GitHub↗1,217
    alexeymezenin/laravel-best-practicesalexeymezenin avatar

    alexeymezenin/laravel-best-practices

    12,299View on GitHub↗

    This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable applications within the Laravel framework. It focuses on clean code standards, applying the single responsibility and DRY principles to ensure codebase predictability and consistency. The guide emphasizes decoupling components by moving business logic into service layers and shifting input validation into dedicated request classes to keep controllers lean. It advocates for the use of a service container and dependency injection to reduce class coupling and improve testability. The

    View on GitHub↗12,299
  • cosmicpython/bookcosmicpython avatar

    cosmicpython/book

    3,823View on GitHub↗

    This project is a technical resource and pattern library for building enterprise applications with Python. It serves as a guide for implementing clean architecture, providing a framework for separating core business logic from infrastructure and external frameworks. The material focuses on Domain-Driven Design and the application of architectural patterns to maintain complex business requirements. It provides specific guidance on the Repository pattern for data abstraction, Command-Query Responsibility Segregation for optimizing read and write paths, and the use of dependency inversion to dec

    Python
    View on GitHub↗3,823
    • Compare all 30 related projects→

    Curated searches featuring Frontend Clean Architecture

    Hand-picked collections where Frontend Clean Architecture appears.
    • Clean Architecture and SOLID Principles