@apexkrrish/create-node-app 1.0.0 → 1.1.0

package/bin/cli.js

@@ -1,189 +1,8 @@
 #!/usr/bin/env node
 
 import { program } from 'commander';
-import inquirer from 'inquirer';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import chalk from 'chalk';
-import { execSync } from 'child_process';
-import ora from 'ora';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// ==========================================
-// Helper Functions
-// ==========================================
-
-async function promptUser(projectDirectory) {
-    let targetDir = projectDirectory;
-
-    if (!targetDir) {
-        const answers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'projectDirectory',
-                message: 'What is your project named?',
-                default: 'my-app'
-            }
-        ]);
-        targetDir = answers.projectDirectory;
-    }
-
-    const { packageManager, database } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'packageManager',
-            message: 'Which package manager would you like to use?',
-            choices: ['npm', 'yarn', 'pnpm'],
-            default: 'npm'
-        },
-        {
-            type: 'list',
-            name: 'database',
-            message: 'Which database would you like to use?',
-            choices: ['MongoDB (Mongoose)', 'PostgreSQL (Sequelize)', 'None'],
-            default: 'MongoDB (Mongoose)'
-        }
-    ]);
-
-    return { targetDir, packageManager, database };
-}
-
-function copyTemplateFiles(templateDir, targetPath) {
-    const spinner = ora('Copying template files...').start();
-
-    if (fs.existsSync(targetPath)) {
-        spinner.fail(`Directory ${path.basename(targetPath)} already exists.`);
-        process.exit(1);
-    }
-
-    fs.mkdirSync(targetPath, { recursive: true });
-
-    const copyRecursiveSync = (src, dest) => {
-        const exists = fs.existsSync(src);
-        const stats = exists && fs.statSync(src);
-        if (exists && stats.isDirectory()) {
-            if (!fs.existsSync(dest)) fs.mkdirSync(dest);
-            fs.readdirSync(src).forEach((child) => {
-                if (child === 'node_modules') return;
-                copyRecursiveSync(path.join(src, child), path.join(dest, child));
-            });
-        } else {
-            fs.copyFileSync(src, dest);
-        }
-    };
-
-    try {
-        copyRecursiveSync(templateDir, targetPath);
-        spinner.succeed('Template copied successfully.');
-    } catch (err) {
-        spinner.fail('Failed to copy template.');
-        console.error(err);
-        process.exit(1);
-    }
-}
-
-function configureDatabase(targetPath, database) {
-    const packageJsonPath = path.join(targetPath, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) return;
-
-    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    pkg.name = path.basename(targetPath);
-
-    const dbConfigPath = path.join(targetPath, 'config', 'db.config.js');
-    const targetConfigDir = path.dirname(dbConfigPath);
-    if (!fs.existsSync(targetConfigDir)) {
-        fs.mkdirSync(targetConfigDir, { recursive: true });
-    }
-
-    if (database === 'MongoDB (Mongoose)') {
-        pkg.dependencies = pkg.dependencies || {};
-        pkg.dependencies.mongoose = '^8.0.0';
-
-        const mongooseContent = `import mongoose from "mongoose"
-
-const options = {
-    serverSelectionTimeoutMS: 10000,
-    dbName: '',
-}
-
-const connectDB = async () => {
-    try {
-        await mongoose.connect('', options)
-        console.log(\`✅ MongoDB connected!\`)
-    } catch (error) {
-        console.error(\`❌ MongoDB connection error: \${error.message}\`)
-        process.exit(1)
-    }
-}
-
-export default connectDB`;
-        fs.writeFileSync(dbConfigPath, mongooseContent);
-
-    } else if (database === 'PostgreSQL (Sequelize)') {
-        pkg.dependencies = pkg.dependencies || {};
-        pkg.dependencies.sequelize = '^6.35.0';
-        pkg.dependencies.pg = '^8.11.3';
-        pkg.dependencies.pg_hstore = '^2.3.4';
-
-        const sequelizeContent = `import { Sequelize } from "sequelize"
-
-export const sequelize = new Sequelize(
-    '',          // DB name
-    '',         // User
-    '',      // Password
-    {
-        host: '',
-        dialect: 'postgres',
-        logging: false,
-        port: ''
-    }
-) 
-
-// Test connection
-// (async () => {
-//     try {
-//         await sequelize.authenticate();
-//         console.log("PostgreSQL connected with Sequelize");
-//     } catch (err) {
-//         console.error("Error:", err.message);
-//     }
-// })()
-
-export default sequelize
-`;
-        fs.writeFileSync(dbConfigPath, sequelizeContent);
-
-    } else {
-        fs.writeFileSync(dbConfigPath, '// No database configured\n');
-    }
-
-    // Save updated package.json
-    fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
-}
-
-function installDependencies(targetPath, packageManager) {
-    const installSpinner = ora(`Installing dependencies using ${packageManager}...`).start();
-    try {
-        execSync(`${packageManager} install`, { cwd: targetPath, stdio: 'pipe' });
-        installSpinner.succeed('Dependencies installed successfully.');
-    } catch (err) {
-        installSpinner.fail('Failed to install dependencies.');
-        console.error(err);
-    }
-}
-
-function showSuccessMessage(targetDir, targetPath, packageManager) {
-    console.log(`\n${chalk.green('Success!')} Created ${path.basename(targetPath)} at ${targetPath}`);
-    console.log('\nInside that directory, you can run several commands:\n');
-    console.log(`  ${chalk.cyan(`${packageManager} run dev`)}`);
-    console.log('    Starts the development server with nodemon.\n');
-    console.log('We suggest that you begin by typing:\n');
-    console.log(`  ${chalk.cyan('cd')} ${targetDir}`);
-    console.log(`  ${chalk.cyan(`${packageManager} run dev`)}\n`);
-}
+import { initCommand } from './commands/init.js';
+import { createServiceCommand } from './commands/createService.js';
 
 // ==========================================
 // CLI Application
@@ -191,28 +10,17 @@ function showSuccessMessage(targetDir, targetPath, packageManager) {
 
 program
     .name('create-node-app')
-    .description('Scaffold a new Node.js application')
-    .argument('[project-directory]', 'Directory to create the project in')
-    .action(async (projectDirectory) => {
-
-        // 1. Prompt User
-        const { targetDir, packageManager, database } = await promptUser(projectDirectory);
-        const targetPath = path.resolve(process.cwd(), targetDir);
-        const templateDir = path.join(__dirname, '..', 'template');
-
-        console.log(`\nCreating a new Node.js app in ${chalk.green(targetPath)}\n`);
+    .description('Scaffold a new Node.js application');
 
-        // 2. Copy Template Files
-        copyTemplateFiles(templateDir, targetPath);
-
-        // 3. Configure Database
-        configureDatabase(targetPath, database);
-
-        // 4. Install Dependencies
-        installDependencies(targetPath, packageManager);
+program
+    .command('init [project-directory]', { isDefault: true })
+    .description('Initialize a new Node.js project (Default command)')
+    .action(initCommand);
 
-        // 5. Success Message
-        showSuccessMessage(targetDir, targetPath, packageManager);
-    });
+program
+    .command('create-service <serviceName>')
+    .alias('create')
+    .description('Scaffold a new service (model, controller, routes)')
+    .action(createServiceCommand);
 
 program.parse(process.argv);

package/bin/commands/createService.js

@@ -0,0 +1,147 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function createServiceCommand(serviceName, targetDir = process.cwd()) {
+    if (!serviceName) {
+        console.error(chalk.red('Please provide a service name. Example: create-node-app create-service auth'));
+        process.exit(1);
+    }
+
+    const currentDir = targetDir;
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    
+    // Default to no database if not found
+    let dbType = 'none'; 
+    
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            const deps = pkg.dependencies || {};
+            if (deps.mongoose) {
+                dbType = 'mongoose';
+            } else if (deps.sequelize) {
+                dbType = 'sequelize';
+            }
+        } catch (error) {
+            console.warn(chalk.yellow('Could not parse package.json. Defaulting to standard model generation.'));
+        }
+    } else {
+        console.warn(chalk.yellow('No package.json found in current directory. Generating service without database dependencies.'));
+    }
+
+    const serviceDir = path.join(currentDir, 'services', serviceName);
+    const controllerDir = path.join(serviceDir, 'controller');
+    const modelDir = path.join(serviceDir, 'model');
+    const routesDir = path.join(serviceDir, 'routes');
+
+    const spinner = ora(`Generating ${serviceName} service...`).start();
+
+    try {
+        // Create directories
+        fs.mkdirSync(controllerDir, { recursive: true });
+        fs.mkdirSync(modelDir, { recursive: true });
+        fs.mkdirSync(routesDir, { recursive: true });
+
+        // Generate Controller
+        const controllerContent = `export default {
+    // Add your controller methods here
+    // exampleMethod: async (req, res, next) => { ... }
+}
+`;
+        fs.writeFileSync(path.join(controllerDir, `${serviceName}.controller.js`), controllerContent);
+
+        // Generate Routes
+        const routesContent = `import express from 'express'
+import ${serviceName}Controller from '../controller/${serviceName}.controller.js'
+
+const router = express.Router({ caseSensitive: true })
+
+// Add your routes here
+// router.get('/', ${serviceName}Controller.exampleMethod)
+
+export default router
+`;
+        fs.writeFileSync(path.join(routesDir, `${serviceName}.routes.js`), routesContent);
+
+        // Generate Model
+        let modelContent = '';
+        if (dbType === 'sequelize') {
+            modelContent = `import { DataTypes } from 'sequelize'
+import sequelize from '../../../config/db.config.js'
+
+const ${serviceName.charAt(0).toUpperCase() + serviceName.slice(1)} = sequelize.define('${serviceName}', {
+    name: {
+        type: DataTypes.STRING,
+        allowNull: false
+    }
+}, {
+    timestamps: true
+})
+
+export default ${serviceName.charAt(0).toUpperCase() + serviceName.slice(1)}
+`;
+        } else {
+            // Default to mongoose structure
+            modelContent = `import mongoose from "mongoose";
+
+const ${serviceName}Schema = new mongoose.Schema({
+    
+})
+
+export default mongoose.model('${serviceName}', ${serviceName}Schema);
+`;
+        }
+        
+        fs.writeFileSync(path.join(modelDir, `${serviceName}.model.js`), modelContent);
+
+        // Try to update app.js automatically
+        const appJsPath = path.join(currentDir, 'app.js');
+        if (fs.existsSync(appJsPath)) {
+            let appJsContent = fs.readFileSync(appJsPath, 'utf8');
+
+            const importStatement = `import ${serviceName}Routes from './services/${serviceName}/routes/${serviceName}.routes.js'`;
+            const useStatement = `app.use('/api/${serviceName}', ${serviceName}Routes)`;
+
+            // Inject import statement after the last import
+            if (!appJsContent.includes(importStatement)) {
+                const lastImportIndex = appJsContent.lastIndexOf('import ');
+                if (lastImportIndex !== -1) {
+                    const endOfLastImport = appJsContent.indexOf('\n', lastImportIndex);
+                    appJsContent = appJsContent.slice(0, endOfLastImport + 1) + importStatement + '\n' + appJsContent.slice(endOfLastImport + 1);
+                } else {
+                    appJsContent = importStatement + '\n' + appJsContent;
+                }
+            }
+
+            // Inject app.use statement before app.get('/', or before export default
+            if (!appJsContent.includes(useStatement)) {
+                const appGetIndex = appJsContent.indexOf("app.get('/'");
+                if (appGetIndex !== -1) {
+                    appJsContent = appJsContent.slice(0, appGetIndex) + useStatement + '\n\n' + appJsContent.slice(appGetIndex);
+                } else {
+                    const exportIndex = appJsContent.lastIndexOf('export default app');
+                    if (exportIndex !== -1) {
+                        appJsContent = appJsContent.slice(0, exportIndex) + useStatement + '\n\n' + appJsContent.slice(exportIndex);
+                    } else {
+                        appJsContent += '\n' + useStatement + '\n';
+                    }
+                }
+            }
+
+            fs.writeFileSync(appJsPath, appJsContent);
+            spinner.succeed(`Successfully created ${chalk.green(serviceName)} service and updated app.js`);
+        } else {
+            spinner.succeed(`Successfully created ${chalk.green(serviceName)} service at ./services/${serviceName}`);
+            console.log(`\nDon't forget to register your routes in ${chalk.cyan('app.js')}!`);
+            console.log(`  import ${serviceName}Routes from './services/${serviceName}/routes/${serviceName}.routes.js'`);
+            console.log(`  app.use('/api/${serviceName}', ${serviceName}Routes)\n`);
+        }
+
+    } catch (err) {
+        spinner.fail(`Failed to create ${serviceName} service.`);
+        console.error(err);
+        process.exit(1);
+    }
+}

package/bin/commands/init.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+import { promptUser, copyTemplateFiles, installDependencies, showSuccessMessage } from '../utils/helpers.js';
+import { configureDatabase } from '../utils/database.js';
+import { createServiceCommand } from './createService.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function initCommand(projectDirectory) {
+    // 1. Prompt User
+    const { targetDir, packageManager, database } = await promptUser(projectDirectory);
+    const targetPath = path.resolve(process.cwd(), targetDir);
+    const templateDir = path.join(__dirname, '..', '..', 'template');
+
+    console.log(`\nCreating a new Node.js app in ${chalk.green(targetPath)}\n`);
+
+    // 2. Copy Template Files
+    copyTemplateFiles(templateDir, targetPath);
+
+    // 3. Configure Database
+    configureDatabase(targetPath, database);
+
+    // 4. Dynamically generate the 'auth' service so it uses the correct DB model
+    await createServiceCommand('auth', targetPath);
+
+    // 5. Install Dependencies
+    installDependencies(targetPath, packageManager);
+
+    // 6. Success Message
+    showSuccessMessage(targetDir, targetPath, packageManager);
+}

package/bin/create-service-cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { createServiceCommand } from './commands/createService.js';
+
+program
+    .name('create-service')
+    .description('Scaffold a new service (model, controller, routes)')
+    .argument('<serviceName>', 'Name of the service to create')
+    .action(createServiceCommand);
+
+program.parse(process.argv);

package/bin/utils/database.js

@@ -0,0 +1,81 @@
+import fs from 'fs';
+import path from 'path';
+
+export function configureDatabase(targetPath, database) {
+    const packageJsonPath = path.join(targetPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) return;
+
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    pkg.name = path.basename(targetPath);
+
+    const dbConfigPath = path.join(targetPath, 'config', 'db.config.js');
+    const targetConfigDir = path.dirname(dbConfigPath);
+    if (!fs.existsSync(targetConfigDir)) {
+        fs.mkdirSync(targetConfigDir, { recursive: true });
+    }
+
+    if (database === 'MongoDB (Mongoose)') {
+        pkg.dependencies = pkg.dependencies || {};
+        pkg.dependencies.mongoose = '^8.0.0';
+
+        const mongooseContent = `import mongoose from "mongoose"
+
+const options = {
+    serverSelectionTimeoutMS: 10000,
+    dbName: '',
+}
+
+const connectDB = async () => {
+    try {
+        await mongoose.connect('', options)
+        console.log(\`✅ MongoDB connected!\`)
+    } catch (error) {
+        console.error(\`❌ MongoDB connection error: \${error.message}\`)
+        process.exit(1)
+    }
+}
+
+export default connectDB`;
+        fs.writeFileSync(dbConfigPath, mongooseContent);
+
+    } else if (database === 'PostgreSQL (Sequelize)') {
+        pkg.dependencies = pkg.dependencies || {};
+        pkg.dependencies.sequelize = '^6.35.0';
+        pkg.dependencies.pg = '^8.11.3';
+        pkg.dependencies['pg-hstore'] = '^2.3.4';
+
+        const sequelizeContent = `import { Sequelize } from "sequelize"
+
+export const sequelize = new Sequelize(
+    '',          // DB name
+    '',         // User
+    '',      // Password
+    {
+        host: '',
+        dialect: 'postgres',
+        logging: false,
+        port: ''
+    }
+) 
+
+// Test connection
+// (async () => {
+//     try {
+//         await sequelize.authenticate();
+//         console.log("PostgreSQL connected with Sequelize");
+//     } catch (err) {
+//         console.error("Error:", err.message);
+//     }
+// })()
+
+export default sequelize
+`;
+        fs.writeFileSync(dbConfigPath, sequelizeContent);
+
+    } else {
+        fs.writeFileSync(dbConfigPath, '// No database configured\n');
+    }
+
+    // Save updated package.json
+    fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
+}

package/bin/utils/helpers.js

@@ -0,0 +1,96 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import ora from 'ora';
+import inquirer from 'inquirer';
+
+export async function promptUser(projectDirectory) {
+    let targetDir = projectDirectory;
+
+    if (!targetDir) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'projectDirectory',
+                message: 'What is your project named?',
+                default: 'my-app'
+            }
+        ]);
+        targetDir = answers.projectDirectory;
+    }
+
+    const { packageManager, database } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'packageManager',
+            message: 'Which package manager would you like to use?',
+            choices: ['npm', 'yarn', 'pnpm'],
+            default: 'npm'
+        },
+        {
+            type: 'list',
+            name: 'database',
+            message: 'Which database would you like to use?',
+            choices: ['MongoDB (Mongoose)', 'PostgreSQL (Sequelize)', 'None'],
+            default: 'MongoDB (Mongoose)'
+        }
+    ]);
+
+    return { targetDir, packageManager, database };
+}
+
+export function copyTemplateFiles(templateDir, targetPath) {
+    const spinner = ora('Copying template files...').start();
+
+    if (fs.existsSync(targetPath)) {
+        spinner.fail(`Directory ${path.basename(targetPath)} already exists.`);
+        process.exit(1);
+    }
+
+    fs.mkdirSync(targetPath, { recursive: true });
+
+    const copyRecursiveSync = (src, dest) => {
+        const exists = fs.existsSync(src);
+        const stats = exists && fs.statSync(src);
+        if (exists && stats.isDirectory()) {
+            if (!fs.existsSync(dest)) fs.mkdirSync(dest);
+            fs.readdirSync(src).forEach((child) => {
+                if (child === 'node_modules') return;
+                copyRecursiveSync(path.join(src, child), path.join(dest, child));
+            });
+        } else {
+            fs.copyFileSync(src, dest);
+        }
+    };
+
+    try {
+        copyRecursiveSync(templateDir, targetPath);
+        spinner.succeed('Template copied successfully.');
+    } catch (err) {
+        spinner.fail('Failed to copy template.');
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+export function installDependencies(targetPath, packageManager) {
+    const installSpinner = ora(`Installing dependencies using ${packageManager}...`).start();
+    try {
+        execSync(`${packageManager} install`, { cwd: targetPath, stdio: 'pipe' });
+        installSpinner.succeed('Dependencies installed successfully.');
+    } catch (err) {
+        installSpinner.fail('Failed to install dependencies.');
+        console.error(err);
+    }
+}
+
+export function showSuccessMessage(targetDir, targetPath, packageManager) {
+    console.log(`\n${chalk.green('Success!')} Created ${path.basename(targetPath)} at ${targetPath}`);
+    console.log('\nInside that directory, you can run several commands:\n');
+    console.log(`  ${chalk.cyan(`${packageManager} run dev`)}`);
+    console.log('    Starts the development server with nodemon.\n');
+    console.log('We suggest that you begin by typing:\n');
+    console.log(`  ${chalk.cyan('cd')} ${targetDir}`);
+    console.log(`  ${chalk.cyan(`${packageManager} run dev`)}\n`);
+}

package/package.json

@@ -1,15 +1,17 @@
 {
     "name": "@apexkrrish/create-node-app",
-    "version": "1.0.0",
+    "version": "1.1.0",
     "description": "A CLI tool to scaffold Node.js applications.",
     "main": "index.js",
     "type": "module",
     "private": false,
     "bin": {
-        "create-node-app": "bin/cli.js"
+        "create-node-app": "bin/cli.js",
+        "create-service": "bin/create-service-cli.js"
     },
     "scripts": {
-        "start": "node ./bin/cli.js"
+        "start": "node ./bin/cli.js",
+        "create-service": "node ./bin/cli.js create-service"
     },
     "dependencies": {
         "chalk": "^5.3.0",

package/readme.md

@@ -1,51 +1,83 @@
-# create-node-app
+# @apexkrrish/create-node-app
 
-A fast and interactive CLI tool to scaffold Node.js applications.
+A powerful and fast CLI tool to scaffold production-ready Node.js applications with built-in database configurations and modular service generation.
 
 ## Features
 
-- **Interactive Prompts**: Choose your project name, package manager, and database just by answering simple questions.
-- **Multiple Package Managers**: Supports `npm`, `yarn`, and `pnpm`.
-- **Database Configuration**: Automatically configures database connections with pre-written boilerplate for:
-  - MongoDB (using Mongoose)
-  - PostgreSQL (using Sequelize)
-  - None (no database setup out-of-the-box)
-- **Ready to Go**: Automatically installs dependencies and sets up the basic folder structure based on the provided template.
+- Scaffolds a complete Express.js server structure.
+- Automatic database setup (MongoDB/Mongoose or PostgreSQL/Sequelize).
+- Integrated auto-generator for new service modules (Controllers, Models, Routes).
+- Pre-configured `app.js` with best practices (CORS, compression, error handlers).
 
-## Usage
+## Installation & Usage
 
-You can use the CLI directly:
+You don't need to install this globally (though you can if you want). The easiest way to use it is with `npx`.
+
+### 1. Create a New Application
+
+To create a brand new Node.js app, simply run:
 
 ```bash
-npx create-node-app [project-directory]
+npx @apexkrrish/create-node-app my-app
 ```
+*(If you leave out the `my-app` name, the CLI will ask you for it!)*
+
+The CLI will prompt you to choose:
+- Your preferred package manager (`npm`, `yarn`, `pnpm`).
+- Your preferred database (`MongoDB`, `PostgreSQL`, or `None`).
+
+It will then automatically scaffold your project, configure the database connection, generate an initial `auth` service tailored to your selected database, and install dependencies!
 
-Or, if you clone locally and link:
+### 2. Run Your Application
 
 ```bash
-npm start -- my-new-project
+cd my-app
+npm run dev
 ```
 
-### Interactive Prompts
-
-If you do not provide a project directory, the CLI will ask you for one. It will then prompt you to answer the following:
+---
 
-1. **What is your project named?** (if no folder name was supplied)
-2. **Which package manager would you like to use?**
-   - npm
-   - yarn
-   - pnpm
-3. **Which database would you like to use?**
-   - MongoDB (Mongoose)
-   - PostgreSQL (Sequelize)
-   - None
+## Code Generator: Create Services
 
-### After Setup
+Once your application is created, this tool comes with an amazing built-in code generator that saves you from writing boilerplate.
 
-Once the tool has finished scaffolding the project and installing dependencies, you can navigate into your new app and start the development server:
+To generate a new service module (for example, a `user` service), navigate into your project folder and run:
 
 ```bash
-cd <your-project-directory>
-npm run dev
+npx create-service user
+```
+
+*(If you installed the CLI globally via `npm install -g @apexkrrish/create-node-app`, you can just type `create-service user`)*
+
+### What it does:
+1. It creates `services/user/controller/user.controller.js`
+2. It creates `services/user/routes/user.routes.js`
+3. It detects the database you chose during setup (Mongoose or Sequelize) and generates the correct `services/user/model/user.model.js` structure automatically!
+4. **It automatically updates your `app.js` file** to import and register your new routes!
+
+---
+
+## Folder Structure Generated
+
+```
+my-app/
+├── bin/
+│   └── www
+├── config/
+│   └── db.config.js       # Database connection
+├── public/
+├── services/
+│   ├── auth/              # Automatically generated on init
+│   │   ├── controller/
+│   │   ├── model/
+│   │   └── routes/
+│   └── <your-service>/    # Generated via 'create-service'
+├── utils/
+│   └── helper.utils.js
+├── app.js                 # Express configuration (auto-updated)
+└── package.json
 ```
-*(Replace `npm` with your chosen package manager!)*
+
+## License
+
+ISC License.