frontend-hamroun 1.2.15 → 1.2.17

package/bin/cli.mjs

@@ -1,237 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { execSync } from 'child_process';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Templates available
-const TEMPLATES = {
-  'basic': 'Basic frontend only template',
-  'full-stack': 'Complete frontend and backend template'
-};
-
-// Colors for CLI output
-const colors = {
-  reset: '\x1b[0m',
-  bright: '\x1b[1m',
-  green: '\x1b[32m',
-  blue: '\x1b[34m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m'
-};
-
-// Get package.json to read version
-const packageJsonPath = path.resolve(__dirname, '../package.json');
-const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-
-// Print banner
-function printBanner() {
-  console.log(`
-${colors.blue}${colors.bright}╔══════════════════════════════════════════════╗
-║                                              ║
-║   Frontend Hamroun v${packageJson.version.padEnd(25)}║
-║   A lightweight frontend & backend framework ║
-║                                              ║
-╚══════════════════════════════════════════════╝${colors.reset}
-  `);
-}
-
-// Print help
-function printHelp() {
-  console.log(`
-${colors.bright}USAGE:${colors.reset}
-  ${colors.blue}npx frontend-hamroun${colors.reset} [command] [options]
-
-${colors.bright}COMMANDS:${colors.reset}
-  ${colors.blue}create${colors.reset} <project-name> [options]  Create a new project
-  ${colors.blue}help${colors.reset}                           Display this help message
-  ${colors.blue}version${colors.reset}                        Display version information
-
-${colors.bright}OPTIONS:${colors.reset}
-  ${colors.blue}--template${colors.reset}, ${colors.blue}-t${colors.reset} <template>       Specify template (default: basic)
-  ${colors.blue}--skip-install${colors.reset}, ${colors.blue}-s${colors.reset}            Skip package installation
-
-${colors.bright}AVAILABLE TEMPLATES:${colors.reset}
-${Object.entries(TEMPLATES).map(([name, desc]) => `  ${colors.blue}${name.padEnd(12)}${colors.reset} ${desc}`).join('\n')}
-
-${colors.bright}EXAMPLES:${colors.reset}
-  ${colors.blue}npx frontend-hamroun create${colors.reset} my-app
-  ${colors.blue}npx frontend-hamroun create${colors.reset} my-app --template full-stack
-  `);
-}
-
-// Create project from template
-function createProject(projectName, options) {
-  const template = options.template || 'basic';
-  
-  // Check if template exists
-  if (!Object.keys(TEMPLATES).includes(template)) {
-    console.error(`${colors.red}error:${colors.reset} Template "${template}" not found.`);
-    console.log(`Available templates: ${Object.keys(TEMPLATES).join(', ')}`);
-    process.exit(1);
-  }
-  
-  // Check if project directory already exists
-  const projectPath = path.resolve(process.cwd(), projectName);
-  if (fs.existsSync(projectPath)) {
-    console.error(`${colors.red}error:${colors.reset} Directory ${projectName} already exists.`);
-    process.exit(1);
-  }
-  
-  console.log(`
-${colors.bright}Creating a new project with Frontend Hamroun...${colors.reset}
-${colors.blue}• Project name:${colors.reset} ${projectName}
-${colors.blue}• Template:${colors.reset} ${template}
-${colors.blue}• Directory:${colors.reset} ${projectPath}
-  `);
-  
-  try {
-    // Find templates directory
-    const templateDir = path.resolve(__dirname, '../templates', template);
-    
-    if (!fs.existsSync(templateDir)) {
-      console.error(`${colors.red}error:${colors.reset} Template directory not found: ${templateDir}`);
-      // Try to find template with -app suffix as fallback
-      const fallbackTemplateDir = path.resolve(__dirname, '../templates', `${template}-app`);
-      if (fs.existsSync(fallbackTemplateDir)) {
-        console.log(`${colors.yellow}Using fallback template:${colors.reset} ${template}-app`);
-        templateDir = fallbackTemplateDir;
-      } else {
-        process.exit(1);
-      }
-    }
-    
-    // Create project directory
-    fs.mkdirSync(projectPath, { recursive: true });
-    
-    // Copy template files (recursive function)
-    function copyDir(src, dest) {
-      const entries = fs.readdirSync(src, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-        
-        if (entry.isDirectory()) {
-          fs.mkdirSync(destPath, { recursive: true });
-          copyDir(srcPath, destPath);
-        } else {
-          fs.copyFileSync(srcPath, destPath);
-        }
-      }
-    }
-    
-    // Copy the files
-    copyDir(templateDir, projectPath);
-    console.log(`${colors.green}•${colors.reset} Copied template files`);
-    
-    // Update package.json with project name
-    const projectPackageJsonPath = path.join(projectPath, 'package.json');
-    if (fs.existsSync(projectPackageJsonPath)) {
-      const projectPackageJson = JSON.parse(fs.readFileSync(projectPackageJsonPath, 'utf8'));
-      projectPackageJson.name = projectName;
-      fs.writeFileSync(
-        projectPackageJsonPath, 
-        JSON.stringify(projectPackageJson, null, 2)
-      );
-    }
-    
-    // Install dependencies
-    if (!options.skipInstall) {
-      console.log(`\n${colors.blue}Installing dependencies...${colors.reset}`);
-      
-      try {
-        execSync(`npm install`, { 
-          cwd: projectPath, 
-          stdio: 'inherit' 
-        });
-      } catch (error) {
-        console.error(`\n${colors.red}Failed to install dependencies. You can install them manually:${colors.reset}`);
-        console.log(`  cd ${projectName} && npm install`);
-      }
-    }
-    
-    // Success message
-    console.log(`
-${colors.green}${colors.bright}Success!${colors.reset} Created ${projectName} at ${projectPath}
-
-${colors.blue}Inside that directory, you can run several commands:${colors.reset}
-
-  ${colors.bright}npm run dev${colors.reset}
-    Starts the development server.
-
-  ${colors.bright}npm run build${colors.reset}
-    Builds the app for production.
-
-  ${colors.bright}npm start${colors.reset}
-    Runs the built app in production mode.
-
-${colors.blue}We suggest that you begin by typing:${colors.reset}
-
-  ${colors.bright}cd${colors.reset} ${projectName}
-  ${colors.bright}npm run dev${colors.reset}
-
-${colors.green}Happy coding!${colors.reset}
-    `);
-    
-  } catch (error) {
-    console.error(`${colors.red}Failed to create project:${colors.reset}`, error);
-    process.exit(1);
-  }
-}
-
-// Parse command line arguments
-function parseArgs() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-  
-  if (!command || command === 'help') {
-    printBanner();
-    printHelp();
-    process.exit(0);
-  }
-  
-  if (command === 'version') {
-    console.log(`frontend-hamroun v${packageJson.version}`);
-    process.exit(0);
-  }
-  
-  if (command === 'create') {
-    const projectName = args[1];
-    
-    if (!projectName) {
-      console.error(`${colors.red}error:${colors.reset} Project name is required.`);
-      console.log(`Run ${colors.blue}npx frontend-hamroun help${colors.reset} for usage information.`);
-      process.exit(1);
-    }
-    
-    // Parse options
-    const options = {
-      template: 'basic',
-      skipInstall: false
-    };
-    
-    for (let i = 2; i < args.length; i++) {
-      if (args[i] === '--template' || args[i] === '-t') {
-        options.template = args[++i];
-      } else if (args[i] === '--skip-install' || args[i] === '-s') {
-        options.skipInstall = true;
-      }
-    }
-    
-    printBanner();
-    createProject(projectName, options);
-    return;
-  }
-  
-  console.error(`${colors.red}error:${colors.reset} Unknown command: ${command}`);
-  console.log(`Run ${colors.blue}npx frontend-hamroun help${colors.reset} for usage information.`);
-  process.exit(1);
-}
-
-// Run CLI
-parseArgs();

package/dist/backend/api-utils.d.ts

@@ -1,38 +0,0 @@
-import { Request, Response, NextFunction, Router } from 'express';
-import { ApiResponse, PaginationOptions, RouterOptions } from './types';
-/**
- * Creates a consistent API response structure
- */
-export declare function apiResponse<T>(success: boolean, data?: T, message?: string, error?: string, meta?: Record<string, any>): ApiResponse<T>;
-/**
- * Helper to send successful responses
- */
-export declare function sendSuccess<T>(res: Response, data?: T, message?: string, statusCode?: number, meta?: Record<string, any>): void;
-/**
- * Helper to send error responses
- */
-export declare function sendError(res: Response, error: string | Error, statusCode?: number, meta?: Record<string, any>): void;
-/**
- * Helper to extract pagination parameters from request
- */
-export declare function getPaginationParams(req: Request): PaginationOptions;
-/**
- * Middleware to extract and validate pagination parameters
- */
-export declare function paginationMiddleware(req: Request, res: Response, next: NextFunction): void;
-/**
- * Middleware for basic request validation
- */
-export declare function validateRequest(schema: any): (req: Request, res: Response, next: NextFunction) => void;
-/**
- * Create a new router with common middleware and options
- */
-export declare function createApiRouter(options?: RouterOptions, auth?: any): Router;
-/**
- * Wrap an async route handler to catch errors
- */
-export declare function asyncHandler(fn: (req: Request, res: Response, next: NextFunction) => Promise<any>): (req: Request, res: Response, next: NextFunction) => void;
-/**
- * Create standard REST endpoints for a model
- */
-export declare function createRestEndpoints<T>(model: any): import("express-serve-static-core").Router;

package/dist/backend/api-utils.js

@@ -1,135 +0,0 @@
-import { Router } from 'express';
-/**
- * Creates a consistent API response structure
- */
-export function apiResponse(success, data, message, error, meta) {
-    const response = { success };
-    if (data !== undefined)
-        response.data = data;
-    if (message)
-        response.message = message;
-    if (error)
-        response.error = error;
-    if (meta)
-        response.meta = meta;
-    return response;
-}
-/**
- * Helper to send successful responses
- */
-export function sendSuccess(res, data, message, statusCode = 200, meta) {
-    res.status(statusCode).json(apiResponse(true, data, message, undefined, meta));
-}
-/**
- * Helper to send error responses
- */
-export function sendError(res, error, statusCode = 400, meta) {
-    const errorMessage = error instanceof Error ? error.message : error;
-    res.status(statusCode).json(apiResponse(false, undefined, undefined, errorMessage, meta));
-}
-/**
- * Helper to extract pagination parameters from request
- */
-export function getPaginationParams(req) {
-    const page = parseInt(req.query.page) || 1;
-    const limit = parseInt(req.query.limit) || 10;
-    const sort = req.query.sort || 'createdAt';
-    const order = req.query.order === 'asc' ? 'asc' : 'desc';
-    return { page, limit, sort, order };
-}
-/**
- * Middleware to extract and validate pagination parameters
- */
-export function paginationMiddleware(req, res, next) {
-    req.pagination = getPaginationParams(req);
-    next();
-}
-/**
- * Middleware for basic request validation
- */
-export function validateRequest(schema) {
-    return (req, res, next) => {
-        try {
-            const { error, value } = schema.validate(req.body);
-            if (error) {
-                sendError(res, `Validation error: ${error.message}`, 400);
-                return;
-            }
-            // Replace request body with validated value
-            req.body = value;
-            next();
-        }
-        catch (err) {
-            sendError(res, 'Validation error', 400);
-        }
-    };
-}
-/**
- * Create a new router with common middleware and options
- */
-export function createApiRouter(options = {}, auth) {
-    const router = Router();
-    // Add authentication middleware if required
-    if (options.requireAuth && auth) {
-        router.use(auth.authenticate);
-        // Add role check if specified
-        if (options.requiredRole) {
-            router.use(auth.hasRole(options.requiredRole));
-        }
-    }
-    // Add rate limiting if specified
-    if (options.rateLimit) {
-        console.warn('Rate limiting is disabled: express-rate-limit dependency is not installed');
-        // Note: To use rate limiting, install express-rate-limit: npm install express-rate-limit
-    }
-    return router;
-}
-/**
- * Wrap an async route handler to catch errors
- */
-export function asyncHandler(fn) {
-    return (req, res, next) => {
-        fn(req, res, next).catch(next);
-    };
-}
-/**
- * Create standard REST endpoints for a model
- */
-export function createRestEndpoints(model) {
-    const router = Router();
-    // GET all with pagination
-    router.get('/', paginationMiddleware, asyncHandler(async (req, res) => {
-        const result = await model.getAll(req.pagination);
-        sendSuccess(res, result);
-    }));
-    // GET by ID
-    router.get('/:id', asyncHandler(async (req, res) => {
-        const item = await model.getById(req.params.id);
-        if (!item) {
-            return sendError(res, 'Item not found', 404);
-        }
-        sendSuccess(res, item);
-    }));
-    // POST new item
-    router.post('/', asyncHandler(async (req, res) => {
-        const newItem = await model.create(req.body);
-        sendSuccess(res, newItem, 'Item created successfully', 201);
-    }));
-    // PUT update item
-    router.put('/:id', asyncHandler(async (req, res) => {
-        const updatedItem = await model.update(req.params.id, req.body);
-        if (!updatedItem) {
-            return sendError(res, 'Item not found', 404);
-        }
-        sendSuccess(res, updatedItem, 'Item updated successfully');
-    }));
-    // DELETE item
-    router.delete('/:id', asyncHandler(async (req, res) => {
-        const result = await model.delete(req.params.id);
-        if (!result) {
-            return sendError(res, 'Item not found', 404);
-        }
-        sendSuccess(res, null, 'Item deleted successfully');
-    }));
-    return router;
-}

package/dist/backend/auth.d.ts

@@ -1,134 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-/**
- * Authentication configuration options
- */
-export interface AuthOptions {
-    /**
-     * Secret key for JWT signing
-     */
-    jwtSecret: string;
-    /**
-     * Secret key for refresh token signing (defaults to jwtSecret if not provided)
-     */
-    refreshSecret?: string;
-    /**
-     * JWT token expiration time (default: '15m')
-     */
-    tokenExpiration?: string;
-    /**
-     * Refresh token expiration time (default: '7d')
-     */
-    refreshExpiration?: string;
-    /**
-     * Number of bcrypt salt rounds (default: 10)
-     */
-    saltRounds?: number;
-    /**
-     * Custom user finder function
-     */
-    findUser?: (username: string) => Promise<any>;
-    /**
-     * Custom password verification (defaults to bcrypt compare)
-     */
-    verifyPassword?: (password: string, hashedPassword: string) => Promise<boolean>;
-    /**
-     * Custom function to save refresh token
-     */
-    saveRefreshToken?: (userId: string, token: string, expires: Date) => Promise<void>;
-    /**
-     * Custom function to verify refresh token
-     */
-    verifyRefreshToken?: (userId: string, token: string) => Promise<boolean>;
-    /**
-     * Use secure cookies for tokens (default: process.env.NODE_ENV === 'production')
-     */
-    secureCookies?: boolean;
-    /**
-     * Cookie domain
-     */
-    cookieDomain?: string;
-    /**
-     * Use HTTP-only cookies (default: true)
-     */
-    httpOnlyCookies?: boolean;
-    /**
-     * Implement rate limiting for login attempts (default: true)
-     */
-    rateLimit?: boolean;
-}
-/**
- * Token pair containing access and refresh tokens
- */
-export interface TokenPair {
-    accessToken: string;
-    refreshToken: string;
-    expiresIn: number;
-}
-/**
- * Authentication service
- */
-export declare class Auth {
-    private options;
-    private loginAttempts;
-    constructor(options: AuthOptions);
-    /**
-     * Hash a password using bcrypt
-     */
-    hashPassword(password: string): Promise<string>;
-    /**
-     * Verify a password against a hash using bcrypt
-     */
-    private verifyPasswordWithBcrypt;
-    /**
-     * Generate a cryptographically secure random token
-     */
-    generateSecureToken(length?: number): string;
-    /**
-     * Generate token pair (access token + refresh token)
-     */
-    generateTokenPair(payload: any): TokenPair;
-    /**
-     * Convert JWT expiration time to seconds
-     */
-    private getExpirationSeconds;
-    /**
-     * Verify a JWT token
-     */
-    verifyToken(token: string, type?: 'access' | 'refresh'): any;
-    /**
-     * Set authentication cookies
-     */
-    setAuthCookies(res: Response, tokens: TokenPair): void;
-    /**
-     * Clear authentication cookies
-     */
-    clearAuthCookies(res: Response): void;
-    /**
-     * Check and handle rate limiting
-     */
-    private checkRateLimit;
-    /**
-     * Login middleware to authenticate users
-     */
-    login: (req: Request, res: Response) => Promise<void>;
-    /**
-     * Refresh token handler
-     */
-    refreshToken: (req: Request, res: Response) => Promise<void>;
-    /**
-     * Logout handler
-     */
-    logout: (req: Request, res: Response) => Promise<void>;
-    /**
-     * Middleware to verify user is authenticated
-     */
-    authenticate: (req: Request, res: Response, next: NextFunction) => void;
-    /**
-     * Middleware to check if user has required role
-     */
-    hasRole: (role: string | string[]) => (req: Request, res: Response, next: NextFunction) => void;
-}
-/**
- * Create an authentication service
- */
-export declare function createAuth(options: AuthOptions): Auth;