@diagramers/cli 1.0.25 → 1.0.27

package/README.md

@@ -1,504 +1,355 @@
-# @diagramers/cli
+# Diagramers CLI
 
-A powerful command-line interface for rapid API development with TypeScript, Node.js, and MongoDB. Streamline your development workflow with automated code generation, project scaffolding, and database management.
+A powerful command-line interface for managing Diagramers projects, generating modules, and extending functionality with a comprehensive template system.
 
 ## 🚀 Features
 
-- **Project Initialization**: Create new API and admin projects from templates
-- **Code Generation**: Generate complete CRUD modules, database tables, and relationships
-- **Project Management**: Update and extend existing projects with new features
-- **Database Management**: Create tables, relationships, and manage database context
-- **Template Processing**: Customize project templates for different environments
+### Core Capabilities
+- **Project Initialization** - Create new projects from templates
+- **Module Generation** - Generate complete modules with CRUD operations
+- **Database Schema Generation** - Create tables and collections
+- **Relation Management** - Generate database relations and references
+- **Feature Extension** - Add features to existing projects
+- **Template Management** - Download and update project templates
+
+### Supported Templates
+- **API Projects** - Full-featured Node.js API with TypeScript
+- **Admin Projects** - Admin dashboard and management interfaces
+- **Custom Templates** - Extensible template system
+
+### Database Support
+- **MongoDB** - Primary database with Mongoose schemas
+- **SQL Databases** - MySQL, PostgreSQL, SQLite support
+- **Schema Generation** - Automatic schema and relation creation
 
 ## 📦 Installation
 
+### Global Installation
 ```bash
 npm install -g @diagramers/cli
 ```
 
-## 🎯 Quick Start
+### Local Installation
+```bash
+npm install @diagramers/cli
+npx diagramers --help
+```
+
+## 🚀 Quick Start
 
 ```bash
-# Create a new API project
-diagramers init api my-ecommerce-api
+# Install the CLI globally
+npm install -g @diagramers/cli
 
-# Navigate to your project
-cd my-ecommerce-api
+# Create a new API project
+diagramers init api my-new-api
 
-# Generate a complete product module
-diagramers api generate:module product
+# Navigate to the project
+cd my-new-api
 
-# Generate database tables
-diagramers api generate:table category
-diagramers api generate:table brand
+# Set up environment variables
+cp env.example .env.development
+echo "NODE_ENV=development" >> .env.development
 
-# Create relationships between tables
-diagramers api generate:relation product category
-diagramers api generate:relation product brand
+# Start development server
+npm start
 ```
 
-## 📋 Command Reference
-
-### Project Initialization
+## 🛠️ Usage
 
+### Initialize New Project
 ```bash
-# Create new API project with TypeScript, MongoDB, and Express
-diagramers init api <project-name>
+# Initialize new API project
+diagramers init api my-api-project
 
-# Create new admin dashboard project
-diagramers init admin <project-name>
-```
+# Initialize new admin project
+diagramers init admin my-admin-project
 
-**What's included:**
-- TypeScript configuration
-- Express.js server setup
-- MongoDB with Mongoose
-- Firebase Functions integration
-- Socket.io for real-time features
-- **Multi-Provider Authentication System** - Internal, Firebase, OAuth, SMS OTP, Email OTP
-- Email and SMS services
-- Audit logging
-- Environment configurations with comprehensive auth settings
+# Initialize with specific template version
+diagramers init api my-project --template 1.0.0
 
-### Project Updates
+# Skip prompts and use defaults
+diagramers init api my-project --yes
+```
+
+**Important:** After initializing a project, remember to:
+1. Copy `env.example` to `.env.development`
+2. Set `NODE_ENV=development` in `.env.development`
+3. Configure your database and other environment variables
 
+### Generate Modules
 ```bash
-# Update with latest features
-diagramers update
+# Generate basic module
+diagramers extend --module products
 
-# Update with backup (recommended)
-diagramers update --backup
+# Generate module with CRUD operations
+diagramers extend --module orders --crud
 
-# Force update (overwrites conflicts)
-diagramers update --force
+# Generate module with custom fields
+diagramers extend --module categories --fields name,description,slug
+
+# Generate module with specific database type
+diagramers extend --module users --type mongodb --fields email,username,role
 ```
 
-### Project Extensions
+### Generate Database Schemas
+```bash
+# Generate MongoDB collection
+diagramers extend --table products --fields name,price,description
+
+# Generate SQL table
+diagramers extend --table orders --type mysql --fields customer_id,amount,status
 
+# Generate PostgreSQL table
+diagramers extend --table categories --type postgres --fields name,slug,parent_id
+```
+
+### Generate Database Relations
 ```bash
-# List available features
-diagramers extend --list
+# Generate MongoDB relations
+diagramers extend --relation user-posts --type mongodb
+
+# Generate SQL relations
+diagramers extend --relation product-categories --type mysql
+```
 
-# Add authentication system (includes multi-provider auth)
+### Add Features
+```bash
+# Add authentication feature
 diagramers extend --feature auth
 
-# Add email service
+# Add email notification feature
 diagramers extend --feature email
 
-# Add WebSocket support
+# Add WebSocket feature
 diagramers extend --feature socket
 
-# Add cron job system
+# Add scheduled tasks feature
 diagramers extend --feature cron
 
-# Add audit logging
+# Add audit logging feature
 diagramers extend --feature audit
 ```
 
-### Authentication System Features
-
-The CLI now supports the enhanced multi-provider authentication system:
-
-- **Internal Authentication** - Email/password with configurable policies
-- **Firebase Authentication** - Google Firebase integration
-- **OAuth Providers** - Google, Facebook, GitHub, LinkedIn, Twitter
-- **SMS OTP** - One-time passwords via SMS (Twilio/AWS SNS)
-- **Email OTP** - One-time passwords via email
-- **Session Management** - JWT tokens with refresh capabilities
-- **Unified User Model** - Single user with multiple auth providers
-
-All new projects include comprehensive authentication configuration with dummy values that developers can replace with their own credentials.
-
-## 🔧 API Development Commands
-
-### Generate Complete Module
-
-Creates a full CRUD module with all layers:
-
+### List Available Options
 ```bash
-diagramers api generate:module <name>
+# List all available features and templates
+diagramers extend --list
 ```
 
-**Example:**
+### Update Projects
 ```bash
-diagramers api generate:module product
-```
+# Update project structure
+diagramers update
 
-**Generated Files:**
+# Update with specific version
+diagramers update --version 1.0.0
 ```
-src/
-├── entities/product.ts              # TypeScript interface
-├── schemas/product.ts               # Mongoose schema
-├── services/product-service.ts      # Business logic
-├── controllers/product-controller.ts # Request handlers
-└── routes/product-routes.ts         # API endpoints
-```
-
-**API Endpoints Created:**
-- `GET /api/products` - List all products
-- `GET /api/products/:id` - Get product by ID
-- `POST /api/products` - Create new product
-- `PUT /api/products/:id` - Update product
-- `DELETE /api/products/:id` - Delete product
 
-### Generate Database Table
+## 📁 Generated Module Structure
 
-Creates only the database layer (entity and schema):
+When you generate a module, the CLI creates a complete structure:
 
-```bash
-diagramers api generate:table <name>
 ```
-
-**Example:**
-```bash
-diagramers api generate:table category
-diagramers api generate:table brand
-diagramers api generate:table inventory
+src/modules/your-module/
+├── entities/
+│   └── your-module.entity.ts      # TypeScript interfaces
+├── schemas/
+│   └── your-module.schema.ts      # Database schemas
+├── services/
+│   └── your-module.service.ts     # Business logic
+├── controllers/
+│   └── your-module.controller.ts  # HTTP handlers
+└── routes/
+    └── your-module.routes.ts      # API routes
 ```
 
-**Generated Files:**
-```
-src/
-├── entities/category.ts    # TypeScript interface
-└── schemas/category.ts     # Mongoose schema
-```
-
-**Use Cases:**
-- Lookup tables (categories, brands, statuses)
-- Configuration tables (settings, preferences)
-- Reference data (countries, currencies)
-- Internal data models
-
-### Generate Table Relationships
+### Generated Files Include:
+- **Entities** - TypeScript interfaces with CRUD operations
+- **Schemas** - Database schemas with validation and indexes
+- **Services** - Business logic with Result model integration
+- **Controllers** - HTTP handlers with Swagger documentation
+- **Routes** - Express routes with proper binding
 
-Creates relationships between existing tables:
+## 🔧 Configuration
 
+### Template Configuration
+The CLI uses npm packages for templates:
+- `@diagramers/api` - API project template
+- `@diagramers/admin` - Admin project template
+
+### Custom Templates
+You can create custom templates by:
+1. Creating a package with the template structure
+2. Publishing to npm with `@diagramers/` prefix
+3. Using the template with `--template` flag
+
+## 📋 Available Features
+
+### Authentication Features
+- **Internal Auth** - Username/password with JWT
+- **Firebase Auth** - Google Firebase integration
+- **OAuth Providers** - Google, GitHub, Facebook
+- **SMS OTP** - Twilio, AWS SNS integration
+- **Email OTP** - Email-based verification
+
+### Communication Features
+- **Email System** - Nodemailer with templates
+- **SMS System** - Twilio integration
+- **WebSocket** - Real-time communication
+- **Push Notifications** - Firebase messaging
+
+### System Features
+- **Cron Jobs** - Scheduled task system
+- **Audit Logging** - Activity tracking
+- **File Upload** - File management system
+- **Caching** - Redis integration
+
+## 🗄️ Database Support
+
+### MongoDB (Default)
 ```bash
-diagramers api generate:relation <table1> <table2> [type]
+# Generate MongoDB collection
+diagramers extend --table products --type mongodb --fields name,price,category
 ```
 
-**Relationship Types:**
-- `one-to-one` (default)
-- `one-to-many`
-- `many-to-many`
-
-**Examples:**
+### SQL Databases
 ```bash
-# One-to-many: Product belongs to Category
-diagramers api generate:relation product category one-to-many
+# MySQL table
+diagramers extend --table orders --type mysql --fields customer_id,amount,status
 
-# Many-to-many: Product has many Tags
-diagramers api generate:relation product tag many-to-many
+# PostgreSQL table
+diagramers extend --table users --type postgres --fields email,username,role
 
-# One-to-one: User has one Profile
-diagramers api generate:relation user profile one-to-one
+# SQLite table
+diagramers extend --table settings --type sqlite --fields key,value
 ```
 
-**What it does:**
-- Updates entity interfaces with relationship fields
-- Updates schemas with references and indexes
-- Adds population methods to services
-- Updates database context
-
-### Process Template
-
-Customize your project for different environments:
-
+### Relations
 ```bash
-diagramers api process:template <project-name>
-```
+# One-to-Many relations
+diagramers extend --relation user-posts --type mongodb
 
-**Example:**
-```bash
-diagramers api process:template ecommerce-production
-```
-
-**What it updates:**
-- Package.json name and description
-- README.md title and description
-- Database names in configuration files
-- Environment-specific settings
-- Creates .env.example template
-
-## 🏗️ Project Structure
-
-After using the CLI, your project will have this structure:
-
-```
-src/
-├── entities/              # TypeScript interfaces
-│   ├── user.ts
-│   ├── product.ts
-│   └── category.ts
-├── schemas/               # Mongoose schemas
-│   ├── user.ts
-│   ├── product.ts
-│   └── category.ts
-├── services/              # Business logic layer
-│   ├── user-service.ts
-│   ├── product-service.ts
-│   └── category-service.ts
-├── controllers/           # Request handlers
-│   ├── user-controller.ts
-│   ├── product-controller.ts
-│   └── category-controller.ts
-├── routes/                # API endpoints
-│   ├── user-routes.ts
-│   ├── product-routes.ts
-│   ├── category-routes.ts
-│   └── index.ts
-├── helpers/               # Utilities and helpers
-│   ├── dbcontext.ts       # Database context
-│   ├── auth.ts
-│   ├── mailer.ts
-│   └── result.ts
-└── config/                # Environment configurations
-    ├── development.ts
-    ├── staging.ts
-    └── production.ts
+# Many-to-Many relations
+diagramers extend --relation product-categories --type mysql
 ```
 
-## 🎯 Real-World Examples
+## 🔌 Plugin System
 
-### E-commerce API Development
+The CLI supports plugin generation for extending functionality:
 
+### Generate Plugin
 ```bash
-# 1. Initialize project
-diagramers init api ecommerce-api
-cd ecommerce-api
-
-# 2. Generate main entities with full CRUD
-diagramers api generate:module product
-diagramers api generate:module user
-diagramers api generate:module order
-
-# 3. Generate supporting tables
-diagramers api generate:table category
-diagramers api generate:table brand
-diagramers api generate:table tag
-diagramers api generate:table shipping_method
-diagramers api generate:table payment_method
-
-# 4. Create relationships
-diagramers api generate:relation product category one-to-many
-diagramers api generate:relation product brand one-to-many
-diagramers api generate:relation product tag many-to-many
-diagramers api generate:relation order user one-to-many
-diagramers api generate:relation order shipping_method one-to-one
-
-# 5. Customize for production
-diagramers api process:template ecommerce-production
-```
-
-### Blog API Development
+# Generate plugin structure
+diagramers extend --plugin my-plugin
 
-```bash
-# 1. Initialize project
-diagramers init api blog-api
-cd blog-api
-
-# 2. Generate main entities
-diagramers api generate:module post
-diagramers api generate:module user
-diagramers api generate:module comment
-
-# 3. Generate supporting tables
-diagramers api generate:table category
-diagramers api generate:table tag
-
-# 4. Create relationships
-diagramers api generate:relation post user one-to-many
-diagramers api generate:relation post category one-to-many
-diagramers api generate:relation post tag many-to-many
-diagramers api generate:relation comment post one-to-many
-diagramers api generate:relation comment user one-to-many
+# Generate plugin with configuration
+diagramers extend --plugin payment-gateway --config stripe,paypal
 ```
 
-## 🔄 Database Relationships
+## 📚 Examples
 
-### One-to-Many Relationship
+### Complete E-commerce Module
+```bash
+# Generate products module
+diagramers extend --module products --crud --fields name,price,description,category,stock
 
-```typescript
-// Product belongs to Category
-interface IProduct {
-  _id: ObjectId;
-  name: string;
-  _categoryId: ObjectId;  // Reference to category (with _ prefix)
-  category?: ICategory;   // Populated field
-}
+# Generate orders module
+diagramers extend --module orders --crud --fields customer_id,products,total,status
 
-interface ICategory {
-  _id: ObjectId;
-  name: string;
-  products?: IProduct[];  // Virtual field
-}
-```
+# Generate categories module
+diagramers extend --module categories --crud --fields name,description,parent_id
 
-### Many-to-Many Relationship
-
-```typescript
-// Product has many Tags
-interface IProduct {
-  _id: ObjectId;
-  name: string;
-  _tagIds: ObjectId[];    // Array of references (with _ prefix)
-  tags?: ITag[];          // Populated field
-}
-
-interface ITag {
-  _id: ObjectId;
-  name: string;
-  _productIds: ObjectId[]; // Array of references (with _ prefix)
-  products?: IProduct[];   // Virtual field
-}
+# Generate relations
+diagramers extend --relation product-category --type mongodb
+diagramers extend --relation order-product --type mongodb
 ```
 
-### One-to-One Relationship
-
-```typescript
-// User has one Profile
-interface IUser {
-  _id: ObjectId;
-  email: string;
-  _profileId: ObjectId;   // Reference to profile (with _ prefix)
-  profile?: IProfile;     // Populated field
-}
-
-interface IProfile {
-  _id: ObjectId;
-  firstName: string;
-  lastName: string;
-  _userId: ObjectId;      // Reference back to user (with _ prefix)
-  user?: IUser;           // Populated field
-}
-```
-
-## 🛠️ Development Workflow
-
-### 1. Project Setup
+### User Management System
 ```bash
-# Create new project
-diagramers init api my-api
-cd my-api
+# Generate users module
+diagramers extend --module users --crud --fields email,username,role,status
 
-# Install dependencies
-npm install
+# Generate profiles module
+diagramers extend --module profiles --crud --fields user_id,first_name,last_name,avatar
 
-# Start development server
-npm run serve
-```
+# Generate permissions module
+diagramers extend --module permissions --crud --fields name,description,resource
 
-### 2. Database Design
-```bash
-# Generate main entities
-diagramers api generate:module user
-diagramers api generate:module product
+# Generate relations
+diagramers extend --relation user-profile --type mongodb
+diagramers extend --relation user-permissions --type mongodb
+```
 
-# Generate supporting tables
-diagramers api generate:table category
-diagramers api generate:table brand
+## 🚀 Advanced Usage
 
-# Create relationships
-diagramers api generate:relation product category one-to-many
-diagramers api generate:relation product brand one-to-many
+### Custom Field Types
+```bash
+# Generate with different field types
+diagramers extend --module products --fields name:string,price:number,active:boolean,created:date
 ```
 
-### 3. API Development
+### Nested Modules
 ```bash
-# Test your endpoints
-curl http://localhost:4000/api/products
-curl http://localhost:4000/api/categories
+# Generate nested module structure
+diagramers extend --module admin/users --crud --fields email,role,permissions
 ```
 
-### 4. Production Deployment
+### API Documentation
 ```bash
-# Process template for production
-diagramers api process:template my-api-production
-
-# Build and deploy
-npm run build:prod
-npm run deploy
+# Generate with enhanced Swagger docs
+diagramers extend --module api/products --crud --swagger --fields name,price,description
 ```
 
-## 🔧 Configuration
+## 🔧 Development
 
-### Environment Variables
-
-The CLI creates a comprehensive `.env.example` file with:
-
-```env
-# Server Configuration
-PORT=4000
-HOST=localhost
-
-# Database Configuration
-MONGODB_URI=mongodb://127.0.0.1:27017/my-api-development
+### Local Development
+```bash
+# Clone the repository
+git clone https://github.com/diagramers/diagramers-cli.git
+cd diagramers-cli
 
-# Firebase Configuration
-FIREBASE_API_KEY=your-api-key
-FIREBASE_AUTH_DOMAIN=your-project.firebaseapp.com
+# Install dependencies
+npm install
 
-# JWT Configuration
-JWT_SECRET=your-jwt-secret-key
+# Build the project
+npm run build
 
-# Email Configuration
-SMTP_HOST=smtp.gmail.com
-SMTP_PORT=587
-SMTP_USER=your-email@gmail.com
-SMTP_PASS=your-app-password
+# Link for local development
+npm link
 ```
 
-### Database Configuration
-
-The CLI automatically configures different database names for each environment:
-
-- **Development**: `my-api-development`
-- **Staging**: `my-api-staging`
-- **Production**: `my-api-production`
-
-## 🚀 Best Practices
-
-### 1. Naming Conventions
-- Use singular names for entities: `product`, `user`, `category`
-- Use descriptive names: `user_profile`, `product_inventory`
-- Follow camelCase for multi-word names
+### Testing
+```bash
+# Run tests
+npm test
 
-### 2. Database Design
-- Generate tables first, then relationships
-- Use `generate:table` for lookup data
-- Use `generate:module` for main business entities
-- Always create relationships after both tables exist
+# Run with coverage
+npm run test:coverage
+```
 
-### 3. API Development
-- Test endpoints after generation
-- Customize generated code for your business logic
-- Add validation and error handling
-- Implement proper authentication and authorization
+## 📄 License
 
-### 4. Project Organization
-- Keep related files together
-- Use consistent naming patterns
-- Document your API endpoints
-- Version your API properly
+This project is licensed under the MIT License.
 
 ## 🤝 Contributing
 
 1. Fork the repository
 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add amazing feature'`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
 4. Push to the branch (`git push origin feature/amazing-feature`)
 5. Open a Pull Request
 
-## 📄 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## 🆘 Support
+## 📞 Support
 
-- **Documentation**: [GitHub Wiki](https://github.com/diagramers/diagramers-cli/wiki)
-- **Issues**: [GitHub Issues](https://github.com/diagramers/diagramers-cli/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/diagramers/diagramers-cli/discussions)
+For support and questions:
+- 📖 Check the documentation
+- 🐛 Open an issue on GitHub
+- 💬 Join our community discussions
+- 📧 Contact: support@diagramers.com
 
----
+## 🔗 Related Packages
 
-**Built with ❤️ by the Diagramers Team** 
+- **@diagramers/api** - API framework and template
+- **@diagramers/admin** - Admin dashboard template
+- **@diagramers/shared** - Shared utilities and types