@webtypen/webframez-react 0.0.14 → 0.0.15

package/dist/http.cjs

@@ -429,6 +429,7 @@ function createFileRouter(options) {
   const pagesDir = options.pagesDir;
   const layoutPath = import_node_path2.default.join(pagesDir, "layout.js");
   const errorPath = import_node_path2.default.join(pagesDir, "errors.js");
+  const middlewaresPath = import_node_path2.default.join(pagesDir, "middlewares.js");
   function buildRouteEntries() {
     const files = walkFiles(pagesDir);
     return files.map((filePath) => toRouteEntry(pagesDir, filePath)).filter((entry) => entry !== null).sort((a, b) => {
@@ -471,6 +472,75 @@ function createFileRouter(options) {
       head: mergeHead(layoutHead, errorHead)
     };
   }
+  function normalizeMiddlewareNames(config) {
+    if (!config) {
+      return [];
+    }
+    return Array.isArray(config) ? config : [config];
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+  function mergeRouteData(currentData, nextData) {
+    if (typeof nextData === "undefined") {
+      return currentData;
+    }
+    if (isPlainObject(currentData) && isPlainObject(nextData)) {
+      return {
+        ...currentData,
+        ...nextData
+      };
+    }
+    return nextData;
+  }
+  async function resolveMiddlewares(config, context) {
+    const middlewareNames = normalizeMiddlewareNames(config);
+    const requiresNamedMiddleware = middlewareNames.length > 0;
+    if (!import_node_fs.default.existsSync(middlewaresPath)) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const middlewareModule = resolveModule(middlewaresPath);
+    const registry = middlewareModule.middlewares;
+    if (!registry) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const orderedMiddlewareNames = typeof registry["*"] === "function" ? ["*", ...middlewareNames] : middlewareNames;
+    if (orderedMiddlewareNames.length === 0) {
+      return context;
+    }
+    let nextContext = context;
+    for (const middlewareName of orderedMiddlewareNames) {
+      const middleware = registry[middlewareName];
+      if (typeof middleware !== "function") {
+        throw createAbort({
+          status: 500,
+          message: `Invalid middleware '${middlewareName}'`
+        });
+      }
+      const middlewareData = await middleware(nextContext);
+      nextContext = {
+        ...nextContext,
+        data: mergeRouteData(nextContext.data, middlewareData)
+      };
+    }
+    return nextContext;
+  }
   async function resolve(input) {
     const pathname = normalizePathname(input.pathname);
     const contextBase = {
@@ -496,10 +566,12 @@ function createFileRouter(options) {
       activeContext = context;
       const pageModule = resolveModule(match.entry.filePath);
       const layoutModule = import_node_fs.default.existsSync(layoutPath) ? resolveModule(layoutPath) : null;
-      const pageData = await resolvePageData(pageModule, context);
+      const middlewareContext = await resolveMiddlewares(pageModule.middlewares, context);
+      activeContext = middlewareContext;
+      const pageData = await resolvePageData(pageModule, middlewareContext);
       const pageContext = {
-        ...context,
-        data: pageData
+        ...middlewareContext,
+        data: mergeRouteData(middlewareContext.data, pageData)
       };
       activeContext = pageContext;
       const pageNode = await pageModule.default(pageContext);

package/dist/http.js

@@ -404,6 +404,7 @@ function createFileRouter(options) {
   const pagesDir = options.pagesDir;
   const layoutPath = path2.join(pagesDir, "layout.js");
   const errorPath = path2.join(pagesDir, "errors.js");
+  const middlewaresPath = path2.join(pagesDir, "middlewares.js");
   function buildRouteEntries() {
     const files = walkFiles(pagesDir);
     return files.map((filePath) => toRouteEntry(pagesDir, filePath)).filter((entry) => entry !== null).sort((a, b) => {
@@ -446,6 +447,75 @@ function createFileRouter(options) {
       head: mergeHead(layoutHead, errorHead)
     };
   }
+  function normalizeMiddlewareNames(config) {
+    if (!config) {
+      return [];
+    }
+    return Array.isArray(config) ? config : [config];
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+  function mergeRouteData(currentData, nextData) {
+    if (typeof nextData === "undefined") {
+      return currentData;
+    }
+    if (isPlainObject(currentData) && isPlainObject(nextData)) {
+      return {
+        ...currentData,
+        ...nextData
+      };
+    }
+    return nextData;
+  }
+  async function resolveMiddlewares(config, context) {
+    const middlewareNames = normalizeMiddlewareNames(config);
+    const requiresNamedMiddleware = middlewareNames.length > 0;
+    if (!fs.existsSync(middlewaresPath)) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const middlewareModule = resolveModule(middlewaresPath);
+    const registry = middlewareModule.middlewares;
+    if (!registry) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const orderedMiddlewareNames = typeof registry["*"] === "function" ? ["*", ...middlewareNames] : middlewareNames;
+    if (orderedMiddlewareNames.length === 0) {
+      return context;
+    }
+    let nextContext = context;
+    for (const middlewareName of orderedMiddlewareNames) {
+      const middleware = registry[middlewareName];
+      if (typeof middleware !== "function") {
+        throw createAbort({
+          status: 500,
+          message: `Invalid middleware '${middlewareName}'`
+        });
+      }
+      const middlewareData = await middleware(nextContext);
+      nextContext = {
+        ...nextContext,
+        data: mergeRouteData(nextContext.data, middlewareData)
+      };
+    }
+    return nextContext;
+  }
   async function resolve(input) {
     const pathname = normalizePathname(input.pathname);
     const contextBase = {
@@ -471,10 +541,12 @@ function createFileRouter(options) {
       activeContext = context;
       const pageModule = resolveModule(match.entry.filePath);
       const layoutModule = fs.existsSync(layoutPath) ? resolveModule(layoutPath) : null;
-      const pageData = await resolvePageData(pageModule, context);
+      const middlewareContext = await resolveMiddlewares(pageModule.middlewares, context);
+      activeContext = middlewareContext;
+      const pageData = await resolvePageData(pageModule, middlewareContext);
       const pageContext = {
-        ...context,
-        data: pageData
+        ...middlewareContext,
+        data: mergeRouteData(middlewareContext.data, pageData)
       };
       activeContext = pageContext;
       const pageNode = await pageModule.default(pageContext);

package/dist/index.cjs

@@ -462,6 +462,7 @@ function createFileRouter(options) {
   const pagesDir = options.pagesDir;
   const layoutPath = import_node_path2.default.join(pagesDir, "layout.js");
   const errorPath = import_node_path2.default.join(pagesDir, "errors.js");
+  const middlewaresPath = import_node_path2.default.join(pagesDir, "middlewares.js");
   function buildRouteEntries() {
     const files = walkFiles(pagesDir);
     return files.map((filePath) => toRouteEntry(pagesDir, filePath)).filter((entry) => entry !== null).sort((a, b) => {
@@ -504,6 +505,75 @@ function createFileRouter(options) {
       head: mergeHead(layoutHead, errorHead)
     };
   }
+  function normalizeMiddlewareNames(config) {
+    if (!config) {
+      return [];
+    }
+    return Array.isArray(config) ? config : [config];
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+  function mergeRouteData(currentData, nextData) {
+    if (typeof nextData === "undefined") {
+      return currentData;
+    }
+    if (isPlainObject(currentData) && isPlainObject(nextData)) {
+      return {
+        ...currentData,
+        ...nextData
+      };
+    }
+    return nextData;
+  }
+  async function resolveMiddlewares(config, context) {
+    const middlewareNames = normalizeMiddlewareNames(config);
+    const requiresNamedMiddleware = middlewareNames.length > 0;
+    if (!import_node_fs.default.existsSync(middlewaresPath)) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const middlewareModule = resolveModule(middlewaresPath);
+    const registry = middlewareModule.middlewares;
+    if (!registry) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const orderedMiddlewareNames = typeof registry["*"] === "function" ? ["*", ...middlewareNames] : middlewareNames;
+    if (orderedMiddlewareNames.length === 0) {
+      return context;
+    }
+    let nextContext = context;
+    for (const middlewareName of orderedMiddlewareNames) {
+      const middleware = registry[middlewareName];
+      if (typeof middleware !== "function") {
+        throw createAbort({
+          status: 500,
+          message: `Invalid middleware '${middlewareName}'`
+        });
+      }
+      const middlewareData = await middleware(nextContext);
+      nextContext = {
+        ...nextContext,
+        data: mergeRouteData(nextContext.data, middlewareData)
+      };
+    }
+    return nextContext;
+  }
   async function resolve(input) {
     const pathname = normalizePathname(input.pathname);
     const contextBase = {
@@ -529,10 +599,12 @@ function createFileRouter(options) {
       activeContext = context;
       const pageModule = resolveModule(match.entry.filePath);
       const layoutModule = import_node_fs.default.existsSync(layoutPath) ? resolveModule(layoutPath) : null;
-      const pageData = await resolvePageData(pageModule, context);
+      const middlewareContext = await resolveMiddlewares(pageModule.middlewares, context);
+      activeContext = middlewareContext;
+      const pageData = await resolvePageData(pageModule, middlewareContext);
       const pageContext = {
-        ...context,
-        data: pageData
+        ...middlewareContext,
+        data: mergeRouteData(middlewareContext.data, pageData)
       };
       activeContext = pageContext;
       const pageNode = await pageModule.default(pageContext);

package/dist/index.js

@@ -426,6 +426,7 @@ function createFileRouter(options) {
   const pagesDir = options.pagesDir;
   const layoutPath = path2.join(pagesDir, "layout.js");
   const errorPath = path2.join(pagesDir, "errors.js");
+  const middlewaresPath = path2.join(pagesDir, "middlewares.js");
   function buildRouteEntries() {
     const files = walkFiles(pagesDir);
     return files.map((filePath) => toRouteEntry(pagesDir, filePath)).filter((entry) => entry !== null).sort((a, b) => {
@@ -468,6 +469,75 @@ function createFileRouter(options) {
       head: mergeHead(layoutHead, errorHead)
     };
   }
+  function normalizeMiddlewareNames(config) {
+    if (!config) {
+      return [];
+    }
+    return Array.isArray(config) ? config : [config];
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+  function mergeRouteData(currentData, nextData) {
+    if (typeof nextData === "undefined") {
+      return currentData;
+    }
+    if (isPlainObject(currentData) && isPlainObject(nextData)) {
+      return {
+        ...currentData,
+        ...nextData
+      };
+    }
+    return nextData;
+  }
+  async function resolveMiddlewares(config, context) {
+    const middlewareNames = normalizeMiddlewareNames(config);
+    const requiresNamedMiddleware = middlewareNames.length > 0;
+    if (!fs.existsSync(middlewaresPath)) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const middlewareModule = resolveModule(middlewaresPath);
+    const registry = middlewareModule.middlewares;
+    if (!registry) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const orderedMiddlewareNames = typeof registry["*"] === "function" ? ["*", ...middlewareNames] : middlewareNames;
+    if (orderedMiddlewareNames.length === 0) {
+      return context;
+    }
+    let nextContext = context;
+    for (const middlewareName of orderedMiddlewareNames) {
+      const middleware = registry[middlewareName];
+      if (typeof middleware !== "function") {
+        throw createAbort({
+          status: 500,
+          message: `Invalid middleware '${middlewareName}'`
+        });
+      }
+      const middlewareData = await middleware(nextContext);
+      nextContext = {
+        ...nextContext,
+        data: mergeRouteData(nextContext.data, middlewareData)
+      };
+    }
+    return nextContext;
+  }
   async function resolve(input) {
     const pathname = normalizePathname(input.pathname);
     const contextBase = {
@@ -493,10 +563,12 @@ function createFileRouter(options) {
       activeContext = context;
       const pageModule = resolveModule(match.entry.filePath);
       const layoutModule = fs.existsSync(layoutPath) ? resolveModule(layoutPath) : null;
-      const pageData = await resolvePageData(pageModule, context);
+      const middlewareContext = await resolveMiddlewares(pageModule.middlewares, context);
+      activeContext = middlewareContext;
+      const pageData = await resolvePageData(pageModule, middlewareContext);
       const pageContext = {
-        ...context,
-        data: pageData
+        ...middlewareContext,
+        data: mergeRouteData(middlewareContext.data, pageData)
       };
       activeContext = pageContext;
       const pageNode = await pageModule.default(pageContext);

package/dist/router.cjs

@@ -298,6 +298,7 @@ function createFileRouter(options) {
   const pagesDir = options.pagesDir;
   const layoutPath = import_node_path.default.join(pagesDir, "layout.js");
   const errorPath = import_node_path.default.join(pagesDir, "errors.js");
+  const middlewaresPath = import_node_path.default.join(pagesDir, "middlewares.js");
   function buildRouteEntries() {
     const files = walkFiles(pagesDir);
     return files.map((filePath) => toRouteEntry(pagesDir, filePath)).filter((entry) => entry !== null).sort((a, b) => {
@@ -340,6 +341,75 @@ function createFileRouter(options) {
       head: mergeHead(layoutHead, errorHead)
     };
   }
+  function normalizeMiddlewareNames(config) {
+    if (!config) {
+      return [];
+    }
+    return Array.isArray(config) ? config : [config];
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+  function mergeRouteData(currentData, nextData) {
+    if (typeof nextData === "undefined") {
+      return currentData;
+    }
+    if (isPlainObject(currentData) && isPlainObject(nextData)) {
+      return {
+        ...currentData,
+        ...nextData
+      };
+    }
+    return nextData;
+  }
+  async function resolveMiddlewares(config, context) {
+    const middlewareNames = normalizeMiddlewareNames(config);
+    const requiresNamedMiddleware = middlewareNames.length > 0;
+    if (!import_node_fs.default.existsSync(middlewaresPath)) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const middlewareModule = resolveModule(middlewaresPath);
+    const registry = middlewareModule.middlewares;
+    if (!registry) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const orderedMiddlewareNames = typeof registry["*"] === "function" ? ["*", ...middlewareNames] : middlewareNames;
+    if (orderedMiddlewareNames.length === 0) {
+      return context;
+    }
+    let nextContext = context;
+    for (const middlewareName of orderedMiddlewareNames) {
+      const middleware = registry[middlewareName];
+      if (typeof middleware !== "function") {
+        throw createAbort({
+          status: 500,
+          message: `Invalid middleware '${middlewareName}'`
+        });
+      }
+      const middlewareData = await middleware(nextContext);
+      nextContext = {
+        ...nextContext,
+        data: mergeRouteData(nextContext.data, middlewareData)
+      };
+    }
+    return nextContext;
+  }
   async function resolve(input) {
     const pathname = normalizePathname(input.pathname);
     const contextBase = {
@@ -365,10 +435,12 @@ function createFileRouter(options) {
       activeContext = context;
       const pageModule = resolveModule(match.entry.filePath);
       const layoutModule = import_node_fs.default.existsSync(layoutPath) ? resolveModule(layoutPath) : null;
-      const pageData = await resolvePageData(pageModule, context);
+      const middlewareContext = await resolveMiddlewares(pageModule.middlewares, context);
+      activeContext = middlewareContext;
+      const pageData = await resolvePageData(pageModule, middlewareContext);
       const pageContext = {
-        ...context,
-        data: pageData
+        ...middlewareContext,
+        data: mergeRouteData(middlewareContext.data, pageData)
       };
       activeContext = pageContext;
       const pageNode = await pageModule.default(pageContext);

package/dist/router.js

@@ -268,6 +268,7 @@ function createFileRouter(options) {
   const pagesDir = options.pagesDir;
   const layoutPath = path.join(pagesDir, "layout.js");
   const errorPath = path.join(pagesDir, "errors.js");
+  const middlewaresPath = path.join(pagesDir, "middlewares.js");
   function buildRouteEntries() {
     const files = walkFiles(pagesDir);
     return files.map((filePath) => toRouteEntry(pagesDir, filePath)).filter((entry) => entry !== null).sort((a, b) => {
@@ -310,6 +311,75 @@ function createFileRouter(options) {
       head: mergeHead(layoutHead, errorHead)
     };
   }
+  function normalizeMiddlewareNames(config) {
+    if (!config) {
+      return [];
+    }
+    return Array.isArray(config) ? config : [config];
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+  function mergeRouteData(currentData, nextData) {
+    if (typeof nextData === "undefined") {
+      return currentData;
+    }
+    if (isPlainObject(currentData) && isPlainObject(nextData)) {
+      return {
+        ...currentData,
+        ...nextData
+      };
+    }
+    return nextData;
+  }
+  async function resolveMiddlewares(config, context) {
+    const middlewareNames = normalizeMiddlewareNames(config);
+    const requiresNamedMiddleware = middlewareNames.length > 0;
+    if (!fs.existsSync(middlewaresPath)) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const middlewareModule = resolveModule(middlewaresPath);
+    const registry = middlewareModule.middlewares;
+    if (!registry) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const orderedMiddlewareNames = typeof registry["*"] === "function" ? ["*", ...middlewareNames] : middlewareNames;
+    if (orderedMiddlewareNames.length === 0) {
+      return context;
+    }
+    let nextContext = context;
+    for (const middlewareName of orderedMiddlewareNames) {
+      const middleware = registry[middlewareName];
+      if (typeof middleware !== "function") {
+        throw createAbort({
+          status: 500,
+          message: `Invalid middleware '${middlewareName}'`
+        });
+      }
+      const middlewareData = await middleware(nextContext);
+      nextContext = {
+        ...nextContext,
+        data: mergeRouteData(nextContext.data, middlewareData)
+      };
+    }
+    return nextContext;
+  }
   async function resolve(input) {
     const pathname = normalizePathname(input.pathname);
     const contextBase = {
@@ -335,10 +405,12 @@ function createFileRouter(options) {
       activeContext = context;
       const pageModule = resolveModule(match.entry.filePath);
       const layoutModule = fs.existsSync(layoutPath) ? resolveModule(layoutPath) : null;
-      const pageData = await resolvePageData(pageModule, context);
+      const middlewareContext = await resolveMiddlewares(pageModule.middlewares, context);
+      activeContext = middlewareContext;
+      const pageData = await resolvePageData(pageModule, middlewareContext);
       const pageContext = {
-        ...context,
-        data: pageData
+        ...middlewareContext,
+        data: mergeRouteData(middlewareContext.data, pageData)
       };
       activeContext = pageContext;
       const pageNode = await pageModule.default(pageContext);

package/dist/types.d.ts

@@ -69,10 +69,18 @@ export type PageDataResolver<TData = unknown> = (
   context: RouteContext
 ) => TData | Promise<TData>;
 
+export type RouteMiddlewareResult = Record<string, unknown> | undefined | void;
+export type RouteMiddlewareResolver<TData = unknown> = (
+  context: RouteContext<TData>
+) => RouteMiddlewareResult | Promise<RouteMiddlewareResult>;
+export type RouteMiddlewareRegistry = Record<string, RouteMiddlewareResolver<any>>;
+export type RouteMiddlewareConfig = string | string[];
+
 export type PageModule<TData = unknown> = {
   default: (props: PageProps<TData>) => ReactNode | Promise<ReactNode>;
   Head?: HeadResolver<PageProps<TData>>;
   Data?: PageDataResolver<TData>;
+  middlewares?: RouteMiddlewareConfig;
 };
 
 export type LayoutModule = {
@@ -91,6 +99,8 @@ export type CreateHtmlShellOptions = {
   clientScriptUrl?: string;
   headTags?: string;
   rootHtml?: string;
+  initialFlightData?: string;
+  clientRenderMode?: "hydrate" | "mount";
   basename?: string;
   liveReloadPath?: string;
   liveReloadServerId?: string;

package/dist/webframez-core.cjs

@@ -432,6 +432,7 @@ function createFileRouter(options) {
   const pagesDir = options.pagesDir;
   const layoutPath = import_node_path2.default.join(pagesDir, "layout.js");
   const errorPath = import_node_path2.default.join(pagesDir, "errors.js");
+  const middlewaresPath = import_node_path2.default.join(pagesDir, "middlewares.js");
   function buildRouteEntries() {
     const files = walkFiles(pagesDir);
     return files.map((filePath) => toRouteEntry(pagesDir, filePath)).filter((entry) => entry !== null).sort((a, b) => {
@@ -474,6 +475,75 @@ function createFileRouter(options) {
       head: mergeHead(layoutHead, errorHead)
     };
   }
+  function normalizeMiddlewareNames(config) {
+    if (!config) {
+      return [];
+    }
+    return Array.isArray(config) ? config : [config];
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+  function mergeRouteData(currentData, nextData) {
+    if (typeof nextData === "undefined") {
+      return currentData;
+    }
+    if (isPlainObject(currentData) && isPlainObject(nextData)) {
+      return {
+        ...currentData,
+        ...nextData
+      };
+    }
+    return nextData;
+  }
+  async function resolveMiddlewares(config, context) {
+    const middlewareNames = normalizeMiddlewareNames(config);
+    const requiresNamedMiddleware = middlewareNames.length > 0;
+    if (!import_node_fs.default.existsSync(middlewaresPath)) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const middlewareModule = resolveModule(middlewaresPath);
+    const registry = middlewareModule.middlewares;
+    if (!registry) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const orderedMiddlewareNames = typeof registry["*"] === "function" ? ["*", ...middlewareNames] : middlewareNames;
+    if (orderedMiddlewareNames.length === 0) {
+      return context;
+    }
+    let nextContext = context;
+    for (const middlewareName of orderedMiddlewareNames) {
+      const middleware = registry[middlewareName];
+      if (typeof middleware !== "function") {
+        throw createAbort({
+          status: 500,
+          message: `Invalid middleware '${middlewareName}'`
+        });
+      }
+      const middlewareData = await middleware(nextContext);
+      nextContext = {
+        ...nextContext,
+        data: mergeRouteData(nextContext.data, middlewareData)
+      };
+    }
+    return nextContext;
+  }
   async function resolve(input) {
     const pathname = normalizePathname(input.pathname);
     const contextBase = {
@@ -499,10 +569,12 @@ function createFileRouter(options) {
       activeContext = context;
       const pageModule = resolveModule(match.entry.filePath);
       const layoutModule = import_node_fs.default.existsSync(layoutPath) ? resolveModule(layoutPath) : null;
-      const pageData = await resolvePageData(pageModule, context);
+      const middlewareContext = await resolveMiddlewares(pageModule.middlewares, context);
+      activeContext = middlewareContext;
+      const pageData = await resolvePageData(pageModule, middlewareContext);
       const pageContext = {
-        ...context,
-        data: pageData
+        ...middlewareContext,
+        data: mergeRouteData(middlewareContext.data, pageData)
       };
       activeContext = pageContext;
       const pageNode = await pageModule.default(pageContext);

package/dist/webframez-core.js

@@ -404,6 +404,7 @@ function createFileRouter(options) {
   const pagesDir = options.pagesDir;
   const layoutPath = path2.join(pagesDir, "layout.js");
   const errorPath = path2.join(pagesDir, "errors.js");
+  const middlewaresPath = path2.join(pagesDir, "middlewares.js");
   function buildRouteEntries() {
     const files = walkFiles(pagesDir);
     return files.map((filePath) => toRouteEntry(pagesDir, filePath)).filter((entry) => entry !== null).sort((a, b) => {
@@ -446,6 +447,75 @@ function createFileRouter(options) {
       head: mergeHead(layoutHead, errorHead)
     };
   }
+  function normalizeMiddlewareNames(config) {
+    if (!config) {
+      return [];
+    }
+    return Array.isArray(config) ? config : [config];
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  }
+  function mergeRouteData(currentData, nextData) {
+    if (typeof nextData === "undefined") {
+      return currentData;
+    }
+    if (isPlainObject(currentData) && isPlainObject(nextData)) {
+      return {
+        ...currentData,
+        ...nextData
+      };
+    }
+    return nextData;
+  }
+  async function resolveMiddlewares(config, context) {
+    const middlewareNames = normalizeMiddlewareNames(config);
+    const requiresNamedMiddleware = middlewareNames.length > 0;
+    if (!fs.existsSync(middlewaresPath)) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const middlewareModule = resolveModule(middlewaresPath);
+    const registry = middlewareModule.middlewares;
+    if (!registry) {
+      if (!requiresNamedMiddleware) {
+        return context;
+      }
+      throw createAbort({
+        status: 500,
+        message: `Invalid middleware '${middlewareNames[0]}'`
+      });
+    }
+    const orderedMiddlewareNames = typeof registry["*"] === "function" ? ["*", ...middlewareNames] : middlewareNames;
+    if (orderedMiddlewareNames.length === 0) {
+      return context;
+    }
+    let nextContext = context;
+    for (const middlewareName of orderedMiddlewareNames) {
+      const middleware = registry[middlewareName];
+      if (typeof middleware !== "function") {
+        throw createAbort({
+          status: 500,
+          message: `Invalid middleware '${middlewareName}'`
+        });
+      }
+      const middlewareData = await middleware(nextContext);
+      nextContext = {
+        ...nextContext,
+        data: mergeRouteData(nextContext.data, middlewareData)
+      };
+    }
+    return nextContext;
+  }
   async function resolve(input) {
     const pathname = normalizePathname(input.pathname);
     const contextBase = {
@@ -471,10 +541,12 @@ function createFileRouter(options) {
       activeContext = context;
       const pageModule = resolveModule(match.entry.filePath);
       const layoutModule = fs.existsSync(layoutPath) ? resolveModule(layoutPath) : null;
-      const pageData = await resolvePageData(pageModule, context);
+      const middlewareContext = await resolveMiddlewares(pageModule.middlewares, context);
+      activeContext = middlewareContext;
+      const pageData = await resolvePageData(pageModule, middlewareContext);
       const pageContext = {
-        ...context,
-        data: pageData
+        ...middlewareContext,
+        data: mergeRouteData(middlewareContext.data, pageData)
       };
       activeContext = pageContext;
       const pageNode = await pageModule.default(pageContext);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webtypen/webframez-react",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "TypeScript React RSC addition for @webtypen/webframez-core",
   "homepage": "https://webtypen.de/",
   "author": {