saas-backend-kit 1.0.1 → 1.0.2

package/jest.config.js

@@ -0,0 +1,19 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/tests'],
+  testMatch: ['**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts'
+  ],
+  coverageDirectory: 'coverage',
+  verbose: true,
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  transform: {
+    '^.+\\.tsx?$': ['ts-jest', {
+      tsconfig: 'tsconfig.test.json',
+      diagnostics: false
+    }]
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saas-backend-kit",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Production-grade modular backend toolkit for building scalable SaaS applications",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -55,8 +55,8 @@
   "scripts": {
     "build": "tsup && node copy-dts.js",
     "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "test": "jest",
+    "test:watch": "jest --watch",
     "lint": "eslint src --ext .ts",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"
@@ -84,10 +84,10 @@
     "bcryptjs": "^2.4.3",
     "bullmq": "^5.1.0",
     "express": "^4.18.2",
-    "fastify": "^4.25.0",
+    "fastify": "^5.0.0",
     "ioredis": "^5.3.2",
     "jsonwebtoken": "^9.0.2",
-    "nodemailer": "^6.9.8",
+    "nodemailer": "^7.0.0",
     "pino": "^8.17.2",
     "pino-pretty": "^10.3.1",
     "twilio": "^4.20.1",
@@ -96,13 +96,15 @@
   "devDependencies": {
     "@types/bcryptjs": "^2.4.6",
     "@types/express": "^4.17.21",
+    "@types/jest": "^29.5.11",
     "@types/jsonwebtoken": "^9.0.5",
     "@types/node": "^20.10.6",
     "@types/nodemailer": "^6.4.14",
     "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
     "tsup": "^8.0.1",
-    "typescript": "^5.3.3",
-    "vitest": "^1.1.3"
+    "typescript": "^5.3.3"
   },
   "peerDependencies": {
     "express": "^4.0.0",

package/src/auth/jwt.ts

@@ -39,7 +39,7 @@ export class JWTService {
   }
 
   refreshTokens(refreshToken: string): TokenPair {
-    const payload = this.verifyRefreshToken(refreshToken);
+    const { iat, exp, nbf, ...payload } = this.verifyRefreshToken(refreshToken) as JWTPayload & { iat?: number; exp?: number; nbf?: number };
     return this.generateTokenPair(payload);
   }
 }

package/src/rate-limit/express.ts

@@ -22,6 +22,7 @@ class InMemoryRateLimiter {
 
   constructor() {
     this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
+    this.cleanupInterval.unref();
   }
 
   private cleanup(): void {

package/src/response/index.ts

@@ -13,7 +13,8 @@ export interface ApiResponse<T = unknown> {
   };
 }
 
-export interface PaginatedResponse<T> extends ApiResponse<T> {
+export interface PaginatedResponse<T> extends Omit<ApiResponse<T[]>, 'data'> {
+  data: T[];
   meta: {
     page: number;
     limit: number;
@@ -141,57 +142,65 @@ declare global {
   }
 }
 
-Response.prototype.success = function <T>(data?: T, message?: string, statusCode: number = 200) {
-  return ResponseHelper.success(this, data, message, statusCode);
-};
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const proto = require('express').response;
+  if (proto) {
+    proto.success = function <T>(this: Response, data?: T, message?: string, statusCode: number = 200) {
+      return ResponseHelper.success(this, data, message, statusCode);
+    };
 
-Response.prototype.created = function <T>(data?: T, message?: string) {
-  return ResponseHelper.created(this, data, message);
-};
+    proto.created = function <T>(this: Response, data?: T, message?: string) {
+      return ResponseHelper.created(this, data, message);
+    };
 
-Response.prototype.updated = function <T>(data?: T, message?: string) {
-  return ResponseHelper.updated(this, data, message);
-};
+    proto.updated = function <T>(this: Response, data?: T, message?: string) {
+      return ResponseHelper.updated(this, data, message);
+    };
 
-Response.prototype.deleted = function (message?: string) {
-  return ResponseHelper.deleted(this, message);
-};
+    proto.deleted = function (this: Response, message?: string) {
+      return ResponseHelper.deleted(this, message);
+    };
 
-Response.prototype.error = function (error: string, statusCode: number = 400, code?: string, details?: Record<string, unknown>) {
-  return ResponseHelper.error(this, error, statusCode, code, details);
-};
+    proto.error = function (this: Response, error: string, statusCode: number = 400, code?: string, details?: Record<string, unknown>) {
+      return ResponseHelper.error(this, error, statusCode, code, details);
+    };
 
-Response.prototype.badRequest = function (error?: string, code?: string) {
-  return ResponseHelper.badRequest(this, error, code);
-};
+    proto.badRequest = function (this: Response, error?: string, code?: string) {
+      return ResponseHelper.badRequest(this, error, code);
+    };
 
-Response.prototype.unauthorized = function (error?: string, code?: string) {
-  return ResponseHelper.unauthorized(this, error, code);
-};
+    proto.unauthorized = function (this: Response, error?: string, code?: string) {
+      return ResponseHelper.unauthorized(this, error, code);
+    };
 
-Response.prototype.forbidden = function (error?: string, code?: string) {
-  return ResponseHelper.forbidden(this, error, code);
-};
+    proto.forbidden = function (this: Response, error?: string, code?: string) {
+      return ResponseHelper.forbidden(this, error, code);
+    };
 
-Response.prototype.notFound = function (error?: string, code?: string) {
-  return ResponseHelper.notFound(this, error, code);
-};
+    proto.notFound = function (this: Response, error?: string, code?: string) {
+      return ResponseHelper.notFound(this, error, code);
+    };
 
-Response.prototype.conflict = function (error?: string, code?: string) {
-  return ResponseHelper.conflict(this, error, code);
-};
+    proto.conflict = function (this: Response, error?: string, code?: string) {
+      return ResponseHelper.conflict(this, error, code);
+    };
 
-Response.prototype.validationError = function (error: string, details?: Record<string, unknown>) {
-  return ResponseHelper.validationError(this, error, details);
-};
+    proto.validationError = function (this: Response, error: string, details?: Record<string, unknown>) {
+      return ResponseHelper.validationError(this, error, details);
+    };
 
-Response.prototype.internalError = function (error?: string) {
-  return ResponseHelper.internalError(this, error);
-};
+    proto.internalError = function (this: Response, error?: string) {
+      return ResponseHelper.internalError(this, error);
+    };
 
-Response.prototype.paginated = function <T>(data: T[], page: number, limit: number, total: number) {
-  return ResponseHelper.paginated(this, data, page, limit, total);
-};
+    proto.paginated = function <T>(this: Response, data: T[], page: number, limit: number, total: number) {
+      return ResponseHelper.paginated(this, data, page, limit, total);
+    };
+  }
+} catch {
+  // express not available at runtime
+}
 
 export const response = ResponseHelper;
 export default ResponseHelper;

package/tests/auth.test.ts

@@ -0,0 +1,134 @@
+describe('Auth Module', () => {
+  const mockUserStore = {
+    users: new Map(),
+    
+    async findByEmail(email: string) {
+      for (const user of this.users.values()) {
+        if (user.email === email) return user;
+      }
+      return null;
+    },
+    
+    async findById(id: string) {
+      return this.users.get(id) || null;
+    },
+    
+    async create(data: any) {
+      const bcrypt = require('bcryptjs');
+      const id = Math.random().toString(36).substr(2, 9);
+      const hashedPassword = await bcrypt.hash(data.password, 10);
+      const user = { id, email: data.email, role: data.role || 'user', ...data, password: hashedPassword };
+      this.users.set(id, user);
+      return user;
+    },
+    
+    async update(id: string, data: any) {
+      const user = this.users.get(id);
+      if (!user) throw new Error('User not found');
+      const updated = { ...user, ...data };
+      this.users.set(id, updated);
+      return updated;
+    }
+  };
+
+  test('should create auth service', () => {
+    const { createAuth } = require('../dist/auth');
+    const auth = createAuth({ jwtSecret: 'test-secret-key-that-is-at-least-32-chars' }, mockUserStore);
+    
+    expect(auth).toBeDefined();
+    expect(auth.initialize).toBeDefined();
+    expect(auth.register).toBeDefined();
+    expect(auth.login).toBeDefined();
+  });
+
+  test('should register a new user', async () => {
+    const { createAuth } = require('../dist/auth');
+    const auth = createAuth({ jwtSecret: 'test-secret-key-that-is-at-least-32-chars' }, mockUserStore);
+    
+    const result = await auth.register({
+      email: 'test@example.com',
+      password: 'password123',
+      name: 'Test User'
+    });
+    
+    expect(result.user).toBeDefined();
+    expect(result.user.email).toBe('test@example.com');
+    expect(result.tokens).toHaveProperty('accessToken');
+    expect(result.tokens).toHaveProperty('refreshToken');
+  });
+
+  test('should login with valid credentials', async () => {
+    const { createAuth } = require('../dist/auth');
+    const auth = createAuth({ jwtSecret: 'test-secret-key-that-is-at-least-32-chars' }, mockUserStore);
+    
+    await auth.register({
+      email: 'login@test.com',
+      password: 'password123'
+    });
+    
+    const result = await auth.login({
+      email: 'login@test.com',
+      password: 'password123'
+    });
+    
+    expect(result.user).toBeDefined();
+    expect(result.tokens).toHaveProperty('accessToken');
+  });
+
+  test('should fail login with invalid credentials', async () => {
+    const { createAuth } = require('../dist/auth');
+    const auth = createAuth({ jwtSecret: 'test-secret-key-that-is-at-least-32-chars' }, mockUserStore);
+    
+    await auth.register({
+      email: 'fail@test.com',
+      password: 'password123'
+    });
+    
+    await expect(auth.login({
+      email: 'fail@test.com',
+      password: 'wrongpassword'
+    })).rejects.toThrow('Invalid credentials');
+  });
+
+  test('should throw error for duplicate registration', async () => {
+    const { createAuth } = require('../dist/auth');
+    const auth = createAuth({ jwtSecret: 'test-secret-key-that-is-at-least-32-chars' }, mockUserStore);
+    
+    await auth.register({
+      email: 'duplicate@test.com',
+      password: 'password123'
+    });
+    
+    await expect(auth.register({
+      email: 'duplicate@test.com',
+      password: 'password123'
+    })).rejects.toThrow('User already exists');
+  });
+
+  test('should generate middleware', () => {
+    const { createAuth } = require('../dist/auth');
+    const auth = createAuth({ jwtSecret: 'test-secret-key-that-is-at-least-32-chars' }, mockUserStore);
+    
+    const middleware = auth.getMiddleware();
+    expect(middleware).toBeDefined();
+    expect(typeof middleware).toBe('function');
+  });
+
+  test('should create requireUser middleware', () => {
+    const { createAuth } = require('../dist/auth');
+    const auth = createAuth({ jwtSecret: 'test-secret-key-that-is-at-least-32-chars' }, mockUserStore);
+    
+    const middleware = auth.requireUser();
+    expect(middleware).toBeDefined();
+    expect(typeof middleware).toBe('function');
+  });
+
+  test('should create requireRole middleware', () => {
+    const { createAuth } = require('../dist/auth');
+    const auth = createAuth({ jwtSecret: 'test-secret-key-that-is-at-least-32-chars' }, mockUserStore);
+    
+    const middleware = auth.requireRole('admin');
+    expect(middleware).toBeDefined();
+    expect(typeof middleware).toBe('function');
+  });
+});

package/tests/config.test.ts

@@ -0,0 +1,36 @@
+describe('Config Module', () => {
+  test('should load config with defaults', async () => {
+    const { config } = require('../dist/config');
+    const cfg = config.load();
+    
+    expect(cfg.NODE_ENV).toBe('test');
+    expect(cfg.PORT).toBe('3000');
+    expect(cfg.REDIS_URL).toBe('redis://localhost:6379');
+  });
+
+  test('should get config value', async () => {
+    const { config } = require('../dist/config');
+    config.load();
+    
+    const port = config.int('PORT');
+    expect(port).toBe(3000);
+  });
+
+  test('should check environment', async () => {
+    const { config } = require('../dist/config');
+    config.load();
+    
+    expect(config.isTest()).toBe(true);
+    expect(config.isProduction()).toBe(false);
+    expect(config.isDevelopment()).toBe(false);
+  });
+
+  test('should get all config', async () => {
+    const { config } = require('../dist/config');
+    const cfg = config.getAll();
+    
+    expect(cfg).toHaveProperty('NODE_ENV');
+    expect(cfg).toHaveProperty('PORT');
+    expect(cfg).toHaveProperty('AWS_REGION');
+  });
+});

package/tests/logger.test.ts

@@ -0,0 +1,47 @@
+describe('Logger Module', () => {
+  test('should create logger', () => {
+    const { logger } = require('../dist/logger');
+    
+    expect(logger).toBeDefined();
+    expect(logger.info).toBeDefined();
+    expect(logger.error).toBeDefined();
+    expect(logger.warn).toBeDefined();
+    expect(logger.debug).toBeDefined();
+  });
+
+  test('should log info message', () => {
+    const { logger } = require('../dist/logger');
+    
+    expect(() => logger.info('test message')).not.toThrow();
+  });
+
+  test('should log error with metadata', () => {
+    const { logger } = require('../dist/logger');
+    
+    expect(() => logger.error('error occurred', { code: 500 })).not.toThrow();
+  });
+
+  test('should create child logger', () => {
+    const { logger } = require('../dist/logger');
+    
+    const child = logger.child({ module: 'auth' });
+    expect(child).toBeDefined();
+    expect(child.info).toBeDefined();
+  });
+
+  test('should create named logger', () => {
+    const { logger } = require('../dist/logger');
+    
+    const named = logger.create({ name: 'test-logger' });
+    expect(named).toBeDefined();
+    expect(named.info).toBeDefined();
+  });
+
+  test('should get logger by name', () => {
+    const { logger } = require('../dist/logger');
+    
+    logger.create({ name: 'custom-logger' });
+    const custom = logger.get('custom-logger');
+    expect(custom).toBeDefined();
+  });
+});

package/tests/notifications.test.ts

@@ -0,0 +1,19 @@
+describe('Notifications Module', () => {
+  test('should have notify object defined', () => {
+    const { notify } = require('../dist/notifications');
+    
+    expect(notify).toBeDefined();
+    expect(notify.email).toBeDefined();
+    expect(notify.sms).toBeDefined();
+    expect(notify.webhook).toBeDefined();
+    expect(notify.slack).toBeDefined();
+  });
+
+  test('should have notification export', () => {
+    const { notification } = require('../dist/notifications');
+    
+    expect(notification).toBeDefined();
+    expect(notification.email).toBeDefined();
+    expect(notification.sms).toBeDefined();
+  });
+});

package/tests/rate-limit.test.ts

@@ -0,0 +1,50 @@
+describe('Rate Limit Module', () => {
+  test('should create rate limiter middleware', () => {
+    const { rateLimit } = require('../src/rate-limit');
+    
+    const middleware = rateLimit({ window: '1m', limit: 100 });
+    expect(middleware).toBeDefined();
+    expect(typeof middleware).toBe('function');
+  });
+
+  test('should create rate limiter with defaults', () => {
+    const { rateLimit } = require('../src/rate-limit');
+    
+    const middleware = rateLimit();
+    expect(middleware).toBeDefined();
+    expect(typeof middleware).toBe('function');
+  });
+
+  test('should create custom rate limiter', () => {
+    const { createRateLimiter } = require('../src/rate-limit');
+    
+    const limiter = createRateLimiter({ window: '1m', limit: 10 });
+    expect(limiter).toBeDefined();
+    expect(limiter.middleware).toBeDefined();
+    expect(limiter.destroy).toBeDefined();
+  });
+
+  test('should use custom key generator', () => {
+    const { rateLimit } = require('../src/rate-limit');
+    
+    const middleware = rateLimit({
+      window: '1m',
+      limit: 100,
+      keyGenerator: (req: any) => req.userId || 'anonymous'
+    });
+    
+    expect(middleware).toBeDefined();
+  });
+
+  test('should use custom skip function', () => {
+    const { rateLimit } = require('../src/rate-limit');
+    
+    const middleware = rateLimit({
+      window: '1m',
+      limit: 100,
+      skip: (req: any) => req.skipRateLimit === true
+    });
+    
+    expect(middleware).toBeDefined();
+  });
+});

package/tests/upload.test.ts

@@ -0,0 +1,33 @@
+describe('Upload Module (S3)', () => {
+  test('should have upload functions defined', () => {
+    const { upload } = require('../dist/upload');
+    
+    expect(upload).toBeDefined();
+    expect(upload.initialize).toBeDefined();
+    expect(upload.file).toBeDefined();
+    expect(upload.image).toBeDefined();
+    expect(upload.video).toBeDefined();
+    expect(upload.delete).toBeDefined();
+    expect(upload.getSignedUrl).toBeDefined();
+    expect(upload.getPublicUrl).toBeDefined();
+  });
+
+  test('should initialize S3 service', () => {
+    const { upload } = require('../dist/upload');
+    
+    expect(() => {
+      upload.initialize({
+        region: 'us-east-1',
+        accessKeyId: 'test-key',
+        secretAccessKey: 'test-secret',
+        bucket: 'test-bucket'
+      });
+    }).not.toThrow();
+  });
+
+  test('should have s3Service defined', () => {
+    const { s3Service } = require('../dist/upload');
+    
+    expect(s3Service).toBeDefined();
+  });
+});

package/tsconfig.test.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "types": ["jest", "node"],
+    "composite": false,
+    "declaration": false,
+    "declarationMap": false,
+    "sourceMap": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  },
+  "include": ["src/**/*", "tests/**/*"]
+}