saas-backend-kit 1.0.2 → 1.0.4

package/src/queue/index.ts

@@ -1,208 +0,0 @@
-import { Queue, Worker, Job, JobsOptions, WorkerOptions } from 'bullmq';
-import { config } from '../config';
-import { logger } from '../logger';
-
-export interface QueueOptions {
-  name: string;
-  defaultJobOptions?: JobsOptions;
-}
-
-export interface RedisOptions {
-  host?: string;
-  port?: number;
-  password?: string;
-  db?: number;
-  url?: string;
-}
-
-export interface JobData {
-  [key: string]: unknown;
-}
-
-export type JobProcessor = (job: Job<JobData>) => Promise<unknown>;
-
-class QueueManager {
-  private queues: Map<string, Queue> = new Map();
-  private workers: Map<string, Worker> = new Map();
-  private redisOptions: RedisOptions;
-
-  constructor() {
-    const redisUrl = config.get('REDIS_URL');
-    if (redisUrl) {
-      this.redisOptions = { url: redisUrl };
-    } else {
-      this.redisOptions = {
-        host: 'localhost',
-        port: 6379,
-      };
-    }
-  }
-
-  setRedisOptions(options: RedisOptions): void {
-    this.redisOptions = options;
-  }
-
-  createQueue(name: string, options?: Partial<QueueOptions>): Queue {
-    if (this.queues.has(name)) {
-      return this.queues.get(name)!;
-    }
-
-    const queue = new Queue(name, {
-      connection: this.redisOptions as any,
-      defaultJobOptions: options?.defaultJobOptions || {
-        removeOnComplete: 100,
-        removeOnFail: 100,
-      },
-    });
-
-    this.queues.set(name, queue);
-    logger.info(`Queue "${name}" created`);
-
-    return queue;
-  }
-
-  getQueue(name: string): Queue | undefined {
-    return this.queues.get(name);
-  }
-
-  async addJob(
-    queueName: string,
-    jobName: string,
-    data: JobData,
-    options?: JobsOptions
-  ): Promise<Job> {
-    const queue = this.getQueue(queueName) || this.createQueue(queueName);
-    const job = await queue.add(jobName, data, options);
-    logger.debug(`Job "${jobName}" added to queue "${queueName}"`, { jobId: job.id });
-    return job;
-  }
-
-  async addBulkJobs(
-    queueName: string,
-    jobs: Array<{ name: string; data: JobData; options?: JobsOptions }>
-  ): Promise<Job[]> {
-    const queue = this.getQueue(queueName) || this.createQueue(queueName);
-    const bulkJobs = jobs.map(job => ({
-      name: job.name,
-      data: job.data,
-      ...job.options,
-    }));
-    const result = await queue.addBulk(bulkJobs);
-    logger.debug(`${jobs.length} jobs added to queue "${queueName}"`);
-    return result;
-  }
-
-  processJob(
-    queueName: string,
-    processor: JobProcessor,
-    options?: WorkerOptions
-  ): Worker {
-    const queue = this.getQueue(queueName) || this.createQueue(queueName);
-    
-    const worker = new Worker(queueName, async (job) => {
-      logger.debug(`Processing job "${job.name}"`, { jobId: job.id, queue: queueName });
-      return await processor(job);
-    }, {
-      connection: this.redisOptions as any,
-      concurrency: options?.concurrency || 1,
-      ...options,
-    });
-
-    worker.on('completed', (job) => {
-      logger.debug(`Job completed`, { jobId: job.id, queue: queueName });
-    });
-
-    worker.on('failed', (job, err) => {
-      logger.error(`Job failed`, { jobId: job?.id, queue: queueName, error: err.message });
-    });
-
-    worker.on('error', (err) => {
-      logger.error(`Worker error`, { queue: queueName, error: err.message });
-    });
-
-    this.workers.set(queueName, worker);
-    logger.info(`Worker started for queue "${queueName}"`);
-
-    return worker;
-  }
-
-  async getJobCounts(queueName: string): Promise<Record<string, number>> {
-    const queue = this.getQueue(queueName);
-    if (!queue) {
-      return { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };
-    }
-    return await queue.getJobCounts();
-  }
-
-  async getJobs(queueName: string, start: number = 0, end: number = 10): Promise<Job[]> {
-    const queue = this.getQueue(queueName);
-    if (!queue) return [];
-    return await queue.getJobs(['waiting', 'active', 'completed', 'failed'], start, end);
-  }
-
-  async closeQueue(name: string): Promise<void> {
-    const queue = this.queues.get(name);
-    if (queue) {
-      await queue.close();
-      this.queues.delete(name);
-      logger.info(`Queue "${name}" closed`);
-    }
-  }
-
-  async closeWorker(name: string): Promise<void> {
-    const worker = this.workers.get(name);
-    if (worker) {
-      await worker.close();
-      this.workers.delete(name);
-      logger.info(`Worker for queue "${name}" closed`);
-    }
-  }
-
-  async closeAll(): Promise<void> {
-    await Promise.all([
-      ...Array.from(this.queues.values()).map(q => q.close()),
-      ...Array.from(this.workers.values()).map(w => w.close()),
-    ]);
-    this.queues.clear();
-    this.workers.clear();
-    logger.info('All queues and workers closed');
-  }
-}
-
-const queueManager = new QueueManager();
-
-export const createQueue = (name: string, options?: Partial<QueueOptions>): Queue => {
-  return queueManager.createQueue(name, options);
-};
-
-export const addJob = (
-  queueName: string,
-  jobName: string,
-  data: JobData,
-  options?: JobsOptions
-): Promise<Job> => {
-  return queueManager.addJob(queueName, jobName, data, options);
-};
-
-export const processJob = (
-  queueName: string,
-  processor: JobProcessor,
-  options?: WorkerOptions
-): Worker => {
-  return queueManager.processJob(queueName, processor, options);
-};
-
-export const queue = {
-  create: createQueue,
-  add: addJob,
-  process: processJob,
-  get: (name: string) => queueManager.getQueue(name),
-  getJobCounts: (name: string) => queueManager.getJobCounts(name),
-  getJobs: (name: string, start?: number, end?: number) => queueManager.getJobs(name, start, end),
-  close: (name: string) => queueManager.closeQueue(name),
-  closeAll: () => queueManager.closeAll(),
-  setRedisOptions: (options: RedisOptions) => queueManager.setRedisOptions(options),
-};
-
-export { QueueManager };
-export default queue;

package/src/rate-limit/express.ts

@@ -1,145 +0,0 @@
-import { Request, Response, NextFunction, RequestHandler } from 'express';
-import { config } from '../config';
-
-export interface RateLimitOptions {
-  window?: string;
-  limit?: number;
-  keyGenerator?: (req: Request) => string;
-  handler?: (req: Request, res: Response) => void;
-  skipSuccessfulRequests?: boolean;
-  skipFailedRequests?: boolean;
-  skip?: (req: Request) => boolean;
-}
-
-interface RateLimitRecord {
-  count: number;
-  resetTime: number;
-}
-
-class InMemoryRateLimiter {
-  private store: Map<string, RateLimitRecord> = new Map();
-  private cleanupInterval: NodeJS.Timeout;
-
-  constructor() {
-    this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
-    this.cleanupInterval.unref();
-  }
-
-  private cleanup(): void {
-    const now = Date.now();
-    for (const [key, record] of this.store.entries()) {
-      if (record.resetTime < now) {
-        this.store.delete(key);
-      }
-    }
-  }
-
-  increment(key: string, windowMs: number): RateLimitRecord {
-    const now = Date.now();
-    const record = this.store.get(key);
-
-    if (!record || record.resetTime < now) {
-      const resetTime = now + windowMs;
-      this.store.set(key, { count: 1, resetTime });
-      return { count: 1, resetTime };
-    }
-
-    record.count++;
-    return record;
-  }
-
-  get(key: string): RateLimitRecord | undefined {
-    return this.store.get(key);
-  }
-
-  destroy(): void {
-    clearInterval(this.cleanupInterval);
-  }
-}
-
-class RateLimiter {
-  private options: Required<RateLimitOptions>;
-  private store: InMemoryRateLimiter;
-
-  constructor(options: RateLimitOptions = {}) {
-    const defaultWindow = config.get('RATE_LIMIT_WINDOW') || '1m';
-    const defaultLimit = parseInt(config.get('RATE_LIMIT_LIMIT') || '100', 10);
-
-    this.options = {
-      window: options.window || defaultWindow,
-      limit: options.limit || defaultLimit,
-      keyGenerator: options.keyGenerator || ((req: Request) => req.ip || 'unknown'),
-      handler: options.handler || this.defaultHandler,
-      skipSuccessfulRequests: options.skipSuccessfulRequests || false,
-      skipFailedRequests: options.skipFailedRequests || false,
-      skip: options.skip || (() => false),
-    };
-
-    this.store = new InMemoryRateLimiter();
-  }
-
-  private getWindowMs(): number {
-    const window = this.options.window;
-    const match = window.match(/^(\d+)(s|m|h|d)$/);
-    if (!match) return 60000;
-
-    const value = parseInt(match[1], 10);
-    const unit = match[2];
-
-    switch (unit) {
-      case 's': return value * 1000;
-      case 'm': return value * 60 * 1000;
-      case 'h': return value * 60 * 60 * 1000;
-      case 'd': return value * 24 * 60 * 60 * 1000;
-      default: return 60000;
-    }
-  }
-
-  private defaultHandler(req: Request, res: Response): void {
-    res.status(429).json({
-      error: 'Too many requests',
-      message: `Rate limit exceeded. Please try again later.`,
-    });
-  }
-
-  middleware(): RequestHandler {
-    const windowMs = this.getWindowMs();
-
-    return (req: Request, res: Response, next: NextFunction) => {
-      if (this.options.skip(req)) {
-        return next();
-      }
-
-      const key = this.options.keyGenerator(req);
-      const record = this.store.increment(key, windowMs);
-
-      const remaining = Math.max(0, this.options.limit - record.count);
-      const resetTime = new Date(record.resetTime);
-
-      res.setHeader('X-RateLimit-Limit', this.options.limit);
-      res.setHeader('X-RateLimit-Remaining', remaining);
-      res.setHeader('X-RateLimit-Reset', Math.ceil(record.resetTime / 1000));
-
-      if (record.count > this.options.limit) {
-        return this.options.handler(req, res);
-      }
-
-      next();
-    };
-  }
-
-  destroy(): void {
-    this.store.destroy();
-  }
-}
-
-export function rateLimit(options: RateLimitOptions = {}): RequestHandler {
-  const limiter = new RateLimiter(options);
-  return limiter.middleware();
-}
-
-export function createRateLimiter(options: RateLimitOptions): RateLimiter {
-  return new RateLimiter(options);
-}
-
-export default rateLimit;

package/src/rate-limit/fastify.ts

@@ -1,47 +0,0 @@
-import { FastifyInstance, FastifyRequest, FastifyReply, HookHandlerDoneFunction } from 'fastify';
-import { RateLimitOptions, InMemoryRateLimiter } from './express';
-
-export function registerRateLimitPlugin(fastify: FastifyInstance, options: RateLimitOptions = {}, done: HookHandlerDoneFunction) {
-  const limiter = new (require('./express').createRateLimiter.constructor)(options);
-  
-  fastify.addHook('onRequest', async (request: FastifyRequest, reply: FastifyReply) => {
-    const key = options.keyGenerator 
-      ? options.keyGenerator(request.raw as any)
-      : request.ip || 'unknown';
-    
-    const windowMs = parseWindowMs(options.window || '1m');
-    const record = (limiter as any).store.increment(key, windowMs);
-    const limit = options.limit || 100;
-    const remaining = Math.max(0, limit - record.count);
-
-    reply.header('X-RateLimit-Limit', limit);
-    reply.header('X-RateLimit-Remaining', remaining);
-    reply.header('X-RateLimit-Reset', Math.ceil(record.resetTime / 1000));
-
-    if (record.count > limit) {
-      reply.status(429).send({
-        error: 'Too many requests',
-        message: 'Rate limit exceeded. Please try again later.',
-      });
-      return reply;
-    }
-  });
-
-  done();
-}
-
-function parseWindowMs(window: string): number {
-  const match = window.match(/^(\d+)(s|m|h|d)$/);
-  if (!match) return 60000;
-
-  const value = parseInt(match[1], 10);
-  const unit = match[2];
-
-  switch (unit) {
-    case 's': return value * 1000;
-    case 'm': return value * 60 * 1000;
-    case 'h': return value * 60 * 60 * 1000;
-    case 'd': return value * 24 * 60 * 60 * 1000;
-    default: return 60000;
-  }
-}

package/src/rate-limit/index.ts

@@ -1,2 +0,0 @@
-export * from './express';
-export * from './fastify';

package/src/response/index.ts

@@ -1,206 +0,0 @@
-import { Response } from 'express';
-
-export interface ApiResponse<T = unknown> {
-  success: boolean;
-  data?: T;
-  error?: string;
-  message?: string;
-  meta?: {
-    page?: number;
-    limit?: number;
-    total?: number;
-    totalPages?: number;
-  };
-}
-
-export interface PaginatedResponse<T> extends Omit<ApiResponse<T[]>, 'data'> {
-  data: T[];
-  meta: {
-    page: number;
-    limit: number;
-    total: number;
-    totalPages: number;
-  };
-}
-
-export interface ErrorResponse {
-  success: false;
-  error: string;
-  code?: string;
-  details?: Record<string, unknown>;
-}
-
-export class ResponseHelper {
-  static success<T>(res: Response, data?: T, message?: string, statusCode: number = 200): Response {
-    const response: ApiResponse<T> = {
-      success: true,
-      data,
-      message,
-    };
-    return res.status(statusCode).json(response);
-  }
-
-  static created<T>(res: Response, data?: T, message: string = 'Resource created'): Response {
-    return this.success(res, data, message, 201);
-  }
-
-  static updated<T>(res: Response, data?: T, message: string = 'Resource updated'): Response {
-    return this.success(res, data, message, 200);
-  }
-
-  static deleted(res: Response, message: string = 'Resource deleted'): Response {
-    return this.success(res, null, message, 200);
-  }
-
-  static error(
-    res: Response,
-    error: string,
-    statusCode: number = 400,
-    code?: string,
-    details?: Record<string, unknown>
-  ): Response {
-    const response: ErrorResponse = {
-      success: false,
-      error,
-      code,
-      ...(details && { details }),
-    };
-    return res.status(statusCode).json(response);
-  }
-
-  static badRequest(res: Response, error: string = 'Bad request', code?: string): Response {
-    return this.error(res, error, 400, code);
-  }
-
-  static unauthorized(res: Response, error: string = 'Unauthorized', code?: string): Response {
-    return this.error(res, error, 401, code);
-  }
-
-  static forbidden(res: Response, error: string = 'Forbidden', code?: string): Response {
-    return this.error(res, error, 403, code);
-  }
-
-  static notFound(res: Response, error: string = 'Resource not found', code?: string): Response {
-    return this.error(res, error, 404, code);
-  }
-
-  static conflict(res: Response, error: string = 'Conflict', code?: string): Response {
-    return this.error(res, error, 409, code);
-  }
-
-  static validationError(res: Response, error: string, details?: Record<string, unknown>): Response {
-    return this.error(res, error, 422, 'VALIDATION_ERROR', details);
-  }
-
-  static internalError(res: Response, error: string = 'Internal server error'): Response {
-    return this.error(res, error, 500, 'INTERNAL_ERROR');
-  }
-
-  static paginated<T>(
-    res: Response,
-    data: T[],
-    page: number,
-    limit: number,
-    total: number
-  ): Response<PaginatedResponse<T>> {
-    const totalPages = Math.ceil(total / limit);
-    const response: PaginatedResponse<T> = {
-      success: true,
-      data,
-      meta: {
-        page,
-        limit,
-        total,
-        totalPages,
-      },
-    };
-    return res.status(200).json(response);
-  }
-
-  static noContent(res: Response): Response {
-    return res.status(204).send();
-  }
-}
-
-declare global {
-  namespace Express {
-    interface Response {
-      success<T>(data?: T, message?: string, statusCode?: number): Response;
-      created<T>(data?: T, message?: string): Response;
-      updated<T>(data?: T, message?: string): Response;
-      deleted(message?: string): Response;
-      error(error: string, statusCode?: number, code?: string, details?: Record<string, unknown>): Response;
-      badRequest(error?: string, code?: string): Response;
-      unauthorized(error?: string, code?: string): Response;
-      forbidden(error?: string, code?: string): Response;
-      notFound(error?: string, code?: string): Response;
-      conflict(error?: string, code?: string): Response;
-      validationError(error: string, details?: Record<string, unknown>): Response;
-      internalError(error?: string): Response;
-      paginated<T>(data: T[], page: number, limit: number, total: number): Response;
-    }
-  }
-}
-
-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);
-    };
-
-    proto.created = function <T>(this: Response, data?: T, message?: string) {
-      return ResponseHelper.created(this, data, message);
-    };
-
-    proto.updated = function <T>(this: Response, data?: T, message?: string) {
-      return ResponseHelper.updated(this, data, message);
-    };
-
-    proto.deleted = function (this: Response, message?: string) {
-      return ResponseHelper.deleted(this, message);
-    };
-
-    proto.error = function (this: Response, error: string, statusCode: number = 400, code?: string, details?: Record<string, unknown>) {
-      return ResponseHelper.error(this, error, statusCode, code, details);
-    };
-
-    proto.badRequest = function (this: Response, error?: string, code?: string) {
-      return ResponseHelper.badRequest(this, error, code);
-    };
-
-    proto.unauthorized = function (this: Response, error?: string, code?: string) {
-      return ResponseHelper.unauthorized(this, error, code);
-    };
-
-    proto.forbidden = function (this: Response, error?: string, code?: string) {
-      return ResponseHelper.forbidden(this, error, code);
-    };
-
-    proto.notFound = function (this: Response, error?: string, code?: string) {
-      return ResponseHelper.notFound(this, error, code);
-    };
-
-    proto.conflict = function (this: Response, error?: string, code?: string) {
-      return ResponseHelper.conflict(this, error, code);
-    };
-
-    proto.validationError = function (this: Response, error: string, details?: Record<string, unknown>) {
-      return ResponseHelper.validationError(this, error, details);
-    };
-
-    proto.internalError = function (this: Response, error?: string) {
-      return ResponseHelper.internalError(this, error);
-    };
-
-    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;