frontend-hamroun 1.2.16 → 1.2.17

package/src/cli/index.js

@@ -1,554 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'fs';
-import path from 'path';
-import readline from 'readline';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-// Promisify fs functions
-const mkdir = promisify(fs.mkdir);
-const readdir = promisify(fs.readdir);
-const writeFile = promisify(fs.writeFile);
-const readFile = promisify(fs.readFile);
-const copyFile = promisify(fs.copyFile);
-const access = promisify(fs.access);
-const execPromise = promisify(exec);
-
-// Find the templates directory
-const TEMPLATES_DIR = path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'templates');
-
-// Create readline interface
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout
-});
-
-// Promisify question
-const question = (query) => new Promise((resolve) => rl.question(query, resolve));
-
-// Simple logger
-const log = {
-  info: (msg) => console.log(`\x1b[36minfo\x1b[0m: ${msg}`),
-  success: (msg) => console.log(`\x1b[32msuccess\x1b[0m: ${msg}`),
-  warn: (msg) => console.log(`\x1b[33mwarning\x1b[0m: ${msg}`),
-  error: (msg) => console.log(`\x1b[31merror\x1b[0m: ${msg}`),
-  title: (msg) => console.log(`\n\x1b[1m${msg}\x1b[0m\n`)
-};
-
-// Rest of the CLI functionality...
-/**
- * Copy directory recursively
- */
-async function copyDir(src, dest) {
-  // Create destination directory if it doesn't exist
-  await mkdir(dest, { recursive: true });
-  
-  // Read the contents of the source directory
-  const entries = await readdir(src, { withFileTypes: true });
-  
-  // Process each file/directory
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    
-    if (entry.isDirectory()) {
-      // Recursively copy directories
-      await copyDir(srcPath, destPath);
-    } else {
-      // Copy files
-      await copyFile(srcPath, destPath);
-    }
-  }
-}
-
-/**
- * Check if directory exists
- */
-async function directoryExists(path) {
-  try {
-    await access(path, fs.constants.F_OK);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-/**
- * Replace placeholders in file content
- */
-async function processTemplateFile(filePath, replacements) {
-  try {
-    // Read file content
-    let content = await readFile(filePath, 'utf8');
-    
-    // Replace each placeholder
-    for (const [key, value] of Object.entries(replacements)) {
-      content = content.replace(new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, 'g'), value);
-    }
-    
-    // Write back to file
-    await writeFile(filePath, content, 'utf8');
-  } catch (error) {
-    log.error(`Failed to process template file ${filePath}: ${error.message}`);
-  }
-}
-
-/**
- * Process all template files in a directory
- */
-async function processTemplateDir(dir, replacements) {
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      
-      if (entry.isDirectory()) {
-        await processTemplateDir(fullPath, replacements);
-      } else if (entry.isFile() && 
-                (entry.name.endsWith('.js') || 
-                 entry.name.endsWith('.ts') || 
-                 entry.name.endsWith('.json') || 
-                 entry.name.endsWith('.tsx') || 
-                 entry.name.endsWith('.md') || 
-                 entry.name.endsWith('.html'))) {
-        await processTemplateFile(fullPath, replacements);
-      }
-    }
-  } catch (error) {
-    log.error(`Failed to process template directory ${dir}: ${error.message}`);
-  }
-}
-
-/**
- * Create a new Hamroun project
- */
-async function createProject(projectName, templateName) {
-  const targetDir = path.resolve(process.cwd(), projectName);
-  
-  // Check if directory already exists
-  if (await directoryExists(targetDir)) {
-    const overwrite = await question(`Directory ${projectName} already exists. Continue and overwrite? (y/N): `);
-    if (overwrite.toLowerCase() !== 'y') {
-      log.info('Project creation cancelled.');
-      rl.close();
-      return;
-    }
-  }
-  
-  // Check if template exists
-  const templateDir = path.join(TEMPLATES_DIR, templateName);
-  if (!(await directoryExists(templateDir))) {
-    log.error(`Template "${templateName}" not found.`);
-    rl.close();
-    return;
-  }
-  
-  try {
-    log.title(`Creating new Hamroun project: ${projectName}`);
-    
-    // Create project directory
-    await mkdir(targetDir, { recursive: true });
-    
-    // Copy template files
-    log.info(`Copying template files from ${templateName}...`);
-    await copyDir(templateDir, targetDir);
-    
-    // Get template customization values
-    const appName = await question('Application name: ') || projectName;
-    const description = await question('Description: ') || `A Hamroun application`;
-    const author = await question('Author: ') || '';
-    
-    // Replace placeholders in template files
-    log.info('Processing template files...');
-    await processTemplateDir(targetDir, {
-      projectName,
-      appName,
-      description,
-      author,
-      creationDate: new Date().toISOString().split('T')[0]
-    });
-    
-    // Install dependencies
-    log.info('Installing dependencies (this may take a while)...');
-    try {
-      await execPromise('npm install', { cwd: targetDir });
-      log.success('Dependencies installed successfully.');
-    } catch (error) {
-      log.warn(`Failed to install dependencies: ${error.message}`);
-      log.info('You can install them later by running "npm install" in the project directory.');
-    }
-    
-    log.success(`Project ${projectName} created successfully!`);
-    log.info(`\nTo get started:\n`);
-    log.info(`  cd ${projectName}`);
-    log.info(`  npm run dev\n`);
-    
-  } catch (error) {
-    log.error(`Failed to create project: ${error.message}`);
-  } finally {
-    rl.close();
-  }
-}
-
-/**
- * Generate a component
- */
-async function generateComponent(componentName, options = {}) {
-  try {
-    const { type = 'functional', directory = 'components' } = options;
-    const targetDir = path.resolve(process.cwd(), directory);
-    
-    // Create directory if it doesn't exist
-    await mkdir(targetDir, { recursive: true });
-    
-    // Determine file path and content
-    const componentFileName = `${componentName}.tsx`;
-    const componentFilePath = path.join(targetDir, componentFileName);
-    
-    // Check if file already exists
-    if (fs.existsSync(componentFilePath)) {
-      const overwrite = await question(`Component ${componentName} already exists. Overwrite? (y/N): `);
-      if (overwrite.toLowerCase() !== 'y') {
-        log.info('Component generation cancelled.');
-        rl.close();
-        return;
-      }
-    }
-    
-    // Generate component content based on type
-    let content = '';
-    if (type === 'functional') {
-      content = `import { useState, useEffect } from 'frontend-hamroun';
-
-interface ${componentName}Props {
-  title?: string;
-}
-
-export function ${componentName}({ title = 'Default Title' }: ${componentName}Props) {
-  const [count, setCount] = useState(0);
-  
-  useEffect(() => {
-    // Component mounted
-    console.log('${componentName} mounted');
-    
-    return () => {
-      // Component will unmount
-      console.log('${componentName} will unmount');
-    };
-  }, []);
-  
-  return (
-    <div className="${componentName.toLowerCase()}">
-      <h2>{title}</h2>
-      <p>Count: {count}</p>
-      <button onClick={() => setCount(count + 1)}>Increment</button>
-    </div>
-  );
-}
-`;
-    } else if (type === 'class') {
-      content = `import { Component } from 'frontend-hamroun';
-
-interface ${componentName}Props {
-  title?: string;
-}
-
-interface ${componentName}State {
-  count: number;
-}
-
-export class ${componentName} extends Component<${componentName}Props, ${componentName}State> {
-  constructor(props: ${componentName}Props) {
-    super(props);
-    this.state = {
-      count: 0
-    };
-  }
-  
-  componentDidMount() {
-    console.log('${componentName} mounted');
-  }
-  
-  componentWillUnmount() {
-    console.log('${componentName} will unmount');
-  }
-  
-  increment = () => {
-    this.setState({ count: this.state.count + 1 });
-  }
-  
-  render() {
-    const { title = 'Default Title' } = this.props;
-    
-    return (
-      <div className="${componentName.toLowerCase()}">
-        <h2>{title}</h2>
-        <p>Count: {this.state.count}</p>
-        <button onClick={this.increment}>Increment</button>
-      </div>
-    );
-  }
-}
-`;
-    }
-    
-    // Write component file
-    await writeFile(componentFilePath, content, 'utf8');
-    
-    log.success(`Component ${componentName} created at ${componentFilePath}`);
-  } catch (error) {
-    log.error(`Failed to generate component: ${error.message}`);
-  } finally {
-    rl.close();
-  }
-}
-
-/**
- * Generate a model
- */
-async function generateModel(modelName, options = {}) {
-  try {
-    const { directory = 'models' } = options;
-    const targetDir = path.resolve(process.cwd(), directory);
-    
-    // Create directory if it doesn't exist
-    await mkdir(targetDir, { recursive: true });
-    
-    // Determine file path and content
-    const modelFileName = `${modelName}.ts`;
-    const modelFilePath = path.join(targetDir, modelFileName);
-    
-    // Check if file already exists
-    if (fs.existsSync(modelFilePath)) {
-      const overwrite = await question(`Model ${modelName} already exists. Overwrite? (y/N): `);
-      if (overwrite.toLowerCase() !== 'y') {
-        log.info('Model generation cancelled.');
-        rl.close();
-        return;
-      }
-    }
-    
-    // Generate model content
-    const content = `import { Schema } from 'mongoose';
-import { createModel, FieldTypes } from 'frontend-hamroun';
-
-// Define the model interface
-export interface ${modelName} {
-  _id?: string;
-  name: string;
-  description?: string;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-// Define the schema
-const ${modelName.toLowerCase()}Schema = new Schema<${modelName}>({
-  name: FieldTypes.Required(FieldTypes.String),
-  description: FieldTypes.String,
-  createdAt: FieldTypes.Default(FieldTypes.Date, Date.now),
-  updatedAt: FieldTypes.Default(FieldTypes.Date, Date.now)
-}, {
-  timestamps: true
-});
-
-// Create and export the model
-export const ${modelName}Model = createModel<${modelName}>('${modelName}', ${modelName.toLowerCase()}Schema);
-`;
-    
-    // Write model file
-    await writeFile(modelFilePath, content, 'utf8');
-    
-    log.success(`Model ${modelName} created at ${modelFilePath}`);
-  } catch (error) {
-    log.error(`Failed to generate model: ${error.message}`);
-  } finally {
-    rl.close();
-  }
-}
-
-/**
- * Generate an API route
- */
-async function generateRoute(routeName, options = {}) {
-  try {
-    const { directory = 'routes', model = null } = options;
-    const targetDir = path.resolve(process.cwd(), directory);
-    
-    // Create directory if it doesn't exist
-    await mkdir(targetDir, { recursive: true });
-    
-    // Determine file path and content
-    const routeFileName = `${routeName}.ts`;
-    const routeFilePath = path.join(targetDir, routeFileName);
-    
-    // Check if file already exists
-    if (fs.existsSync(routeFilePath)) {
-      const overwrite = await question(`Route ${routeName} already exists. Overwrite? (y/N): `);
-      if (overwrite.toLowerCase() !== 'y') {
-        log.info('Route generation cancelled.');
-        rl.close();
-        return;
-      }
-    }
-    
-    // Generate route content based on whether a model is specified
-    let content = '';
-    if (model) {
-      content = `import { Router } from 'express';
-import { createRestEndpoints, asyncHandler, sendSuccess, sendError } from 'frontend-hamroun';
-import { ${model}Model } from '../models/${model}';
-
-// Create router with standard CRUD endpoints
-const router = createRestEndpoints(${model}Model);
-
-// Add custom endpoints
-router.get('/count', asyncHandler(async (req, res) => {
-  const count = await ${model}Model.count();
-  sendSuccess(res, { count });
-}));
-
-export default router;
-`;
-    } else {
-      content = `import { Router } from 'express';
-import { asyncHandler, sendSuccess, sendError } from 'frontend-hamroun';
-
-const router = Router();
-
-// Define routes
-router.get('/', asyncHandler(async (req, res) => {
-  sendSuccess(res, { message: 'Welcome to the ${routeName} API' });
-}));
-
-router.post('/', asyncHandler(async (req, res) => {
-  const { name } = req.body;
-  
-  if (!name) {
-    return sendError(res, 'Name is required', 400);
-  }
-  
-  sendSuccess(res, { name }, 'Resource created', 201);
-}));
-
-router.get('/:id', asyncHandler(async (req, res) => {
-  const { id } = req.params;
-  
-  // Implement your logic here
-  
-  sendSuccess(res, { id, name: 'Sample Item' });
-}));
-
-export default router;
-`;
-    }
-    
-    // Write route file
-    await writeFile(routeFilePath, content, 'utf8');
-    
-    log.success(`Route ${routeName} created at ${routeFilePath}`);
-  } catch (error) {
-    log.error(`Failed to generate route: ${error.message}`);
-  } finally {
-    rl.close();
-  }
-}
-
-/**
- * Print usage instructions
- */
-function printHelp() {
-  log.title('Hamroun CLI Tool');
-  console.log('Usage: hamroun <command> [options]\n');
-  
-  console.log('Commands:');
-  console.log('  create <project-name> [template]  Create a new Hamroun project');
-  console.log('  generate <type> <name>            Generate a component, model, or route');
-  console.log('  help                              Show this help message\n');
-  
-  console.log('Examples:');
-  console.log('  hamroun create my-app full-stack  Create a new full-stack project');
-  console.log('  hamroun generate component Button Generate a new component');
-  console.log('  hamroun generate model User       Generate a new model');
-  console.log('  hamroun generate route users      Generate a new API route\n');
-  
-  console.log('Available templates:');
-  console.log('  full-stack    Full-stack application with API and frontend');
-  console.log('  frontend      Frontend-only application');
-  console.log('  api           API-only application');
-  console.log('  minimal       Minimal starter with essential files only\n');
-  
-  rl.close();
-}
-
-/**
- * Main CLI function
- */
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-  
-  if (!command || command === 'help') {
-    printHelp();
-    return;
-  }
-  
-  switch (command) {
-    case 'create':
-      const projectName = args[1];
-      const templateName = args[2] || 'full-stack';
-      
-      if (!projectName) {
-        log.error('Project name is required.');
-        printHelp();
-        return;
-      }
-      
-      await createProject(projectName, templateName);
-      break;
-      
-    case 'generate':
-      const type = args[1];
-      const name = args[2];
-      
-      if (!type || !name) {
-        log.error('Type and name are required.');
-        printHelp();
-        return;
-      }
-      
-      switch (type) {
-        case 'component':
-          await generateComponent(name, {
-            type: args[3] || 'functional'
-          });
-          break;
-          
-        case 'model':
-          await generateModel(name);
-          break;
-          
-        case 'route':
-          await generateRoute(name, {
-            model: args[3]
-          });
-          break;
-          
-        default:
-          log.error(`Unknown generator type: ${type}`);
-          printHelp();
-      }
-      break;
-      
-    default:
-      log.error(`Unknown command: ${command}`);
-      printHelp();
-  }
-}
-
-// Run CLI
-main().catch(error => {
-  log.error(`An error occurred: ${error.message}`);
-  rl.close();
-});