Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/alexcambose/custom-cache-decorator
A TypeScript library providing a customizable cache decorator for methods. This library allows you to easily cache method results with configurable caching mechanisms.
https://github.com/alexcambose/custom-cache-decorator
cache library lru-cache nodejs redis typescript
Last synced: about 13 hours ago
JSON representation
A TypeScript library providing a customizable cache decorator for methods. This library allows you to easily cache method results with configurable caching mechanisms.
- Host: GitHub
- URL: https://github.com/alexcambose/custom-cache-decorator
- Owner: alexcambose
- License: mit
- Created: 2024-06-15T19:04:59.000Z (5 months ago)
- Default Branch: main
- Last Pushed: 2024-06-18T17:36:04.000Z (5 months ago)
- Last Synced: 2024-09-19T08:39:07.150Z (about 2 months ago)
- Topics: cache, library, lru-cache, nodejs, redis, typescript
- Language: TypeScript
- Homepage:
- Size: 483 KB
- Stars: 29
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
# Cache Decorator
A TypeScript library providing a customizable cache decorator for methods. This library allows you to easily cache method results with configurable caching mechanisms.
## Installation
Install the library via npm:
```
npm install custom-cache-decorator
```
or yarn
```
yarn add custom-cache-decorator
```
## Usage
### Basic Usage
Here's a basic example of how to use the cache decorator in your TypeScript project.
#### 1. Import the Library
```ts
import { createCacheDecorator } from 'custom-cache-decorator';
```
#### 2. Define Your Cache Decorator
Create a cache decorator with custom `getItem` and `setItem` functions:
```ts
import { createCacheDecorator } from 'custom-cache-decorator';
const inMemoryCache = new Map();
const cacheDecorator = createCacheDecorator({
getItem: async (key) => inMemoryCache.get(key),
setItem: async (key, value) => inMemoryCache.set(key, value),
});
```
#### 3. Apply the Cache Decorator
Use the created cache decorator on your methods:
```ts
class ExpensiveOperations {
@cacheDecorator({ ttl: 3000 })
async heavyComputation(arg1: number, arg2: number): Promise {
console.log('Performing heavy computation...');
// Simulate heavy computation
return new Promise((resolve) =>
setTimeout(() => resolve(arg1 * arg2), 1000)
);
}
}
```
#### 4. Use Your Class
```ts
(async () => {
const operations = new ExpensiveOperations();
console.log(await operations.heavyComputation(2, 3)); // Performs computation
console.log(await operations.heavyComputation(2, 3)); // Uses cached result
})();
```
also make sure you have `experimentalDecorators` set to `true` in your `tsconfig.json` file
```
{
"compilerOptions": {
...
"experimentalDecorators": true
...
}
}
```
### Using with Redis
Here's an example of using the cache decorator with Redis as the caching backend.
```ts
import { createCacheDecorator } from 'custom-cache-decorator';
import { createClient } from 'redis';
(async () => {
const client = createClient();
await client.connect();
const redisCacheDecorator = createCacheDecorator({
getItem: async (key) => {
const value = await client.get(key);
return value ? JSON.parse(value) : undefined;
},
setItem: async (key, value, { ttl }: { ttl: number }) => {
await client.setEx(key, ttl, JSON.stringify(value));
},
});
class ExpensiveOperations {
@redisCacheDecorator({ ttl: 60 })
async heavyComputation(arg1: number, arg2: number): Promise {
console.log('Performing heavy computation...');
// Simulate heavy computation
return new Promise((resolve) =>
setTimeout(() => resolve(arg1 * arg2), 1000)
);
}
}
const operations = new ExpensiveOperations();
console.log(await operations.heavyComputation(2, 3)); // Performs computation
console.log(await operations.heavyComputation(2, 3)); // Uses cached result
await client.disconnect();
})();
```
## API
### `createCacheDecorator(options: CreateCacheDecoratorOptions): (decoratorArgs: O) => MethodDecorator`
Creates a cache decorator.
#### Parameters
- `options`: Configuration options for the cache decorator.
- `getItem`: Function to retrieve an item from the cache.
- `setItem`: Function to store an item in the cache.
- `generateKey` (optional): Custom function to generate cache keys. Defaults to `defaultGenerateKey`.
#### Returns
A cache decorator function to be applied to class methods.
### `defaultGenerateKey(className: string, methodName: string, args: unknown[]): string`
Default function to generate cache keys.
#### Parameters
- `className`: The name of the class.
- `methodName`: The name of the method.
- `args`: The arguments passed to the method.
#### Returns
A string representing the cache key.
### Advanced Example with Custom Key Generation
You can customize the cache key generation with the `generateKey` arg.
```ts
import {
createCacheDecorator,
defaultGenerateKey,
} from 'custom-cache-decorator';
const customKeyDecorator = createCacheDecorator({
getItem: async (key) => inMemoryCache.get(key),
setItem: async (key, value) => inMemoryCache.set(key, value),
generateKey: (className, methodName, args) =>
`${className}_${methodName}_${args.join('_')}`,
});
class ExpensiveOperations {
@customKeyDecorator({})
async heavyComputation(arg1: number, arg2: number): Promise {
console.log('Performing heavy computation...');
return new Promise((resolve) =>
setTimeout(() => resolve(arg1 * arg2), 1000)
);
}
}
```
## Contributing
Contributions are welcome! Please open an issue or submit a pull request on GitHub.
## License
This project is licensed under the MIT License.
:star: