servcraft 0.1.0 → 0.1.1

package/src/utils/errors.ts

@@ -22,42 +22,49 @@ export class AppError extends Error {
 export class NotFoundError extends AppError {
   constructor(resource = 'Resource') {
     super(`${resource} not found`, 404);
+    Object.setPrototypeOf(this, NotFoundError.prototype);
   }
 }
 
 export class UnauthorizedError extends AppError {
   constructor(message = 'Unauthorized') {
     super(message, 401);
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
   }
 }
 
 export class ForbiddenError extends AppError {
   constructor(message = 'Forbidden') {
     super(message, 403);
+    Object.setPrototypeOf(this, ForbiddenError.prototype);
   }
 }
 
 export class BadRequestError extends AppError {
   constructor(message = 'Bad request', errors?: Record<string, string[]>) {
     super(message, 400, true, errors);
+    Object.setPrototypeOf(this, BadRequestError.prototype);
   }
 }
 
 export class ConflictError extends AppError {
   constructor(message = 'Resource already exists') {
     super(message, 409);
+    Object.setPrototypeOf(this, ConflictError.prototype);
   }
 }
 
 export class ValidationError extends AppError {
   constructor(errors: Record<string, string[]>) {
     super('Validation failed', 422, true, errors);
+    Object.setPrototypeOf(this, ValidationError.prototype);
   }
 }
 
 export class TooManyRequestsError extends AppError {
   constructor(message = 'Too many requests') {
     super(message, 429);
+    Object.setPrototypeOf(this, TooManyRequestsError.prototype);
   }
 }
 

package/src/utils/pagination.ts

@@ -6,7 +6,10 @@ export const MAX_LIMIT = 100;
 
 export function parsePaginationParams(query: Record<string, unknown>): PaginationParams {
   const page = Math.max(1, parseInt(String(query.page || DEFAULT_PAGE), 10));
-  const limit = Math.min(MAX_LIMIT, Math.max(1, parseInt(String(query.limit || DEFAULT_LIMIT), 10)));
+  const limit = Math.min(
+    MAX_LIMIT,
+    Math.max(1, parseInt(String(query.limit || DEFAULT_LIMIT), 10))
+  );
   const sortBy = typeof query.sortBy === 'string' ? query.sortBy : undefined;
   const sortOrder = query.sortOrder === 'desc' ? 'desc' : 'asc';
 

package/tests/helpers/db-check.ts

@@ -0,0 +1,79 @@
+/**
+ * Database availability check helpers for integration tests
+ */
+import { describe } from 'vitest';
+
+let _dbAvailable: boolean | null = null;
+let _redisAvailable: boolean | null = null;
+
+/**
+ * Check if PostgreSQL database is available
+ */
+export async function isDatabaseAvailable(): Promise<boolean> {
+  if (_dbAvailable !== null) return _dbAvailable;
+
+  try {
+    // Dynamic import to avoid initialization errors
+    const { prisma } = await import('../../src/database/prisma.js');
+    await prisma.$queryRaw`SELECT 1`;
+    _dbAvailable = true;
+  } catch {
+    _dbAvailable = false;
+  }
+
+  return _dbAvailable;
+}
+
+/**
+ * Check if Redis is available
+ */
+export async function isRedisAvailable(): Promise<boolean> {
+  if (_redisAvailable !== null) return _redisAvailable;
+
+  try {
+    const { getRedis } = await import('../../src/database/redis.js');
+    const redis = getRedis();
+    await redis.ping();
+    _redisAvailable = true;
+  } catch {
+    _redisAvailable = false;
+  }
+
+  return _redisAvailable;
+}
+
+/**
+ * Conditionally run describe block based on database availability
+ * If database is not available, tests are skipped
+ */
+export function describeWithDb(
+  name: string,
+  fn: () => void
+): ReturnType<typeof describe> | ReturnType<typeof describe.skip> {
+  // We need to check synchronously for Vitest
+  // Use environment variable to indicate DB availability
+  const dbUrl = process.env.DATABASE_URL;
+  const hasValidDbUrl = dbUrl && !dbUrl.includes('test:test@localhost');
+
+  if (process.env.SKIP_DB_TESTS === 'true' || !hasValidDbUrl) {
+    return describe.skip(name, fn);
+  }
+
+  return describe(name, fn);
+}
+
+/**
+ * Conditionally run describe block based on Redis availability
+ */
+export function describeWithRedis(
+  name: string,
+  fn: () => void
+): ReturnType<typeof describe> | ReturnType<typeof describe.skip> {
+  const redisUrl = process.env.REDIS_URL;
+
+  if (process.env.SKIP_REDIS_TESTS === 'true' || !redisUrl) {
+    return describe.skip(name, fn);
+  }
+
+  return describe(name, fn);
+}

package/tests/integration/auth-redis.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import Redis from 'ioredis';
+
+// These tests verify the Redis token blacklist functionality
+// The @fastify/jwt integration is tested separately when Fastify 5.x is available
+
+describe('Auth Service - Redis Token Blacklist Integration', () => {
+  let redis: Redis;
+  const testRedisUrl = process.env.REDIS_URL || 'redis://localhost:6379';
+
+  beforeAll(async () => {
+    // Setup Redis client for verification
+    redis = new Redis(testRedisUrl);
+
+    // Wait for Redis connection
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('Redis connection timeout')), 5000);
+      redis.once('ready', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      redis.once('error', (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+  });
+
+  afterAll(async () => {
+    if (redis) {
+      await redis.quit();
+    }
+  });
+
+  beforeEach(async () => {
+    // Clean up test keys before each test
+    const keys = await redis.keys('auth:blacklist:*');
+    if (keys.length > 0) {
+      await redis.del(...keys);
+    }
+  });
+
+  describe('Redis Connection', () => {
+    it('should connect to Redis', async () => {
+      const pong = await redis.ping();
+      expect(pong).toBe('PONG');
+    });
+
+    it('should set and get values', async () => {
+      await redis.set('test:key', 'test-value');
+      const value = await redis.get('test:key');
+      expect(value).toBe('test-value');
+      await redis.del('test:key');
+    });
+  });
+
+  describe('Token Blacklist Operations', () => {
+    it('should blacklist a token', async () => {
+      const token = 'test-token-123';
+      const ttl = 3600; // 1 hour
+
+      await redis.setex(`auth:blacklist:${token}`, ttl, '1');
+
+      const exists = await redis.exists(`auth:blacklist:${token}`);
+      expect(exists).toBe(1);
+    });
+
+    it('should check if token is blacklisted', async () => {
+      const token = 'blacklisted-token';
+      await redis.setex(`auth:blacklist:${token}`, 3600, '1');
+
+      const isBlacklisted = (await redis.exists(`auth:blacklist:${token}`)) === 1;
+      expect(isBlacklisted).toBe(true);
+    });
+
+    it('should return false for non-blacklisted token', async () => {
+      const token = 'valid-token';
+
+      const isBlacklisted = (await redis.exists(`auth:blacklist:${token}`)) === 1;
+      expect(isBlacklisted).toBe(false);
+    });
+
+    it('should expire blacklisted tokens', async () => {
+      const token = 'expiring-token';
+      await redis.setex(`auth:blacklist:${token}`, 1, '1'); // 1 second TTL
+
+      // Wait for expiration
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+
+      const exists = await redis.exists(`auth:blacklist:${token}`);
+      expect(exists).toBe(0);
+    });
+  });
+});

package/tests/integration/cache-redis.test.ts

@@ -0,0 +1,387 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { CacheService } from '../../src/modules/cache/cache.service.js';
+
+describe('CacheService - Redis Integration', () => {
+  let redisCache: CacheService;
+  let memoryCache: CacheService;
+
+  beforeAll(() => {
+    // Redis cache instance
+    redisCache = new CacheService({
+      provider: 'redis',
+      ttl: 60, // 1 minute for tests
+      prefix: 'test:',
+      redis: {
+        host: process.env.REDIS_HOST || 'localhost',
+        port: parseInt(process.env.REDIS_PORT || '6379'),
+        password: process.env.REDIS_PASSWORD,
+        db: 1, // Use DB 1 for tests
+      },
+    });
+
+    // Memory cache instance for comparison
+    memoryCache = new CacheService({
+      provider: 'memory',
+      ttl: 60,
+      prefix: 'test:',
+    });
+  });
+
+  afterAll(async () => {
+    await redisCache.close();
+  });
+
+  beforeEach(async () => {
+    // Clear cache before each test
+    await redisCache.clear();
+    await memoryCache.clear();
+  });
+
+  // ==========================================
+  // BASIC OPERATIONS
+  // ==========================================
+
+  describe('Basic Operations', () => {
+    it('should set and get a string value', async () => {
+      await redisCache.set('test-string', 'Hello Redis!');
+      const value = await redisCache.get<string>('test-string');
+      expect(value).toBe('Hello Redis!');
+    });
+
+    it('should set and get a number value', async () => {
+      await redisCache.set('test-number', 42);
+      const value = await redisCache.get<number>('test-number');
+      expect(value).toBe(42);
+    });
+
+    it('should set and get an object value', async () => {
+      const obj = { name: 'John', age: 30, active: true };
+      await redisCache.set('test-object', obj);
+      const value = await redisCache.get<typeof obj>('test-object');
+      expect(value).toEqual(obj);
+    });
+
+    it('should set and get an array value', async () => {
+      const arr = [1, 2, 3, 4, 5];
+      await redisCache.set('test-array', arr);
+      const value = await redisCache.get<number[]>('test-array');
+      expect(value).toEqual(arr);
+    });
+
+    it('should return null for non-existent key', async () => {
+      const value = await redisCache.get('non-existent-key');
+      expect(value).toBeNull();
+    });
+
+    it('should delete a key', async () => {
+      await redisCache.set('test-delete', 'value');
+      const deleted = await redisCache.delete('test-delete');
+      expect(deleted).toBe(true);
+
+      const value = await redisCache.get('test-delete');
+      expect(value).toBeNull();
+    });
+
+    it('should return false when deleting non-existent key', async () => {
+      const deleted = await redisCache.delete('non-existent');
+      expect(deleted).toBe(false);
+    });
+
+    it('should check if key exists', async () => {
+      await redisCache.set('test-exists', 'value');
+      const exists = await redisCache.exists('test-exists');
+      expect(exists).toBe(true);
+
+      const notExists = await redisCache.exists('not-exists');
+      expect(notExists).toBe(false);
+    });
+  });
+
+  // ==========================================
+  // TTL AND EXPIRATION
+  // ==========================================
+
+  describe('TTL and Expiration', () => {
+    it('should expire key after TTL', async () => {
+      await redisCache.set('test-ttl', 'expires soon', { ttl: 1 }); // 1 second
+
+      const valueBefore = await redisCache.get('test-ttl');
+      expect(valueBefore).toBe('expires soon');
+
+      // Wait for expiration
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+
+      const valueAfter = await redisCache.get('test-ttl');
+      expect(valueAfter).toBeNull();
+    });
+
+    it('should use custom TTL per key', async () => {
+      await redisCache.set('short-ttl', 'short', { ttl: 1 });
+      await redisCache.set('long-ttl', 'long', { ttl: 60 });
+
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+
+      const shortValue = await redisCache.get('short-ttl');
+      const longValue = await redisCache.get('long-ttl');
+
+      expect(shortValue).toBeNull();
+      expect(longValue).toBe('long');
+    });
+
+    it('should use default TTL when not specified', async () => {
+      await redisCache.set('default-ttl', 'uses default');
+      const value = await redisCache.get('default-ttl');
+      expect(value).toBe('uses default');
+    });
+  });
+
+  // ==========================================
+  // ADVANCED OPERATIONS
+  // ==========================================
+
+  describe('Advanced Operations', () => {
+    it('should implement getOrSet pattern', async () => {
+      let factoryCalled = 0;
+      const factory = async () => {
+        factoryCalled++;
+        return 'computed value';
+      };
+
+      // First call - should execute factory
+      const value1 = await redisCache.getOrSet('getOrSet-key', factory);
+      expect(value1).toBe('computed value');
+      expect(factoryCalled).toBe(1);
+
+      // Second call - should use cache
+      const value2 = await redisCache.getOrSet('getOrSet-key', factory);
+      expect(value2).toBe('computed value');
+      expect(factoryCalled).toBe(1); // Factory not called again
+    });
+
+    it('should get multiple keys (mget)', async () => {
+      await redisCache.set('mget-1', 'value1');
+      await redisCache.set('mget-2', 'value2');
+      await redisCache.set('mget-3', 'value3');
+
+      const values = await redisCache.mget<string>(['mget-1', 'mget-2', 'mget-3', 'mget-missing']);
+      expect(values).toEqual(['value1', 'value2', 'value3', null]);
+    });
+
+    it('should set multiple keys (mset)', async () => {
+      await redisCache.mset([
+        { key: 'mset-1', value: 'val1' },
+        { key: 'mset-2', value: 'val2' },
+        { key: 'mset-3', value: 'val3', ttl: 30 },
+      ]);
+
+      const value1 = await redisCache.get('mset-1');
+      const value2 = await redisCache.get('mset-2');
+      const value3 = await redisCache.get('mset-3');
+
+      expect(value1).toBe('val1');
+      expect(value2).toBe('val2');
+      expect(value3).toBe('val3');
+    });
+
+    it('should increment a counter', async () => {
+      await redisCache.set('counter', 10);
+
+      const val1 = await redisCache.increment('counter');
+      expect(val1).toBe(11);
+
+      const val2 = await redisCache.increment('counter', 5);
+      expect(val2).toBe(16);
+    });
+
+    it('should increment from 0 if key does not exist', async () => {
+      const val = await redisCache.increment('new-counter');
+      expect(val).toBe(1);
+    });
+
+    it('should decrement a counter', async () => {
+      await redisCache.set('decrement-counter', 20);
+
+      const val1 = await redisCache.decrement('decrement-counter');
+      expect(val1).toBe(19);
+
+      const val2 = await redisCache.decrement('decrement-counter', 5);
+      expect(val2).toBe(14);
+    });
+
+    it('should clear all keys with prefix', async () => {
+      await redisCache.set('clear-1', 'val1');
+      await redisCache.set('clear-2', 'val2');
+      await redisCache.set('clear-3', 'val3');
+
+      await redisCache.clear();
+
+      const val1 = await redisCache.get('clear-1');
+      const val2 = await redisCache.get('clear-2');
+      const val3 = await redisCache.get('clear-3');
+
+      expect(val1).toBeNull();
+      expect(val2).toBeNull();
+      expect(val3).toBeNull();
+    });
+  });
+
+  // ==========================================
+  // STATISTICS
+  // ==========================================
+
+  describe('Statistics', () => {
+    it('should track cache hits and misses', async () => {
+      const initialStats = redisCache.getStats();
+      const initialHits = initialStats.hits;
+      const initialMisses = initialStats.misses;
+
+      await redisCache.set('stats-key', 'value');
+
+      // Hit
+      await redisCache.get('stats-key');
+
+      // Miss
+      await redisCache.get('non-existent');
+
+      const finalStats = redisCache.getStats();
+
+      expect(finalStats.hits).toBeGreaterThan(initialHits);
+      expect(finalStats.misses).toBeGreaterThan(initialMisses);
+    });
+  });
+
+  // ==========================================
+  // COMPARISON WITH MEMORY CACHE
+  // ==========================================
+
+  describe('Comparison with Memory Cache', () => {
+    it('should behave identically to memory cache for basic operations', async () => {
+      const testData = { name: 'Test', value: 123, active: true };
+
+      // Set in both
+      await redisCache.set('comparison-key', testData);
+      await memoryCache.set('comparison-key', testData);
+
+      // Get from both
+      const redisValue = await redisCache.get<typeof testData>('comparison-key');
+      const memoryValue = await memoryCache.get<typeof testData>('comparison-key');
+
+      expect(redisValue).toEqual(memoryValue);
+      expect(redisValue).toEqual(testData);
+    });
+
+    it('should handle increment identically', async () => {
+      await redisCache.set('redis-counter', 5);
+      await memoryCache.set('memory-counter', 5);
+
+      const redisVal = await redisCache.increment('redis-counter', 3);
+      const memoryVal = await memoryCache.increment('memory-counter', 3);
+
+      expect(redisVal).toBe(memoryVal);
+      expect(redisVal).toBe(8);
+    });
+  });
+
+  // ==========================================
+  // ERROR HANDLING
+  // ==========================================
+
+  describe('Error Handling', () => {
+    it('should handle invalid JSON gracefully', async () => {
+      // This test verifies error handling
+      // Set a value and then try to get it
+      await redisCache.set('json-test', { valid: 'json' });
+      const value = await redisCache.get('json-test');
+      expect(value).toEqual({ valid: 'json' });
+    });
+
+    it('should handle concurrent operations', async () => {
+      const operations = [];
+      for (let i = 0; i < 10; i++) {
+        operations.push(redisCache.set(`concurrent-${i}`, `value-${i}`));
+      }
+
+      await Promise.all(operations);
+
+      const value5 = await redisCache.get('concurrent-5');
+      expect(value5).toBe('value-5');
+    });
+  });
+
+  // ==========================================
+  // PREFIX HANDLING
+  // ==========================================
+
+  describe('Prefix Handling', () => {
+    it('should apply prefix to all keys', async () => {
+      await redisCache.set('prefixed-key', 'value');
+
+      // The actual key in Redis should be "test:prefixed-key"
+      // We can't directly verify this without accessing Redis client
+      // But we can verify that get/delete work correctly
+
+      const value = await redisCache.get('prefixed-key');
+      expect(value).toBe('value');
+
+      const deleted = await redisCache.delete('prefixed-key');
+      expect(deleted).toBe(true);
+    });
+  });
+
+  // ==========================================
+  // COMPLEX DATA TYPES
+  // ==========================================
+
+  describe('Complex Data Types', () => {
+    it('should handle nested objects', async () => {
+      const complex = {
+        user: {
+          name: 'John',
+          profile: {
+            age: 30,
+            settings: {
+              theme: 'dark',
+              notifications: true,
+            },
+          },
+        },
+        metadata: {
+          created: new Date().toISOString(),
+          tags: ['admin', 'premium'],
+        },
+      };
+
+      await redisCache.set('complex-object', complex);
+      const value = await redisCache.get<typeof complex>('complex-object');
+
+      expect(value).toEqual(complex);
+      expect(value?.user.profile.settings.theme).toBe('dark');
+    });
+
+    it('should handle arrays of objects', async () => {
+      const users = [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ];
+
+      await redisCache.set('users-array', users);
+      const value = await redisCache.get<typeof users>('users-array');
+
+      expect(value).toEqual(users);
+      expect(value?.length).toBe(3);
+    });
+  });
+
+  // ==========================================
+  // CONNECTION RESILIENCE
+  // ==========================================
+
+  describe('Connection Resilience', () => {
+    it('should handle operations when Redis is available', async () => {
+      await redisCache.set('resilience-test', 'working');
+      const value = await redisCache.get('resilience-test');
+      expect(value).toBe('working');
+    });
+  });
+});