NixBus

NixBus: Simplify Event-Driven Development

NixBus is a secure, robust, and efficient event bus over HTTP, designed to simplify event-driven development and empower microservices architectures. It allows developers to decouple application services and adhere to SOLID principles without the complexities of traditional event bus systems.

What is NixBus?

NixBus is an event bus over HTTP, offering a simple, secure, and scalable solution for inter-service communication. It provides an easy way to integrate with existing infrastructure and ensures robust and efficient event handling.

Key Features of NixBus

• Simple Integration: NixBus can be easily integrated into existing infrastructures using the NPM package or HTTP API.
• Secure Communication: All data is encrypted end-to-end, ensuring that events are safe and secure.
• Scalable and Flexible: NixBus scales with your needs, whether you are running a small application or a complex microservices architecture.
• In-Memory Option: For smaller applications, an in-memory event bus is available to avoid the complexity of persistent storage.

How Does NixBus Work?

NixBus simplifies event-driven architecture by enabling services to publish and subscribe to events over HTTP. Here’s a basic overview:

1. Installation: Install the NixBus NPM package using npm install @nixbus/event-bus --save -E.
2. Event Bus Creation: Create an event bus file, configure it with your token and passphrase, and subscribe to relevant events.
3. Event Publishing: Publish events from anywhere in your application to the event bus.
4. Run the Event Bus: Execute the event bus to start processing events.

Use Cases

• Microservices Communication: Enables seamless communication between microservices by decoupling services and ensuring robust inter-service interactions.
• Real-Time Applications: Ideal for applications requiring real-time data updates, such as chat applications, live dashboards, and notification systems.
• Event-Driven Architectures: Facilitates building event-driven systems, allowing services to react to events in a timely and efficient manner.

Pricing

NixBus offers several token options tailored to different needs:

• Free:
  • 500 events for daily use
  • 50,000 event reserve (use any time)
  • 3-day event retention
  • Up to 5 subscribers
  • 1-month token validity
• Pro (€15):
  • 2,500 daily events
  • 500,000 event reserve (use any time)
  • 7-day event retention
  • Up to 20 subscribers
  • Region selection
  • Never-expiring token
• Custom:
  • Tailored event usage and reserve
  • Direct support
  • Ideal for high-demand environments

How to Use NixBus

1. Install NixBus:

   npm install @nixbus/event-bus --save -E
   

2. Create Event Bus:

   Create an event-bus.ts file and configure the event bus with your token and passphrase:

   import { getNixBusHttp } from '@nixbus/event-bus'
   
   async function main() {
     const nixbus = getNixBusHttp({
       token: 'your_token',
       passphrase: 'your_passphrase',
     })
   
     await nixbus.subscribe('event_type', {
       id: 'subscriber_id',
       action: async (event) => {
         console.log('subscriber_id:', event)
       },
       config: {
         maxRetries: 3,
         timeout: 10,
         concurrency: 5
       },
     })
   
     nixbus.run()
   }
   
   main().catch(console.error)
   

3. Publish Events:

   Publish events from your application:

   import { getNixBusHttp } from '@nixbus/event-bus'
   
   async function runYourApp() {
     const nixbus = getNixBusHttp({
       token: 'your_token',
       passphrase: 'your_passphrase',
     })
   
     await nixbus.publish({
       type: 'event_type',
       payload: { welcome: 'to the event bus 0' },
     })
   
     // Simulate a delay before publishing another event
     await new Promise((resolve) => setTimeout(resolve, 2000))
   
     await nixbus.publish({
       type: 'event_type',
       payload: { welcome: 'to the event bus 1' },
     })
   }
   
   runYourApp().catch(console.error)
   

4. Run Event Bus and Application:

   Execute the event bus and application:

   tsx event-bus.ts
   tsx app.ts
   

Conclusion

NixBus provides a straightforward and efficient solution for implementing event-driven architectures, simplifying microservices communication and ensuring secure and scalable event handling. Whether you’re building a small application or managing a complex system, NixBus offers the flexibility and tools needed to streamline your development process. Start sending events today and unlock the power of event-driven architecture with NixBus.