frontend-hamroun 1.2.15 → 1.2.17

package/src/backend/model.ts

@@ -1,198 +0,0 @@
-import mongoose, { Schema, Document, SortOrder } from 'mongoose';
-import { Model, PaginationOptions, PaginatedResult } from './types';
-import * as bcryptModule from 'bcrypt';
-const bcrypt = bcryptModule.default || bcryptModule;
-
-/**
- * Creates a data model from a Mongoose schema
- * @param name Model name
- * @param schema Mongoose schema definition
- * @returns Model implementation with CRUD operations
- */
-export function createModel<T extends Document>(
-  name: string, 
-  schema: Schema<T>
-): Model<T> {
-  // Create the Mongoose model
-  const mongooseModel = mongoose.model<T>(name, schema);
-  
-  // Return the model implementation with CRUD operations
-  return {
-    getAll: async (options?: PaginationOptions): Promise<PaginatedResult<T>> => {
-      try {
-        const { page = 1, limit = 10, sort = '_id', order = 'desc' } = options || {};
-        
-        const skip = (page - 1) * limit;
-        const sortOrder = order === 'asc' ? 1 : -1;
-        const sortOptions: Record<string, SortOrder> = { [sort]: sortOrder };
-        
-        const [results, total] = await Promise.all([
-          mongooseModel.find()
-            .sort(sortOptions as any)
-            .skip(skip)
-            .limit(limit)
-            .exec(),
-          mongooseModel.countDocuments().exec()
-        ]);
-        
-        const totalPages = Math.ceil(total / limit);
-        
-        return {
-          data: results,
-          pagination: {
-            total,
-            totalPages,
-            currentPage: page,
-            limit,
-            hasNextPage: page < totalPages,
-            hasPrevPage: page > 1
-          }
-        };
-      } catch (error) {
-        console.error(`Error in ${name}.getAll:`, error);
-        throw new Error(`Failed to retrieve ${name} records: ${(error as Error).message}`);
-      }
-    },
-    
-    getById: async (id: string): Promise<T | null> => {
-      try {
-        // Validate ObjectId format to prevent DB errors
-        if (!mongoose.isValidObjectId(id)) {
-          return null;
-        }
-        return await mongooseModel.findById(id).exec();
-      } catch (error) {
-        console.error(`Error in ${name}.getById:`, error);
-        throw new Error(`Failed to retrieve ${name} by ID: ${(error as Error).message}`);
-      }
-    },
-    
-    create: async (data: Partial<T>): Promise<T> => {
-      try {
-        const newDocument = new mongooseModel(data);
-        return await newDocument.save();
-      } catch (error) {
-        console.error(`Error in ${name}.create:`, error);
-        throw new Error(`Failed to create ${name}: ${(error as Error).message}`);
-      }
-    },
-    
-    createMany: async (data: Partial<T>[]): Promise<T[]> => {
-      try {
-        return await mongooseModel.insertMany(data) as unknown as T[];
-      } catch (error) {
-        console.error(`Error in ${name}.createMany:`, error);
-        throw new Error(`Failed to create multiple ${name} records: ${(error as Error).message}`);
-      }
-    },
-    
-    update: async (id: string, data: Partial<T>): Promise<T | null> => {
-      try {
-        // Validate ObjectId format to prevent DB errors
-        if (!mongoose.isValidObjectId(id)) {
-          return null;
-        }
-        return await mongooseModel.findByIdAndUpdate(
-          id, 
-          { $set: data }, 
-          { new: true, runValidators: true }
-        ).exec();
-      } catch (error) {
-        console.error(`Error in ${name}.update:`, error);
-        throw new Error(`Failed to update ${name}: ${(error as Error).message}`);
-      }
-    },
-    
-    delete: async (id: string): Promise<boolean> => {
-      try {
-        // Validate ObjectId format to prevent DB errors
-        if (!mongoose.isValidObjectId(id)) {
-          return false;
-        }
-        const result = await mongooseModel.findByIdAndDelete(id).exec();
-        return result !== null;
-      } catch (error) {
-        console.error(`Error in ${name}.delete:`, error);
-        throw new Error(`Failed to delete ${name}: ${(error as Error).message}`);
-      }
-    },
-    
-    find: async (query: Record<string, any>, options?: PaginationOptions): Promise<PaginatedResult<T>> => {
-      try {
-        const { page = 1, limit = 10, sort = '_id', order = 'desc' } = options || {};
-        
-        const skip = (page - 1) * limit;
-        const sortOrder = order === 'asc' ? 1 : -1;
-        const sortOptions: Record<string, SortOrder> = { [sort]: sortOrder };
-        
-        const [results, total] = await Promise.all([
-          mongooseModel.find(query)
-            .sort(sortOptions as any)
-            .skip(skip)
-            .limit(limit)
-            .exec(),
-          mongooseModel.countDocuments(query).exec()
-        ]);
-        
-        const totalPages = Math.ceil(total / limit);
-        
-        return {
-          data: results,
-          pagination: {
-            total,
-            totalPages,
-            currentPage: page,
-            limit,
-            hasNextPage: page < totalPages,
-            hasPrevPage: page > 1
-          }
-        };
-      } catch (error) {
-        console.error(`Error in ${name}.find:`, error);
-        throw new Error(`Failed to find ${name} records: ${(error as Error).message}`);
-      }
-    },
-    
-    count: async (query?: Record<string, any>): Promise<number> => {
-      try {
-        return await mongooseModel.countDocuments(query || {}).exec();
-      } catch (error) {
-        console.error(`Error in ${name}.count:`, error);
-        throw new Error(`Failed to count ${name} records: ${(error as Error).message}`);
-      }
-    },
-    
-    findOne: async (query: Record<string, any>): Promise<T | null> => {
-      try {
-        return await mongooseModel.findOne(query).exec();
-      } catch (error) {
-        console.error(`Error in ${name}.findOne:`, error);
-        throw new Error(`Failed to find ${name} record: ${(error as Error).message}`);
-      }
-    }
-  };
-}
-
-/**
- * Schema field types for simplified schema creation
- */
-export const FieldTypes = {
-  String: { type: String },
-  Number: { type: Number },
-  Boolean: { type: Boolean },
-  Date: { type: Date },
-  ObjectId: { type: String }, // Fallback to String instead of using Schema.Types.ObjectId
-  
-  // Helper functions for common field patterns
-  Required: (fieldType: any) => ({ ...fieldType, required: true }),
-  Unique: (fieldType: any) => ({ ...fieldType, unique: true }),
-  Ref: (model: string) => ({ 
-    type: String,  // Fallback to String type for tests
-    ref: model 
-  }),
-  Enum: (values: any[]) => ({ type: String, enum: values }),
-  Default: (fieldType: any, defaultValue: any) => ({ ...fieldType, default: defaultValue }),
-  
-  // Array field type
-  Array: (fieldType: any) => ({ type: [fieldType] })
-};

package/src/backend/router.ts

@@ -1,176 +0,0 @@
-import express, { Router, Request, Response, NextFunction } from 'express';
-import { Model, RouteContext } from './types';
-
-// Handler types
-type RequestHandler = (context: RouteContext) => Promise<any> | any;
-type ErrorHandler = (error: any, context: RouteContext) => Promise<any> | any;
-
-// Default error handler with improved formatting and consistent response
-const defaultErrorHandler = (error: any, { res }: RouteContext) => {
-  console.error('API Error:', error);
-  const status = error.status || error.statusCode || 500;
-  const message = error.message || 'Internal server error';
-  res.status(status).json({ 
-    success: false, 
-    error: message,
-    stack: process.env.NODE_ENV !== 'production' ? error.stack : undefined
-  });
-};
-
-/**
- * Options for API route creation
- */
-interface RouteOptions {
-  middleware?: ((req: Request, res: Response, next: NextFunction) => void)[];
-  errorHandler?: ErrorHandler;
-}
-
-/**
- * Creates a router for a data model with CRUD endpoints
- * @param model The data model
- * @param options Router options
- */
-export function createModelRouter<T>(
-  model: Model<T>,
-  options: RouteOptions = {}
-): Router {
-  const router = express.Router();
-  const { middleware = [], errorHandler = defaultErrorHandler } = options;
-
-  // Apply middleware
-  middleware.forEach(mw => router.use(mw));
-  
-  // Helper to wrap handlers with error handling
-  const handleRoute = (handler: RequestHandler) => async (req: Request, res: Response, next: NextFunction) => {
-    try {
-      const context: RouteContext = { req, res, next, params: req.params, query: req.query, body: req.body };
-      return await handler(context);
-    } catch (error) {
-      const context: RouteContext = { req, res, next, params: req.params, query: req.query, body: req.body };
-      return errorHandler(error, context);
-    }
-  };
-  
-  // GET all items with pagination
-  router.get('/', handleRoute(async ({ req, res }) => {
-    const paginationOptions = req.pagination || { page: 1, limit: 10 };
-    const result = await model.getAll(paginationOptions);
-    res.json({ 
-      success: true,
-      ...result
-    });
-  }));
-  
-  // GET item by ID
-  router.get('/:id', handleRoute(async ({ params, res }) => {
-    const item = await model.getById(params.id);
-    if (!item) {
-      res.status(404).json({ 
-        success: false,
-        error: 'Item not found' 
-      });
-      return;
-    }
-    res.json({ 
-      success: true,
-      data: item 
-    });
-  }));
-  
-  // POST new item
-  router.post('/', handleRoute(async ({ body, res }) => {
-    const newItem = await model.create(body);
-    res.status(201).json({ 
-      success: true,
-      data: newItem,
-      message: 'Item created successfully'
-    });
-  }));
-  
-  // PUT update item
-  router.put('/:id', handleRoute(async ({ params, body, res }) => {
-    const updatedItem = await model.update(params.id, body);
-    if (!updatedItem) {
-      res.status(404).json({ 
-        success: false,
-        error: 'Item not found' 
-      });
-      return;
-    }
-    res.json({ 
-      success: true,
-      data: updatedItem,
-      message: 'Item updated successfully'
-    });
-  }));
-  
-  // DELETE item
-  router.delete('/:id', handleRoute(async ({ params, res }) => {
-    const success = await model.delete(params.id);
-    if (!success) {
-      res.status(404).json({ 
-        success: false,
-        error: 'Item not found' 
-      });
-      return;
-    }
-    res.json({ 
-      success: true,
-      message: 'Item deleted successfully'
-    });
-  }));
-  
-  return router;
-}
-
-/**
- * Creates a custom API router
- * @param routeConfig Custom route configuration
- * @param options Router options
- */
-export function createApiRouter(
-  routeConfig: Record<string, { 
-    method: 'get' | 'post' | 'put' | 'delete' | 'patch',
-    handler: RequestHandler 
-  }>,
-  options: RouteOptions = {}
-): Router {
-  const router = express.Router();
-  const { middleware = [], errorHandler = defaultErrorHandler } = options;
-  
-  // Apply middleware
-  middleware.forEach(mw => router.use(mw));
-  
-  // Helper to wrap handlers with error handling
-  const handleRoute = (handler: RequestHandler) => async (req: Request, res: Response, next: NextFunction) => {
-    try {
-      const context: RouteContext = { req, res, next, params: req.params, query: req.query, body: req.body };
-      
-      // Check if response is already sent before calling handler
-      if (res.headersSent) {
-        return;
-      }
-      
-      return await handler(context);
-    } catch (error) {
-      // If response is already sent, just log the error
-      if (res.headersSent) {
-        console.error('Error occurred after response was sent:', error);
-        return;
-      }
-      
-      const context: RouteContext = { req, res, next, params: req.params, query: req.query, body: req.body };
-      return errorHandler(error, context);
-    }
-  };
-  
-  // Create routes from config
-  Object.entries(routeConfig).forEach(([path, config]) => {
-    const { method, handler } = config;
-    router[method](path, handleRoute(handler));
-  });
-  
-  return router;
-}
-
-export { Router };

package/src/backend/server.ts

@@ -1,330 +0,0 @@
-import express, { Express, Request, Response, NextFunction } from 'express';
-import path from 'path';
-import compression from 'compression';
-import helmet from 'helmet';
-import morgan from 'morgan';
-import { renderToString } from '../server-renderer';
-import { RouterOptions, HamrounServerOptions, DatabaseOptions } from './types';
-import { DatabaseConnector } from './database';
-import fs from 'fs';
-
-/**
- * Creates an Express server configured for Frontend Hamroun applications
- * @param options Server configuration options
- * @returns Configured Express application
- */
-export function createServer(options: HamrounServerOptions = {}): Express {
-  const app = express();
-  const {
-    port = 3000,
-    staticDir = 'public',
-    enableCors = true,
-    apiPrefix = '/api',
-    ssrEnabled = true,
-    middlewares = [],
-    enableCompression = true,
-    enableHelmet = true,
-    logFormat = 'dev',
-    trustProxy = false,
-    showErrorDetails = process.env.NODE_ENV !== 'production',
-  } = options;
-
-  // Trust proxy if enabled
-  if (trustProxy) {
-    app.set('trust proxy', trustProxy);
-  }
-
-  // Basic middleware
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
-  
-  // Compression middleware
-  if (enableCompression) {
-    app.use(compression());
-  }
-  
-  // Security middleware
-  if (enableHelmet) {
-    app.use(helmet({
-      contentSecurityPolicy: options.disableCSP ? false : undefined,
-    }));
-  }
-  
-  // Request logging
-  if (logFormat) {
-    app.use(morgan(logFormat));
-  }
-  
-  // CORS if enabled
-  if (enableCors) {
-    app.use((req: Request, res: Response, next: NextFunction) => {
-      res.header('Access-Control-Allow-Origin', '*');
-      res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
-      res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
-      if (req.method === 'OPTIONS') {
-        return res.sendStatus(200);
-      }
-      next();
-    });
-  }
-
-  // Apply custom middlewares
-  middlewares.forEach((middleware: any) => app.use(middleware));
-  
-  // Serve static files with appropriate caching
-  if (staticDir) {
-    const staticPath = path.resolve(process.cwd(), staticDir);
-    if (fs.existsSync(staticPath)) {
-      app.use(express.static(staticPath, {
-        maxAge: options.staticCacheAge || '1d',
-        etag: true,
-      }));
-      console.log(`📂 Serving static files from: ${staticPath}`);
-    } else {
-      console.warn(`⚠️ Static directory not found: ${staticPath}`);
-    }
-  }
-
-  // Database connection reference
-  let dbConnector: DatabaseConnector | null = null;
-
-  // Method to connect to database with better error handling
-  app.connectToDatabase = async (dbOptions: DatabaseOptions): Promise<DatabaseConnector> => {
-    try {
-      if (dbConnector && dbConnector.isConnected()) {
-        console.log('✅ Using existing database connection');
-        return dbConnector;
-      }
-      
-      dbConnector = new DatabaseConnector(dbOptions);
-      await dbConnector.connect();
-      console.log('✅ Database connected successfully');
-      
-      // Add disconnect handler for graceful shutdown
-      process.on('SIGTERM', async () => {
-        if (dbConnector && dbConnector.isConnected()) {
-          await dbConnector.disconnect();
-          console.log('Database connection closed');
-        }
-      });
-      
-      return dbConnector;
-    } catch (error) {
-      console.error('❌ Failed to connect to database:', error);
-      throw error;
-    }
-  };
-
-  // Store registered routes for better management
-  const routes: Record<string, any> = {};
-  const ssrRoutes: Record<string, any> = {};
-
-  // Method to register API routes with better integration of auth middleware
-  app.registerApi = (routePath: string, router: any, routerOptions: RouterOptions = {}) => {
-    try {
-      const { prefix = apiPrefix } = routerOptions;
-      const fullPath = path.posix.join(prefix, routePath).replace(/\\/g, '/');
-      app.use(fullPath, router);
-      routes[fullPath] = { router, options: routerOptions };
-      console.log(`🔌 API registered: ${fullPath}`);
-    } catch (error) {
-      console.error(`❌ Failed to register API at ${routePath}:`, error);
-    }
-    return app;
-  };
-
-  // Method to register SSR handler with better error handling
-  app.registerSSR = (routePath: string, component: any, options: any = {}) => {
-    if (!ssrEnabled) {
-      console.log(`⚠️ SSR disabled: skipping registration of ${routePath}`);
-      return app;
-    }
-    
-    ssrRoutes[routePath] = { component, options };
-    
-    app.get(routePath, async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        // Skip SSR if requested via query param
-        if (req.query.nossr === 'true') {
-          return next();
-        }
-        
-        // Setup props for the component
-        const props = {
-          req, 
-          res,
-          params: req.params,
-          query: req.query,
-          user: (req as any).user,
-          ...options.props
-        };
-        
-        // Server-side render the component
-        const html = await renderToString(component(props));
-        
-        // Send the full HTML document
-        res.send(`
-          <!DOCTYPE html>
-          <html lang="${options.lang || 'en'}">
-            <head>
-              <meta charset="UTF-8">
-              <meta name="viewport" content="width=device-width, initial-scale=1.0">
-              <title>${options.title || 'Frontend Hamroun App'}</title>
-              ${options.meta ? options.meta.map((meta: any) => 
-                `<meta ${Object.entries(meta).map(([k, v]) => `${k}="${v}"`).join(' ')}>`)
-                .join('\n              ') : ''}
-              ${options.head || ''}
-              ${options.styles ? `<style>${options.styles}</style>` : ''}
-              ${options.styleSheets ? options.styleSheets.map((sheet: string) => 
-                `<link rel="stylesheet" href="${sheet}">`).join('\n              ') : ''}
-            </head>
-            <body ${options.bodyAttributes || ''}>
-              <div id="${options.rootId || 'root'}">${html}</div>
-              <script>
-                window.__INITIAL_DATA__ = ${JSON.stringify(options.initialData || {})};
-              </script>
-              ${options.scripts ? options.scripts.map((script: string) => 
-                `<script src="${script}"></script>`).join('\n              ') : ''}
-            </body>
-          </html>
-        `);
-      } catch (error) {
-        console.error('SSR Error:', error);
-        
-        // If fallback is enabled, continue to next middleware
-        if (options.fallback) {
-          return next();
-        }
-        
-        res.status(500).send('Server rendering error');
-      }
-    });
-    
-    console.log(`🖥️  SSR registered: ${routePath}`);
-    return app;
-  };
-
-  // Global error handler with better formatting
-  app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
-    console.error('Server error:', err);
-    
-    // Determine status code
-    const statusCode = (err as any).statusCode || (err as any).status || 500;
-    
-    // Format error response based on the request
-    const isApiRequest = req.path.startsWith(apiPrefix);
-    
-    if (isApiRequest) {
-      // API error response
-      res.status(statusCode).json({
-        success: false,
-        error: showErrorDetails ? err.message : 'Internal Server Error',
-        stack: showErrorDetails ? err.stack : undefined
-      });
-    } else {
-      // Web error response
-      res.status(statusCode).send(`
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <title>Error - ${statusCode}</title>
-            <style>
-              body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
-              .error { background: #f8d7da; border: 1px solid #f5c6cb; padding: 1rem; border-radius: 4px; }
-              .stack { background: #f8f9fa; padding: 1rem; border-radius: 4px; overflow: auto; }
-            </style>
-          </head>
-          <body>
-            <h1>Error ${statusCode}</h1>
-            <div class="error">${showErrorDetails ? err.message : 'Internal Server Error'}</div>
-            ${showErrorDetails && err.stack ? `<pre class="stack">${err.stack}</pre>` : ''}
-          </body>
-        </html>
-      `);
-    }
-  });
-
-  // 404 handler
-  app.use((req: Request, res: Response) => {
-    const isApiRequest = req.path.startsWith(apiPrefix);
-    
-    if (isApiRequest) {
-      res.status(404).json({ success: false, error: 'Not Found' });
-    } else {
-      res.status(404).send(`
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <title>404 - Not Found</title>
-            <style>
-              body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
-            </style>
-          </head>
-          <body>
-            <h1>404 - Not Found</h1>
-            <p>The requested resource was not found on this server.</p>
-            <p><a href="/">Return to homepage</a></p>
-          </body>
-        </html>
-      `);
-    }
-  });
-
-  // Start the server with graceful shutdown
-  app.start = (callback?: () => void) => {
-    const server = app.listen(port, () => {
-      console.log(`
-🚀 Frontend Hamroun server running at http://localhost:${port}
-${Object.keys(routes).length > 0 ? `\n📡 Registered API Routes:
-${Object.keys(routes).map(route => `  ${route}`).join('\n')}` : ''}
-${Object.keys(ssrRoutes).length > 0 ? `\n🖥️  Registered SSR Routes:
-${Object.keys(ssrRoutes).map(route => `  ${route}`).join('\n')}` : ''}
-      `);
-      
-      if (callback) callback();
-    });
-    
-    // Graceful shutdown
-    const gracefulShutdown = async (signal: string) => {
-      console.log(`${signal} signal received: closing HTTP server and cleaning up`);
-      
-      server.close(async () => {
-        console.log('HTTP server closed');
-        
-        // Close database connection if it exists
-        if (dbConnector && dbConnector.isConnected()) {
-          await dbConnector.disconnect();
-          console.log('Database connection closed');
-        }
-        
-        process.exit(0);
-      });
-      
-      // Force close after timeout
-      setTimeout(() => {
-        console.error('Could not close connections in time, forcefully shutting down');
-        process.exit(1);
-      }, 10000);
-    };
-    
-    // Listen for termination signals
-    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-    
-    return server;
-  };
-
-  return app;
-}
-
-// Update the global Express Application interface
-declare global {
-  namespace Express {
-    interface Application {
-      registerApi: (routePath: string, router: any, options?: RouterOptions) => Application;
-      registerSSR: (routePath: string, component: any, options?: any) => Application;
-      start: (callback?: () => void) => any;
-      connectToDatabase: (dbOptions: DatabaseOptions) => Promise<DatabaseConnector>;
-    }
-  }
-}