moleculerjs/moleculer

Features

• Microservice Definitions - Allows defining named microservices with executable actions that can be called by other services in the cluster.
• Node.js Microservices Frameworks - Provides a decentralized architecture for building scalable distributed systems specifically for the Node.js runtime.
• Database Adapters - Provides standardized interfaces to decouple service logic from specific database engines like MongoDB, SQL, and CouchDB.
• Automated Node Discovery - Automatically detects available nodes on a network using UDP discovery or Gossip protocols.
• Distributed Task Orchestration - Provides a coordinated environment for executing parallel service calls, background jobs, and event-driven workflows across multiple nodes.
• Service Discovery - Provides automatic detection and tracking of available service nodes across a cluster for seamless request routing.
• REST API Endpoint Management - Maps internal microservice actions to RESTful HTTP endpoints using aliases and dynamic schemas.
• Service Meshes - Manages inter-service communication by providing built-in circuit breakers, retries, and distributed tracing across a cluster.
• API Gateways - Provides a dedicated API gateway that acts as the primary entry point to manage and route traffic to internal microservices.
• Pluggable Transport Layers - Implements modular interfaces that allow swapping the underlying network transport layer for inter-service communication.
• Middleware-Based Request Pipelines - Implements a modular pipeline of pluggable components to intercept and process service requests and responses.
• Dynamic Service Discovery - Registers services in a shared directory to enable communication between components without hardcoded addresses.
• Event Subscription Bindings - Links specific code handlers to asynchronous event topics for automatic execution upon event production.
• Load Balancers - Distributes incoming requests and events across available service instances using strategies like round-robin or latency.
• Message Brokers - Functions as a communication layer that routes requests and events between independent nodes using pluggable transports.
• Identity and Access Management - Handles core authentication, authorization, and access control lists to protect service actions via JWT or OAuth2.
• API Gateways - Implements a routing layer that maps external HTTP and WebSocket requests to internal service actions with OpenAPI documentation.
• Cluster Load Balancing - Distributes actions and events across cluster nodes using strategies such as round-robin or sharding.
• Event Bus Architectures - Implements an event-bus architecture for asynchronous message passing and decoupled service communication.
• Event Driven Messaging - Implements a decoupled architecture where services communicate via asynchronous events and broadcast messages using message brokers.
• Fault Tolerance - Prevents cascading failures in distributed environments using built-in circuit breakers, retries, and request timeouts.
• Middleware Lifecycle Hooks - Processes service calls through a chain of pluggable hooks to handle validation, authorization, and metadata.
• Remote Action Executions - The project triggers actions across a distributed system and returns the results as promises.
• Action Lifecycle Hooks - Allows developers to run custom logic before and after service actions to manipulate metadata and response data.
• Remote Service Invocations - Calls specific actions on target services using transparent, message-based remote invocation.
• Service Schema Definitions - Creates and registers service instances within the system by parsing structured schema objects.
• Distributed Event Emission - Enables sending payloads or broadcast events to a distributed system to trigger asynchronous reactions.
• Message Broker Routing - Uses message brokers like NATS or Redis to route events between decoupled server processes.
• API Parameter Validation - Enforces data integrity by checking incoming action and event parameters against a defined schema before execution.
• API Routing - Defines HTTP endpoints and routes with independent path prefixes and authorization settings for organized request handling.
• Node.js Server Frameworks - Provides an architectural framework for building distributed Node.js applications with built-in discovery and load balancing.
• Service Action Exposure - Creates public, callable methods within services that can be invoked by other services or the broker.
• Schema Validation - Enforces type safety and data integrity on incoming requests using a variety of supported schema validation libraries.
• CRUD Operations - Ships a set of default actions for creating, reading, updating, and deleting records via pluggable adapters.
• Data Serialization Formats - Supports multiple data serialization formats like JSON and MsgPack for efficient network transport.
• Data Storage Adapters - Abstracts database operations through a pluggable adapter interface to support multiple backends like MongoDB and SQL.
• Payload Serialization - Handles the conversion of data objects into optimized formats for efficient transmission across the network.
• Distributed Event Distribution - Supports both balanced distribution and global broadcasting of messages to services across the distributed system.
• Service Call Caches - Stores results of service actions in memory or external stores to avoid redundant executions of the same logic.
• Multi-Instance Event Broadcasting - Routes real-time events to every instance of a service across multiple server instances for simultaneous processing.
• Cross-Service Entity Population - Resolves identifiers by fetching related data from other microservices, supporting deep and recursive lookups.
• API Documentation Generators - Automatically generates OpenAPI and Swagger specifications based on the parameters defined within service actions.
• Dynamic Service Loading - Automatically discovers and instantiates services from the filesystem using glob patterns and configuration.
• Interactive Consoles - Provides a shell environment for live process communication, enabling action calls and event emission.
• Interactive REPLs - Includes an interactive read-eval-print loop for executing code snippets and inspecting system state in real time.
• Request Retries - Automatically re-executes service calls when retryable errors are encountered to handle transient network failures.
• Broker Instance Scaling - Scales processing capacity by starting multiple copies of the broker with unique worker IDs.
• Service Logic Bootstrapping - Bootstraps microservice instances by initializing logic and action parameters from configuration objects or files.
• CLI Service Bootstrapping - Loads broker configurations and service files from the command line to start the system and enter REPL mode.
• Reusable Service Schemas - Distributes common logic across the system by merging reusable schemas into service definitions.
• Containerized Deployment Orchestration - Orchestrates the distribution of services across multiple containers using environment variables to configure transporters.
• Local Development Environments - Launches a local broker instance with debugging tools and an interactive REPL for development.
• Graceful Shutdowns - Ensures clean termination by allowing in-flight requests to complete before services are deregistered during shutdown.
• Hybrid Deployment Architectures - Supports flexible deployment strategies that allow mixing monolithic and distributed microservice organization on single or multiple nodes.
• Request Rate Limiting - Caps the number of requests a client can make within a specific time window to protect system capacity.
• Service Startup Sequencing - Ensures a service waits for specific required services to be available before completing its startup process.
• Service Lifecycle Management - Executes specific logic during service creation, startup, and shutdown to handle resource allocation.
• Request Timeout Configurations - Sets maximum wait times for service responses at the global, action, or individual call level.
• Custom Load Balancers - Allows the definition of bespoke node selection algorithms by implementing custom selection methods.
• Request Timeout Management - Limits the duration a service call can run and propagates the remaining time across nested distributed calls.
• HTTP2 Protocol Support - Implements the HTTP2 protocol to optimize network performance and reduce latency for service communication.
• Pluggable Serialization - Provides a pluggable serialization pipeline allowing swappable encoders like JSON or MsgPack for network transport.
• Remote Server Connectivity - Allows a local broker to connect to remote transporter servers to interact with a distributed system.
• Service-to-Service Streaming - Provides asynchronous message streaming specifically designed for communication between distributed backend services.
• Circuit Breakers - Prevents cascading failures by tripping a circuit breaker when service failure rates exceed a defined threshold.
• Node-Aware Routing - Directs requests only to healthy, active nodes by consulting a registry of operational services.
• API Access Restrictions - Filters which service actions are reachable via the gateway using whitelist string matches or regular expressions.
• Custom Authorization Logic - Provides customizable authorization methods to enforce business-specific access rules for individual routes.
• Service Communication Security - Secures inter-service communication using JWT, OAuth2, and centralized identity management.
• AES-Encrypted Transports - Protects data exchanged between services via the transporter using AES encryption.
• Action Lifecycle Middleware - Provides middleware hooks to intercept and manipulate the start and finish of service action lifecycles.
• Environment Variable-Based Configuration - Overrides broker settings and nested options using environment variables or dot-env files.
• Service Logic Mixins - Allows sharing reusable functionality and behavior across multiple services by merging mixins into service schemas.
• Circuit Breakers - Implements a circuit breaker pattern that stops repeated calls to failing services based on error rates within a time window.
• Custom Validators - Allows replacing the default validation engine with a custom class or external library for specialized constraints.
• Local Call Prioritization - Routes requests to a local service instance first to avoid network latency before attempting cluster load balancing.
• Service Call Fallbacks - Provides alternative content or executes backup actions when a primary service call fails or times out.
• Exception Handling Strategies - Implements patterns for catching and recovering from unhandled errors in action and event handlers.
• Background Task Schedulers - Ships utilities for managing recurring, scheduled, or delayed background operations and job execution.
• Internal Service Methods - Implements internal helper functions within services that are inaccessible to the broker but reusable by actions.
• Parallel Task Execution - Triggers multiple service calls simultaneously to aggregate data or perform concurrent tasks in parallel.
• Process Isolation - Runs isolated, self-contained modules as separate processes to ensure a crash in one component does not affect the system.
• Request Context State - Maintains lightweight data within the request context to share information between middleware hooks and action handlers.
• Service Action Visibility - Allows defining whether service actions are accessible publicly via gateways, remotely across nodes, or strictly internally.
• State Machine Orchestrators - Provides frameworks for managing complex business logic through state transitions and persistent history.
• Concurrent Request Limits - Controls the number of simultaneous request handlers and queue size to protect system resources from being overwhelmed.
• Application Metric Tracking - Implements specialized counters, gauges, and histograms to track application-specific performance events.
• Cluster State Retrieval - Enables fetching and filtering the current operational state of the distributed cluster, including active nodes and services.
• Event Monitoring Systems - Provides tools for tracking and observing system state changes and message traffic in real-time.
• System Metrics Collection - Gathers internal process and framework performance data for export to tools like Prometheus and Datadog.
• Distributed Tracing - Connects disparate spans by passing parent and request identifiers through external communication channels.
• Node Health Tracking - Monitors the operational status of individual nodes using heartbeats to determine cluster availability.
• Service Mesh Observability - Enables monitoring of system health through distributed tracing, performance metrics, and centralized logging across multiple nodes.
• Service Traffic Logging - Tracks messages exchanged between services and the execution details of specific service actions for debugging.
• Distributed Request Tracing - Tracks a request's path across multiple services and exports spans to distributed tracing tools like Jaeger and Zipkin.
• Balanced Event Emissions - The project sends a message to a group of services where only one available instance processes the event.
• Global Error Handlers - Provides global and route-specific error handlers to standardize the formatting of error responses sent to clients.
• Request Context Propagation - Attaches context-specific metadata to service calls that persists across nested distributed invocations.
• Consistent Hashing Routing - Uses consistent hashing to ensure requests with the same key are always routed to the same service instance.
• HTTP Response Handlers - Allows service action handlers to explicitly set custom HTTP status codes, content types, and response headers.
• Web Frameworks - Fast and powerful microservices framework.

Star history