frontend-hamroun 1.2.15 → 1.2.17

package/dist/backend/model.js

@@ -1,178 +0,0 @@
-import mongoose from 'mongoose';
-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(name, schema) {
-    // Create the Mongoose model
-    const mongooseModel = mongoose.model(name, schema);
-    // Return the model implementation with CRUD operations
-    return {
-        getAll: async (options) => {
-            try {
-                const { page = 1, limit = 10, sort = '_id', order = 'desc' } = options || {};
-                const skip = (page - 1) * limit;
-                const sortOrder = order === 'asc' ? 1 : -1;
-                const sortOptions = { [sort]: sortOrder };
-                const [results, total] = await Promise.all([
-                    mongooseModel.find()
-                        .sort(sortOptions)
-                        .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.message}`);
-            }
-        },
-        getById: async (id) => {
-            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.message}`);
-            }
-        },
-        create: async (data) => {
-            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.message}`);
-            }
-        },
-        createMany: async (data) => {
-            try {
-                return await mongooseModel.insertMany(data);
-            }
-            catch (error) {
-                console.error(`Error in ${name}.createMany:`, error);
-                throw new Error(`Failed to create multiple ${name} records: ${error.message}`);
-            }
-        },
-        update: async (id, data) => {
-            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.message}`);
-            }
-        },
-        delete: async (id) => {
-            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.message}`);
-            }
-        },
-        find: async (query, options) => {
-            try {
-                const { page = 1, limit = 10, sort = '_id', order = 'desc' } = options || {};
-                const skip = (page - 1) * limit;
-                const sortOrder = order === 'asc' ? 1 : -1;
-                const sortOptions = { [sort]: sortOrder };
-                const [results, total] = await Promise.all([
-                    mongooseModel.find(query)
-                        .sort(sortOptions)
-                        .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.message}`);
-            }
-        },
-        count: async (query) => {
-            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.message}`);
-            }
-        },
-        findOne: async (query) => {
-            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.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) => ({ ...fieldType, required: true }),
-    Unique: (fieldType) => ({ ...fieldType, unique: true }),
-    Ref: (model) => ({
-        type: String, // Fallback to String type for tests
-        ref: model
-    }),
-    Enum: (values) => ({ type: String, enum: values }),
-    Default: (fieldType, defaultValue) => ({ ...fieldType, default: defaultValue }),
-    // Array field type
-    Array: (fieldType) => ({ type: [fieldType] })
-};

package/dist/backend/router.d.ts

@@ -1,27 +0,0 @@
-import { Router, Request, Response, NextFunction } from 'express';
-import { Model, RouteContext } from './types';
-type RequestHandler = (context: RouteContext) => Promise<any> | any;
-type ErrorHandler = (error: any, context: RouteContext) => Promise<any> | any;
-/**
- * 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 declare function createModelRouter<T>(model: Model<T>, options?: RouteOptions): Router;
-/**
- * Creates a custom API router
- * @param routeConfig Custom route configuration
- * @param options Router options
- */
-export declare function createApiRouter(routeConfig: Record<string, {
-    method: 'get' | 'post' | 'put' | 'delete' | 'patch';
-    handler: RequestHandler;
-}>, options?: RouteOptions): Router;
-export { Router };

package/dist/backend/router.js

@@ -1,137 +0,0 @@
-import express, { Router } from 'express';
-// Default error handler with improved formatting and consistent response
-const defaultErrorHandler = (error, { res }) => {
-    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
-    });
-};
-/**
- * Creates a router for a data model with CRUD endpoints
- * @param model The data model
- * @param options Router options
- */
-export function createModelRouter(model, options = {}) {
-    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) => async (req, res, next) => {
-        try {
-            const context = { req, res, next, params: req.params, query: req.query, body: req.body };
-            return await handler(context);
-        }
-        catch (error) {
-            const context = { 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, options = {}) {
-    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) => async (req, res, next) => {
-        try {
-            const context = { 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 = { 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/dist/backend/server.d.ts

@@ -1,19 +0,0 @@
-import { Express } from 'express';
-import { RouterOptions, HamrounServerOptions, DatabaseOptions } from './types';
-import { DatabaseConnector } from './database';
-/**
- * Creates an Express server configured for Frontend Hamroun applications
- * @param options Server configuration options
- * @returns Configured Express application
- */
-export declare function createServer(options?: HamrounServerOptions): Express;
-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>;
-        }
-    }
-}

package/dist/backend/server.js

@@ -1,268 +0,0 @@
-import express from 'express';
-import path from 'path';
-import compression from 'compression';
-import helmet from 'helmet';
-import morgan from 'morgan';
-import { renderToString } from '../server-renderer';
-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 = {}) {
-    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, res, next) => {
-            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) => 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 = null;
-    // Method to connect to database with better error handling
-    app.connectToDatabase = async (dbOptions) => {
-        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 = {};
-    const ssrRoutes = {};
-    // Method to register API routes with better integration of auth middleware
-    app.registerApi = (routePath, router, 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, component, options = {}) => {
-        if (!ssrEnabled) {
-            console.log(`⚠️ SSR disabled: skipping registration of ${routePath}`);
-            return app;
-        }
-        ssrRoutes[routePath] = { component, options };
-        app.get(routePath, async (req, res, next) => {
-            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.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) => `<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) => `<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) => `<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, req, res, next) => {
-        console.error('Server error:', err);
-        // Determine status code
-        const statusCode = err.statusCode || err.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, res) => {
-        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) => {
-        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) => {
-            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;
-}