@shakil-dev/shakil-stack 1.2.0 → 1.3.0

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an
+appointed representative at an online or offline event. Representation of a
+project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team. All complaints will be reviewed and 
+investigated and will result in a response that is deemed necessary and 
+appropriate to the circumstances. The project team will maintain confidentiality 
+with regard to the reporter of an incident. Further details of specific 
+enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good 
+faith may face temporary or permanent repercussions as determined by other 
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], 
+version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shakil Ahmed Billal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,79 +1,113 @@
-# Shakil-Stack Project Generator 🚀
+# 🚀 Shakil-Stack
 
-**Shakil-Stack** is a powerful full-stack project generator CLI that scaffolds a robust, production-ready environment based on the **EchoNet** backend architecture and a modern **Next.js** frontend.
+[![npm version](https://img.shields.io/npm/v/@shakil-dev/shakil-stack.svg?style=flat-square)](https://www.npmjs.com/package/@shakil-dev/shakil-stack)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/shakil-ahmed-billal/shakil-stack-cli/publish.yml?branch=main&style=flat-square)](https://github.com/shakil-ahmed-billal/shakil-stack-cli/actions)
 
-## ✨ Features
+**Shakil-Stack** is a high-performance, developer-first full-stack project generator. It scaffolds production-ready applications mirroring the **EchoNet** backend architecture paired with a state-of-the-art **Next.js** frontend.
 
-- **🛡️ EchoNet-Style Backend**:
-    - **Architecture**: Clean `src/app/...` structure (config, middleware, routes, utils).
-    - **Database**: Prisma 7+ with PostgreSQL adapter.
-    - **Authentication**: Pre-configured **Better Auth** with User, Session, and Account models.
-    - **Security**: Helmet, Express Rate Limit, and Request Sanitizer.
-    - **Error Handling**: Global error handler with `ApiError` support.
-    - **Validation**: Zod-ready structure.
-- **🌐 Next.js Frontend**:
-    - Modern Next.js (App Router, TypeScript, Tailwind CSS).
-    - Pre-defined project folders: `config`, `hooks`, `lib`, `services`, `types`.
-- **🛠️ Interactive Setup**: Choose your package manager (npm, pnpm, yarn) and auto-install dependencies.
+---
+
+## 🌟 Key Features
+
+### 🛡️ Backend Excellence (EchoNet Style)
+- **Modular Architecture**: Clean, scalable `src/app/module` pattern.
+- **Prisma 7+**: Next-gen database ORM with pre-configured PostgreSQL adapters.
+- **Better Auth Integration**: Pre-built authentication schemas (User, Session, Account).
+- **Security First**: Integrated Helmet, CORS, Rate Limiting, and XSS Sanitization.
+- **Robust Error Handling**: Centralized global error handler and structured `ApiError` class.
 
-## 🚀 Getting Started
+### 🌐 Modern Frontend (Next.js)
+- **App Router**: Leveraging the latest Next.js 14/15 patterns.
+- **TypeScript & Tailwind**: Pre-configured for visual excellence and type safety.
+- **Clean Structure**: Dedicated directories for hooks, services, lib, and types.
 
-You can generate a new project instantly using `npx`:
+### 🛠️ Developer Experience (CLI)
+- **One-Command Scaffolding**: Setup your entire stack in seconds.
+- **Smart Generation**: Scaffold modules (Controller, Service, Route) with zero boilerplate.
+- **Built-in Utilities**: Quick access to Prisma and build commands.
+
+---
 
+## 🚀 Commands Guide
+
+### 1. Initialize a New Project
+Create your full-stack dream project interactively:
 ```bash
-npx @shakil-dev/shakil-stack my-awesome-project
+npx @shakil-dev/shakil-stack init my-awesome-app
 ```
 
-### Or, if already installed globally:
+### 2. Scaffold a New Module (g)
+Generate a complete module with all layers instantly:
+```bash
+# Must be run in the project root
+shakil-stack g module Product
+```
+**Generated Files:**
+- `product.controller.ts`: Request/Response handling.
+- `product.service.ts`: Business logic & Database interaction.
+- `product.route.ts`: API endpoint definitions.
+- `product.interface.ts`: Data types and contracts.
+- `product.validation.ts`: Zod schema validation.
+- `product.constant.ts`: Reusable constants.
+
+### 3. Production Build
+Prepare your application for the real world:
+```bash
+shakil-stack build
+```
 
+### 4. Prisma Power Tools
+Manage your database without leaving the CLI:
 ```bash
-shakil-stack my-awesome-project
+shakil-stack prisma generate  # Update Prisma Client
+shakil-stack prisma migrate   # Apply migrations to DB
 ```
 
+---
+
 ## 📂 Project Structure
 
 ```text
-my-awesome-project/
+my-awesome-app/
 ├── backend/
-│   ├── prisma/
-│   │   └── schema.prisma (Better Auth & Prisma 7 ready)
+│   ├── prisma/             # Schema & Config
 │   ├── src/
-│   │   ├── server.ts
-│   │   └── app/ (EchoNet logic)
-│   └── .env
-├── frontend/ (Next.js App)
+│   │   ├── server.ts       # Entry point
+│   │   └── app/            # Core logic
+│   │       ├── module/     # Feature-based modules
+│   │       ├── middleware/ # Security & Global handlers
+│   │       └── utils/      # Reusable helpers
+│   └── tsconfig.json
+├── frontend/ (Next.js)
 │   ├── src/
-│   │   ├── app/
-│   │   ├── components/
-│   │   └── ...
+│   │   ├── app/            # Routes & Pages
+│   │   ├── components/     # UI Components
+│   │   └── services/       # API integration
 └── README.md
 ```
 
-## 🏗️ Post-Installation Steps
-
-After the generator finishes, follow these steps to start your development:
-
-1.  **Configure Database**: Update the `DATABASE_URL` in `backend/.env`.
-2.  **Start Backend**:
-    ```bash
-    cd backend
-    pnpm dev  # or npm run dev
-    ```
-3.  **Start Frontend**:
-    ```bash
-    cd frontend
-    pnpm dev  # or npm run dev
-    ```
+---
 
-## 📜 Commands (Backend)
+## 🛠️ Post-Setup Checklist
+1.  **Environment**: Update `backend/.env` with your `DATABASE_URL`.
+2.  **Database**: Run `shakil-stack prisma migrate` to setup your tables.
+3.  **Launch**: Run `npm dev` in both folders.
 
-- `pnpm dev`: Starts the server with `tsx` and `nodemon`.
-- `pnpm build`: Builds the project using `tsup`.
-- `pnpm start`: Runs the built project from  `dist/`.
+---
 
 ## 🤝 Contributing
+Contributions make the open-source community an amazing place to learn, inspire, and create.
+1. Fork the Project.
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`).
+3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`).
+4. Push to the Branch (`git push origin feature/AmazingFeature`).
+5. Open a Pull Request.
+
+Please read our [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) before contributing.
 
-Feel free to open issues or submit pull requests to improve the Shakil-Stack generator!
+## 📄 License
+Distributed under the MIT License. See `LICENSE` for more information.
 
 ---
-Developed with by **Shakil Ahmed Billal**
+Built with ⚡ by **Shakil Ahmed Billal**

package/bin/index.js

@@ -3,11 +3,30 @@
 const fs = require('fs-extra');
 const path = require('path');
 const { execSync } = require('child_process');
+const { Command } = require('commander');
 const inquirer = require('inquirer');
 const chalk = require('chalk');
 const ora = require('ora');
 
-async function main() {
+const program = new Command();
+
+// --- Utils ---
+const getPackageManager = () => {
+  if (fs.existsSync('pnpm-lock.yaml')) return 'pnpm';
+  if (fs.existsSync('yarn.lock')) return 'yarn';
+  return 'npm';
+};
+
+const runCommand = (command, cwd = process.cwd()) => {
+  try {
+    execSync(command, { stdio: 'inherit', cwd });
+  } catch (err) {
+    // console.error(chalk.red(`Failed to execute: ${command}`));
+  }
+};
+
+// --- Command: Init ---
+const initProject = async (name) => {
   console.log(chalk.cyan('\n🚀 Initializing Shakil-Stack Project Generator...\n'));
 
   const answers = await inquirer.prompt([
@@ -15,7 +34,7 @@ async function main() {
       type: 'input',
       name: 'projectName',
       message: 'What is your project name?',
-      default: 'my-new-project',
+      default: name || 'my-new-project',
       validate: (input) => (input ? true : 'Project name is required'),
     },
     {
@@ -42,12 +61,10 @@ async function main() {
   }
 
   try {
-    // 1. Create Root Directory
     await fs.ensureDir(projectPath);
-
     const spinner = ora(`🚀 Creating project: ${chalk.cyan(projectName)}...`).start();
 
-    // 2. Define Backend Folder Structure
+    // Backend Folder Structure
     const backendDirs = [
       'prisma',
       'src/app/config',
@@ -65,11 +82,9 @@ async function main() {
       await fs.ensureDir(path.join(projectPath, 'backend', dir));
     }
 
-    // 3. Generate Frontend using create-next-app FIRST
+    // Frontend (create-next-app)
     spinner.text = `📦 Running create-next-app for frontend...`;
     spinner.stop(); 
-    
-    // We run create-next-app in the project root to create the 'frontend' folder
     const nextAppCmd = `npx create-next-app@latest frontend --typescript --tailwind --eslint --app --src-dir --import-alias "@/*" --use-${packageManager} --no-git`;
     try {
       execSync(nextAppCmd, { cwd: projectPath, stdio: 'inherit' });
@@ -78,7 +93,7 @@ async function main() {
       await fs.ensureDir(path.join(projectPath, 'frontend'));
     }
 
-    // 4. Create additional frontend folders AFTER create-next-app
+    // Frontend extra folders
     const frontendExtraFolders = ['config', 'hooks', 'lib', 'services', 'types'];
     for (const folder of frontendExtraFolders) {
         await fs.ensureDir(path.join(projectPath, 'frontend', 'src', folder));
@@ -86,13 +101,12 @@ async function main() {
 
     spinner.start(`📂 Finalizing root files and backend code...`);
 
-    // 5. Root Files
+    // Root Files
     await fs.outputFile(path.join(projectPath, '.env'), 'DATABASE_URL="postgresql://user:password@localhost:5432/mydb"\nPORT=8000\nNODE_ENV=development\nJWT_SECRET="your-secret-key"');
     await fs.outputFile(path.join(projectPath, '.gitignore'), 'node_modules\n.env\ndist\n*.db\n.next\n.DS_Store');
     await fs.outputFile(path.join(projectPath, 'README.md'), `# ${projectName}\n\nGenerated with Full Shakil-Stack CLI.`);
 
-    // 6. Backend Files (Complete EchoNet Clone)
-    
+    // Backend Files Templates
     const serverTs = `import { Server } from 'http';
 import app from './app.js';
 import config from './app/config/index.js';
@@ -379,7 +393,33 @@ export default defineConfig({
 }
 `;
 
-    // Write backend files
+    const sendResponseTs = `import { Response } from 'express';
+
+type IResponse<T> = {
+  statusCode: number;
+  success: boolean;
+  message?: string | null;
+  meta?: {
+    limit: number;
+    page: number;
+    total: number;
+  };
+  data: T;
+};
+
+const sendResponse = <T>(res: Response, data: IResponse<T>) => {
+  res.status(data.statusCode).json({
+    success: data.success,
+    message: data.message || null,
+    meta: data.meta || null,
+    data: data.data || null,
+  });
+};
+
+export default sendResponse;
+`;
+
+    // Writing Backend Files
     await fs.outputFile(path.join(projectPath, 'backend', 'src', 'server.ts'), serverTs);
     await fs.outputFile(path.join(projectPath, 'backend', 'src', 'app.ts'), appTs);
     await fs.outputFile(path.join(projectPath, 'backend', 'src', 'app', 'config', 'index.ts'), configTs);
@@ -390,6 +430,7 @@ export default defineConfig({
     await fs.outputFile(path.join(projectPath, 'backend', 'src', 'app', 'middleware', 'notFound.ts'), notFoundTs);
     await fs.outputFile(path.join(projectPath, 'backend', 'src', 'app', 'middleware', 'sanitizeRequest.ts'), sanitizeRequestTs);
     await fs.outputFile(path.join(projectPath, 'backend', 'src', 'app', 'utils', 'catchAsync.ts'), catchAsyncTs);
+    await fs.outputFile(path.join(projectPath, 'backend', 'src', 'app', 'utils', 'sendResponse.ts'), sendResponseTs);
     await fs.outputFile(path.join(projectPath, 'backend', 'src', 'app', 'utils', 'sanitizer.ts'), sanitizerTs);
     await fs.outputFile(path.join(projectPath, 'backend', 'src', 'app', 'errorHelpers', 'ApiError.ts'), apiErrorTs);
     await fs.outputFile(path.join(projectPath, 'backend', 'prisma', 'schema.prisma'), schemaPrisma);
@@ -398,7 +439,6 @@ export default defineConfig({
     await fs.outputFile(path.join(projectPath, 'backend', '.gitignore'), 'node_modules\ndist\n.env');
     await fs.outputFile(path.join(projectPath, 'backend', '.env'), 'DATABASE_URL="postgresql://user:password@localhost:5432/mydb"\nJWT_SECRET="your-secret-key"');
 
-    // Backend package.json
     const backendPkg = {
       name: `${projectName}-backend`,
       version: '1.0.0',
@@ -446,15 +486,9 @@ export default defineConfig({
 
     spinner.succeed(chalk.green(`✅ Project structure created! ✨`));
 
-    // 7. Dependency Installation
     if (installDeps) {
       console.log(chalk.yellow(`\n📦 Finalizing dependencies with ${packageManager}...\n`));
-      try {
-        execSync(`cd "${path.join(projectPath, 'backend')}" && ${packageManager} install`, { stdio: 'inherit' });
-        console.log(chalk.green(`\n✅ Backend dependencies installed! ✨\n`));
-      } catch (err) {
-        console.log(chalk.red(`\n❌ Step failed. You can manually run '${packageManager} install' in the backend folder.\n`));
-      }
+      runCommand(`cd "${path.join(projectPath, 'backend')}" && ${packageManager} install`);
     }
 
     console.log(chalk.cyan(`To get started:`));
@@ -466,6 +500,170 @@ export default defineConfig({
     console.error(error);
     process.exit(1);
   }
-}
+};
+
+// --- Command: Generate Module ---
+const generateModule = async (name) => {
+  if (!name) {
+    console.log(chalk.red('❌ Error: Module name is required.'));
+    process.exit(1);
+  }
 
-main();
+  const moduleName = name.charAt(0).toUpperCase() + name.slice(1);
+  const lowercaseName = name.toLowerCase();
+  
+  // Check if inside a shakil-stack project
+  const backendRoot = fs.existsSync('backend') ? 'backend' : '.';
+  const moduleDir = path.join(backendRoot, 'src', 'app', 'module', moduleName);
+
+  if (!fs.existsSync(path.join(backendRoot, 'src', 'app', 'module'))) {
+    console.log(chalk.red('❌ Error: This command must be run inside your shakil-stack project root or backend directory.'));
+    process.exit(1);
+  }
+
+  if (fs.existsSync(moduleDir)) {
+    console.log(chalk.red(`❌ Error: Module ${moduleName} already exists.`));
+    process.exit(1);
+  }
+
+  const spinner = ora(`🛠️ Generating module: ${chalk.cyan(moduleName)}...`).start();
+
+  try {
+    await fs.ensureDir(moduleDir);
+
+    const files = {
+      'controller.ts': `import { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import catchAsync from '../../utils/catchAsync.js';
+import sendResponse from '../../utils/sendResponse.js';
+import { ${moduleName}Service } from './${lowercaseName}.service.js';
+
+const create${moduleName} = catchAsync(async (req: Request, res: Response) => {
+  const result = await ${moduleName}Service.create${moduleName}IntoDB(req.body);
+  sendResponse(res, {
+    statusCode: httpStatus.OK,
+    success: true,
+    message: '${moduleName} created successfully',
+    data: result,
+  });
+});
+
+export const ${moduleName}Controller = {
+  create${moduleName},
+};
+`,
+      'service.ts': `import { ${moduleName} } from '@prisma/client';
+import prisma from '../../lib/prisma.js';
+
+const create${moduleName}IntoDB = async (payload: any) => {
+  // Logic here
+  return payload;
+};
+
+export const ${moduleName}Service = {
+  create${moduleName}IntoDB,
+};
+`,
+      'route.ts': `import { Router } from 'express';
+import { ${moduleName}Controller } from './${lowercaseName}.controller.js';
+
+const router = Router();
+
+router.post('/create-${lowercaseName}', ${moduleName}Controller.create${moduleName});
+
+export const ${moduleName}Routes = router;
+`,
+      'interface.ts': `export type I${moduleName} = {
+  // Define interface
+};
+`,
+      'validation.ts': `import { z } from 'zod';
+
+const create${moduleName}ValidationSchema = z.object({
+  body: z.object({
+    // Define schema
+  }),
+});
+
+export const ${moduleName}Validations = {
+  create${moduleName}ValidationSchema,
+};
+`,
+      'constant.ts': `export const ${moduleName}SearchableFields = [];
+`,
+    };
+
+    for (const [ext, content] of Object.entries(files)) {
+      await fs.outputFile(path.join(moduleDir, `${lowercaseName}.${ext}`), content);
+    }
+
+    spinner.succeed(chalk.green(`✅ Module ${moduleName} generated successfully! ✨`));
+    console.log(chalk.gray(`Created at: ${moduleDir}`));
+
+  } catch (error) {
+    spinner.fail(chalk.red('❌ Failed to generate module.'));
+    console.error(error);
+  }
+};
+
+// --- CLI Structure ---
+program
+  .name('shakil-stack')
+  .description('Full-stack EchoNet-style project generator CLI')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Initialize a new full-stack project')
+  .argument('[projectName]', 'Name of the project')
+  .action((projectName) => {
+    initProject(projectName);
+  });
+
+program
+  .command('generate')
+  .alias('g')
+  .description('Generate a new module')
+  .argument('<type>', 'Type of generation (module)')
+  .argument('<name>', 'Name of the module')
+  .action((type, name) => {
+    if (type === 'module') {
+      generateModule(name);
+    } else {
+      console.log(chalk.red(`❌ Error: Unknown generation type: ${type}`));
+    }
+  });
+
+program
+  .command('build')
+  .description('Build the backend for production')
+  .action(() => {
+    const pm = getPackageManager();
+    const backendRoot = fs.existsSync('backend') ? 'backend' : '.';
+    console.log(chalk.cyan(`🏗️ Building backend with ${pm}...`));
+    runCommand(`${pm} run build`, backendRoot);
+  });
+
+program
+  .command('prisma')
+  .description('Prisma utilities')
+  .argument('<subcommand>', 'generate | migrate')
+  .action((subcommand) => {
+    const backendRoot = fs.existsSync('backend') ? 'backend' : '.';
+    if (subcommand === 'generate') {
+      console.log(chalk.cyan('🔄 Generating Prisma client...'));
+      runCommand('npx prisma generate', backendRoot);
+    } else if (subcommand === 'migrate') {
+      console.log(chalk.cyan('🚀 Running Prisma migrations...'));
+      runCommand('npx prisma migrate dev', backendRoot);
+    } else {
+      console.log(chalk.red(`❌ Error: Unknown prisma subcommand: ${subcommand}`));
+    }
+  });
+
+// Handle default action (no command)
+if (!process.argv.slice(2).length) {
+    initProject();
+} else {
+    program.parse(process.argv);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shakil-dev/shakil-stack",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Full-stack EchoNet-style project generator CLI",
   "main": "./bin/index.js",
   "bin": {