create-jerry 1.0.0

package/README.md

@@ -0,0 +1,81 @@
+# JERRIT: Backend Project Scaffolding Tool
+---
+
+## Problem Statement:
+A Project Scaffolding Framework similar to Vite.js and Next.js that aims to provide a ready-to-code boilerplate for working with MongoDB or MySQL databases through express.js server. The Project aims to minimize the setup time for building a MERN or SERN app, enhancing productivity and efficiency for developers.
+
+---
+
+
+## Project Structure:
+``` 
+XeoBuilds/
+ |_ Templates/
+ |  |_ db-mongo.js
+ |  |_ db-sql.js
+ |  |_ express.js
+ |
+ |_ .gitignore
+ |_ fileCreator.js
+ |_ folderCreator.js
+ |_ installer.js
+ |_ index.js
+ |_ package.json
+ |_ package-lock.json
+ |_ README.md
+```
+---
+
+
+## Libraries used to build:
+- inquirer
+- chalk 
+- chalkAnimation
+- execSync
+- nanospinner
+- fs module
+<!-- fs/promises module -->
+---
+
+
+## Packages/Libraries for Backend:
+- express
+- cors
+- mongoose
+- mysql2
+- dotenv
+- router
+---
+
+
+## Backend Generated:
+```
+project-name/
+ |_ Models/
+ |  |_ db.js
+ |
+ |_ Controller/
+ |  |_ index.js
+ |
+ |_ Middleware/
+ |  |_ handler.js
+ |
+ |_ Config/
+ |  |_ .env
+ |
+ |_ app.js
+ |_ package.json
+```
+---
+
+
+## Demo Video:
+Video Link: https://drive.google.com/file/d/1o_9_5RMI21Inew4knCqXlCmeArhAG3xD/view?usp=sharing  
+<!-- ![]() -->
+---
+
+
+
+<!-- ## Low Level Daigram   ## Challenges  -->
+# Thank You, Don't forget to add a ⭐
+

package/Templates/db-mongo.js

@@ -0,0 +1,20 @@
+import mongoose from 'mongoose';
+
+const userSchema = new mongoose.Schema({
+    username: {
+        type: String,
+        required: true,
+        unique: true,
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true,
+    },
+    password: {
+        type: String,
+        required: true,
+    },
+}, { timestamps: true });
+
+export const User = mongoose.model('User', userSchema);

package/Templates/db-sql.js

@@ -0,0 +1,35 @@
+import mysql from 'mysql2'
+import dotenv from 'dotenv'
+dotenv.config()
+    
+const pool = mysql.createPool({
+    host: process.env.MYSQL_HOST ,
+    user: process.env.MYSQL_USER ,
+    password: process.env.MYSQL_PASSWORD ,
+    database: process.env.MYSQL_DATABASE
+    }).promise()
+        
+export async function getData() {
+    const [rows] = await pool.query("SELECT * FROM Db")
+    return rows
+}
+            
+export async function getDataById(id) {
+    const [rows] = await pool.query(`
+    SELECT * FROM Db
+    WHERE id = ${id};
+    `)
+    return rows[0]
+    }
+                
+export async function createData(title, contents) {
+        const [result] = await pool.query(`
+        INSERT INTO Db (title, contents)
+        VALUES(?, ?);
+        `, [title, contents])
+        const id = result.insertId 
+        return getData(id)
+}
+                    
+const result = await createData('test', 'test')
+console.log(result)

package/Templates/express.js

@@ -0,0 +1,35 @@
+import express from 'express'
+import cors from 'cors'
+const app = express()
+
+app.use(cors())
+app.use(json)
+
+
+//get the details
+app.get('/view', async (req, res) => {
+    res.send('hello')
+})
+
+//add new details
+app.post('/add', (req, res) => {
+    
+})
+
+//make changes in the database
+app.put('/edit', (req, res) => {
+    
+})
+
+//delete in the database
+app.delete('/delete', (req, res) => {
+    
+})
+
+app.listen(3000, () => {
+    try {
+        console.log(`The server is running on port: ${process.env.PORT}`)
+    } catch(err) {
+        console.log(err) 
+    }
+})

package/fileCreator.js

@@ -0,0 +1,49 @@
+import { fileURLToPath } from 'url';
+import path from 'path';
+import * as fs from 'node:fs/promises';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Stable reference to your Templates folder in scaff/
+const templateDir = path.join(__dirname, 'Templates');
+
+// 🟡 Create empty .env
+export const writeEnvFile = async () => {
+  const envPath = path.join(process.cwd(), 'src', 'config', '.env');
+  try {
+    await fs.writeFile(envPath, '', 'utf-8');
+    console.log('✅ .env file created in src/config');
+  } catch (error) {
+    console.error('❌ Failed to create .env file:', error);
+  }
+};
+
+// 🔵 Generate db.js from template
+export const writeDbFiles = async (dbchoice) => {
+  const dbfile = dbchoice === 'MySQL' ? 'db-sql.js' : 'db-mongo.js';
+  const dbTemplatePath = path.join(templateDir, dbfile);
+  const targetPath = path.join(process.cwd(), 'src', 'models', 'db.js');
+
+  try {
+    const content = await fs.readFile(dbTemplatePath, 'utf-8');
+    await fs.writeFile(targetPath, content);
+    console.log('✅ db.js created successfully');
+  } catch (error) {
+    console.error('❌ Failed to create db.js:', error);
+  }
+};
+
+// 🟢 Generate app.js from express.js
+export const writeServerFiles = async () => {
+  const serverTemplatePath = path.join(templateDir, 'express.js');
+  const targetPath = path.join(process.cwd(), 'app.js');
+
+  try {
+    const content = await fs.readFile(serverTemplatePath, 'utf-8');
+    await fs.writeFile(targetPath, content);
+    console.log('✅ app.js created successfully');
+  } catch (error) {
+    console.error('❌ Failed to create app.js:', error);
+  }
+};

package/folderCreater.js

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Creates multiple nested folders inside the project.
+ * @param {string[]} paths - Relative paths from project root (e.g., ['src/config', 'src/models'])
+ */
+
+
+export const createProjectDir = (rawProjectName) => {
+  const projectDir = path.join(process.cwd(), rawProjectName);
+
+  // Create the project folder
+  if (!fs.existsSync(projectDir)) {
+    fs.mkdirSync(projectDir);
+    console.log(`📁 Project root created: ${rawProjectName}`);
+  }
+
+  // Switch working directory
+  process.chdir(projectDir);
+}
+
+
+export const createFolders = (paths) => {
+  paths.forEach((folderPath) => {
+    const fullPath = path.join(process.cwd(), folderPath);
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+      console.log(`📁 Folder created: ${folderPath}`);
+    } else {
+      console.log(`📂 Folder already exists: ${folderPath}`);
+    }
+  });
+};

package/index.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk';
+import chalkAnimation from 'chalk-animation';
+import inquirer from 'inquirer';
+import { installer } from './installer.js';
+import { 
+    writeDbFiles, 
+    writeServerFiles, 
+    writeEnvFile 
+} from './fileCreator.js';
+import { createFolders, createProjectDir } from './folderCreater.js';
+import { createPackageJson } from './packageJsonCreator.js';
+
+// global responses
+let rawProjectName;
+let dbchoice;
+let langchoice;
+
+// timeout
+export const sleep = (ms = 1000) => new Promise((r) => setTimeout(r, ms));
+
+// welcome function 
+async function welcome() {
+    const rainbowTitle = chalkAnimation.rainbow("\n Welcome to JERRIT \n");
+    await sleep();
+    rainbowTitle.stop();
+}
+
+// project name
+async function askName() {
+    const res = await inquirer.prompt({
+        name: 'admin_name',
+        type: 'input',
+        message: `${chalk.magentaBright('Project name ?')}`,
+        default() {
+            return 'my-app';
+        },
+    });
+    
+    return res.admin_name;
+}
+
+// database selection
+async function askDb() {
+    const res = await inquirer.prompt({
+        name: 'db_name',
+        type: 'list',
+        message: `${chalk.yellowBright('Select your Database ...')}`,
+        choices: [
+            { name: chalk.greenBright('MongoDB'), value: 'MongoDB' },
+            { name: chalk.whiteBright('MySQL'), value: 'MySQL' },
+        ],
+    });
+
+    dbchoice = res.db_name;
+}
+
+// language selection
+async function askLang() {
+    const res = await inquirer.prompt({
+        name: 'lang_name',
+        type: 'list',
+        message: `${chalk.green('Select your Language...')}`,
+        choices: [
+            `${chalk.cyanBright('Typescript')}`,
+            `${chalk.yellowBright('Javascript')}`,
+        ],
+    });
+
+    langchoice = res.lang_name;
+}
+
+// exit function 
+export async function exit(str) {
+    const rainbowTitle = chalkAnimation.rainbow(str);
+    await sleep();
+    rainbowTitle.stop();
+}
+
+// Main execution
+await welcome();
+
+rawProjectName = await askName();
+
+// Creating root directory
+createProjectDir(rawProjectName);
+
+await askDb();
+await askLang();
+
+console.log("\n");
+
+// Project setup execution calls
+console.log(chalk.whiteBright("Setting up your Project ... "));
+
+// 1. Create folder structure
+const backendFolders = [
+  'src/config',
+  'src/controllers',
+  'src/middlewares',
+  'src/models',
+  'src/routes',
+];
+createFolders(backendFolders);
+
+// 2. Create configuration and code files
+await writeEnvFile();
+await writeServerFiles();
+await writeDbFiles(dbchoice);
+
+// 3. Generate package.json
+await createPackageJson(rawProjectName, dbchoice, langchoice);
+
+// 4. Install dependencies
+installer();

package/installer.js

@@ -0,0 +1,32 @@
+import { createSpinner } from 'nanospinner';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import { exit } from './index.js';
+
+/**
+ * Installs dependencies using npm install
+ * Assumes package.json already exists in the current directory
+ */
+export function installer() {
+  const spinner = createSpinner(chalk.whiteBright('Installing Dependencies...')).start();
+
+  try {
+    // Simple npm install command - reads from package.json
+    execSync('npm install', { stdio: 'inherit' });
+
+    console.log('\n');
+
+    spinner.success({ 
+      text: `${chalk.greenBright('Dependencies Installed Successfully!\n')}` 
+    });
+
+    exit("Get Started !!!\n");
+
+  } catch (err) {
+    spinner.error({ 
+      text: `${chalk.redBright('Failed to Install Dependencies')}` 
+    });
+    console.error(err);
+    exit("Try Again !!!");
+  }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "create-jerry",
+  "version": "1.0.0",
+  "description": "A CLI tool to scaffold Express backend projects with MongoDB or MySQL",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "create-jerry": "./index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "backend",
+    "express",
+    "mongodb",
+    "mysql",
+    "generator",
+    "boilerplate",
+    "nodejs"
+  ],
+  "author": "Tanmay Khanna",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TomLucasakaTGeek/JerrIt"
+  },
+  "bugs": {
+    "url": "https://github.com/TomLucasakaTGeek/JerrIt/issues"
+  },
+  "homepage": "https://github.com/TomLucasakaTGeek/JerrIt#readme",
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "chalk-animation": "^2.0.3",
+    "inquirer": "^12.3.0",
+    "nanospinner": "^1.2.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "installer.js",
+    "fileCreator.js",
+    "folderCreater.js",
+    "packageJsonCreator.js",
+    "Templates/",
+    "README.md"
+  ]
+}

package/packageJsonCreator.js

@@ -0,0 +1,92 @@
+import * as fs from 'node:fs/promises';
+import path from 'path';
+
+/**
+ * Generates package.json file based on project configuration
+ * @param {string} projectName - Name of the project
+ * @param {string} dbchoice - Database choice ('MongoDB' or 'MySQL')
+ * @param {string} langchoice - Language choice ('Typescript' or 'Javascript')
+ */
+export const createPackageJson = async (projectName, dbchoice, langchoice) => {
+  // Base dependencies that every project needs
+  const baseDependencies = {
+    express: '^4.18.2',
+    dotenv: '^16.3.1',
+    cors: '^2.8.5'
+  };
+
+  // Database-specific dependencies
+  const dbDependencies = {
+    MongoDB: {
+      mongoose: '^8.0.3'
+    },
+    MySQL: {
+      mysql2: '^3.6.5'
+    }
+  };
+
+  // Merge base dependencies with database-specific ones
+  const dependencies = {
+    ...baseDependencies,
+    ...dbDependencies[dbchoice]
+  };
+
+  // Development dependencies (common for both JS and TS)
+  const devDependencies = {
+    nodemon: '^3.0.2'
+  };
+
+  // Add TypeScript-specific dev dependencies if needed
+  if (langchoice.includes('Typescript')) {
+    devDependencies['typescript'] = '^5.3.3';
+    devDependencies['@types/node'] = '^20.10.6';
+    devDependencies['@types/express'] = '^4.17.21';
+    devDependencies['@types/cors'] = '^2.8.17';
+    devDependencies['ts-node'] = '^10.9.2';
+  }
+
+  // Scripts configuration
+  const scripts = {
+    start: 'node app.js',
+    dev: 'nodemon app.js',
+    test: 'echo "Error: no test specified" && exit 1'
+  };
+
+  // Modify scripts for TypeScript
+  if (langchoice.includes('Typescript')) {
+    scripts.start = 'node dist/app.js';
+    scripts.dev = 'nodemon --exec ts-node app.ts';
+    scripts.build = 'tsc';
+  }
+
+  // Complete package.json object
+  const packageJson = {
+    name: projectName.toLowerCase().replace(/\s+/g, '-'),
+    version: '1.0.0',
+    description: `A ${dbchoice} backend project scaffolded with JerrIt`,
+    main: langchoice.includes('Typescript') ? 'dist/app.js' : 'app.js',
+    type: 'module',
+    scripts,
+    keywords: ['express', 'backend', dbchoice.toLowerCase()],
+    author: '',
+    license: 'ISC',
+    dependencies,
+    devDependencies
+  };
+
+  // Write package.json to the project root
+  const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+  try {
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(packageJson, null, 2),
+      'utf-8'
+    );
+    console.log('✅ package.json created successfully');
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to create package.json:', error);
+    return false;
+  }
+};