node-async-semaphore: Advanced & Fast Semaphore for TypeScript

Node-Async-Semaphore is not just another counting mechanism. It's a highly optimized, TypeScript-based Semaphore solution that leverages a vector of resources instead of a mere permit count, making integration into projects both convenient and efficient. Whether you're designing pooling systems, rate limiters, or merely trying to regulate access, Semaphore has got you covered.

Features

• 🚀 Performance: Experience optimized performance regardless of scale.
• 🚦 Rate Limiting: Includes built-in rate limiting capabilities.
• 💡 TypeScript Support: Written in TypeScript and perfectly typed, ensuring robust development.

Getting Started

Installation

Using npm:

1npm install node-async-semaphore

or

Using yarn:

1yarn add node-async-semaphore

Usage

Simple Semaphore without resource

1import { Semaphore, voidResource } from 'node-async-semaphore';
2
3const counterSemaphore = new Semaphore({
4  permits: 3,
5  resource: voidResource,
6});
7
8async function performConcurrentOperation(index: number) {
9  await counterSemaphore.acquire();
10  console.log(`Operation ${index} is running`);
11  setTimeout(() => {
12    console.log(`Finishing operation ${index}`);
13    counterSemaphore.release();
14  }, 1000);
15}
16
17for (let i = 1; i <= 5; i++) {
18  performConcurrentOperation(i); // Only 3 operations will run concurrently due to the semaphore.
19}

Resource-pooling

1import { Semaphore } from 'node-async-semaphore';
2import { createClient } from 'promise-redis';
3
4const redisSemaphore = new Semaphore({
5  permits: 3,
6  resource: () => createClient(),
7});
8
9async function runRedisCommand() {
10  const client = await redisSemaphore.acquire();
11  console.log('Running Redis command...');
12  await client.set('key', 'value');
13  const result = await client.get('key');
14  console.log(`Retrieved value: ${result}`);
15  redisSemaphore.release(client);
16}
17
18for (let i = 0; i < 5; i++) {
19  runRedisCommand();  // Only 3 Redis commands will be active at once due to the semaphore.
20}

Rate-limiter

1import { SimpleRateLimiter } from 'node-async-semaphore';
2
3const rateLimiter = new SimpleRateLimiter({
4  requests: 10,              // Allow 10 tasks every 5 seconds.
5  interval: 5000,            // 5 seconds interval.
6  uniformDistribution: false // Delay is not spread evenly across requests.
7});
8
9async function rateLimitedTask() {
10  await rateLimiter.acquire();
11  console.log("Task running at", new Date().toISOString());
12  // The task logic goes here...
13}
14
15for (let i = 0; i < 15; i++) {
16  rateLimitedTask();  // Only the first 10 tasks will run immediately. The next 5 will be queued with a delay.
17}

License

This code is licensed under the MIT License.