create-lumina-project 1.0.0 → 1.0.1

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import fs from 'fs-extra';
 import path from 'path';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-lumina-project",
-  "version": "1.0.0",
-  "author": "Ghost",
+  "version": "1.0.1",
+  "author": "Glenson Ansin",
   "description": "Scaffold a modern Node.js API with Lumina architecture.",
   "type": "module",
   "bin": {

package/template/.env.example

@@ -1,15 +1,25 @@
+# Database Configuration
+# Supported dialects: mysql, postgres, mariadb, sqlite
 DB_DIALECT=mysql
 DB_HOST=127.0.0.1
 DB_PORT=3306
 DB_DATABASE=lumina
+DB_DATABASE_TEST=lumina_test
 DB_USERNAME=root
-DB_PASSWORD=
+DB_PASSWORD=your_password
+#true or false
+DB_SSL=
 
-JWT_SECRET=secret_key
+# JWT Configuration
+JWT_SECRET=your_super_secret_key_here
 JWT_EXPIRES_IN=1d
 
-LOG_LEVEL=
-
+# Application
 NODE_ENV=development
+APP_PORT=3000
+
+# Logging
+LOG_LEVEL=info
 
-MAINTENANCE_SECRET=secret_key
+# Maintenance Mode
+MAINTENANCE_SECRET=secret_key_for_bypass

package/template/package.json

@@ -17,10 +17,10 @@
     "create:model": "tsx scripts/create-model.ts",
     "create:migration": "tsx scripts/create-migration.ts",
     "create:controller": "tsx scripts/create-controller.ts",
-    "create:factory": "tsx scripts/create-factory.ts"
+    "create:factory": "tsx scripts/create-factory.ts",
+    "key:generate": "tsx scripts/generate-keys.ts"
   },
-  "author": "Ghost",
-  "license": "ISC",
+  "private": true,
   "type": "module",
   "dependencies": {
     "@faker-js/faker": "^10.2.0",
@@ -35,6 +35,8 @@
     "multer": "^2.0.2",
     "mysql2": "^3.16.2",
     "nodemon": "^3.1.11",
+    "pg": "^8.18.0",
+    "pg-hstore": "^2.3.4",
     "sequelize": "^6.37.7",
     "sequelize-cli": "^6.6.5",
     "umzug": "^3.8.2",

package/template/scripts/generate-keys.ts

@@ -0,0 +1,78 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import Logger from '../src/utils/Logger.js';
+
+class KeyGenerator {
+  private envPath: string;
+  private examplePath: string;
+
+  constructor() {
+    this.envPath = path.join(process.cwd(), '.env');
+    this.examplePath = path.join(process.cwd(), '.env.example');
+  }
+
+  public run(): void {
+    try {
+      this.ensureEnvExists();
+      this.updateKeys();
+      Logger.info('Application keys generated and saved to .env successfully.');
+    } catch (error) {
+      Logger.error('Failed to generate keys:', error);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Generates a random 64-character hex string.
+   */
+  private generateSecret(): string {
+    return crypto.randomBytes(32).toString('hex');
+  }
+
+  /**
+   * Checks if .env exists. If not, copies .env.example.
+   */
+  private ensureEnvExists(): void {
+    if (!fs.existsSync(this.envPath)) {
+      if (fs.existsSync(this.examplePath)) {
+        fs.copyFileSync(this.examplePath, this.envPath);
+        Logger.info('Created .env file from .env.example');
+      } else {
+        throw new Error('.env.example file not found. Cannot generate .env.');
+      }
+    }
+  }
+
+  /**
+   * Reads .env, replaces specific keys, and writes it back.
+   */
+  private updateKeys(): void {
+    let envContent = fs.readFileSync(this.envPath, 'utf-8');
+
+    // 1. Update JWT_SECRET
+    envContent = this.replaceOrAppend(envContent, 'JWT_SECRET', this.generateSecret());
+
+    // 2. Update MAINTENANCE_SECRET
+    envContent = this.replaceOrAppend(envContent, 'MAINTENANCE_SECRET', this.generateSecret());
+
+    fs.writeFileSync(this.envPath, envContent);
+  }
+
+  /**
+   * Helper to replace an existing key's value or append if missing.
+   */
+  private replaceOrAppend(content: string, key: string, newValue: string): string {
+    const regex = new RegExp(`^${key}=.*`, 'm');
+    
+    if (regex.test(content)) {
+      // Key exists, replace it
+      return content.replace(regex, `${key}=${newValue}`);
+    } else {
+      // Key missing, append it
+      return content + `\n${key}=${newValue}`;
+    }
+  }
+}
+
+new KeyGenerator().run();

package/template/scripts/migrate.ts

@@ -43,6 +43,19 @@ class MigrationRunner {
     }
   }
 
+  /**
+   * Helper to get SSL config for the temp connection
+   */
+  private getSSLConfig() {
+    const useSSL = process.env.DB_SSL === 'true';
+    return useSSL ? {
+      ssl: {
+        require: true,
+        rejectUnauthorized: false
+      }
+    } : {};
+  }
+
   /**
    * Check if the database exists and create it if not.
    */
@@ -50,19 +63,36 @@ class MigrationRunner {
     const env = process.env.NODE_ENV || 'development';
     const config = (configList as any)[env];
     const dbName = config.database;
+    const isPostgres = config.dialect === 'postgres';
+
+    const connectionDb = isPostgres ? 'postgres' : '';
 
     // Connect to the server, not the specific DB
-    const tempSequelize = new Sequelize('', config.username, config.password, {
+    const tempSequelize = new Sequelize(connectionDb, config.username, config.password, {
       host: config.host,
+      port: config.port,
       dialect: config.dialect,
       logging: false,
+      dialectOptions: this.getSSLConfig(),
     });
 
     try {
-      await tempSequelize.query(`CREATE DATABASE IF NOT EXISTS \`${dbName}\`;`);
+      if (isPostgres) {
+        const result = await tempSequelize.query(
+          `SELECT 1 FROM pg_database WHERE datname = '${dbName}'`
+        );
+        
+        if ((result[0] as any[]).length === 0) {
+            Logger.info(`Database "${dbName}" not found. Creating...`);
+            await tempSequelize.query(`CREATE DATABASE "${dbName}"`);
+            Logger.info(`Database "${dbName}" created.`);
+        }
+      } else {
+        // MySQL fallback
+        await tempSequelize.query(`CREATE DATABASE IF NOT EXISTS \`${dbName}\`;`);
+      }
     } catch (error) {
       Logger.error('Failed to create database:', error);
-      throw error;
     } finally {
       await tempSequelize.close();
     }

package/template/src/config/database.ts

@@ -22,6 +22,7 @@ class DatabaseConfig {
   private getEnvironmentConfig(env: 'development' | 'test' | 'production' = 'development'): Options {
     const isTest = env === 'test';
     const isProd = env === 'production';
+    const useSSL = process.env.DB_SSL === 'true';
 
     return {
       username: process.env.DB_USERNAME,
@@ -30,6 +31,12 @@ class DatabaseConfig {
       host: process.env.DB_HOST,
       port: Number(process.env.DB_PORT) || 3306,
       dialect: (process.env.DB_DIALECT as any) || 'mysql',
+      dialectOptions: useSSL ? {
+        ssl: {
+          require: true,
+          rejectUnauthorized: false
+        }
+      } : {},
       // Disable logging in test/production to keep logs clean
       logging: isProd || isTest ? false : (msg) => Logger.info(`[SQL] ${msg}`),
     };