create-arktos 1.2.0 → 1.4.0

package/bin/cli.js

@@ -3,11 +3,13 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const { input, select } = require('inquirer');
 
-const TEMPLATE_DIR = path.join(__dirname, '../src');
+const TEMPLATE_TS_DIR = path.join(__dirname, '../src');
+const TEMPLATE_JS_DIR = path.join(__dirname, '../src-js');
 const ROOT_DIR = path.join(__dirname, '..');
 
-function createProject(projectName) {
+async function createProject(projectName) {
   console.log(`🚀 Creating Arktos project: ${projectName}`);
   console.log();
 
@@ -23,15 +25,29 @@ function createProject(projectName) {
     process.exit(1);
   }
 
+  // Ask user for language preference
+  const language = await select({
+    message: '📝 Which language would you like to use?',
+    choices: [
+      { name: 'TypeScript (Recommended)', value: 'typescript' },
+      { name: 'JavaScript', value: 'javascript' }
+    ],
+    default: 'typescript'
+  });
+
+  const useTypeScript = language === 'typescript';
+  const templateDir = useTypeScript ? TEMPLATE_TS_DIR : TEMPLATE_JS_DIR;
+  const packageTemplate = useTypeScript ? 'template.package.json' : 'template.js.package.json';
+
   try {
     // Create project directory
     console.log('📁 Creating project directory...');
     fs.mkdirSync(projectName);
 
     // Copy src directory
-    console.log('📋 Copying source files...');
+    console.log(`📋 Copying ${useTypeScript ? 'TypeScript' : 'JavaScript'} source files...`);
     const targetSrcDir = path.join(projectName, 'src');
-    copyDir(TEMPLATE_DIR, targetSrcDir);
+    copyDir(templateDir, targetSrcDir);
 
     // Copy prisma directory
     console.log('🗄️  Copying database schema...');
@@ -43,11 +59,11 @@ function createProject(projectName) {
 
     // Copy template config files
     console.log('📝 Copying configuration files...');
-    copyTemplateFiles(projectName);
+    copyTemplateFiles(projectName, useTypeScript);
 
     // Copy and update package.json
     console.log('🔧 Updating project configuration...');
-    const templatePackageJsonPath = path.join(ROOT_DIR, 'template.package.json');
+    const templatePackageJsonPath = path.join(ROOT_DIR, packageTemplate);
     const targetPackageJsonPath = path.join(projectName, 'package.json');
     
     if (fs.existsSync(templatePackageJsonPath)) {
@@ -59,6 +75,12 @@ function createProject(projectName) {
       fs.writeFileSync(targetPackageJsonPath, JSON.stringify(packageJson, null, 2));
     }
 
+    // Clean up TypeScript specific files if JavaScript is selected
+    if (!useTypeScript) {
+      console.log('🧹 Cleaning up TypeScript specific files...');
+      cleanupTypeScriptFiles(projectName);
+    }
+
     console.log('✅ Project created successfully!');
     console.log();
     console.log('🎯 Next steps:');
@@ -122,7 +144,30 @@ function copyDir(src, dest) {
   }
 }
 
-function copyTemplateFiles(dest) {
+function cleanupTypeScriptFiles(projectPath) {
+  try {
+    // Remove TypeScript specific directories and files
+    const tsSpecificPaths = [
+      path.join(projectPath, 'src', 'types'),
+      path.join(projectPath, 'tsconfig.json')
+    ];
+
+    for (const tsPath of tsSpecificPaths) {
+      if (fs.existsSync(tsPath)) {
+        const stats = fs.statSync(tsPath);
+        if (stats.isDirectory()) {
+          fs.rmSync(tsPath, { recursive: true, force: true });
+        } else {
+          fs.unlinkSync(tsPath);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn('⚠️  Warning: Could not clean up some TypeScript files:', error.message);
+  }
+}
+
+function copyTemplateFiles(dest, useTypeScript = true) {
   // Create common config files
   const configFiles = {
     '.gitignore': `# Dependencies
@@ -263,8 +308,11 @@ Happy coding! 🎉`
     fs.writeFileSync(path.join(dest, fileName), content);
   }
 
-  // Copy template files from root
-  const templateFiles = ['.env.example', 'vercel.json', 'tsconfig.json', 'eslint.config.js'];
+  // Copy template files from root based on language choice
+  const commonTemplateFiles = ['.env.example', 'vercel.json'];
+  const templateFiles = useTypeScript 
+    ? [...commonTemplateFiles, 'tsconfig.json', 'eslint.config.js']
+    : [...commonTemplateFiles];
   
   for (const templateFile of templateFiles) {
     const srcPath = path.join(ROOT_DIR, templateFile);
@@ -274,6 +322,16 @@ Happy coding! 🎉`
       fs.copyFileSync(srcPath, destPath);
     }
   }
+
+  // Copy appropriate ESLint config for JavaScript projects
+  if (!useTypeScript) {
+    const jsEslintConfigPath = path.join(ROOT_DIR, 'eslint.config.js.template');
+    const destEslintConfigPath = path.join(dest, 'eslint.config.js');
+    
+    if (fs.existsSync(jsEslintConfigPath)) {
+      fs.copyFileSync(jsEslintConfigPath, destEslintConfigPath);
+    }
+  }
 }
 
 function showHelp() {
@@ -324,4 +382,7 @@ if (args[0] === '-v' || args[0] === '--version') {
 }
 
 const projectName = args[0];
-createProject(projectName);
+createProject(projectName).catch((error) => {
+  console.error('❌ Error creating project:', error.message);
+  process.exit(1);
+});

package/eslint.config.js.template

@@ -0,0 +1,31 @@
+export default [
+  {
+    files: ['**/*.js'],
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      globals: {
+        process: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        console: 'readonly',
+        global: 'readonly',
+      }
+    },
+    rules: {
+      'no-unused-vars': ['warn', { 
+        argsIgnorePattern: '^_',
+        varsIgnorePattern: '^_' 
+      }],
+      'no-console': 'off',
+      'prefer-const': 'error',
+      'no-var': 'error',
+      'no-undef': 'error',
+      'semi': ['error', 'always'],
+      'quotes': ['error', 'single'],
+      'indent': ['error', 2],
+      'comma-dangle': ['error', 'always-multiline'],
+    }
+  }
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-arktos",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "🚀 A modern Node.js backend boilerplate with TypeScript, Express, JWT authentication, Prisma ORM, PostgreSQL, and Resend email service. Includes complete authentication flow, security middleware, and database management.",
   "main": "bin/cli.js",
   "bin": {
@@ -9,12 +9,15 @@
   "files": [
     "bin/",
     "src/",
+    "src-js/",
     "prisma/",
     "template.package.json",
+    "template.js.package.json",
     ".env.example",
     "vercel.json",
     "tsconfig.json",
     "eslint.config.js",
+    "eslint.config.js.template",
     "README.md",
     "LICENSE"
   ],

package/src-js/app.js

@@ -0,0 +1,97 @@
+import express from 'express';
+import dotenv from 'dotenv';
+import routes from './routes/index.js';
+import { errorHandling, securityMiddleware, rateLimiter } from './middleware/index.js';
+import DatabaseService from './services/database.service.js';
+import logger from './config/logger.js';
+
+// 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('*', (req, res) => {
+  res.status(404).json({
+    success: false,
+    message: 'Route not found',
+    error: `Cannot ${req.method} ${req.originalUrl}`,
+  });
+});
+
+// Global error handler
+app.use(errorHandling);
+
+// Graceful shutdown
+const gracefulShutdown = async (signal) => {
+  logger.info(`Received ${signal}, shutting down gracefully...`);
+  
+  try {
+    const dbService = DatabaseService.getInstance();
+    await dbService.disconnect();
+    logger.info('Database connection closed');
+  } catch (error) {
+    logger.error('Error during graceful shutdown:', error);
+  }
+  
+  process.exit(0);
+};
+
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+
+const startServer = async () => {
+  try {
+    // Initialize database connection
+    const dbService = DatabaseService.getInstance();
+    await dbService.connect();
+    
+    app.listen(PORT, () => {
+      logger.info(`Server running on port ${PORT}`);
+      logger.info(`Health check: http://localhost:${PORT}/health`);
+      logger.info(`API base URL: http://localhost:${PORT}/api`);
+    });
+  } catch (error) {
+    logger.error('Failed to start server:', error);
+    process.exit(1);
+  }
+};
+
+startServer();

package/src-js/config/env.validation.js

@@ -0,0 +1,15 @@
+import logger from './logger.js';
+import { envSchema } from '../schemas/index.js';
+
+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-js/config/logger.js

@@ -0,0 +1,76 @@
+import winston from 'winston';
+import path from 'path';
+import fs from 'fs';
+
+const logLevel = process.env.LOG_LEVEL || 'info';
+const logFile = process.env.LOG_FILE || 'logs/app.log';
+
+// Ensure logs directory exists
+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-js/constants/errorCodes.js

@@ -0,0 +1,57 @@
+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',
+};

package/src-js/constants/messages.js

@@ -0,0 +1,240 @@
+import { ERROR_CODES } from './errorCodes.js';
+
+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,
+    },
+    TOKEN_INVALID: {
+      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: 'Email address is not verified',
+      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 to access this resource',
+      statusCode: 403,
+    },
+    USER_EXISTS: {
+      code: ERROR_CODES.AUTH_USER_EXISTS,
+      message: 'User already exists with this email',
+      statusCode: 409,
+    },
+    USERNAME_TAKEN: {
+      code: ERROR_CODES.AUTH_USERNAME_TAKEN,
+      message: 'Username is already taken',
+      statusCode: 409,
+    },
+    TOKEN_REQUIRED: {
+      code: ERROR_CODES.AUTH_TOKEN_REQUIRED,
+      message: 'Authentication token is required',
+      statusCode: 401,
+    },
+  },
+
+  // 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_LENGTH: {
+      code: ERROR_CODES.VALIDATION_INVALID_LENGTH,
+      message: 'Invalid length for field',
+      statusCode: 400,
+    },
+    INVALID_TYPE: {
+      code: ERROR_CODES.VALIDATION_INVALID_TYPE,
+      message: 'Invalid type provided',
+      statusCode: 400,
+    },
+    VALIDATION_ERROR: {
+      code: ERROR_CODES.VALIDATION_ERROR,
+      message: 'Validation failed',
+      statusCode: 400,
+    },
+  },
+
+  // Database messages
+  DATABASE: {
+    CONNECTION_ERROR: {
+      code: ERROR_CODES.DB_CONNECTION_ERROR,
+      message: 'Database connection failed',
+      statusCode: 503,
+    },
+    QUERY_ERROR: {
+      code: ERROR_CODES.DB_QUERY_ERROR,
+      message: 'Database query failed',
+      statusCode: 500,
+    },
+    CONSTRAINT_VIOLATION: {
+      code: ERROR_CODES.DB_CONSTRAINT_VIOLATION,
+      message: 'Database constraint violation',
+      statusCode: 409,
+    },
+    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: 'Duplicate entry detected',
+      statusCode: 409,
+    },
+  },
+
+  // File upload messages
+  FILE: {
+    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,
+    },
+    UPLOAD_FAILED: {
+      code: ERROR_CODES.FILE_UPLOAD_FAILED,
+      message: 'File upload failed',
+      statusCode: 500,
+    },
+    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: 'Rate limit exceeded. Please try again later',
+      statusCode: 429,
+    },
+  },
+
+  // Server messages
+  SERVER: {
+    INTERNAL_ERROR: {
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: 'Internal server error occurred',
+      statusCode: 500,
+    },
+    SERVICE_UNAVAILABLE: {
+      code: ERROR_CODES.SERVICE_UNAVAILABLE,
+      message: 'Service temporarily unavailable',
+      statusCode: 503,
+    },
+    EXTERNAL_SERVICE_ERROR: {
+      code: ERROR_CODES.EXTERNAL_SERVICE_ERROR,
+      message: 'External service error',
+      statusCode: 502,
+    },
+    GENERIC_ERROR: {
+      code: ERROR_CODES.GENERIC_ERROR,
+      message: 'An unexpected error occurred',
+      statusCode: 500,
+    },
+    ROUTE_NOT_FOUND: {
+      code: ERROR_CODES.ROUTE_NOT_FOUND,
+      message: 'Route not found',
+      statusCode: 404,
+    },
+  },
+
+  // Email service messages
+  EMAIL: {
+    SEND_FAILED: {
+      code: ERROR_CODES.EMAIL_SEND_FAILED,
+      message: 'Failed to send email',
+      statusCode: 500,
+    },
+    TEMPLATE_NOT_FOUND: {
+      code: ERROR_CODES.EMAIL_TEMPLATE_NOT_FOUND,
+      message: 'Email template not found',
+      statusCode: 404,
+    },
+    INVALID_RECIPIENT: {
+      code: ERROR_CODES.EMAIL_INVALID_RECIPIENT,
+      message: 'Invalid email recipient',
+      statusCode: 400,
+    },
+  },
+};