frontend-hamroun 1.1.90 → 1.2.0

package/dist/frontend-hamroun.es.js

@@ -0,0 +1,1680 @@
+import express, { Router } from "express";
+import { Router as Router2 } from "express";
+import path from "path";
+import compression from "compression";
+import helmet from "helmet";
+import morgan from "morgan";
+import mongoose from "mongoose";
+import fs from "fs";
+import jwt from "jsonwebtoken";
+import bcrypt from "bcrypt";
+const globalObj = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+function jsx(type, props, key) {
+  return {
+    type,
+    props: props || {},
+    key
+  };
+}
+function jsxs(type, props, key) {
+  return jsx(type, props, key);
+}
+function createElement$1(vnode) {
+  if (typeof vnode === "string" || typeof vnode === "number") {
+    return document.createTextNode(String(vnode));
+  }
+  if (typeof vnode.type === "function") {
+    const result = vnode.type(vnode.props);
+    return createElement$1(result);
+  }
+  const element = document.createElement(vnode.type);
+  Object.entries(vnode.props || {}).forEach(([name, value]) => {
+    if (name === "children") {
+      const children = Array.isArray(value) ? value : [value];
+      children.forEach((child) => {
+        if (child != null) {
+          const childElement = createElement$1(child);
+          if (process.env.NODE_ENV === "test" && typeof window !== "undefined") {
+            if (!globalObj.__renderStats) {
+              globalObj.__renderStats = {
+                elementsCreated: 0,
+                textNodesCreated: 0,
+                eventsAttached: 0,
+                renderTime: 0
+              };
+              if (typeof afterAll === "function") {
+                afterAll(() => {
+                  try {
+                    const fs2 = require("fs");
+                    const path2 = require("path");
+                    const statsPath = path2.resolve(process.cwd(), "jsx-runtime-stats.json");
+                    fs2.writeFileSync(statsPath, JSON.stringify(globalObj.__renderStats, null, 2));
+                    console.log(`JSX runtime stats written to ${statsPath}`);
+                  } catch (error) {
+                    console.error("Failed to write stats file:", error);
+                  }
+                });
+              }
+            }
+            if (childElement instanceof Text) {
+              globalObj.__renderStats.textNodesCreated++;
+            } else {
+              globalObj.__renderStats.elementsCreated++;
+            }
+          }
+          element.appendChild(childElement);
+        }
+      });
+    } else if (name.startsWith("on")) {
+      const eventName = name.toLowerCase().substring(2);
+      element.addEventListener(eventName, value);
+      if (process.env.NODE_ENV === "test" && typeof window !== "undefined" && globalObj.__renderStats) {
+        globalObj.__renderStats.eventsAttached++;
+      }
+    } else if (name === "className") {
+      element.setAttribute("class", value);
+    } else if (name === "style" && typeof value === "object") {
+      Object.entries(value).forEach(([styleProp, styleValue]) => {
+        element.style[styleProp] = String(styleValue);
+      });
+    } else {
+      element.setAttribute(name, value);
+    }
+  });
+  return element;
+}
+const Fragment = Symbol("Fragment");
+if (typeof window !== "undefined") {
+  window.jsx = jsx;
+  window.jsxs = jsxs;
+  window.Fragment = Fragment;
+}
+const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+async function createElement(vnode) {
+  var _a;
+  console.log("Creating element from:", vnode);
+  if (!isBrowser) {
+    if (vnode == null) {
+      return { nodeType: 3, textContent: "" };
+    }
+    if (typeof vnode === "boolean") {
+      return { nodeType: 3, textContent: "" };
+    }
+    if (typeof vnode === "number" || typeof vnode === "string") {
+      return { nodeType: 3, textContent: String(vnode) };
+    }
+    if (Array.isArray(vnode)) {
+      const fragment = { nodeType: 11, childNodes: [] };
+      for (const child of vnode) {
+        const node = await createElement(child);
+        fragment.childNodes.push(node);
+      }
+      return fragment;
+    }
+    if ("type" in vnode && vnode.props !== void 0) {
+      const { type, props } = vnode;
+      if (typeof type === "function") {
+        try {
+          const result = await type(props || {});
+          const node = await createElement(result);
+          return node;
+        } catch (error) {
+          console.error("Error rendering component:", error);
+          return { nodeType: 3, textContent: "" };
+        }
+      }
+      const element = {
+        nodeType: 1,
+        tagName: type,
+        attributes: {},
+        style: {},
+        childNodes: [],
+        setAttribute: function(key, value) {
+          this.attributes[key] = value;
+        },
+        appendChild: function(child) {
+          this.childNodes.push(child);
+        }
+      };
+      for (const [key, value] of Object.entries(props || {})) {
+        if (key === "children")
+          continue;
+        if (key.startsWith("on") && typeof value === "function") {
+          const eventName = key.toLowerCase().slice(2);
+          if (!element.__events) {
+            element.__events = {};
+          }
+          element.__events[eventName] = value;
+        } else if (key === "style" && typeof value === "object") {
+          Object.assign(element.style, value);
+        } else if (key === "className") {
+          element.setAttribute("class", String(value));
+        } else if (key !== "key" && key !== "ref") {
+          element.setAttribute(key, String(value));
+        }
+      }
+      const children = props == null ? void 0 : props.children;
+      if (children != null) {
+        const childArray = Array.isArray(children) ? children.flat() : [children];
+        for (const child of childArray) {
+          const childNode = await createElement(child);
+          element.appendChild(childNode);
+        }
+      }
+      return element;
+    }
+    return { nodeType: 3, textContent: String(vnode) };
+  }
+  if (vnode == null) {
+    return document.createTextNode("");
+  }
+  if (typeof vnode === "boolean") {
+    return document.createTextNode("");
+  }
+  if (typeof vnode === "number" || typeof vnode === "string") {
+    return document.createTextNode(String(vnode));
+  }
+  if (Array.isArray(vnode)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of vnode) {
+      const node = await createElement(child);
+      fragment.appendChild(node);
+    }
+    return fragment;
+  }
+  if ("type" in vnode && vnode.props !== void 0) {
+    const { type, props } = vnode;
+    if (typeof type === "function") {
+      try {
+        const result = await type(props || {});
+        const node = await createElement(result);
+        if (node instanceof Element) {
+          node.setAttribute("data-component-id", type.name || type.toString());
+        }
+        return node;
+      } catch (error) {
+        console.error("Error rendering component:", error);
+        return document.createTextNode("");
+      }
+    }
+    const element = document.createElement(type);
+    for (const [key, value] of Object.entries(props || {})) {
+      if (key === "children")
+        continue;
+      if (key.startsWith("on") && typeof value === "function") {
+        const eventName = key.toLowerCase().slice(2);
+        const existingHandler = (_a = element.__events) == null ? void 0 : _a[eventName];
+        if (existingHandler) {
+          element.removeEventListener(eventName, existingHandler);
+        }
+        element.addEventListener(eventName, value);
+        if (!element.__events) {
+          element.__events = {};
+        }
+        element.__events[eventName] = value;
+      } else if (key === "style" && typeof value === "object") {
+        Object.assign(element.style, value);
+      } else if (key === "className") {
+        element.setAttribute("class", String(value));
+      } else if (key !== "key" && key !== "ref") {
+        element.setAttribute(key, String(value));
+      }
+    }
+    const children = props == null ? void 0 : props.children;
+    if (children != null) {
+      const childArray = Array.isArray(children) ? children.flat() : [children];
+      for (const child of childArray) {
+        const childNode = await createElement(child);
+        element.appendChild(childNode);
+      }
+    }
+    return element;
+  }
+  return document.createTextNode(String(vnode));
+}
+class Component {
+  constructor(props = {}) {
+    this.state = {};
+    this.element = null;
+    this._mounted = false;
+    this.props = props;
+  }
+  componentDidMount() {
+  }
+  async setState(newState) {
+    const prevState = { ...this.state };
+    this.state = { ...prevState, ...newState };
+    console.log(`${this.constructor.name} state updated:`, {
+      prev: prevState,
+      next: this.state
+    });
+    await Promise.resolve();
+    if (this._mounted) {
+      await this.update();
+    } else {
+      await this.update();
+    }
+  }
+  _replayEvents(oldElement, newElement) {
+    const oldEvents = oldElement.__events || {};
+    Object.entries(oldEvents).forEach(([event, handler]) => {
+      newElement.addEventListener(event, handler);
+    });
+    newElement.__events = oldEvents;
+  }
+  _deepCloneWithEvents(node) {
+    const clone = node.cloneNode(false);
+    const events = node.__events || {};
+    clone.__events = events;
+    Object.entries(events).forEach(([event, handler]) => {
+      clone.addEventListener(event, handler);
+    });
+    Array.from(node.childNodes).forEach((child) => {
+      if (child instanceof HTMLElement) {
+        clone.appendChild(this._deepCloneWithEvents(child));
+      } else {
+        clone.appendChild(child.cloneNode(true));
+      }
+    });
+    return clone;
+  }
+  async update() {
+    const vdom = this.render();
+    if (!vdom)
+      return document.createTextNode("");
+    const rendered = await createElement(vdom);
+    if (rendered instanceof HTMLElement) {
+      return this._updateElement(rendered);
+    }
+    const wrapper = document.createElement("div");
+    wrapper.appendChild(rendered);
+    return this._updateElement(wrapper);
+  }
+  async _updateElement(rendered) {
+    const newElement = this._deepCloneWithEvents(rendered);
+    newElement.__instance = this;
+    if (!this.element) {
+      this.element = newElement;
+      if (!this._mounted) {
+        this._mounted = true;
+        queueMicrotask(() => this.componentDidMount());
+      }
+    } else if (this.element.parentNode) {
+      this.element.parentNode.replaceChild(newElement, this.element);
+      this.element = newElement;
+    }
+    return this.element;
+  }
+  render() {
+    throw new Error("Component must implement render() method");
+  }
+}
+let isBatching = false;
+const queue = [];
+function batchUpdates(fn) {
+  if (isBatching) {
+    queue.push(fn);
+    return;
+  }
+  isBatching = true;
+  try {
+    fn();
+    while (queue.length > 0) {
+      const nextFn = queue.shift();
+      nextFn == null ? void 0 : nextFn();
+    }
+  } finally {
+    isBatching = false;
+  }
+}
+let currentRender = 0;
+const states = /* @__PURE__ */ new Map();
+const stateIndices = /* @__PURE__ */ new Map();
+const effects = /* @__PURE__ */ new Map();
+const memos = /* @__PURE__ */ new Map();
+const refs = /* @__PURE__ */ new Map();
+let globalRenderCallback = null;
+let globalContainer = null;
+let currentElement = null;
+const isServer = typeof window === "undefined";
+const serverStates = /* @__PURE__ */ new Map();
+function setRenderCallback(callback, element, container) {
+  globalRenderCallback = callback;
+  globalContainer = container;
+  currentElement = element;
+}
+function prepareRender() {
+  currentRender++;
+  stateIndices.set(currentRender, 0);
+  return currentRender;
+}
+function finishRender() {
+  if (isServer) {
+    serverStates.delete(currentRender);
+  }
+  currentRender = 0;
+}
+function useState(initial) {
+  if (!currentRender) {
+    throw new Error("useState must be called within a render");
+  }
+  if (isServer) {
+    if (!serverStates.has(currentRender)) {
+      serverStates.set(currentRender, /* @__PURE__ */ new Map());
+    }
+    const componentState = serverStates.get(currentRender);
+    const index22 = stateIndices.get(currentRender) || 0;
+    if (!componentState.has(index22)) {
+      componentState.set(index22, initial);
+    }
+    const state2 = componentState.get(index22);
+    const setState2 = (newValue) => {
+    };
+    stateIndices.set(currentRender, index22 + 1);
+    return [state2, setState2];
+  }
+  if (!states.has(currentRender)) {
+    states.set(currentRender, []);
+  }
+  const componentStates = states.get(currentRender);
+  const index2 = stateIndices.get(currentRender);
+  if (index2 >= componentStates.length) {
+    componentStates.push(initial);
+  }
+  const state = componentStates[index2];
+  const setState = (newValue) => {
+    const nextValue = typeof newValue === "function" ? newValue(componentStates[index2]) : newValue;
+    if (componentStates[index2] === nextValue)
+      return;
+    componentStates[index2] = nextValue;
+    if (isBatching) {
+      batchUpdates(() => rerender(currentRender));
+    } else {
+      rerender(currentRender);
+    }
+  };
+  stateIndices.set(currentRender, index2 + 1);
+  return [state, setState];
+}
+function useEffect(callback, deps) {
+  if (!currentRender)
+    throw new Error("useEffect must be called within a render");
+  const effectIndex = stateIndices.get(currentRender);
+  if (!effects.has(currentRender)) {
+    effects.set(currentRender, []);
+  }
+  const componentEffects = effects.get(currentRender);
+  const prevEffect = componentEffects[effectIndex];
+  if (!prevEffect || !deps || !prevEffect.deps || deps.some((dep, i) => dep !== prevEffect.deps[i])) {
+    if (prevEffect == null ? void 0 : prevEffect.cleanup) {
+      prevEffect.cleanup();
+    }
+    queueMicrotask(() => {
+      const cleanup = callback() || void 0;
+      componentEffects[effectIndex] = { cleanup, deps };
+    });
+  }
+  stateIndices.set(currentRender, effectIndex + 1);
+}
+function useMemo(factory, deps) {
+  if (!currentRender)
+    throw new Error("useMemo must be called within a render");
+  const memoIndex = stateIndices.get(currentRender);
+  if (!memos.has(currentRender)) {
+    memos.set(currentRender, []);
+  }
+  const componentMemos = memos.get(currentRender);
+  const prevMemo = componentMemos[memoIndex];
+  if (!prevMemo || deps && deps.some((dep, i) => !Object.is(dep, prevMemo.deps[i]))) {
+    const value = factory();
+    componentMemos[memoIndex] = { value, deps };
+    stateIndices.set(currentRender, memoIndex + 1);
+    return value;
+  }
+  stateIndices.set(currentRender, memoIndex + 1);
+  return prevMemo.value;
+}
+function useRef(initial) {
+  if (!currentRender)
+    throw new Error("useRef must be called within a render");
+  const refIndex = stateIndices.get(currentRender);
+  if (!refs.has(currentRender)) {
+    refs.set(currentRender, []);
+  }
+  const componentRefs = refs.get(currentRender);
+  if (refIndex >= componentRefs.length) {
+    const ref2 = { current: initial };
+    componentRefs.push(ref2);
+    stateIndices.set(currentRender, refIndex + 1);
+    return ref2;
+  }
+  const ref = componentRefs[refIndex];
+  stateIndices.set(currentRender, refIndex + 1);
+  return ref;
+}
+async function rerender(rendererId) {
+  try {
+    const componentEffects = effects.get(rendererId);
+    if (componentEffects) {
+      componentEffects.forEach((effect) => {
+        if (effect.cleanup)
+          effect.cleanup();
+      });
+      effects.set(rendererId, []);
+    }
+    if (globalRenderCallback && globalContainer && currentElement) {
+      await globalRenderCallback(currentElement, globalContainer);
+    }
+  } catch (error) {
+    console.error("Error during rerender:", error);
+  }
+}
+function useErrorBoundary() {
+  const [error, setError] = useState(null);
+  return [error, () => setError(null)];
+}
+let isHydrating = false;
+async function hydrate(element, container) {
+  isHydrating = true;
+  try {
+    await render(element, container);
+  } finally {
+    isHydrating = false;
+  }
+}
+async function render(element, container) {
+  console.log("Rendering to:", container.id || "unnamed-container");
+  batchUpdates(async () => {
+    const rendererId = prepareRender();
+    try {
+      setRenderCallback(render, element, container);
+      const domNode = await createElement(element);
+      if (!isHydrating) {
+        container.innerHTML = "";
+      }
+      if (isHydrating && container.firstChild) {
+        console.log("Hydrating existing DOM");
+      } else {
+        container.appendChild(domNode);
+      }
+    } finally {
+      finishRender();
+    }
+  });
+}
+async function renderToString(element) {
+  prepareRender();
+  setRenderCallback(() => {
+  }, element, null);
+  try {
+    if (element == null)
+      return "";
+    if (typeof element === "boolean")
+      return "";
+    if (typeof element === "number" || typeof element === "string") {
+      return escapeHtml(String(element));
+    }
+    if (Array.isArray(element)) {
+      const children = await Promise.all(element.map(renderToString));
+      return children.join("");
+    }
+    if ("type" in element && element.props !== void 0) {
+      const { type, props } = element;
+      if (typeof type === "function") {
+        try {
+          prepareRender();
+          const result = await type(props || {});
+          const html2 = await renderToString(result);
+          finishRender();
+          return html2;
+        } catch (error) {
+          console.error("Error rendering component:", error);
+          return "";
+        }
+      }
+      if (type === Symbol.for("react.fragment") || type.name === "Fragment") {
+        if (props.children) {
+          const children = Array.isArray(props.children) ? props.children : [props.children];
+          const renderedChildren = await Promise.all(children.map(renderToString));
+          return renderedChildren.join("");
+        }
+        return "";
+      }
+      let html = `<${type}`;
+      for (const [key, value] of Object.entries(props || {})) {
+        if (key === "children" || key === "key")
+          continue;
+        if (key === "className") {
+          html += ` class="${escapeHtml(String(value))}"`;
+        } else if (key === "style" && typeof value === "object") {
+          html += ` style="${stringifyStyle(value || {})}"`;
+        } else if (!key.startsWith("on")) {
+          html += ` ${key}="${escapeHtml(String(value))}"`;
+        }
+      }
+      const voidElements = /* @__PURE__ */ new Set([
+        "area",
+        "base",
+        "br",
+        "col",
+        "embed",
+        "hr",
+        "img",
+        "input",
+        "link",
+        "meta",
+        "param",
+        "source",
+        "track",
+        "wbr"
+      ]);
+      if (voidElements.has(type)) {
+        return html + "/>";
+      }
+      html += ">";
+      if (props == null ? void 0 : props.children) {
+        const children = Array.isArray(props.children) ? props.children : [props.children];
+        for (const child of children) {
+          html += await renderToString(child);
+        }
+      }
+      return html + `</${type}>`;
+    }
+    return escapeHtml(String(element));
+  } finally {
+    finishRender();
+  }
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function stringifyStyle(style) {
+  return Object.entries(style).map(([key, value]) => `${hyphenate(key)}:${value}`).join(";");
+}
+function hyphenate(str) {
+  return str.replace(/[A-Z]/g, (match) => "-" + match.toLowerCase());
+}
+class DatabaseConnector {
+  // Renamed from isConnected to _connected
+  constructor(options) {
+    this.connection = null;
+    this._connected = false;
+    this.options = {
+      retryAttempts: 3,
+      retryDelay: 1e3,
+      connectionTimeout: 1e4,
+      autoIndex: true,
+      ...options
+    };
+  }
+  /**
+   * Connect to the database
+   */
+  async connect() {
+    try {
+      if (this._connected && this.connection) {
+        return this.connection;
+      }
+      mongoose.set("strictQuery", true);
+      let attempts = 0;
+      while (attempts < (this.options.retryAttempts || 3)) {
+        try {
+          await mongoose.connect(this.options.uri, {
+            dbName: this.options.name,
+            connectTimeoutMS: this.options.connectionTimeout,
+            autoIndex: this.options.autoIndex,
+            ...this.options.options
+          });
+          break;
+        } catch (error) {
+          attempts++;
+          if (attempts >= (this.options.retryAttempts || 3)) {
+            throw error;
+          }
+          console.log(`Connection attempt ${attempts} failed. Retrying in ${this.options.retryDelay}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, this.options.retryDelay));
+        }
+      }
+      this.connection = mongoose.connection;
+      this._connected = true;
+      console.log(`Connected to MongoDB at ${this.options.uri}/${this.options.name}`);
+      this.connection.on("error", (err) => {
+        console.error("MongoDB connection error:", err);
+        this._connected = false;
+      });
+      this.connection.on("disconnected", () => {
+        console.log("MongoDB disconnected");
+        this._connected = false;
+      });
+      return this.connection;
+    } catch (error) {
+      console.error("Failed to connect to MongoDB:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from the database
+   */
+  async disconnect() {
+    if (this.connection) {
+      await mongoose.disconnect();
+      this._connected = false;
+      this.connection = null;
+      console.log("Disconnected from MongoDB");
+    }
+  }
+  /**
+   * Check if connected to the database
+   */
+  isConnected() {
+    return this._connected;
+  }
+  /**
+   * Get the mongoose connection
+   */
+  getConnection() {
+    return this.connection;
+  }
+}
+function createServer(options = {}) {
+  const app = express();
+  const {
+    port = 3e3,
+    staticDir = "public",
+    enableCors = true,
+    apiPrefix = "/api",
+    ssrEnabled = true,
+    middlewares = [],
+    enableCompression = true,
+    enableHelmet = true,
+    logFormat = "dev",
+    trustProxy = false,
+    showErrorDetails = process.env.NODE_ENV !== "production"
+  } = options;
+  if (trustProxy) {
+    app.set("trust proxy", trustProxy);
+  }
+  app.use(express.json());
+  app.use(express.urlencoded({ extended: true }));
+  if (enableCompression) {
+    app.use(compression());
+  }
+  if (enableHelmet) {
+    app.use(helmet({
+      contentSecurityPolicy: options.disableCSP ? false : void 0
+    }));
+  }
+  if (logFormat) {
+    app.use(morgan(logFormat));
+  }
+  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();
+    });
+  }
+  middlewares.forEach((middleware) => app.use(middleware));
+  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}`);
+    }
+  }
+  let dbConnector = null;
+  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");
+      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;
+    }
+  };
+  const routes = {};
+  const ssrRoutes = {};
+  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;
+  };
+  app.registerSSR = (routePath, component, options2 = {}) => {
+    if (!ssrEnabled) {
+      console.log(`⚠️ SSR disabled: skipping registration of ${routePath}`);
+      return app;
+    }
+    ssrRoutes[routePath] = { component, options: options2 };
+    app.get(routePath, async (req, res, next) => {
+      try {
+        if (req.query.nossr === "true") {
+          return next();
+        }
+        const props = {
+          req,
+          res,
+          params: req.params,
+          query: req.query,
+          user: req.user,
+          ...options2.props
+        };
+        const html = await renderToString(component(props));
+        res.send(`
+          <!DOCTYPE html>
+          <html lang="${options2.lang || "en"}">
+            <head>
+              <meta charset="UTF-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1.0">
+              <title>${options2.title || "Frontend Hamroun App"}</title>
+              ${options2.meta ? options2.meta.map((meta) => `<meta ${Object.entries(meta).map(([k, v]) => `${k}="${v}"`).join(" ")}>`).join("\n              ") : ""}
+              ${options2.head || ""}
+              ${options2.styles ? `<style>${options2.styles}</style>` : ""}
+              ${options2.styleSheets ? options2.styleSheets.map((sheet) => `<link rel="stylesheet" href="${sheet}">`).join("\n              ") : ""}
+            </head>
+            <body ${options2.bodyAttributes || ""}>
+              <div id="${options2.rootId || "root"}">${html}</div>
+              <script>
+                window.__INITIAL_DATA__ = ${JSON.stringify(options2.initialData || {})};
+              <\/script>
+              ${options2.scripts ? options2.scripts.map((script) => `<script src="${script}"><\/script>`).join("\n              ") : ""}
+            </body>
+          </html>
+        `);
+      } catch (error) {
+        console.error("SSR Error:", error);
+        if (options2.fallback) {
+          return next();
+        }
+        res.status(500).send("Server rendering error");
+      }
+    });
+    console.log(`🖥️  SSR registered: ${routePath}`);
+    return app;
+  };
+  app.use((err, req, res, next) => {
+    console.error("Server error:", err);
+    const statusCode = err.statusCode || err.status || 500;
+    const isApiRequest = req.path.startsWith(apiPrefix);
+    if (isApiRequest) {
+      res.status(statusCode).json({
+        success: false,
+        error: showErrorDetails ? err.message : "Internal Server Error",
+        stack: showErrorDetails ? err.stack : void 0
+      });
+    } else {
+      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>
+      `);
+    }
+  });
+  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>
+      `);
+    }
+  });
+  app.start = (callback) => {
+    const server = app.listen(port, () => {
+      console.log(`
+🚀 Frontend Hamroun server running at http://localhost:${port}
+${Object.keys(routes).length > 0 ? `
+📡 Registered API Routes:
+${Object.keys(routes).map((route) => `  ${route}`).join("\n")}` : ""}
+${Object.keys(ssrRoutes).length > 0 ? `
+🖥️  Registered SSR Routes:
+${Object.keys(ssrRoutes).map((route) => `  ${route}`).join("\n")}` : ""}
+      `);
+      if (callback)
+        callback();
+    });
+    const gracefulShutdown = async (signal) => {
+      console.log(`${signal} signal received: closing HTTP server and cleaning up`);
+      server.close(async () => {
+        console.log("HTTP server closed");
+        if (dbConnector && dbConnector.isConnected()) {
+          await dbConnector.disconnect();
+          console.log("Database connection closed");
+        }
+        process.exit(0);
+      });
+      setTimeout(() => {
+        console.error("Could not close connections in time, forcefully shutting down");
+        process.exit(1);
+      }, 1e4);
+    };
+    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+    return server;
+  };
+  return app;
+}
+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 : void 0
+  });
+};
+function createModelRouter(model, options = {}) {
+  const router = express.Router();
+  const { middleware = [], errorHandler = defaultErrorHandler } = options;
+  middleware.forEach((mw) => router.use(mw));
+  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);
+    }
+  };
+  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
+    });
+  }));
+  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
+    });
+  }));
+  router.post("/", handleRoute(async ({ body, res }) => {
+    const newItem = await model.create(body);
+    res.status(201).json({
+      success: true,
+      data: newItem,
+      message: "Item created successfully"
+    });
+  }));
+  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"
+    });
+  }));
+  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;
+}
+function createApiRouter$1(routeConfig, options = {}) {
+  const router = express.Router();
+  const { middleware = [], errorHandler = defaultErrorHandler } = options;
+  middleware.forEach((mw) => router.use(mw));
+  const handleRoute = (handler) => async (req, res, next) => {
+    try {
+      const context = { req, res, next, params: req.params, query: req.query, body: req.body };
+      if (res.headersSent) {
+        return;
+      }
+      return await handler(context);
+    } catch (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);
+    }
+  };
+  Object.entries(routeConfig).forEach(([path2, config]) => {
+    const { method, handler } = config;
+    router[method](path2, handleRoute(handler));
+  });
+  return router;
+}
+function apiResponse(success, data, message, error, meta) {
+  const response = { success };
+  if (data !== void 0)
+    response.data = data;
+  if (message)
+    response.message = message;
+  if (error)
+    response.error = error;
+  if (meta)
+    response.meta = meta;
+  return response;
+}
+function sendSuccess(res, data, message, statusCode = 200, meta) {
+  res.status(statusCode).json(apiResponse(true, data, message, void 0, meta));
+}
+function sendError(res, error, statusCode = 400, meta) {
+  const errorMessage = error instanceof Error ? error.message : error;
+  res.status(statusCode).json(apiResponse(false, void 0, void 0, errorMessage, meta));
+}
+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 };
+}
+function paginationMiddleware(req, res, next) {
+  req.pagination = getPaginationParams(req);
+  next();
+}
+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;
+      }
+      req.body = value;
+      next();
+    } catch (err) {
+      sendError(res, "Validation error", 400);
+    }
+  };
+}
+function createApiRouter(options = {}, auth) {
+  const router = Router();
+  if (options.requireAuth && auth) {
+    router.use(auth.authenticate);
+    if (options.requiredRole) {
+      router.use(auth.hasRole(options.requiredRole));
+    }
+  }
+  if (options.rateLimit) {
+    console.warn("Rate limiting is disabled: express-rate-limit dependency is not installed");
+  }
+  return router;
+}
+function asyncHandler(fn) {
+  return (req, res, next) => {
+    fn(req, res, next).catch(next);
+  };
+}
+function createRestEndpoints(model) {
+  const router = Router();
+  router.get("/", paginationMiddleware, asyncHandler(async (req, res) => {
+    const result = await model.getAll(req.pagination);
+    sendSuccess(res, result);
+  }));
+  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);
+  }));
+  router.post("/", asyncHandler(async (req, res) => {
+    const newItem = await model.create(req.body);
+    sendSuccess(res, newItem, "Item created successfully", 201);
+  }));
+  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");
+  }));
+  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;
+}
+const crypto = {};
+class Auth {
+  constructor(options) {
+    this.loginAttempts = /* @__PURE__ */ new Map();
+    this.login = async (req, res) => {
+      try {
+        const { username, password } = req.body;
+        const ip = req.ip || req.connection.remoteAddress || "";
+        if (!this.checkRateLimit(ip)) {
+          res.status(429).json({
+            success: false,
+            message: "Too many login attempts. Please try again later."
+          });
+          return;
+        }
+        if (!username || !password) {
+          res.status(400).json({
+            success: false,
+            message: "Username and password are required"
+          });
+          return;
+        }
+        if (!this.options.findUser) {
+          res.status(500).json({
+            success: false,
+            message: "User finder function not configured"
+          });
+          return;
+        }
+        const user = await this.options.findUser(username);
+        if (!user) {
+          res.status(401).json({
+            success: false,
+            message: "Invalid credentials"
+          });
+          return;
+        }
+        const isPasswordValid = await this.options.verifyPassword(
+          password,
+          user.password
+        );
+        if (!isPasswordValid) {
+          res.status(401).json({
+            success: false,
+            message: "Invalid credentials"
+          });
+          return;
+        }
+        const userWithoutPassword = { ...user };
+        delete userWithoutPassword.password;
+        const tokenPair = this.generateTokenPair({
+          id: user.id || user._id,
+          username: user.username,
+          role: user.role || "user"
+        });
+        if (this.options.saveRefreshToken) {
+          const refreshExpiry = /* @__PURE__ */ new Date();
+          refreshExpiry.setSeconds(refreshExpiry.getSeconds() + this.getExpirationSeconds(this.options.refreshExpiration || "7d"));
+          await this.options.saveRefreshToken(
+            user.id || user._id,
+            tokenPair.refreshToken,
+            refreshExpiry
+          );
+        }
+        if (req.body.useCookies) {
+          this.setAuthCookies(res, tokenPair);
+        }
+        res.json({
+          success: true,
+          message: "Authentication successful",
+          tokens: tokenPair,
+          user: userWithoutPassword
+        });
+      } catch (error) {
+        console.error("Authentication error:", error);
+        res.status(500).json({
+          success: false,
+          message: "Authentication failed",
+          error: process.env.NODE_ENV !== "production" ? error.message : void 0
+        });
+      }
+    };
+    this.refreshToken = async (req, res) => {
+      var _a, _b;
+      try {
+        const refreshToken = ((_a = req.cookies) == null ? void 0 : _a.refreshToken) || req.body.refreshToken;
+        if (!refreshToken) {
+          res.status(401).json({
+            success: false,
+            message: "Refresh token required"
+          });
+          return;
+        }
+        const decoded = this.verifyToken(refreshToken, "refresh");
+        if (this.options.verifyRefreshToken) {
+          const isValid = await this.options.verifyRefreshToken(decoded.id, refreshToken);
+          if (!isValid) {
+            this.clearAuthCookies(res);
+            res.status(401).json({
+              success: false,
+              message: "Invalid refresh token"
+            });
+            return;
+          }
+        }
+        const tokenPair = this.generateTokenPair({
+          id: decoded.id,
+          // We need to fetch the user data again for complete payload
+          ...this.options.findUser ? await this.options.findUser(decoded.id) : {}
+        });
+        if (this.options.saveRefreshToken) {
+          const refreshExpiry = /* @__PURE__ */ new Date();
+          refreshExpiry.setSeconds(refreshExpiry.getSeconds() + this.getExpirationSeconds(this.options.refreshExpiration || "7d"));
+          await this.options.saveRefreshToken(
+            decoded.id,
+            tokenPair.refreshToken,
+            refreshExpiry
+          );
+        }
+        const useCookies = ((_b = req.cookies) == null ? void 0 : _b.accessToken) || req.body.useCookies;
+        if (useCookies) {
+          this.setAuthCookies(res, tokenPair);
+        }
+        res.json({
+          success: true,
+          message: "Token refreshed successfully",
+          tokens: tokenPair
+        });
+      } catch (error) {
+        this.clearAuthCookies(res);
+        res.status(401).json({
+          success: false,
+          message: "Invalid or expired refresh token",
+          error: process.env.NODE_ENV !== "production" ? error.message : void 0
+        });
+      }
+    };
+    this.logout = async (req, res) => {
+      var _a;
+      try {
+        this.clearAuthCookies(res);
+        const refreshToken = ((_a = req.cookies) == null ? void 0 : _a.refreshToken) || req.body.refreshToken;
+        if (refreshToken && this.options.saveRefreshToken) {
+          try {
+            const decoded = this.verifyToken(refreshToken, "refresh");
+            if (typeof this.options.saveRefreshToken === "function") {
+              await this.options.saveRefreshToken(decoded.id, "", /* @__PURE__ */ new Date());
+            }
+          } catch (e) {
+          }
+        }
+        res.json({ success: true, message: "Logged out successfully" });
+      } catch (error) {
+        console.error("Logout error:", error);
+        res.status(500).json({ success: false, message: "Logout failed", error: error.message });
+      }
+    };
+    this.authenticate = (req, res, next) => {
+      var _a;
+      try {
+        let token = (_a = req.cookies) == null ? void 0 : _a.accessToken;
+        if (!token) {
+          const authHeader = req.headers.authorization;
+          if (authHeader && authHeader.startsWith("Bearer ")) {
+            token = authHeader.split(" ")[1];
+          }
+        }
+        if (!token) {
+          res.status(401).json({
+            success: false,
+            message: "Authentication required"
+          });
+          return;
+        }
+        const decoded = this.verifyToken(token, "access");
+        req.user = decoded;
+        next();
+      } catch (error) {
+        res.status(401).json({
+          success: false,
+          message: "Invalid or expired token",
+          error: process.env.NODE_ENV !== "production" ? error.message : void 0
+        });
+      }
+    };
+    this.hasRole = (role) => {
+      return (req, res, next) => {
+        const user = req.user;
+        if (!user) {
+          res.status(401).json({
+            success: false,
+            message: "Authentication required"
+          });
+          return;
+        }
+        const roles = Array.isArray(role) ? role : [role];
+        if (roles.includes(user.role)) {
+          next();
+        } else {
+          res.status(403).json({
+            success: false,
+            message: "Insufficient permissions"
+          });
+        }
+      };
+    };
+    this.options = {
+      tokenExpiration: "15m",
+      refreshExpiration: "7d",
+      saltRounds: 10,
+      secureCookies: process.env.NODE_ENV === "production",
+      httpOnlyCookies: true,
+      rateLimit: true,
+      ...options,
+      refreshSecret: options.refreshSecret || options.jwtSecret
+    };
+    if (!options.jwtSecret) {
+      throw new Error("JWT secret is required for authentication");
+    }
+    if (!this.options.verifyPassword) {
+      this.options.verifyPassword = this.verifyPasswordWithBcrypt;
+    }
+  }
+  /**
+   * Hash a password using bcrypt
+   */
+  async hashPassword(password) {
+    return await bcrypt.hash(password, this.options.saltRounds || 10);
+  }
+  /**
+   * Verify a password against a hash using bcrypt
+   */
+  async verifyPasswordWithBcrypt(password, hashedPassword) {
+    return await bcrypt.compare(password, hashedPassword);
+  }
+  /**
+   * Generate a cryptographically secure random token
+   */
+  generateSecureToken(length = 32) {
+    return crypto.randomBytes(length).toString("hex");
+  }
+  /**
+   * Generate token pair (access token + refresh token)
+   */
+  generateTokenPair(payload) {
+    const expiresIn = this.getExpirationSeconds(this.options.tokenExpiration || "15m");
+    const accessToken = jwt.sign(
+      { ...payload, type: "access" },
+      this.options.jwtSecret,
+      { expiresIn: this.options.tokenExpiration }
+    );
+    const refreshToken = jwt.sign(
+      { id: payload.id, type: "refresh" },
+      this.options.refreshSecret,
+      { expiresIn: this.options.refreshExpiration }
+    );
+    return {
+      accessToken,
+      refreshToken,
+      expiresIn
+    };
+  }
+  /**
+   * Convert JWT expiration time to seconds
+   */
+  getExpirationSeconds(expiration) {
+    const unit = expiration.charAt(expiration.length - 1);
+    const value = parseInt(expiration.slice(0, -1));
+    switch (unit) {
+      case "s":
+        return value;
+      case "m":
+        return value * 60;
+      case "h":
+        return value * 60 * 60;
+      case "d":
+        return value * 60 * 60 * 24;
+      default:
+        return 3600;
+    }
+  }
+  /**
+   * Verify a JWT token
+   */
+  verifyToken(token, type = "access") {
+    try {
+      const secret = type === "access" ? this.options.jwtSecret : this.options.refreshSecret;
+      const decoded = jwt.verify(token, secret);
+      if (typeof decoded === "object" && decoded.type !== type) {
+        throw new Error("Invalid token type");
+      }
+      return decoded;
+    } catch (error) {
+      throw new Error("Invalid or expired token");
+    }
+  }
+  /**
+   * Set authentication cookies
+   */
+  setAuthCookies(res, tokens) {
+    res.cookie("accessToken", tokens.accessToken, {
+      httpOnly: this.options.httpOnlyCookies,
+      secure: this.options.secureCookies,
+      domain: this.options.cookieDomain,
+      sameSite: "strict",
+      maxAge: tokens.expiresIn * 1e3
+    });
+    const refreshExpiresIn = this.getExpirationSeconds(this.options.refreshExpiration || "7d");
+    res.cookie("refreshToken", tokens.refreshToken, {
+      httpOnly: true,
+      // Always HTTP only for refresh tokens
+      secure: this.options.secureCookies,
+      domain: this.options.cookieDomain,
+      sameSite: "strict",
+      maxAge: refreshExpiresIn * 1e3,
+      path: "/api/auth/refresh"
+      // Restrict to refresh endpoint
+    });
+  }
+  /**
+   * Clear authentication cookies
+   */
+  clearAuthCookies(res) {
+    res.clearCookie("accessToken");
+    res.clearCookie("refreshToken", { path: "/api/auth/refresh" });
+  }
+  /**
+   * Check and handle rate limiting
+   */
+  checkRateLimit(ip) {
+    if (!this.options.rateLimit) {
+      return true;
+    }
+    const now = Date.now();
+    const attempt = this.loginAttempts.get(ip);
+    if (!attempt) {
+      this.loginAttempts.set(ip, { count: 1, resetTime: now + 36e5 });
+      return true;
+    }
+    if (now > attempt.resetTime) {
+      this.loginAttempts.set(ip, { count: 1, resetTime: now + 36e5 });
+      return true;
+    }
+    if (attempt.count >= 5) {
+      return false;
+    }
+    attempt.count++;
+    this.loginAttempts.set(ip, attempt);
+    return true;
+  }
+}
+function createAuth(options) {
+  return new Auth(options);
+}
+function createModel(name, schema) {
+  const mongooseModel = mongoose.model(name, schema);
+  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 {
+        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 {
+        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 {
+        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}`);
+      }
+    }
+  };
+}
+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] })
+};
+const index = {
+  // Frontend
+  jsx,
+  jsxs,
+  createElement: createElement$1,
+  Fragment,
+  Component,
+  useState,
+  useEffect,
+  useRef,
+  useMemo,
+  useErrorBoundary,
+  render,
+  hydrate,
+  renderToString,
+  prepareRender,
+  finishRender,
+  batchUpdates,
+  // Backend
+  createServer,
+  Router,
+  createApiRouter
+};
+export {
+  Component,
+  DatabaseConnector,
+  FieldTypes,
+  Fragment,
+  Router2 as Router,
+  apiResponse,
+  asyncHandler,
+  batchUpdates,
+  createApiRouter,
+  createAuth,
+  createApiRouter$1 as createCustomRouter,
+  createElement$1 as createElement,
+  createModel,
+  createModelRouter,
+  createRestEndpoints,
+  createServer,
+  index as default,
+  finishRender,
+  getPaginationParams,
+  hydrate,
+  jsx,
+  jsxs,
+  paginationMiddleware,
+  prepareRender,
+  render,
+  renderToString,
+  sendError,
+  sendSuccess,
+  useEffect,
+  useErrorBoundary,
+  useMemo,
+  useRef,
+  useState,
+  validateRequest
+};
+//# sourceMappingURL=frontend-hamroun.es.js.map