@diagramers/cli 1.0.25 → 1.0.27

package/dist/services/project-extender.js

@@ -75,8 +75,9 @@ class ProjectExtender {
         ];
     }
     async listFeatures() {
-        console.log(chalk_1.default.blue('📋 Available features:'));
+        console.log(chalk_1.default.blue('�� Available features and templates:'));
         console.log('');
+        console.log(chalk_1.default.green('🔧 Features:'));
         this.features.forEach(feature => {
             console.log(chalk_1.default.green(`  ${feature.name}`));
             console.log(chalk_1.default.gray(`    ${feature.description}`));
@@ -85,6 +86,18 @@ class ProjectExtender {
             }
             console.log('');
         });
+        console.log(chalk_1.default.blue('📦 Module Templates:'));
+        console.log(chalk_1.default.green('  --module <name> --crud --fields field1,field2'));
+        console.log(chalk_1.default.gray('    Generate complete module with CRUD operations'));
+        console.log('');
+        console.log(chalk_1.default.blue('🗄️  Database Templates:'));
+        console.log(chalk_1.default.green('  --table <name> --fields field1,field2 --type mongodb'));
+        console.log(chalk_1.default.gray('    Generate database table/collection schema'));
+        console.log('');
+        console.log(chalk_1.default.blue('🔗 Relation Templates:'));
+        console.log(chalk_1.default.green('  --relation <name> --type mongodb'));
+        console.log(chalk_1.default.gray('    Generate database relations and references'));
+        console.log('');
     }
     async addFeature(featureName) {
         const feature = this.features.find(f => f.name === featureName);
@@ -108,6 +121,38 @@ class ProjectExtender {
         console.log(chalk_1.default.green(`✅ Feature '${featureName}' added successfully!`));
         console.log(chalk_1.default.blue(`📝 Main configuration updated to include ${featureName} feature`));
     }
+    async generateModule(moduleName, options = {}) {
+        const projectPath = process.cwd();
+        // Check if module already exists
+        const modulePath = path.join(projectPath, 'src', 'modules', moduleName);
+        if (await fs.pathExists(modulePath)) {
+            throw new Error(`Module '${moduleName}' already exists in this project.`);
+        }
+        console.log(chalk_1.default.blue(`📁 Creating module structure for: ${moduleName}`));
+        // Create module directory structure
+        await this.createModuleStructure(projectPath, moduleName, options);
+        // Generate CRUD operations if requested
+        if (options.crud) {
+            await this.generateCRUDOperations(projectPath, moduleName, options);
+        }
+        // Update main application to include the module
+        await this.registerModule(projectPath, moduleName);
+        console.log(chalk_1.default.green(`✅ Module '${moduleName}' generated successfully!`));
+    }
+    async generateTable(tableName, options = {}) {
+        const projectPath = process.cwd();
+        console.log(chalk_1.default.blue(`🗄️  Generating table schema for: ${tableName}`));
+        // Create table schema based on database type
+        await this.createTableSchema(projectPath, tableName, options);
+        console.log(chalk_1.default.green(`✅ Table '${tableName}' generated successfully!`));
+    }
+    async generateRelations(relationName, options = {}) {
+        const projectPath = process.cwd();
+        console.log(chalk_1.default.blue(`🔗 Generating relations for: ${relationName}`));
+        // Create relation definitions
+        await this.createRelations(projectPath, relationName, options);
+        console.log(chalk_1.default.green(`✅ Relations '${relationName}' generated successfully!`));
+    }
     async createFeatureStructure(projectPath, feature) {
         const featurePath = path.join(projectPath, 'src', 'features', feature.name);
         // Create basic feature structure
@@ -195,6 +240,637 @@ export interface ${this.capitalizeFirst(feature.name)}Data {
 `;
         await fs.writeFile(path.join(featurePath, 'types', `${feature.name}-types.ts`), typesContent);
     }
+    async createModuleStructure(projectPath, moduleName, options) {
+        const modulePath = path.join(projectPath, 'src', 'modules', moduleName);
+        // Create module directory structure
+        const structure = {
+            'entities': 'Data models and interfaces',
+            'schemas': 'Database schemas and validation',
+            'services': 'Business logic and data access',
+            'controllers': 'HTTP request handlers',
+            'routes': 'API route definitions'
+        };
+        for (const [dir, description] of Object.entries(structure)) {
+            const dirPath = path.join(modulePath, dir);
+            await fs.ensureDir(dirPath);
+            // Create index file
+            const indexContent = `// ${description} for ${moduleName} module
+export * from './${moduleName}.${dir.slice(0, -1)}';
+`;
+            await fs.writeFile(path.join(dirPath, 'index.ts'), indexContent);
+        }
+        // Create main entity
+        await this.createEntity(modulePath, moduleName, options);
+        // Create schema
+        await this.createSchema(modulePath, moduleName, options);
+        // Create service
+        await this.createService(modulePath, moduleName, options);
+        // Create controller
+        await this.createController(modulePath, moduleName, options);
+        // Create routes
+        await this.createRoutes(modulePath, moduleName, options);
+    }
+    async createEntity(modulePath, moduleName, options) {
+        const entityName = this.capitalizeFirst(moduleName);
+        const fields = options.fields || ['name', 'description'];
+        const entityContent = `import { BaseEntity } from '../../../shared/types/base-entity';
+
+export interface I${entityName} extends BaseEntity {
+${fields.map((field) => `  ${field}: string;`).join('\n')}
+}
+
+export interface I${entityName}Create {
+${fields.map((field) => `  ${field}: string;`).join('\n')}
+}
+
+export interface I${entityName}Update {
+${fields.map((field) => `  ${field}?: string;`).join('\n')}
+}
+`;
+        await fs.writeFile(path.join(modulePath, 'entities', `${moduleName}.entity.ts`), entityContent);
+    }
+    async createSchema(modulePath, moduleName, options) {
+        const entityName = this.capitalizeFirst(moduleName);
+        const fields = options.fields || ['name', 'description'];
+        const schemaContent = `import mongoose, { Schema, Document } from 'mongoose';
+import { I${entityName} } from '../entities/${moduleName}.entity';
+
+export interface I${entityName}Document extends Omit<I${entityName}, '_id'>, Document {}
+
+const ${moduleName}Schema = new Schema({
+${fields.map((field) => `  ${field}: {
+    type: String,
+    required: true,
+    trim: true
+  }`).join(',\n')}
+}, {
+  timestamps: true,
+  toJSON: {
+    transform: function(doc, ret) {
+      return ret;
+    }
+  }
+});
+
+// Indexes
+${fields.map((field) => `${moduleName}Schema.index({ ${field}: 1 });`).join('\n')}
+
+export const ${entityName}Model = mongoose.model<I${entityName}Document>('${entityName}', ${moduleName}Schema);
+`;
+        await fs.writeFile(path.join(modulePath, 'schemas', `${moduleName}.schema.ts`), schemaContent);
+    }
+    async createService(modulePath, moduleName, options) {
+        const entityName = this.capitalizeFirst(moduleName);
+        const serviceContent = `import { Result } from '../../../shared/types/result';
+import { ${entityName}Model, I${entityName}Document } from '../schemas/${moduleName}.schema';
+import { I${entityName}, I${entityName}Create, I${entityName}Update } from '../entities/${moduleName}.entity';
+
+export class ${entityName}Service {
+  /**
+   * Get all ${moduleName}s
+   */
+  async getAll(): Promise<Result<I${entityName}[]>> {
+    try {
+      const ${moduleName}s = await ${entityName}Model.find({ status: 1 }).lean();
+      const converted${entityName}s = ${moduleName}s.map(${moduleName} => ({
+        ...${moduleName},
+        _id: ${moduleName}._id?.toString() || ''
+      })) as I${entityName}[];
+      return Result.success(converted${entityName}s);
+    } catch (error: any) {
+      return Result.error('Failed to fetch ${moduleName}s', error.message);
+    }
+  }
+
+  /**
+   * Get ${moduleName} by ID
+   */
+  async getById(id: string): Promise<Result<I${entityName} | null>> {
+    try {
+      const ${moduleName} = await ${entityName}Model.findOne({ _id: id, status: 1 });
+      if (!${moduleName}) {
+        return Result.error('${entityName} not found', '${entityName} with the specified ID does not exist');
+      }
+      const ${moduleName}Obj = ${moduleName}.toObject();
+      const converted${entityName} = {
+        ...${moduleName}Obj,
+        _id: ${moduleName}Obj._id?.toString() || ''
+      } as I${entityName};
+      return Result.success(converted${entityName});
+    } catch (error: any) {
+      return Result.error('Failed to fetch ${moduleName}', error.message);
+    }
+  }
+
+  /**
+   * Create new ${moduleName}
+   */
+  async create(${moduleName}Data: I${entityName}Create): Promise<Result<I${entityName}>> {
+    try {
+      const ${moduleName} = new ${entityName}Model({
+        ...${moduleName}Data,
+        status: 1
+      });
+
+      const saved${entityName} = await ${moduleName}.save();
+      const ${moduleName}Obj = saved${entityName}.toObject();
+      
+      const converted${entityName} = {
+        ...${moduleName}Obj,
+        _id: ${moduleName}Obj._id?.toString() || ''
+      } as I${entityName};
+
+      return Result.success(converted${entityName});
+    } catch (error: any) {
+      return Result.error('Failed to create ${moduleName}', error.message);
+    }
+  }
+
+  /**
+   * Update ${moduleName}
+   */
+  async update(id: string, ${moduleName}Data: I${entityName}Update): Promise<Result<I${entityName} | null>> {
+    try {
+      const ${moduleName} = await ${entityName}Model.findOne({ _id: id, status: 1 });
+      if (!${moduleName}) {
+        return Result.error('${entityName} not found', '${entityName} with the specified ID does not exist');
+      }
+
+      Object.assign(${moduleName}, ${moduleName}Data);
+      const updated${entityName} = await ${moduleName}.save();
+      
+      const ${moduleName}Obj = updated${entityName}.toObject();
+      
+      const converted${entityName} = {
+        ...${moduleName}Obj,
+        _id: ${moduleName}Obj._id?.toString() || ''
+      } as I${entityName};
+
+      return Result.success(converted${entityName});
+    } catch (error: any) {
+      return Result.error('Failed to update ${moduleName}', error.message);
+    }
+  }
+
+  /**
+   * Delete ${moduleName} (soft delete)
+   */
+  async delete(id: string): Promise<Result<boolean>> {
+    try {
+      const ${moduleName} = await ${entityName}Model.findOne({ _id: id, status: 1 });
+      if (!${moduleName}) {
+        return Result.error('${entityName} not found', '${entityName} with the specified ID does not exist');
+      }
+
+      ${moduleName}.status = 0;
+      await ${moduleName}.save();
+
+      return Result.success(true);
+    } catch (error: any) {
+      return Result.error('Failed to delete ${moduleName}', error.message);
+    }
+  }
+}
+`;
+        await fs.writeFile(path.join(modulePath, 'services', `${moduleName}.service.ts`), serviceContent);
+    }
+    async createController(modulePath, moduleName, options) {
+        const entityName = this.capitalizeFirst(moduleName);
+        const controllerContent = `import { Request, Response } from 'express';
+import { ${entityName}Service } from '../services/${moduleName}.service';
+import { I${entityName}Create, I${entityName}Update } from '../entities/${moduleName}.entity';
+
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ${entityName}:
+ *       type: object
+ *       properties:
+ *         _id:
+ *           type: string
+ *         name:
+ *           type: string
+ *         description:
+ *           type: string
+ *         createdAt:
+ *           type: string
+ *           format: date-time
+ *         updatedAt:
+ *           type: string
+ *           format: date-time
+ */
+
+export class ${entityName}Controller {
+  constructor(private service: ${entityName}Service) {}
+
+  /**
+   * @swagger
+   * /api/${moduleName}s:
+   *   get:
+   *     summary: Get all ${moduleName}s
+   *     tags: [${entityName}s]
+   *     responses:
+   *       200:
+   *         description: List of ${moduleName}s
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 Data:
+   *                   type: array
+   *                   items:
+   *                     $ref: '#/components/schemas/${entityName}'
+   *                 StatusCode:
+   *                   type: number
+   *                 Message:
+   *                   type: string
+   */
+  async getAll(req: Request, res: Response): Promise<void> {
+    try {
+      const result = await this.service.getAll();
+      res.status(result.StatusCode === 1000 ? 200 : 400).json(result);
+    } catch (error: any) {
+      res.status(500).json({ error: error.message });
+    }
+  }
+
+  /**
+   * @swagger
+   * /api/${moduleName}s/{id}:
+   *   get:
+   *     summary: Get ${moduleName} by ID
+   *     tags: [${entityName}s]
+   *     parameters:
+   *       - in: path
+   *         name: id
+   *         required: true
+   *         schema:
+   *           type: string
+   *     responses:
+   *       200:
+   *         description: ${entityName} details
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 Data:
+   *                   $ref: '#/components/schemas/${entityName}'
+   *                 StatusCode:
+   *                   type: number
+   *                 Message:
+   *                   type: string
+   */
+  async getById(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      const result = await this.service.getById(id);
+      res.status(result.StatusCode === 1000 ? 200 : 400).json(result);
+    } catch (error: any) {
+      res.status(500).json({ error: error.message });
+    }
+  }
+
+  /**
+   * @swagger
+   * /api/${moduleName}s:
+   *   post:
+   *     summary: Create new ${moduleName}
+   *     tags: [${entityName}s]
+   *     requestBody:
+   *       required: true
+   *       content:
+   *         application/json:
+   *           schema:
+   *             type: object
+   *             properties:
+   *               name:
+   *                 type: string
+   *               description:
+   *                 type: string
+   *     responses:
+   *       201:
+   *         description: ${entityName} created successfully
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 Data:
+   *                   $ref: '#/components/schemas/${entityName}'
+   *                 StatusCode:
+   *                   type: number
+   *                 Message:
+   *                   type: string
+   */
+  async create(req: Request, res: Response): Promise<void> {
+    try {
+      const ${moduleName}Data: I${entityName}Create = req.body;
+      const result = await this.service.create(${moduleName}Data);
+      res.status(result.StatusCode === 1000 ? 201 : 400).json(result);
+    } catch (error: any) {
+      res.status(500).json({ error: error.message });
+    }
+  }
+
+  /**
+   * @swagger
+   * /api/${moduleName}s/{id}:
+   *   put:
+   *     summary: Update ${moduleName}
+   *     tags: [${entityName}s]
+   *     parameters:
+   *       - in: path
+   *         name: id
+   *         required: true
+   *         schema:
+   *           type: string
+   *     requestBody:
+   *       required: true
+   *       content:
+   *         application/json:
+   *           schema:
+   *             type: object
+   *             properties:
+   *               name:
+   *                 type: string
+   *               description:
+   *                 type: string
+   *     responses:
+   *       200:
+   *         description: ${entityName} updated successfully
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 Data:
+   *                   $ref: '#/components/schemas/${entityName}'
+   *                 StatusCode:
+   *                   type: number
+   *                 Message:
+   *                   type: string
+   */
+  async update(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      const ${moduleName}Data: I${entityName}Update = req.body;
+      const result = await this.service.update(id, ${moduleName}Data);
+      res.status(result.StatusCode === 1000 ? 200 : 400).json(result);
+    } catch (error: any) {
+      res.status(500).json({ error: error.message });
+    }
+  }
+
+  /**
+   * @swagger
+   * /api/${moduleName}s/{id}:
+   *   delete:
+   *     summary: Delete ${moduleName}
+   *     tags: [${entityName}s]
+   *     parameters:
+   *       - in: path
+   *         name: id
+   *         required: true
+   *         schema:
+   *           type: string
+   *     responses:
+   *       200:
+   *         description: ${entityName} deleted successfully
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 Data:
+   *                   type: boolean
+   *                 StatusCode:
+   *                   type: number
+   *                 Message:
+   *                   type: string
+   */
+  async delete(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      const result = await this.service.delete(id);
+      res.status(result.StatusCode === 1000 ? 200 : 400).json(result);
+    } catch (error: any) {
+      res.status(500).json({ error: error.message });
+    }
+  }
+}
+`;
+        await fs.writeFile(path.join(modulePath, 'controllers', `${moduleName}.controller.ts`), controllerContent);
+    }
+    async createRoutes(modulePath, moduleName, options) {
+        const entityName = this.capitalizeFirst(moduleName);
+        const routesContent = `import { Router } from 'express';
+import { ${entityName}Controller } from '../controllers/${moduleName}.controller';
+import { ${entityName}Service } from '../services/${moduleName}.service';
+
+const router = Router();
+const service = new ${entityName}Service();
+const controller = new ${entityName}Controller(service);
+
+// ${entityName} routes
+router.get('/', controller.getAll.bind(controller));
+router.get('/:id', controller.getById.bind(controller));
+router.post('/', controller.create.bind(controller));
+router.put('/:id', controller.update.bind(controller));
+router.delete('/:id', controller.delete.bind(controller));
+
+export default router;
+`;
+        await fs.writeFile(path.join(modulePath, 'routes', `${moduleName}.routes.ts`), routesContent);
+    }
+    async generateCRUDOperations(projectPath, moduleName, options) {
+        console.log(chalk_1.default.blue(`🔄 Generating CRUD operations for ${moduleName}...`));
+        // CRUD operations are already included in the service and controller generation
+    }
+    async registerModule(projectPath, moduleName) {
+        console.log(chalk_1.default.blue(`📝 Registering ${moduleName} module in main application...`));
+        // Update main routes index to include the new module
+        const routesIndexPath = path.join(projectPath, 'src', 'modules', 'index.ts');
+        if (await fs.pathExists(routesIndexPath)) {
+            let content = await fs.readFile(routesIndexPath, 'utf8');
+            // Add import for the new module
+            const importStatement = `import ${moduleName}Routes from './${moduleName}/routes/${moduleName}.routes';`;
+            if (!content.includes(importStatement)) {
+                // Find the last import statement and add after it
+                const importRegex = /import.*from.*['"];?\s*$/gm;
+                const matches = [...content.matchAll(importRegex)];
+                if (matches.length > 0) {
+                    const lastImport = matches[matches.length - 1];
+                    const insertIndex = lastImport.index + lastImport[0].length;
+                    content = content.slice(0, insertIndex) + '\n' + importStatement + content.slice(insertIndex);
+                }
+            }
+            // Add route registration
+            const routeRegistration = `app.use('/api/${moduleName}s', ${moduleName}Routes);`;
+            if (!content.includes(routeRegistration)) {
+                // Find where routes are registered and add after
+                const routeRegex = /app\.use\(.*\);?\s*$/gm;
+                const matches = [...content.matchAll(routeRegex)];
+                if (matches.length > 0) {
+                    const lastRoute = matches[matches.length - 1];
+                    const insertIndex = lastRoute.index + lastRoute[0].length;
+                    content = content.slice(0, insertIndex) + '\n' + routeRegistration + content.slice(insertIndex);
+                }
+            }
+            await fs.writeFile(routesIndexPath, content);
+        }
+    }
+    async createTableSchema(projectPath, tableName, options) {
+        const entityName = this.capitalizeFirst(tableName);
+        const fields = options.fields || ['name', 'description'];
+        const dbType = options.type || 'mongodb';
+        if (dbType === 'mongodb') {
+            await this.createMongoDBSchema(projectPath, tableName, fields);
+        }
+        else {
+            await this.createSQLSchema(projectPath, tableName, fields, dbType);
+        }
+    }
+    async createMongoDBSchema(projectPath, tableName, fields) {
+        const schemaPath = path.join(projectPath, 'src', 'schemas', `${tableName}.schema.ts`);
+        await fs.ensureDir(path.dirname(schemaPath));
+        const entityName = this.capitalizeFirst(tableName);
+        const schemaContent = `import mongoose, { Schema, Document } from 'mongoose';
+
+export interface I${entityName}Document extends Document {
+${fields.map(field => `  ${field}: string;`).join('\n')}
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const ${tableName}Schema = new Schema({
+${fields.map(field => `  ${field}: {
+    type: String,
+    required: true,
+    trim: true
+  }`).join(',\n')}
+}, {
+  timestamps: true
+});
+
+// Indexes
+${fields.map(field => `${tableName}Schema.index({ ${field}: 1 });`).join('\n')}
+
+export const ${entityName}Model = mongoose.model<I${entityName}Document>('${entityName}', ${tableName}Schema);
+`;
+        await fs.writeFile(schemaPath, schemaContent);
+    }
+    async createSQLSchema(projectPath, tableName, fields, dbType) {
+        const schemaPath = path.join(projectPath, 'src', 'schemas', `${tableName}.sql`);
+        await fs.ensureDir(path.dirname(schemaPath));
+        const entityName = this.capitalizeFirst(tableName);
+        const schemaContent = `-- ${entityName} table schema for ${dbType.toUpperCase()}
+CREATE TABLE ${tableName}s (
+  id ${dbType === 'postgres' ? 'SERIAL' : 'INT AUTO_INCREMENT'} PRIMARY KEY,
+${fields.map(field => `  ${field} VARCHAR(255) NOT NULL,`).join('\n')}
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+);
+
+-- Indexes
+${fields.map(field => `CREATE INDEX idx_${tableName}_${field} ON ${tableName}s(${field});`).join('\n')}
+`;
+        await fs.writeFile(schemaPath, schemaContent);
+    }
+    async createRelations(projectPath, relationName, options) {
+        const dbType = options.type || 'mongodb';
+        const relationPath = path.join(projectPath, 'src', 'schemas', 'relations', `${relationName}.relations.ts`);
+        await fs.ensureDir(path.dirname(relationPath));
+        if (dbType === 'mongodb') {
+            await this.createMongoDBRelations(relationPath, relationName);
+        }
+        else {
+            await this.createSQLRelations(relationPath, relationName, dbType);
+        }
+    }
+    async createMongoDBRelations(relationPath, relationName) {
+        const relationContent = `// MongoDB relations for ${relationName}
+import mongoose from 'mongoose';
+
+// Example: One-to-Many relationship
+// const userSchema = new mongoose.Schema({
+//   name: String,
+//   email: String,
+//   posts: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Post' }]
+// });
+
+// const postSchema = new mongoose.Schema({
+//   title: String,
+//   content: String,
+//   author: { type: mongoose.Schema.Types.ObjectId, ref: 'User' }
+// });
+
+// Example: Many-to-Many relationship
+// const categorySchema = new mongoose.Schema({
+//   name: String,
+//   products: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Product' }]
+// });
+
+// const productSchema = new mongoose.Schema({
+//   name: String,
+//   price: Number,
+//   categories: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Category' }]
+// });
+
+export const ${relationName}Relations = {
+  // Define your relations here
+  // User: userSchema,
+  // Post: postSchema,
+  // Category: categorySchema,
+  // Product: productSchema
+};
+`;
+        await fs.writeFile(relationPath, relationContent);
+    }
+    async createSQLRelations(relationPath, relationName, dbType) {
+        const relationContent = `-- SQL relations for ${relationName} (${dbType.toUpperCase()})
+
+-- Example: One-to-Many relationship
+-- CREATE TABLE users (
+--   id ${dbType === 'postgres' ? 'SERIAL' : 'INT AUTO_INCREMENT'} PRIMARY KEY,
+--   name VARCHAR(255) NOT NULL,
+--   email VARCHAR(255) UNIQUE NOT NULL
+-- );
+
+-- CREATE TABLE posts (
+--   id ${dbType === 'postgres' ? 'SERIAL' : 'INT AUTO_INCREMENT'} PRIMARY KEY,
+--   title VARCHAR(255) NOT NULL,
+--   content TEXT,
+--   user_id INT,
+--   FOREIGN KEY (user_id) REFERENCES users(id)
+-- );
+
+-- Example: Many-to-Many relationship
+-- CREATE TABLE categories (
+--   id ${dbType === 'postgres' ? 'SERIAL' : 'INT AUTO_INCREMENT'} PRIMARY KEY,
+--   name VARCHAR(255) NOT NULL
+-- );
+
+-- CREATE TABLE products (
+--   id ${dbType === 'postgres' ? 'SERIAL' : 'INT AUTO_INCREMENT'} PRIMARY KEY,
+--   name VARCHAR(255) NOT NULL,
+--   price DECIMAL(10,2)
+-- );
+
+-- CREATE TABLE product_categories (
+--   product_id INT,
+--   category_id INT,
+--   PRIMARY KEY (product_id, category_id),
+--   FOREIGN KEY (product_id) REFERENCES products(id),
+--   FOREIGN KEY (category_id) REFERENCES categories(id)
+-- );
+
+-- Add your relations here
+`;
+        await fs.writeFile(relationPath, relationContent);
+    }
     async addDependencies(dependencies) {
         console.log(chalk_1.default.blue('📦 Installing dependencies...'));
         // This would typically run npm install with the dependencies