frontend-hamroun 1.1.90 → 1.2.0

package/dist/backend/model.js

@@ -0,0 +1,176 @@
+import mongoose from 'mongoose';
+/**
+ * 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/{src/backend → backend}/router.d.ts

@@ -24,4 +24,4 @@ export declare function createApiRouter(routeConfig: Record<string, {
     method: 'get' | 'post' | 'put' | 'delete' | 'patch';
     handler: RequestHandler;
 }>, options?: RouteOptions): Router;
-export {};
+export { Router };

package/dist/backend/router.js

@@ -0,0 +1,137 @@
+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.js

@@ -0,0 +1,268 @@
+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;
+}

package/dist/batch.js

@@ -0,0 +1,22 @@
+export let isBatching = false;
+const queue = [];
+export function batchUpdates(fn) {
+    if (isBatching) {
+        queue.push(fn);
+        return;
+    }
+    isBatching = true;
+    try {
+        fn();
+        while (queue.length > 0) {
+            const nextFn = queue.shift();
+            nextFn?.();
+        }
+    }
+    finally {
+        isBatching = false;
+    }
+}
+export function getIsBatching() {
+    return isBatching;
+}

package/dist/cli/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/{src/component.d.ts → component.d.ts}

@@ -8,7 +8,7 @@ export declare class Component {
     setState(newState: any): Promise<void>;
     private _replayEvents;
     private _deepCloneWithEvents;
-    update(): Promise<HTMLElement | Text>;
+    update(): Promise<Text | HTMLElement>;
     private _updateElement;
     render(): any;
 }