saas-backend-kit 1.0.3 → 1.0.4

package/src/config/index.ts

@@ -1,126 +0,0 @@
-import { z } from 'zod';
-
-export const envSchema = z.object({
-  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
-  PORT: z.string().default('3000'),
-  DATABASE_URL: z.string().optional(),
-  MONGODB_URL: z.string().optional(),
-  REDIS_URL: z.string().default('redis://localhost:6379'),
-  JWT_SECRET: z.string().min(32).optional(),
-  JWT_EXPIRES_IN: z.string().default('7d'),
-  JWT_REFRESH_SECRET: z.string().min(32).optional(),
-  JWT_REFRESH_EXPIRES_IN: z.string().default('30d'),
-  GOOGLE_CLIENT_ID: z.string().optional(),
-  GOOGLE_CLIENT_SECRET: z.string().optional(),
-  GOOGLE_REDIRECT_URI: z.string().optional(),
-  SMTP_HOST: z.string().optional(),
-  SMTP_PORT: z.string().default('587'),
-  SMTP_USER: z.string().optional(),
-  SMTP_PASS: z.string().optional(),
-  SMTP_FROM: z.string().optional(),
-  TWILIO_ACCOUNT_SID: z.string().optional(),
-  TWILIO_AUTH_TOKEN: z.string().optional(),
-  TWILIO_PHONE_NUMBER: z.string().optional(),
-  SLACK_WEBHOOK_URL: z.string().optional(),
-  RATE_LIMIT_WINDOW: z.string().default('1m'),
-  RATE_LIMIT_LIMIT: z.string().default('100'),
-  LOG_LEVEL: z.enum(['fatal', 'error', 'warn', 'info', 'debug', 'trace']).default('info'),
-  AWS_REGION: z.string().default('us-east-1'),
-  AWS_ACCESS_KEY_ID: z.string().optional(),
-  AWS_SECRET_ACCESS_KEY: z.string().optional(),
-  AWS_S3_BUCKET: z.string().optional(),
-  AWS_ENDPOINT: z.string().optional(),
-});
-
-export type EnvConfig = z.infer<typeof envSchema>;
-
-export interface ConfigOptions {
-  schema?: z.ZodSchema;
-  envPath?: string;
-  validate?: boolean;
-}
-
-class ConfigManager {
-  private config: EnvConfig | null = null;
-  private schema: z.ZodSchema;
-  private validate: boolean;
-
-  constructor(options: ConfigOptions = {}) {
-    this.schema = options.schema || envSchema;
-    this.validate = options.validate ?? true;
-  }
-
-  load(): EnvConfig {
-    if (this.config) return this.config;
-
-    const env: Record<string, string | undefined> = {};
-    
-    for (const key of Object.keys(this.schema.shape)) {
-      env[key] = process.env[key];
-    }
-
-    if (this.validate) {
-      const result = this.schema.safeParse(env);
-      if (!result.success) {
-        const errors = result.error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
-        throw new Error(`Config validation failed: ${errors}`);
-      }
-      this.config = result.data;
-    } else {
-      this.config = env as EnvConfig;
-    }
-
-    return this.config;
-  }
-
-  get<K extends keyof EnvConfig>(key: K): EnvConfig[K] {
-    if (!this.config) this.load();
-    return this.config![key];
-  }
-
-  int(key: keyof EnvConfig): number {
-    const value = this.get(key);
-    if (typeof value === 'string') return parseInt(value, 10);
-    return Number(value);
-  }
-
-  bool(key: keyof EnvConfig): boolean {
-    const value = this.get(key);
-    if (typeof value === 'boolean') return value;
-    if (typeof value === 'string') return value.toLowerCase() === 'true';
-    return Boolean(value);
-  }
-
-  isProduction(): boolean {
-    return this.get('NODE_ENV') === 'production';
-  }
-
-  isDevelopment(): boolean {
-    return this.get('NODE_ENV') === 'development';
-  }
-
-  isTest(): boolean {
-    return this.get('NODE_ENV') === 'test';
-  }
-
-  getAll(): EnvConfig {
-    if (!this.config) this.load();
-    return this.config!;
-  }
-}
-
-const globalConfig = new ConfigManager();
-
-export const config = {
-  load: () => globalConfig.load(),
-  get: <K extends keyof EnvConfig>(key: K) => globalConfig.get(key),
-  int: (key: keyof EnvConfig) => globalConfig.int(key),
-  bool: (key: keyof EnvConfig) => globalConfig.bool(key),
-  isProduction: () => globalConfig.isProduction(),
-  isDevelopment: () => globalConfig.isDevelopment(),
-  isTest: () => globalConfig.isTest(),
-  getAll: () => globalConfig.getAll(),
-  create: (options?: ConfigOptions) => new ConfigManager(options),
-};
-
-export default config;

package/src/database/index.ts

@@ -1,102 +0,0 @@
-import { MongoClient, Db, Collection, MongoClientOptions } from 'mongodb';
-
-export interface DatabaseConfig {
-  url?: string;
-  options?: MongoClientOptions;
-}
-
-export interface DatabaseOptions {
-  url: string;
-  options?: MongoClientOptions;
-}
-
-class DatabaseManager {
-  private client: MongoClient | null = null;
-  private db: Db | null = null;
-  private url: string | null = null;
-
-  async connect(options: DatabaseOptions): Promise<Db> {
-    if (this.db) return this.db;
-
-    this.url = options.url;
-    const clientOptions: MongoClientOptions = {
-      ...options.options,
-      maxPoolSize: 10,
-      minPoolSize: 1,
-      serverSelectionTimeoutMS: 5000,
-      socketTimeoutMS: 45000,
-    };
-
-    this.client = new MongoClient(this.url, clientOptions);
-    await this.client.connect();
-    this.db = this.client.db();
-
-    return this.db;
-  }
-
-  async connectTo(uri: string, dbName?: string, options?: MongoClientOptions): Promise<Db> {
-    if (this.db) return this.db;
-
-    const clientOptions: MongoClientOptions = {
-      ...options,
-      maxPoolSize: 10,
-      minPoolSize: 1,
-      serverSelectionTimeoutMS: 5000,
-      socketTimeoutMS: 45000,
-    };
-
-    this.client = new MongoClient(uri, clientOptions);
-    await this.client.connect();
-    this.db = this.client.db(dbName);
-
-    return this.db;
-  }
-
-  getDb(): Db {
-    if (!this.db) {
-      throw new Error('Database not connected. Call connect() first.');
-    }
-    return this.db;
-  }
-
-  getClient(): MongoClient {
-    if (!this.client) {
-      throw new Error('Database not connected. Call connect() first.');
-    }
-    return this.client;
-  }
-
-  collection<T = any>(name: string): Collection<T> {
-    return this.getDb().collection<T>(name);
-  }
-
-  async close(): Promise<void> {
-    if (this.client) {
-      await this.client.close();
-      this.client = null;
-      this.db = null;
-    }
-  }
-
-  isConnected(): boolean {
-    return this.client !== null && this.db !== null;
-  }
-}
-
-const databaseManager = new DatabaseManager();
-
-export const database = {
-  connect: (options: DatabaseOptions) => databaseManager.connect(options),
-  connectTo: (uri: string, dbName?: string, options?: MongoClientOptions) => 
-    databaseManager.connectTo(uri, dbName, options),
-  getDb: () => databaseManager.getDb(),
-  getClient: () => databaseManager.getClient(),
-  collection: <T = any>(name: string) => databaseManager.collection<T>(name),
-  close: () => databaseManager.close(),
-  isConnected: () => databaseManager.isConnected(),
-};
-
-export const db = database;
-
-export { DatabaseManager };
-export default database;

package/src/index.ts

@@ -1,19 +0,0 @@
-export { AuthService, createAuth, auth, Auth } from './auth';
-export { QueueManager, createQueue, queue } from './queue';
-export { notify, notification } from './notifications';
-export { logger } from './logger';
-export { rateLimit, createRateLimiter } from './rate-limit';
-export { config } from './config';
-export { ResponseHelper, response } from './response';
-export { upload, s3Service, S3Service } from './upload';
-export { createApp, createExpressApp, SaaSAppBuilder, PluginManager, Plugin, AppOptions } from './plugin';
-export { database, db, DatabaseManager, DatabaseConfig, DatabaseOptions } from './database';
-
-export { AuthOptions, User, JWTPayload, TokenPair, LoginCredentials, RegisterData, Role, Permission, RolePermissions } from './auth/types';
-export { QueueOptions, JobData, JobProcessor } from './queue';
-export { EmailOptions, SMSOptions, WebhookOptions, SlackOptions } from './notifications';
-export { LoggerConfig, LogLevel } from './logger';
-export { RateLimitOptions } from './rate-limit';
-export { EnvConfig, ConfigOptions } from './config';
-export { ApiResponse, PaginatedResponse, ErrorResponse } from './response';
-export { S3Config, UploadOptions, UploadResult, SignedUrlOptions, FileObject } from './upload';

package/src/logger/index.ts

@@ -1,110 +0,0 @@
-import pino, { Logger, LoggerOptions, Bindings } from 'pino';
-import { config } from '../config';
-
-export type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
-
-export interface LoggerConfig extends Partial<LoggerOptions> {
-  level?: LogLevel;
-  name?: string;
-  prettyPrint?: boolean;
-}
-
-export interface RequestLoggerOptions {
-  logLevel?: LogLevel;
-  autoLogging?: boolean;
-}
-
-class LoggerManager {
-  private loggers: Map<string, Logger> = new Map();
-  private defaultLogger: Logger;
-
-  constructor() {
-    const level = (config.get('LOG_LEVEL') as LogLevel) || 'info';
-    this.defaultLogger = pino({
-      level,
-      name: 'saas-backend-kit',
-      formatters: {
-        bindings: (bindings: Bindings) => ({
-          ...bindings,
-          service: 'saas-backend-kit',
-        }),
-      },
-    });
-  }
-
-  createLogger(options: LoggerConfig = {}): Logger {
-    const name = options.name || 'default';
-    
-    if (this.loggers.has(name)) {
-      return this.loggers.get(name)!;
-    }
-
-    const level = options.level || (config.get('LOG_LEVEL') as LogLevel) || 'info';
-    
-    const logger = pino({
-      level,
-      name: options.name,
-      ...options,
-    });
-
-    this.loggers.set(name, logger);
-    return logger;
-  }
-
-  getLogger(name?: string): Logger {
-    if (name) {
-      return this.loggers.get(name) || this.defaultLogger;
-    }
-    return this.defaultLogger;
-  }
-
-  child(bindings: Bindings, options?: { name?: string }): Logger {
-    const name = options?.name || 'child';
-    const parent = options?.name ? this.getLogger(name) : this.defaultLogger;
-    return parent.child(bindings);
-  }
-}
-
-const loggerManager = new LoggerManager();
-
-export const logger = {
-  info: (message: string, ...args: unknown[]) => loggerManager.getLogger().info(message, ...args),
-  warn: (message: string, ...args: unknown[]) => loggerManager.getLogger().warn(message, ...args),
-  error: (message: string, ...args: unknown[]) => loggerManager.getLogger().error(message, ...args),
-  debug: (message: string, ...args: unknown[]) => loggerManager.getLogger().debug(message, ...args),
-  trace: (message: string, ...args: unknown[]) => loggerManager.getLogger().trace(message, ...args),
-  fatal: (message: string, ...args: unknown[]) => loggerManager.getLogger().fatal(message, ...args),
-  child: (bindings: Bindings, options?: { name?: string }) => loggerManager.child(bindings, options),
-  create: (options?: LoggerConfig) => loggerManager.createLogger(options),
-  get: (name?: string) => loggerManager.getLogger(name),
-};
-
-export function createRequestLogger(options: RequestLoggerOptions = {}) {
-  const logLevel = options.logLevel || 'info';
-  const logger = loggerManager.getLogger('http');
-
-  return function requestLogger(
-    req: { method: string; url: string; headers: Record<string, string | string[] | undefined> },
-    res: { statusCode: number; statusMessage?: string },
-    elapsed: number
-  ) {
-    const log = logger.child({
-      method: req.method,
-      url: req.url,
-      status: res.statusCode,
-      responseTime: elapsed,
-      ip: req.headers['x-forwarded-for'] || req.headers['x-real-ip'] || 'unknown',
-      userAgent: req.headers['user-agent'],
-    });
-
-    if (res.statusCode >= 500) {
-      log.error(`Request completed`);
-    } else if (res.statusCode >= 400) {
-      log.warn(`Request completed`);
-    } else {
-      log.info(`Request completed`);
-    }
-  };
-}
-
-export default logger;

package/src/notifications/index.ts

@@ -1,262 +0,0 @@
-import nodemailer, { Transporter, SendMailOptions } from 'nodemailer';
-import { config } from '../config';
-import { logger } from '../logger';
-
-export interface EmailOptions {
-  to: string | string[];
-  subject: string;
-  text?: string;
-  html?: string;
-  template?: string;
-  templateData?: Record<string, unknown>;
-  from?: string;
-  cc?: string | string[];
-  bcc?: string | string[];
-  attachments?: Array<{
-    filename: string;
-    content?: Buffer | string;
-    path?: string;
-    contentType?: string;
-  }>;
-}
-
-export interface SMSOptions {
-  to: string;
-  message: string;
-  from?: string;
-}
-
-export interface WebhookOptions {
-  url: string;
-  method?: 'GET' | 'POST' | 'PUT' | 'PATCH';
-  headers?: Record<string, string>;
-  body?: unknown;
-  timeout?: number;
-}
-
-export interface SlackOptions {
-  text?: string;
-  blocks?: Array<{
-    type: string;
-    text?: { type: string; text: string; emoji?: boolean };
-    elements?: Array<{ type: string; text?: { type: string; text: string } }>;
-    accessory?: { type: string; image_url?: string; alt_text?: string };
-  }>;
-  channel?: string;
-  username?: string;
-  iconEmoji?: string;
-}
-
-export interface NotificationTransporter {
-  email: Transporter;
-  twilio?: {
-    accountSid: string;
-    authToken: string;
-    phoneNumber: string;
-  };
-  slack?: {
-    webhookUrl: string;
-  };
-}
-
-class EmailService {
-  private transporter: Transporter | null = null;
-  private from: string;
-
-  constructor() {
-    this.from = config.get('SMTP_FROM') || 'noreply@example.com';
-    this.initialize();
-  }
-
-  private initialize(): void {
-    const host = config.get('SMTP_HOST');
-    const port = parseInt(config.get('SMTP_PORT') || '587', 10);
-    const user = config.get('SMTP_USER');
-    const pass = config.get('SMTP_PASS');
-
-    if (host && user && pass) {
-      this.transporter = nodemailer.createTransport({
-        host,
-        port,
-        secure: port === 465,
-        auth: {
-          user,
-          pass,
-        },
-      });
-      logger.info('Email service initialized');
-    }
-  }
-
-  setTransporter(transporter: Transporter): void {
-    this.transporter = transporter;
-  }
-
-  async send(options: EmailOptions): Promise<{ messageId: string }> {
-    if (!this.transporter) {
-      logger.warn('Email transporter not configured, skipping email');
-      return { messageId: 'mock-message-id' };
-    }
-
-    const mailOptions: SendMailOptions = {
-      from: options.from || this.from,
-      to: Array.isArray(options.to) ? options.to.join(', ') : options.to,
-      subject: options.subject,
-      text: options.text,
-      html: options.html || this.renderTemplate(options.template, options.templateData),
-      cc: options.cc,
-      bcc: options.bcc,
-      attachments: options.attachments,
-    };
-
-    const result = await this.transporter.sendMail(mailOptions);
-    logger.info(`Email sent to ${options.to}`, { messageId: result.messageId });
-    return { messageId: result.messageId };
-  }
-
-  private renderTemplate(templateName?: string, data?: Record<string, unknown>): string | undefined {
-    if (!templateName || !data) return undefined;
-
-    const templates: Record<string, (data: Record<string, unknown>) => string> = {
-      welcome: (data) => `
-        <h1>Welcome, ${data.name || 'User'}!</h1>
-        <p>Thank you for joining ${data.appName || 'our platform'}.</p>
-        <p>Get started by verifying your email.</p>
-      `,
-      passwordReset: (data) => `
-        <h1>Password Reset</h1>
-        <p>Click <a href="${data.resetUrl}">here</a> to reset your password.</p>
-        <p>This link expires in ${data.expiry || '1 hour'}.</p>
-      `,
-      verification: (data) => `
-        <h1>Verify Your Email</h1>
-        <p>Click <a href="${data.verifyUrl}">here</a> to verify your email.</p>
-      `,
-    };
-
-    const template = templates[templateName];
-    return template ? template(data) : undefined;
-  }
-}
-
-class SMSService {
-  private accountSid: string;
-  private authToken: string;
-  private phoneNumber: string;
-  private initialized: boolean = false;
-
-  constructor() {
-    this.accountSid = config.get('TWILIO_ACCOUNT_SID') || '';
-    this.authToken = config.get('TWILIO_AUTH_TOKEN') || '';
-    this.phoneNumber = config.get('TWILIO_PHONE_NUMBER') || '';
-    this.initialized = !!(this.accountSid && this.authToken && this.phoneNumber);
-  }
-
-  async send(options: SMSOptions): Promise<{ sid: string }> {
-    if (!this.initialized) {
-      logger.warn('Twilio not configured, skipping SMS');
-      return { sid: 'mock-sid' };
-    }
-
-    try {
-      const twilio = await import('twilio');
-      const client = twilio.default(this.accountSid, this.authToken);
-
-      const result = await client.messages.create({
-        body: options.message,
-        from: options.from || this.phoneNumber,
-        to: options.to,
-      });
-
-      logger.info(`SMS sent to ${options.to}`, { sid: result.sid });
-      return { sid: result.sid };
-    } catch (error) {
-      logger.error('Failed to send SMS', { error });
-      throw error;
-    }
-  }
-}
-
-class WebhookService {
-  async send(options: WebhookOptions): Promise<{ status: number; body: unknown }> {
-    const response = await fetch(options.url, {
-      method: options.method || 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...options.headers,
-      },
-      body: options.body ? JSON.stringify(options.body) : undefined,
-      signal: options.timeout ? AbortSignal.timeout(options.timeout) : undefined,
-    });
-
-    const body = await response.json().catch(() => null);
-    logger.info(`Webhook sent to ${options.url}`, { status: response.status });
-    return { status: response.status, body };
-  }
-}
-
-class SlackService {
-  private webhookUrl: string;
-
-  constructor() {
-    this.webhookUrl = config.get('SLACK_WEBHOOK_URL') || '';
-  }
-
-  setWebhookUrl(url: string): void {
-    this.webhookUrl = url;
-  }
-
-  async send(options: SlackOptions): Promise<{ ok: boolean }> {
-    if (!this.webhookUrl) {
-      logger.warn('Slack webhook not configured, skipping message');
-      return { ok: false };
-    }
-
-    const payload = {
-      text: options.text,
-      blocks: options.blocks,
-      channel: options.channel,
-      username: options.username,
-      icon_emoji: options.iconEmoji,
-    };
-
-    const response = await fetch(this.webhookUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload),
-    });
-
-    const ok = response.ok;
-    if (ok) {
-      logger.info('Slack message sent');
-    } else {
-      logger.error('Failed to send Slack message');
-    }
-    return { ok };
-  }
-}
-
-class NotificationService {
-  email: EmailService;
-  sms: SMSService;
-  webhook: WebhookService;
-  slack: SlackService;
-
-  constructor() {
-    this.email = new EmailService();
-    this.sms = new SMSService();
-    this.webhook = new WebhookService();
-    this.slack = new SlackService();
-  }
-}
-
-export const notify = new NotificationService();
-
-export const notification = {
-  email: (options: EmailOptions) => notify.email.send(options),
-  sms: (options: SMSOptions) => notify.sms.send(options),
-  webhook: (options: WebhookOptions) => notify.webhook.send(options),
-  slack: (options: SlackOptions) => notify.slack.send(options),
-};
-
-export default notification;