style: apply Prettier formatting to entire codebase

- Format all TypeScript, JavaScript, JSON, and Markdown files
- Make Prettier check blocking in CI (no longer continue-on-error)

Author: claude

.github/workflows/test.yml

@@ -62,4 +62,3 @@ jobs:
 
       - name: Check Prettier formatting
         run: npm run format
-        continue-on-error: true  # Existing code has formatting issues

README.md

@@ -23,16 +23,16 @@ npm install @hokify/node-ts-cache
 ```
 
 ```typescript
-import { Cache, ExpirationStrategy, MemoryStorage } from "@hokify/node-ts-cache";
+import { Cache, ExpirationStrategy, MemoryStorage } from '@hokify/node-ts-cache';
 
 const cacheStrategy = new ExpirationStrategy(new MemoryStorage());
 
 class UserService {
-  @Cache(cacheStrategy, { ttl: 300 })
-  async getUser(id: string): Promise<User> {
-    // This result will be cached for 5 minutes
-    return await fetchUserFromDatabase(id);
-  }
+	@Cache(cacheStrategy, { ttl: 300 })
+	async getUser(id: string): Promise<User> {
+		// This result will be cached for 5 minutes
+		return await fetchUserFromDatabase(id);
+	}
 }
 ```
 
@@ -42,19 +42,19 @@ This is a monorepo containing the following packages:
 
 ### Core Package
 
-| Package | Version | Description |
-|---------|---------|-------------|
+| Package                             | Version                                                        | Description                                                            |
+| ----------------------------------- | -------------------------------------------------------------- | ---------------------------------------------------------------------- |
 | [@hokify/node-ts-cache](./ts-cache) | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache.svg) | Core caching module with decorators, strategies, and built-in storages |
 
 ### Storage Adapters
 
-| Package | Version | Description |
-|---------|---------|-------------|
-| [@hokify/node-ts-cache-redis-storage](./storages/redis) | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-redis-storage.svg) | Redis storage using `redis` package (v3.x) |
-| [@hokify/node-ts-cache-redisio-storage](./storages/redisio) | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-redisio-storage.svg) | Redis storage using `ioredis` with compression support |
-| [@hokify/node-ts-cache-node-cache-storage](./storages/node-cache) | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-node-cache-storage.svg) | In-memory cache using `node-cache` |
-| [@hokify/node-ts-cache-lru-storage](./storages/lru) | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-lru-storage.svg) | LRU cache with automatic eviction |
-| [@hokify/node-ts-cache-lru-redis-storage](./storages/lru-redis) | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-lru-redis-storage.svg) | Two-tier caching (local LRU + remote Redis) |
+| Package                                                           | Version                                                                           | Description                                            |
+| ----------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------ |
+| [@hokify/node-ts-cache-redis-storage](./storages/redis)           | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-redis-storage.svg)      | Redis storage using `redis` package (v3.x)             |
+| [@hokify/node-ts-cache-redisio-storage](./storages/redisio)       | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-redisio-storage.svg)    | Redis storage using `ioredis` with compression support |
+| [@hokify/node-ts-cache-node-cache-storage](./storages/node-cache) | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-node-cache-storage.svg) | In-memory cache using `node-cache`                     |
+| [@hokify/node-ts-cache-lru-storage](./storages/lru)               | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-lru-storage.svg)        | LRU cache with automatic eviction                      |
+| [@hokify/node-ts-cache-lru-redis-storage](./storages/lru-redis)   | ![npm](https://img.shields.io/npm/v/@hokify/node-ts-cache-lru-redis-storage.svg)  | Two-tier caching (local LRU + remote Redis)            |
 
 ## Documentation
 
@@ -90,15 +90,15 @@ For detailed documentation, see the [main package README](./ts-cache/README.md).
 
 ## Choosing a Storage
 
-| Storage | Type | Use Case | Features |
-|---------|------|----------|----------|
-| **MemoryStorage** | Sync | Development, small datasets | Zero config, bundled |
-| **FsJsonStorage** | Async | Persistent local cache | File-based, survives restarts |
-| **NodeCacheStorage** | Sync | Production single-instance | TTL support, multi-ops |
-| **LRUStorage** | Sync | Memory-constrained apps | Auto-eviction, size limits |
-| **RedisStorage** | Async | Distributed systems | Shared cache, legacy redis |
-| **RedisIOStorage** | Async | Distributed systems | Compression, modern ioredis |
-| **LRUWithRedisStorage** | Async | High-performance distributed | Local + remote tiers |
+| Storage                 | Type  | Use Case                     | Features                      |
+| ----------------------- | ----- | ---------------------------- | ----------------------------- |
+| **MemoryStorage**       | Sync  | Development, small datasets  | Zero config, bundled          |
+| **FsJsonStorage**       | Async | Persistent local cache       | File-based, survives restarts |
+| **NodeCacheStorage**    | Sync  | Production single-instance   | TTL support, multi-ops        |
+| **LRUStorage**          | Sync  | Memory-constrained apps      | Auto-eviction, size limits    |
+| **RedisStorage**        | Async | Distributed systems          | Shared cache, legacy redis    |
+| **RedisIOStorage**      | Async | Distributed systems          | Compression, modern ioredis   |
+| **LRUWithRedisStorage** | Async | High-performance distributed | Local + remote tiers          |
 
 ## Requirements
 

gulpfile.js

@@ -3,19 +3,19 @@ const del = require('del');
 const glob = require('glob');
 const childProcess = require('child_process');
 
-task('cleanModules', function() {
+task('cleanModules', function () {
 	return del(['./ts-cache/node_modules', './storages/*/node_modules']);
 });
 
-task('cleanTmp', function() {
+task('cleanTmp', function () {
 	return del(['./ts-cache/.tmp', './storages/*/.tmp']);
 });
 
-task('cleanDist', function() {
+task('cleanDist', function () {
 	return del(['./ts-cache/dist', './storages/*/dist']);
 });
 
-task('updatePackages', function(cb) {
+task('updatePackages', function (cb) {
 	const check = pkgJsonPath => {
 		try {
 			return childProcess.execSync(`npx ncu --packageFile ${pkgJsonPath} -u`).toString();

lerna.json

@@ -1,8 +1,5 @@
 {
-	"packages": [
-		"storages/*",
-		"ts-cache"
-	],
+	"packages": ["storages/*", "ts-cache"],
 	"version": "independent",
 	"command": {
 		"publish": {
@@ -13,8 +10,5 @@
 	"forceLocal": true,
 	"conventionalCommits": true,
 	"reject-cycles": true,
-	"ignoreChanges": [
-		"**/test/**",
-		"**/*.md"
-	]
+	"ignoreChanges": ["**/test/**", "**/*.md"]
 }

package.json

@@ -1,35 +1,35 @@
 {
-  "name": "root",
-  "private": true,
-  "scripts": {
-    "publish": "lerna publish",
-    "build": "lerna run build",
-    "test": "lerna run test",
-    "lint": "eslint --ext .ts ts-cache/src storages/*/src",
-    "lint:fix": "eslint --ext .ts ts-cache/src storages/*/src --fix",
-    "format": "prettier --check \"**/*.{ts,js,json,md}\" --ignore-path .gitignore",
-    "format:fix": "prettier --write \"**/*.{ts,js,json,md}\" --ignore-path .gitignore",
-    "release": "lerna publish",
-    "prepublishOnly": "npm run test",
-    "check-package-updates": "ncu -u && gulp updatePackages"
-  },
-  "devDependencies": {
-    "@hokify/eslint-config": "^2.2.1",
-    "@types/mocha": "10.0.6",
-    "@types/node": "18.19.0",
-    "lerna": "^8.0.0",
-    "mocha": "10.4.0",
-    "ts-node": "10.9.1",
-    "typescript": "5.1.6"
-  },
-  "dependencies": {
-    "del": "^6.0.0",
-    "glob": "^7.2.0",
-    "gulp": "^4.0.2",
-    "prettier": "^2.4.1"
-  },
-  "workspaces": [
-    "storages/*",
-    "ts-cache"
-  ]
+	"name": "root",
+	"private": true,
+	"workspaces": [
+		"storages/*",
+		"ts-cache"
+	],
+	"scripts": {
+		"build": "lerna run build",
+		"check-package-updates": "ncu -u && gulp updatePackages",
+		"format": "prettier --check \"**/*.{ts,js,json,md}\" --ignore-path .gitignore",
+		"format:fix": "prettier --write \"**/*.{ts,js,json,md}\" --ignore-path .gitignore",
+		"lint": "eslint --ext .ts ts-cache/src storages/*/src",
+		"lint:fix": "eslint --ext .ts ts-cache/src storages/*/src --fix",
+		"prepublishOnly": "npm run test",
+		"publish": "lerna publish",
+		"release": "lerna publish",
+		"test": "lerna run test"
+	},
+	"dependencies": {
+		"del": "^6.0.0",
+		"glob": "^7.2.0",
+		"gulp": "^4.0.2",
+		"prettier": "^2.4.1"
+	},
+	"devDependencies": {
+		"@hokify/eslint-config": "^2.2.1",
+		"@types/mocha": "10.0.6",
+		"@types/node": "18.19.0",
+		"lerna": "^8.0.0",
+		"mocha": "10.4.0",
+		"ts-node": "10.9.1",
+		"typescript": "5.1.6"
+	}
 }

storages/lru-redis/README.md

@@ -50,39 +50,39 @@ npm install @hokify/node-ts-cache @hokify/node-ts-cache-lru-redis-storage ioredi
 ### Basic Usage
 
 ```typescript
-import { Cache, ExpirationStrategy } from "@hokify/node-ts-cache";
-import LRUWithRedisStorage from "@hokify/node-ts-cache-lru-redis-storage";
-import Redis from "ioredis";
+import { Cache, ExpirationStrategy } from '@hokify/node-ts-cache';
+import LRUWithRedisStorage from '@hokify/node-ts-cache-lru-redis-storage';
+import Redis from 'ioredis';
 
 const redisClient = new Redis({
-  host: "localhost",
-  port: 6379
+	host: 'localhost',
+	port: 6379
 });
 
 const storage = new LRUWithRedisStorage(
-  { max: 1000 },        // LRU options: max 1000 items locally
-  () => redisClient     // Redis client factory
+	{ max: 1000 }, // LRU options: max 1000 items locally
+	() => redisClient // Redis client factory
 );
 
 const strategy = new ExpirationStrategy(storage);
 
 class UserService {
-  @Cache(strategy, { ttl: 300 })
-  async getUser(id: string): Promise<User> {
-    return await db.users.findById(id);
-  }
+	@Cache(strategy, { ttl: 300 })
+	async getUser(id: string): Promise<User> {
+		return await db.users.findById(id);
+	}
 }
 ```
 
 ### With LRU TTL
 
 ```typescript
 const storage = new LRUWithRedisStorage(
-  {
-    max: 500,
-    maxAge: 1000 * 60  // Local cache TTL: 1 minute (milliseconds)
-  },
-  () => redisClient
+	{
+		max: 500,
+		maxAge: 1000 * 60 // Local cache TTL: 1 minute (milliseconds)
+	},
+	() => redisClient
 );
 ```
 
@@ -93,13 +93,13 @@ const storage = new LRUWithRedisStorage({ max: 100 }, () => redisClient);
 const strategy = new ExpirationStrategy(storage);
 
 // Store (writes to both LRU and Redis)
-await strategy.setItem("user:123", { name: "John" }, { ttl: 60 });
+await strategy.setItem('user:123', { name: 'John' }, { ttl: 60 });
 
 // First get - might hit Redis if not in LRU
-const user1 = await strategy.getItem<User>("user:123");
+const user1 = await strategy.getItem<User>('user:123');
 
 // Second get - hits local LRU (fast!)
-const user2 = await strategy.getItem<User>("user:123");
+const user2 = await strategy.getItem<User>('user:123');
 
 // Clear both caches
 await strategy.clear();
@@ -114,27 +114,27 @@ new LRUWithRedisStorage(
 )
 ```
 
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `lruOptions` | `LRU.Options` | Options for local LRU cache (see [lru-cache](https://www.npmjs.com/package/lru-cache#options)) |
-| `redis` | `() => Redis.Redis` | Factory function returning an ioredis client |
+| Parameter    | Type                | Description                                                                                    |
+| ------------ | ------------------- | ---------------------------------------------------------------------------------------------- |
+| `lruOptions` | `LRU.Options`       | Options for local LRU cache (see [lru-cache](https://www.npmjs.com/package/lru-cache#options)) |
+| `redis`      | `() => Redis.Redis` | Factory function returning an ioredis client                                                   |
 
 ### LRU Options
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `max` | `number` | Required | Maximum items in local cache |
-| `maxAge` | `number` | - | Local TTL in **milliseconds** |
-| `maxSize` | `number` | - | Maximum total size |
-| `sizeCalculation` | `function` | - | Size calculator function |
+| Option            | Type       | Default  | Description                   |
+| ----------------- | ---------- | -------- | ----------------------------- |
+| `max`             | `number`   | Required | Maximum items in local cache  |
+| `maxAge`          | `number`   | -        | Local TTL in **milliseconds** |
+| `maxSize`         | `number`   | -        | Maximum total size            |
+| `sizeCalculation` | `function` | -        | Size calculator function      |
 
 ## Interface
 
 ```typescript
 interface IAsynchronousCacheType {
-  getItem<T>(key: string): Promise<T | undefined>;
-  setItem(key: string, content: any, options?: any): Promise<void>;
-  clear(): Promise<void>;
+	getItem<T>(key: string): Promise<T | undefined>;
+	setItem(key: string, content: any, options?: any): Promise<void>;
+	clear(): Promise<void>;
 }
 ```
 
@@ -144,13 +144,13 @@ interface IAsynchronousCacheType {
 
 ```typescript
 class ProductAPI {
-  @Cache(strategy, { ttl: 60 })
-  async getProduct(id: string): Promise<Product> {
-    // Hot products served from local LRU (~0.01ms)
-    // Cold products fetched from Redis (~1-5ms)
-    // Very cold products hit database
-    return await db.products.findById(id);
-  }
+	@Cache(strategy, { ttl: 60 })
+	async getProduct(id: string): Promise<Product> {
+		// Hot products served from local LRU (~0.01ms)
+		// Cold products fetched from Redis (~1-5ms)
+		// Very cold products hit database
+		return await db.products.findById(id);
+	}
 }
 ```
 
@@ -178,12 +178,12 @@ Multiple application instances share the same Redis cache while maintaining thei
 
 ```typescript
 class SessionService {
-  @Cache(strategy, { ttl: 1800 })  // 30 minutes
-  async getSession(token: string): Promise<Session> {
-    // Active sessions stay in local LRU
-    // Inactive sessions fall back to Redis
-    return await db.sessions.findByToken(token);
-  }
+	@Cache(strategy, { ttl: 1800 }) // 30 minutes
+	async getSession(token: string): Promise<Session> {
+		// Active sessions stay in local LRU
+		// Inactive sessions fall back to Redis
+		return await db.sessions.findByToken(token);
+	}
 }
 ```