create-arktos 1.0.0

package/src/app.ts

@@ -0,0 +1,101 @@
+import express from 'express';
+import dotenv from 'dotenv';
+import routes from './routes';
+import { errorHandling, securityMiddleware, rateLimiter } from './middleware';
+import DatabaseService from './services/database.service';
+import logger from './config/logger';
+
+// Load environment variables
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3001;
+
+// Security middleware stack
+app.use(securityMiddleware);
+
+// Rate limiting
+app.use('/api', rateLimiter.general);
+
+// Body parsing middleware
+app.use(express.json({ limit: '10mb' }));
+app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+
+// Trust proxy (for accurate IP addresses)
+app.set('trust proxy', 1);
+
+// API routes
+app.use('/api', routes);
+
+// Health check route (outside of rate limiting)
+app.get('/health', async (req, res) => {
+  try {
+    const dbService = DatabaseService.getInstance();
+    const dbHealth = await dbService.healthCheck();
+    
+    res.json({
+      status: dbHealth.connected ? 'ok' : 'error',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+      database: dbHealth,
+    });
+  } catch (error) {
+    res.status(503).json({
+      status: 'error',
+      message: 'Health check failed',
+    });
+  }
+});
+
+// 404 handler
+app.use(errorHandling.notFound);
+
+// Global error handler
+app.use(errorHandling.handler);
+
+// Initialize database connection
+const initializeApp = async () => {
+  try {
+    const dbService = DatabaseService.getInstance();
+    await dbService.connect();
+    
+    logger.info('✅ Database connected successfully');
+    
+    app.listen(PORT, () => {
+      logger.info(`🚀 Server is running on port ${PORT}`);
+      logger.info(`🌐 Environment: ${process.env.NODE_ENV || 'development'}`);
+      logger.info(`📚 API Documentation: http://localhost:${PORT}/api`);
+      logger.info(`❤️ Health Check: http://localhost:${PORT}/health`);
+    });
+  } catch (error) {
+    logger.error('❌ Failed to initialize application:', error);
+    process.exit(1);
+  }
+};
+
+// Graceful shutdown
+const gracefulShutdown = async (signal: string) => {
+  logger.info(`📡 Received ${signal}, starting graceful shutdown...`);
+  
+  try {
+    const dbService = DatabaseService.getInstance();
+    await dbService.disconnect();
+    logger.info('✅ Database disconnected');
+    
+    process.exit(0);
+  } catch (error) {
+    logger.error('❌ Error during graceful shutdown:', error);
+    process.exit(1);
+  }
+};
+
+// Handle shutdown signals
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+
+// Start the application
+if (require.main === module) {
+  initializeApp();
+}
+
+export default app;

package/src/config/env.validation.ts

@@ -0,0 +1,15 @@
+import logger from './logger';
+import { envSchema } from '../schemas';
+
+export function validateEnv() {
+  try {
+    const env = envSchema.parse(process.env);
+    logger.info('Environment validation successful');
+    return env;
+  } catch (error) {
+    logger.error('Environment validation failed:', error);
+    process.exit(1);
+  }
+}
+
+export const config = validateEnv();

package/src/config/logger.ts

@@ -0,0 +1,76 @@
+import winston from 'winston';
+import path from 'path';
+
+const logLevel = process.env.LOG_LEVEL || 'info';
+const logFile = process.env.LOG_FILE || 'logs/app.log';
+
+// Ensure logs directory exists
+import fs from 'fs';
+const logDir = path.dirname(logFile);
+if (!fs.existsSync(logDir)) {
+  fs.mkdirSync(logDir, { recursive: true });
+}
+
+const logFormat = winston.format.combine(
+  winston.format.timestamp({
+    format: 'YYYY-MM-DD HH:mm:ss',
+  }),
+  winston.format.errors({ stack: true }),
+  winston.format.json(),
+  winston.format.prettyPrint()
+);
+
+const consoleFormat = winston.format.combine(
+  winston.format.colorize(),
+  winston.format.timestamp({
+    format: 'HH:mm:ss',
+  }),
+  winston.format.printf(({ timestamp, level, message, ...meta }) => {
+    return `${timestamp} [${level}]: ${message} ${Object.keys(meta).length ? JSON.stringify(meta, null, 2) : ''}`;
+  })
+);
+
+const logger = winston.createLogger({
+  level: logLevel,
+  format: logFormat,
+  defaultMeta: { service: 'arktos-backend' },
+  transports: [
+    // File transport
+    new winston.transports.File({
+      filename: logFile,
+      handleExceptions: true,
+      maxsize: 5242880, // 5MB
+      maxFiles: 5,
+    }),
+    // Error file transport
+    new winston.transports.File({
+      filename: path.join(logDir, 'error.log'),
+      level: 'error',
+      handleExceptions: true,
+      maxsize: 5242880, // 5MB
+      maxFiles: 5,
+    }),
+  ],
+});
+
+// Console transport for non-production environments
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(
+    new winston.transports.Console({
+      format: consoleFormat,
+      handleExceptions: true,
+    })
+  );
+}
+
+// Handle uncaught exceptions and unhandled rejections
+process.on('uncaughtException', (error) => {
+  logger.error('Uncaught Exception:', error);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+});
+
+export default logger;

package/src/constants/errorCodes.ts

@@ -0,0 +1,59 @@
+export const ERROR_CODES = {
+  // Authentication errors
+  AUTH_INVALID_CREDENTIALS: 'AUTH_001',
+  AUTH_TOKEN_EXPIRED: 'AUTH_002',
+  AUTH_TOKEN_INVALID: 'AUTH_003',
+  AUTH_USER_NOT_FOUND: 'AUTH_004',
+  AUTH_EMAIL_NOT_VERIFIED: 'AUTH_005',
+  AUTH_ACCOUNT_DISABLED: 'AUTH_006',
+  AUTH_INSUFFICIENT_PERMISSIONS: 'AUTH_007',
+  AUTH_USER_EXISTS: 'AUTH_008',
+  AUTH_USERNAME_TAKEN: 'AUTH_009',
+  AUTH_INVALID_PASSWORD: 'AUTH_010',
+  AUTH_TOKEN_REQUIRED: 'AUTH_011',
+  AUTH_INVALID_TOKEN: 'AUTH_003', // Alias for AUTH_TOKEN_INVALID
+  AUTH_ACCOUNT_DEACTIVATED: 'AUTH_006', // Alias for AUTH_ACCOUNT_DISABLED
+
+  // Validation errors
+  VALIDATION_REQUIRED_FIELD: 'VAL_001',
+  VALIDATION_INVALID_FORMAT: 'VAL_002',
+  VALIDATION_INVALID_LENGTH: 'VAL_003',
+  VALIDATION_INVALID_TYPE: 'VAL_004',
+  VALIDATION_ERROR: 'VAL_005',
+
+  // Database errors
+  DB_CONNECTION_ERROR: 'DB_001',
+  DB_QUERY_ERROR: 'DB_002',
+  DB_CONSTRAINT_VIOLATION: 'DB_003',
+  DB_RECORD_NOT_FOUND: 'DB_004',
+  DB_DUPLICATE_ENTRY: 'DB_005',
+  DATABASE_CONNECTION: 'DB_001', // Alias
+  DATABASE_ERROR: 'DB_002', // Alias
+  DATABASE_CONSTRAINT: 'DB_003', // Alias
+  DATABASE_NOT_FOUND: 'DB_004', // Alias
+  DATABASE_CONFLICT: 'DB_005', // Alias
+
+  // File/Upload errors
+  FILE_TOO_LARGE: 'FILE_001',
+  FILE_INVALID_TYPE: 'FILE_002',
+  FILE_UPLOAD_FAILED: 'FILE_003',
+  FILE_NOT_FOUND: 'FILE_004',
+
+  // Rate limiting errors
+  RATE_LIMIT_EXCEEDED: 'RATE_001',
+
+  // Server errors
+  INTERNAL_SERVER_ERROR: 'SRV_001',
+  SERVICE_UNAVAILABLE: 'SRV_002',
+  EXTERNAL_SERVICE_ERROR: 'SRV_003',
+  INTERNAL_ERROR: 'SRV_001', // Alias
+  GENERIC_ERROR: 'SRV_004',
+  ROUTE_NOT_FOUND: 'SRV_005',
+
+  // Email service errors
+  EMAIL_SEND_FAILED: 'EMAIL_001',
+  EMAIL_TEMPLATE_NOT_FOUND: 'EMAIL_002',
+  EMAIL_INVALID_RECIPIENT: 'EMAIL_003',
+} as const;
+
+export type ErrorCode = typeof ERROR_CODES[keyof typeof ERROR_CODES];

package/src/constants/messages.ts

@@ -0,0 +1,190 @@
+import { ERROR_CODES } from './errorCodes';
+
+export const SERVICE_MESSAGES = {
+  // Application messages
+  APP: {
+    API_RUNNING: {
+      code: 'APP_001',
+      message: 'API is running successfully',
+      statusCode: 200,
+    },
+    HEALTH_CHECK_FAILED: {
+      code: 'APP_002',
+      message: 'Health check failed',
+      statusCode: 503,
+    },
+    ENDPOINT_NOT_FOUND: {
+      code: 'APP_003',
+      message: 'Endpoint not found',
+      statusCode: 404,
+    },
+  },
+
+  // Authentication messages
+  AUTH: {
+    LOGIN_SUCCESS: {
+      code: 'AUTH_S001',
+      message: 'Login successful',
+      statusCode: 200,
+    },
+    REGISTER_SUCCESS: {
+      code: 'AUTH_S002',
+      message: 'Registration successful',
+      statusCode: 201,
+    },
+    LOGOUT_SUCCESS: {
+      code: 'AUTH_S003',
+      message: 'Logout successful',
+      statusCode: 200,
+    },
+    EMAIL_VERIFICATION_SUCCESS: {
+      code: 'AUTH_S004',
+      message: 'Email verified successfully',
+      statusCode: 200,
+    },
+    PASSWORD_RESET_SUCCESS: {
+      code: 'AUTH_S005',
+      message: 'Password reset successful',
+      statusCode: 200,
+    },
+    INVALID_CREDENTIALS: {
+      code: ERROR_CODES.AUTH_INVALID_CREDENTIALS,
+      message: 'Invalid email or password',
+      statusCode: 401,
+    },
+    TOKEN_EXPIRED: {
+      code: ERROR_CODES.AUTH_TOKEN_EXPIRED,
+      message: 'Token has expired',
+      statusCode: 401,
+    },
+    INVALID_TOKEN: {
+      code: ERROR_CODES.AUTH_TOKEN_INVALID,
+      message: 'Invalid token provided',
+      statusCode: 401,
+    },
+    USER_NOT_FOUND: {
+      code: ERROR_CODES.AUTH_USER_NOT_FOUND,
+      message: 'User not found',
+      statusCode: 404,
+    },
+    EMAIL_NOT_VERIFIED: {
+      code: ERROR_CODES.AUTH_EMAIL_NOT_VERIFIED,
+      message: 'Please verify your email address',
+      statusCode: 403,
+    },
+    ACCOUNT_DISABLED: {
+      code: ERROR_CODES.AUTH_ACCOUNT_DISABLED,
+      message: 'Account has been disabled',
+      statusCode: 403,
+    },
+    INSUFFICIENT_PERMISSIONS: {
+      code: ERROR_CODES.AUTH_INSUFFICIENT_PERMISSIONS,
+      message: 'Insufficient permissions',
+      statusCode: 403,
+    },
+  },
+
+  // Validation messages
+  VALIDATION: {
+    REQUIRED_FIELD: {
+      code: ERROR_CODES.VALIDATION_REQUIRED_FIELD,
+      message: 'Required field is missing',
+      statusCode: 400,
+    },
+    INVALID_FORMAT: {
+      code: ERROR_CODES.VALIDATION_INVALID_FORMAT,
+      message: 'Invalid format provided',
+      statusCode: 400,
+    },
+    INVALID_EMAIL: {
+      code: ERROR_CODES.VALIDATION_INVALID_FORMAT,
+      message: 'Invalid email format',
+      statusCode: 400,
+    },
+    PASSWORD_TOO_SHORT: {
+      code: ERROR_CODES.VALIDATION_INVALID_LENGTH,
+      message: 'Password must be at least 8 characters long',
+      statusCode: 400,
+    },
+  },
+
+  // Database messages
+  DATABASE: {
+    CONNECTION_ERROR: {
+      code: ERROR_CODES.DB_CONNECTION_ERROR,
+      message: 'Database connection failed',
+      statusCode: 503,
+    },
+    RECORD_NOT_FOUND: {
+      code: ERROR_CODES.DB_RECORD_NOT_FOUND,
+      message: 'Record not found',
+      statusCode: 404,
+    },
+    DUPLICATE_ENTRY: {
+      code: ERROR_CODES.DB_DUPLICATE_ENTRY,
+      message: 'Record already exists',
+      statusCode: 409,
+    },
+  },
+
+  // File/Upload messages
+  FILE: {
+    UPLOAD_SUCCESS: {
+      code: 'FILE_S001',
+      message: 'File uploaded successfully',
+      statusCode: 200,
+    },
+    TOO_LARGE: {
+      code: ERROR_CODES.FILE_TOO_LARGE,
+      message: 'File size exceeds maximum limit',
+      statusCode: 413,
+    },
+    INVALID_TYPE: {
+      code: ERROR_CODES.FILE_INVALID_TYPE,
+      message: 'Invalid file type',
+      statusCode: 400,
+    },
+    NOT_FOUND: {
+      code: ERROR_CODES.FILE_NOT_FOUND,
+      message: 'File not found',
+      statusCode: 404,
+    },
+  },
+
+  // Rate limiting messages
+  RATE_LIMIT: {
+    EXCEEDED: {
+      code: ERROR_CODES.RATE_LIMIT_EXCEEDED,
+      message: 'Too many requests, please try again later',
+      statusCode: 429,
+    },
+  },
+
+  // Email messages
+  EMAIL: {
+    SEND_SUCCESS: {
+      code: 'EMAIL_S001',
+      message: 'Email sent successfully',
+      statusCode: 200,
+    },
+    SEND_FAILED: {
+      code: ERROR_CODES.EMAIL_SEND_FAILED,
+      message: 'Failed to send email',
+      statusCode: 503,
+    },
+  },
+
+  // Server messages
+  SERVER: {
+    INTERNAL_ERROR: {
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: 'Internal server error',
+      statusCode: 500,
+    },
+    SERVICE_UNAVAILABLE: {
+      code: ERROR_CODES.SERVICE_UNAVAILABLE,
+      message: 'Service temporarily unavailable',
+      statusCode: 503,
+    },
+  },
+} as const;