saas-backend-kit 1.0.0 → 1.0.2

package/src/upload/index.ts

@@ -0,0 +1,268 @@
+import { S3Client, PutObjectCommand, DeleteObjectCommand, GetObjectCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { config } from '../config';
+import { logger } from '../logger';
+
+export interface S3Config {
+  region?: string;
+  accessKeyId?: string;
+  secretAccessKey?: string;
+  bucket: string;
+  endpoint?: string;
+  forcePathStyle?: boolean;
+}
+
+export interface UploadOptions {
+  key?: string;
+  contentType?: string;
+  expiresIn?: number;
+  metadata?: Record<string, string>;
+}
+
+export interface UploadResult {
+  key: string;
+  url: string;
+  bucket: string;
+  contentType?: string;
+  size?: number;
+}
+
+export interface SignedUrlOptions {
+  expiresIn?: number;
+}
+
+export interface FileObject {
+  key: string;
+  lastModified?: Date;
+  size?: number;
+  contentType?: string;
+}
+
+class S3Service {
+  private client: S3Client | null = null;
+  private bucket: string;
+  private initialized: boolean = false;
+
+  constructor() {
+    this.bucket = '';
+  }
+
+  initialize(config: S3Config): void {
+    this.client = new S3Client({
+      region: config.region || 'us-east-1',
+      credentials: config.accessKeyId && config.secretAccessKey
+        ? {
+            accessKeyId: config.accessKeyId,
+            secretAccessKey: config.secretAccessKey,
+          }
+        : undefined,
+      endpoint: config.endpoint,
+      forcePathStyle: config.forcePathStyle || false,
+    });
+
+    this.bucket = config.bucket;
+    this.initialized = true;
+    logger.info('S3 service initialized', { bucket: this.bucket });
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  private ensureInitialized(): void {
+    if (!this.initialized) {
+      const region = config.get('AWS_REGION') || 'us-east-1';
+      const bucket = config.get('AWS_S3_BUCKET') || '';
+      
+      this.initialize({
+        region,
+        accessKeyId: config.get('AWS_ACCESS_KEY_ID'),
+        secretAccessKey: config.get('AWS_SECRET_ACCESS_KEY'),
+        bucket,
+        endpoint: config.get('AWS_ENDPOINT'),
+      });
+    }
+  }
+
+  async upload(
+    file: Buffer | Uint8Array | string,
+    options: UploadOptions = {}
+  ): Promise<UploadResult> {
+    this.ensureInitialized();
+
+    const key = options.key || this.generateKey();
+    const contentType = options.contentType || this.guessContentType(key);
+
+    const command = new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      Body: file,
+      ContentType: contentType,
+      Metadata: options.metadata,
+    });
+
+    await this.client!.send(command);
+
+    const url = await this.getSignedUrl(key, { expiresIn: options.expiresIn || 3600 });
+
+    logger.info('File uploaded to S3', { key, bucket: this.bucket, contentType });
+
+    return {
+      key,
+      url,
+      bucket: this.bucket,
+      contentType,
+    };
+  }
+
+  async uploadImage(
+    file: Buffer | Uint8Array | string,
+    filename: string,
+    options: UploadOptions = {}
+  ): Promise<UploadResult> {
+    const key = options.key || `images/${Date.now()}-${filename}`;
+    
+    return this.upload(file, {
+      ...options,
+      key,
+      contentType: options.contentType || this.getImageContentType(filename),
+    });
+  }
+
+  async uploadVideo(
+    file: Buffer | Uint8Array | string,
+    filename: string,
+    options: UploadOptions = {}
+  ): Promise<UploadResult> {
+    const key = options.key || `videos/${Date.now()}-${filename}`;
+    
+    return this.upload(file, {
+      ...options,
+      key,
+      contentType: options.contentType || this.getVideoContentType(filename),
+    });
+  }
+
+  async delete(key: string): Promise<void> {
+    this.ensureInitialized();
+
+    const command = new DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    });
+
+    await this.client!.send(command);
+    logger.info('File deleted from S3', { key, bucket: this.bucket });
+  }
+
+  async getSignedUrl(key: string, options: SignedUrlOptions = {}): Promise<string> {
+    this.ensureInitialized();
+
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    });
+
+    return getSignedUrl(this.client!, command, {
+      expiresIn: options.expiresIn || 3600,
+    });
+  }
+
+  async getPublicUrl(key: string): Promise<string> {
+    return `https://${this.bucket}.s3.${config.get('AWS_REGION') || 'us-east-1'}.amazonaws.com/${key}`;
+  }
+
+  async listFiles(prefix?: string, maxKeys: number = 1000): Promise<FileObject[]> {
+    this.ensureInitialized();
+
+    const command = new ListObjectsV2Command({
+      Bucket: this.bucket,
+      Prefix: prefix,
+      MaxKeys: maxKeys,
+    });
+
+    const response = await this.client!.send(command);
+    
+    return (response.Contents || []).map((item) => ({
+      key: item.Key || '',
+      lastModified: item.LastModified,
+      size: item.Size,
+    }));
+  }
+
+  private generateKey(): string {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 15);
+    return `uploads/${timestamp}-${random}`;
+  }
+
+  private guessContentType(key: string): string {
+    const ext = key.split('.').pop()?.toLowerCase();
+    
+    const contentTypes: Record<string, string> = {
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      png: 'image/png',
+      gif: 'image/gif',
+      webp: 'image/webp',
+      svg: 'image/svg+xml',
+      mp4: 'video/mp4',
+      webm: 'video/webm',
+      mov: 'video/quicktime',
+      avi: 'video/x-msvideo',
+      pdf: 'application/pdf',
+      json: 'application/json',
+      txt: 'text/plain',
+    };
+
+    return contentTypes[ext || ''] || 'application/octet-stream';
+  }
+
+  private getImageContentType(filename: string): string {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    const imageTypes: Record<string, string> = {
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      png: 'image/png',
+      gif: 'image/gif',
+      webp: 'image/webp',
+      svg: 'image/svg+xml',
+    };
+    return imageTypes[ext || ''] || 'image/jpeg';
+  }
+
+  private getVideoContentType(filename: string): string {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    const videoTypes: Record<string, string> = {
+      mp4: 'video/mp4',
+      webm: 'video/webm',
+      mov: 'video/quicktime',
+      avi: 'video/x-msvideo',
+      mkv: 'video/x-matroska',
+      ogv: 'video/ogg',
+    };
+    return videoTypes[ext || ''] || 'video/mp4';
+  }
+}
+
+export const s3Service = new S3Service();
+
+export const upload = {
+  initialize: (config: S3Config) => s3Service.initialize(config),
+  
+  file: (file: Buffer | Uint8Array | string, options?: UploadOptions) => 
+    s3Service.upload(file, options),
+  
+  image: (file: Buffer | Uint8Array | string, filename: string, options?: UploadOptions) =>
+    s3Service.uploadImage(file, filename, options),
+  
+  video: (file: Buffer | Uint8Array | string, filename: string, options?: UploadOptions) =>
+    s3Service.uploadVideo(file, filename, options),
+  
+  delete: (key: string) => s3Service.delete(key),
+  getSignedUrl: (key: string, options?: SignedUrlOptions) => s3Service.getSignedUrl(key, options),
+  getPublicUrl: (key: string) => s3Service.getPublicUrl(key),
+  listFiles: (prefix?: string, maxKeys?: number) => s3Service.listFiles(prefix, maxKeys),
+};
+
+export default upload;

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/**/*"]
+}

package/tsup.config.ts

@@ -10,13 +10,14 @@ export default defineConfig({
     'rate-limit/index': 'src/rate-limit/index.ts',
     'config/index': 'src/config/index.ts',
     'response/index': 'src/response/index.ts',
+    'upload/index': 'src/upload/index.ts',
   },
   format: ['cjs', 'esm'],
   dts: false,
   splitting: false,
   sourcemap: true,
   clean: false,
-  external: ['express', 'fastify', 'ioredis', 'bullmq'],
+  external: ['express', 'fastify', 'ioredis', 'bullmq', '@aws-sdk/client-s3', '@aws-sdk/s3-request-presigner'],
   treeshake: true,
   exports: {
     namedExports: true,