zuby 1.0.40 → 1.0.41

package/config.js

@@ -1,4 +1,4 @@
-import { ZUBY_BUILD_CHUNKS_MANIFEST, ZUBY_CONFIG_FILE } from './constants.js';
+import { BUILD_CHUNKS_MANIFEST, ZUBY_CONFIG_FILE } from './constants.js';
 import { existsSync } from 'fs';
 import { bundleRequire } from 'bundle-require';
 import { createLogger } from './logger/index.js';
@@ -112,7 +112,7 @@ export const mergeDefaultConfig = async (config) => {
     config.vite.customLogger = config.vite.customLogger ?? config.customLogger;
     config.vite.server = config.vite.server ?? config.server;
     config.vite.publicDir = config.vite.publicDir ?? config.publicDir;
-    config.vite.build.ssrManifest = ZUBY_BUILD_CHUNKS_MANIFEST;
+    config.vite.build.ssrManifest = BUILD_CHUNKS_MANIFEST;
     config.vite.build.ssrEmitAssets = config.vite.build.ssrEmitAssets ?? true;
     config.vite.build.modulePreload = { polyfill: false };
     config.vite.optimizeDeps = config.vite.optimizeDeps ?? {};
@@ -133,5 +133,11 @@ export const mergeDefaultConfig = async (config) => {
  * before removing any of them.
  */
 export const getBuiltInPlugins = () => {
-    return [contextPlugin(), compileTimePlugin(), chunkNamingPlugin(), manifestPlugin(), prerenderPlugin()];
+    return [
+        contextPlugin(),
+        compileTimePlugin(),
+        chunkNamingPlugin(),
+        manifestPlugin(),
+        prerenderPlugin(),
+    ];
 };

package/constants.d.ts

@@ -1,5 +1,25 @@
 export declare const ZUBY_CONFIG_FILE = "zuby.config.mjs";
-export declare const ZUBY_BUILD_CHUNKS_MANIFEST = "chunks-manifest.json";
-export declare const ZUBY_CLIENT_CHUNKS_MANIFEST = "client-chunks-manifest.json";
-export declare const ZUBY_SERVER_CHUNKS_MANIFEST = "server-chunks-manifest.json";
-export declare const ZUBY_PAGES_MANIFEST = "pages-manifest.json";
+export declare const BUILD_CHUNKS_MANIFEST = "chunks-manifest.json";
+export declare const CLIENT_CHUNKS_MANIFEST = "client-chunks-manifest.json";
+export declare const SERVER_CHUNKS_MANIFEST = "server-chunks-manifest.json";
+export declare const PAGES_MANIFEST = "pages-manifest.json";
+export declare const HTTP_HEADERS: {
+    Age: string;
+    Host: string;
+    Server: string;
+    ContentType: string;
+    ContentLength: string;
+    ContentRange: string;
+    ContentEncoding: string;
+    ContentLanguage: string;
+    AcceptRanges: string;
+    CacheControl: string;
+    XForwardedProto: string;
+    XForwardedHost: string;
+    XPoweredBy: string;
+    XZubyVersion: string;
+    XZubyProps: string;
+    XZubyCachedTime: string;
+    XZubyCacheTTL: string;
+    XZubyCache: string;
+};

package/constants.js

@@ -1,5 +1,28 @@
 export const ZUBY_CONFIG_FILE = 'zuby.config.mjs';
-export const ZUBY_BUILD_CHUNKS_MANIFEST = 'chunks-manifest.json';
-export const ZUBY_CLIENT_CHUNKS_MANIFEST = 'client-chunks-manifest.json';
-export const ZUBY_SERVER_CHUNKS_MANIFEST = 'server-chunks-manifest.json';
-export const ZUBY_PAGES_MANIFEST = 'pages-manifest.json';
+export const BUILD_CHUNKS_MANIFEST = 'chunks-manifest.json';
+export const CLIENT_CHUNKS_MANIFEST = 'client-chunks-manifest.json';
+export const SERVER_CHUNKS_MANIFEST = 'server-chunks-manifest.json';
+export const PAGES_MANIFEST = 'pages-manifest.json';
+export const HTTP_HEADERS = {
+    // Standard HTTP headers
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers
+    Age: 'Age',
+    Host: 'Host',
+    Server: 'Server',
+    ContentType: 'Content-Type',
+    ContentLength: 'Content-Length',
+    ContentRange: 'Content-Range',
+    ContentEncoding: 'Content-Encoding',
+    ContentLanguage: 'Content-Language',
+    AcceptRanges: 'Accept-Ranges',
+    CacheControl: 'Cache-Control',
+    XForwardedProto: 'X-Forwarded-Proto',
+    XForwardedHost: 'X-Forwarded-Host',
+    XPoweredBy: 'X-Powered-By',
+    // Zuby specific
+    XZubyVersion: 'X-Zuby-Version',
+    XZubyProps: 'X-Zuby-Props',
+    XZubyCachedTime: 'X-Zuby-Cached-Time',
+    XZubyCacheTTL: 'X-Zuby-Cache-TTL',
+    XZubyCache: 'X-Zuby-Cache',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuby",
-  "version": "1.0.40",
+  "version": "1.0.41",
   "description": "Zuby.js is framework for building SPA apps using Vite",
   "type": "module",
   "main": "index.js",

package/pageContext/index.d.ts

@@ -6,6 +6,8 @@ export declare class ZubyPageContext {
     protected _params: Record<string, string>;
     protected _clientAddress?: string;
     protected _statusCode: number;
+    protected _headers: Headers;
+    protected _cache: number;
     protected _props: Record<string, any>;
     protected _zubyContext: ZubyContext;
     constructor(options: {
@@ -15,6 +17,7 @@ export declare class ZubyPageContext {
         clientAddress?: string;
         statusCode?: number;
         props?: Record<string, any>;
+        headers?: Headers;
         zubyContext?: ZubyContext;
     });
     get url(): URL;
@@ -40,4 +43,7 @@ export declare class ZubyPageContext {
     set props(value: Record<string, any>);
     get statusCode(): number | undefined;
     set statusCode(value: number | undefined);
+    get headers(): Headers;
+    get cache(): number;
+    set cache(value: number);
 }

package/pageContext/index.js

@@ -1,13 +1,15 @@
 import { getContext } from '../context/index.js';
 export class ZubyPageContext {
     constructor(options) {
-        this._url = options?.url || new URL('http://localhost/');
-        this._title = options?.title || '';
         this._request = options?.request;
+        this._url = options?.url || new URL(options?.request?.url || '/', 'http://localhost/');
+        this._title = options?.title || '';
         this._params = {};
         this._clientAddress = options?.clientAddress;
         this._statusCode = options?.statusCode || 200;
         this._props = options?.props || {};
+        this._cache = 0;
+        this._headers = options?.headers || new Headers();
         this._zubyContext = options?.zubyContext || getContext();
     }
     get url() {
@@ -70,4 +72,16 @@ export class ZubyPageContext {
         }
         this._statusCode = value;
     }
+    get headers() {
+        return this._headers;
+    }
+    get cache() {
+        return this._cache;
+    }
+    set cache(value) {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error(`Invalid cache value: ${value}`);
+        }
+        this._cache = value;
+    }
 }

package/plugins/manifestPlugin/index.js

@@ -1,7 +1,7 @@
 import { renameSync } from 'fs';
 import { normalizePath } from '../../utils/pathUtils.js';
 import { join } from 'path';
-import { ZUBY_BUILD_CHUNKS_MANIFEST, ZUBY_CLIENT_CHUNKS_MANIFEST, ZUBY_SERVER_CHUNKS_MANIFEST, } from '../../constants.js';
+import { BUILD_CHUNKS_MANIFEST, CLIENT_CHUNKS_MANIFEST, SERVER_CHUNKS_MANIFEST, } from '../../constants.js';
 /**
  * This is internal plugin
  * which generated and moves required manifest files.
@@ -21,8 +21,8 @@ export default function manifestPlugin() {
                 return;
             }
             // Move chunks manifest files
-            renameSync(normalizePath(join(viteConfig.build.outDir, '..', 'client', ZUBY_BUILD_CHUNKS_MANIFEST)), normalizePath(join(viteConfig.build.outDir, '..', ZUBY_CLIENT_CHUNKS_MANIFEST)));
-            renameSync(normalizePath(join(viteConfig.build.outDir, '..', 'server', ZUBY_BUILD_CHUNKS_MANIFEST)), normalizePath(join(viteConfig.build.outDir, '..', ZUBY_SERVER_CHUNKS_MANIFEST)));
-        }
+            renameSync(normalizePath(join(viteConfig.build.outDir, '..', 'client', BUILD_CHUNKS_MANIFEST)), normalizePath(join(viteConfig.build.outDir, '..', CLIENT_CHUNKS_MANIFEST)));
+            renameSync(normalizePath(join(viteConfig.build.outDir, '..', 'server', BUILD_CHUNKS_MANIFEST)), normalizePath(join(viteConfig.build.outDir, '..', SERVER_CHUNKS_MANIFEST)));
+        },
     };
 }

package/plugins/prerenderPlugin/index.js

@@ -10,7 +10,7 @@ import { OUTPUTS } from '../../types.js';
 import { PATH_TYPES } from '../../templates/types.js';
 import { substitutePathParams } from '../../templates/pathUtils.js';
 import { normalizePath } from '../../utils/pathUtils.js';
-import { ZUBY_SERVER_CHUNKS_MANIFEST } from '../../constants.js';
+import { SERVER_CHUNKS_MANIFEST } from '../../constants.js';
 /**
  * This is internal plugin
  * that pre-renders the pages during the build.
@@ -31,7 +31,7 @@ export default function prerenderPlugin() {
             }
             const startTime = performance.now();
             const { srcDir, outDir, customLogger, prerenderPaths, site, output } = await getZubyInternalConfig();
-            const chunksManifestPath = resolve(outDir, ZUBY_SERVER_CHUNKS_MANIFEST);
+            const chunksManifestPath = resolve(outDir, SERVER_CHUNKS_MANIFEST);
             const chunksManifest = existsSync(chunksManifestPath)
                 ? JSON.parse(readFileSync(chunksManifestPath, 'utf-8'))
                 : {};

package/server/index.js

@@ -2099,13 +2099,15 @@ var getContext = () => {
 // src/pageContext/index.ts
 var ZubyPageContext = class {
   constructor(options) {
-    this._url = options?.url || new URL("http://localhost/");
-    this._title = options?.title || "";
     this._request = options?.request;
+    this._url = options?.url || new URL(options?.request?.url || "/", "http://localhost/");
+    this._title = options?.title || "";
     this._params = {};
     this._clientAddress = options?.clientAddress;
     this._statusCode = options?.statusCode || 200;
     this._props = options?.props || {};
+    this._cache = 0;
+    this._headers = options?.headers || new Headers();
     this._zubyContext = options?.zubyContext || getContext();
   }
   get url() {
@@ -2168,6 +2170,18 @@ var ZubyPageContext = class {
     }
     this._statusCode = value;
   }
+  get headers() {
+    return this._headers;
+  }
+  get cache() {
+    return this._cache;
+  }
+  set cache(value) {
+    if (!Number.isInteger(value) || value < 0) {
+      throw new Error(`Invalid cache value: ${value}`);
+    }
+    this._cache = value;
+  }
 };
 
 // src/server/zubyRenderer.ts
@@ -8390,7 +8404,30 @@ function findMatchingTemplate(templates, path2) {
 }
 
 // src/constants.ts
-var ZUBY_CLIENT_CHUNKS_MANIFEST = "client-chunks-manifest.json";
+var CLIENT_CHUNKS_MANIFEST = "client-chunks-manifest.json";
+var HTTP_HEADERS = {
+  // Standard HTTP headers
+  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers
+  Age: "Age",
+  Host: "Host",
+  Server: "Server",
+  ContentType: "Content-Type",
+  ContentLength: "Content-Length",
+  ContentRange: "Content-Range",
+  ContentEncoding: "Content-Encoding",
+  ContentLanguage: "Content-Language",
+  AcceptRanges: "Accept-Ranges",
+  CacheControl: "Cache-Control",
+  XForwardedProto: "X-Forwarded-Proto",
+  XForwardedHost: "X-Forwarded-Host",
+  XPoweredBy: "X-Powered-By",
+  // Zuby specific
+  XZubyVersion: "X-Zuby-Version",
+  XZubyProps: "X-Zuby-Props",
+  XZubyCachedTime: "X-Zuby-Cached-Time",
+  XZubyCacheTTL: "X-Zuby-Cache-TTL",
+  XZubyCache: "X-Zuby-Cache"
+};
 
 // src/server/zubyRenderer.ts
 var ZubyRenderer = class {
@@ -8412,7 +8449,7 @@ var ZubyRenderer = class {
     if (this.entryClientCss) {
       this.entryClientCss = `/chunks/${basename(this.entryClientCss || "")}`;
     }
-    const manifestPath = resolve2(this.outDir, ZUBY_CLIENT_CHUNKS_MANIFEST);
+    const manifestPath = resolve2(this.outDir, CLIENT_CHUNKS_MANIFEST);
     if (existsSync(manifestPath)) {
       this.chunksManifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
     }
@@ -8440,33 +8477,42 @@ var ZubyRenderer = class {
     if (!handlerResult)
       return;
     if (handlerResult instanceof Response) {
-      return handlerResult;
+      return this.injectHeaders(handlerResult, pageContext);
     }
     if (typeof handlerResult === "string") {
-      return new Response(handlerResult.toString(), {
+      return this.injectHeaders(
+        new Response(handlerResult.toString(), {
+          status: pageContext.statusCode || 200,
+          headers: {
+            "Content-Type": "text/html;charset=UTF-8"
+          }
+        }),
+        pageContext
+      );
+    }
+    return this.injectHeaders(
+      new Response(JSON.stringify(handlerResult, null, 2), {
         status: pageContext.statusCode || 200,
         headers: {
-          "Content-Type": "text/html;charset=UTF-8"
+          "Content-Type": "application/json;charset=UTF-8"
         }
-      });
-    }
-    return new Response(JSON.stringify(handlerResult, null, 2), {
-      status: pageContext.statusCode || 200,
-      headers: {
-        "Content-Type": "application/json;charset=UTF-8"
-      }
-    });
+      }),
+      pageContext
+    );
   }
   async executeProps(pageContext) {
-    const propsHeader = pageContext.request?.headers.get("x-zuby-props");
+    const propsHeader = pageContext.request?.headers.get(HTTP_HEADERS.XZubyProps);
     if (propsHeader !== "true")
       return;
-    return new Response(JSON.stringify(pageContext.props, null, 2), {
-      status: pageContext.statusCode || 200,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
+    return this.injectHeaders(
+      new Response(JSON.stringify(pageContext.props, null, 2), {
+        status: pageContext.statusCode || 200,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }),
+      pageContext
+    );
   }
   async executeEntry(pageContext) {
     const pages = this.zubyContext?.templates?.pages || [];
@@ -8494,7 +8540,8 @@ var ZubyRenderer = class {
     ) || "";
     const layoutChildren = layoutComponent({
       children: innerLayoutComponent({
-        innerHtml: entryHtml
+        innerHtml: entryHtml,
+        context: pageContext
       }),
       context: pageContext
     });
@@ -8518,42 +8565,59 @@ var ZubyRenderer = class {
     jsImports.forEach((imp) => {
       html = html.replace(/(<\/head>)/, `<script type="module" src="${imp}" defer></script>$1`);
     });
-    return new Response(html, {
-      status: pageContext.statusCode || 200,
-      headers: {
-        "Content-Type": "text/html;charset=UTF-8"
-      }
-    });
+    return this.injectHeaders(
+      new Response(html, {
+        status: pageContext.statusCode || 200,
+        headers: {
+          "Content-Type": "text/html;charset=UTF-8"
+        }
+      }),
+      pageContext
+    );
   }
   createPageContext(req) {
     const pageUrl = new URL(req.url);
     if (pageUrl.pathname.startsWith("/_props/")) {
       pageUrl.pathname = pageUrl.pathname.replace(/^\/_props\//, "/");
-      req.headers.set("x-zuby-props", "true");
+      req.headers.set(HTTP_HEADERS.XZubyProps, "true");
     }
     return new ZubyPageContext({
       url: pageUrl,
       request: req,
       statusCode: 200,
       props: {},
-      zubyContext: this.zubyContext
+      zubyContext: this.zubyContext,
+      headers: new Headers({
+        [HTTP_HEADERS.XPoweredBy]: "Zuby.js"
+      })
     });
   }
   async render(req) {
     const pageContext = this.createPageContext(req);
     return await this.executeHandlers(pageContext) || await this.executeProps(pageContext) || await this.executeEntry(pageContext);
   }
+  injectHeaders(res, pageContext) {
+    pageContext.headers.forEach((value, key) => {
+      if (res.headers.has(key))
+        return;
+      res.headers.set(key, value);
+    });
+    if (pageContext.cache) {
+      res.headers.set(HTTP_HEADERS.XZubyCacheTTL, pageContext.cache.toString());
+    }
+    return res;
+  }
 };
 
 // src/server/zubyServer.ts
 var ZubyServer = class {
   constructor(options) {
+    this.cache = /* @__PURE__ */ new Map();
     this.options = options;
     this.options.responseHeaders = this.options.responseHeaders || {};
     this.logger = options.logger || createLogger("info");
     this.renderer = options.renderer || new ZubyRenderer(options.outDir);
     this.middlewares = [
-      this.defaultHeadersMiddleware.bind(this),
       this.trailingSlashMiddleware.bind(this),
       this.clientDirMiddleware.bind(this),
       this.serverDirMiddleware.bind(this)
@@ -8633,11 +8697,38 @@ var ZubyServer = class {
       res.end();
     });
   }
-  async serverDirMiddleware(nodeReq, nodeRes) {
+  async serverDirMiddleware(nodeReq, nodeRes, _next) {
     const req = await this.toRequest(nodeReq);
-    const res = await this.renderer.render(req);
+    const cacheKey = new URL(req.url, "http://localhost").pathname;
+    const res = this.cacheRead(cacheKey) || this.cacheWrite(cacheKey, await this.renderer.render(req));
     return this.toNodeResponse(res, nodeRes);
   }
+  cacheRead(key) {
+    const cachedResponse = this.cache.get(key)?.clone();
+    if (!cachedResponse)
+      return void 0;
+    const cachedTime = Number(cachedResponse.headers.get(HTTP_HEADERS.XZubyCachedTime));
+    const cacheTTL = Number(cachedResponse.headers.get(HTTP_HEADERS.XZubyCacheTTL));
+    const age = Math.ceil(((/* @__PURE__ */ new Date()).getTime() - cachedTime) / 1e3);
+    if (age > cacheTTL) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    cachedResponse.headers.set(HTTP_HEADERS.Age, age.toString());
+    cachedResponse.headers.set(HTTP_HEADERS.XZubyCache, "HIT");
+    return cachedResponse;
+  }
+  cacheWrite(key, response) {
+    const cacheTTL = Number(response.headers.get(HTTP_HEADERS.XZubyCacheTTL));
+    if (!cacheTTL) {
+      response.headers.set(HTTP_HEADERS.XZubyCache, "BYPASS");
+      return response;
+    }
+    response.headers.set(HTTP_HEADERS.XZubyCachedTime, (/* @__PURE__ */ new Date()).getTime().toString());
+    response.headers.set(HTTP_HEADERS.XZubyCache, "MISS");
+    this.cache.set(key, response.clone());
+    return response;
+  }
   async listen() {
     const serverPromise = new Promise((resolve5, reject) => {
       this.server.listen(this.options.port, this.options.host, 511, () => {
@@ -8659,10 +8750,6 @@ var ZubyServer = class {
       });
     });
   }
-  defaultHeadersMiddleware(_req, res, next) {
-    res.setHeader("X-Powered-By", "Zuby.js");
-    next();
-  }
   trailingSlashMiddleware(req, res, next) {
     const [path2, query] = req.url?.split("?") || [];
     if (path2.endsWith("/") || path2.match(/[.](.+)$/)) {

package/server/zubyDevRenderer.js

@@ -3,6 +3,7 @@ import { relative } from 'path';
 import { getContext } from '../context/index.js';
 import ZubyRenderer from './zubyRenderer.js';
 import { getEntryFile } from '../commands/build.js';
+import { HTTP_HEADERS } from '../constants.js';
 export default class ZubyDevRenderer extends ZubyRenderer {
     constructor(zubyConfig, viteServerDevServer) {
         super(zubyConfig.outDir);
@@ -23,6 +24,9 @@ export default class ZubyDevRenderer extends ZubyRenderer {
     }
     async render(req) {
         const originalRes = await super.render(req);
+        // Do not cache responses in dev mode
+        originalRes.headers.set(HTTP_HEADERS.XZubyCacheTTL, '0');
+        originalRes.headers.set(HTTP_HEADERS.CacheControl, 'no-store, no-cache, must-revalidate');
         // Do not transform non-html responses
         if (!originalRes.headers.get('content-type')?.includes('text/html'))
             return originalRes;

package/server/zubyDevServer.js

@@ -15,7 +15,6 @@ export default class ZubyDevServer extends ZubyServer {
         });
         this.zubyInternalConfig = zubyConfig;
         this.middlewares = [
-            this.defaultHeadersMiddleware.bind(this),
             this.trailingSlashMiddleware.bind(this),
             this.serverDirMiddleware.bind(this),
         ];

package/server/zubyRenderer.d.ts

@@ -21,4 +21,5 @@ export default class ZubyRenderer {
     executeEntry(pageContext: ZubyPageContext): Promise<Response>;
     createPageContext(req: Request): ZubyPageContext;
     render(req: Request): Promise<Response>;
+    injectHeaders(res: Response, pageContext: ZubyPageContext): Response;
 }

package/server/zubyRenderer.js

@@ -5,7 +5,7 @@ import { basename, resolve } from 'path';
 import { glob } from 'glob';
 import { existsSync, readFileSync } from 'fs';
 import { findMatchingTemplate } from '../templates/pathUtils.js';
-import { ZUBY_CLIENT_CHUNKS_MANIFEST } from '../constants.js';
+import { CLIENT_CHUNKS_MANIFEST, HTTP_HEADERS } from '../constants.js';
 export default class ZubyRenderer {
     constructor(outDir) {
         this.outDir = outDir;
@@ -25,7 +25,7 @@ export default class ZubyRenderer {
         if (this.entryClientCss) {
             this.entryClientCss = `/chunks/${basename(this.entryClientCss || '')}`;
         }
-        const manifestPath = resolve(this.outDir, ZUBY_CLIENT_CHUNKS_MANIFEST);
+        const manifestPath = resolve(this.outDir, CLIENT_CHUNKS_MANIFEST);
         if (existsSync(manifestPath)) {
             this.chunksManifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
         }
@@ -57,36 +57,36 @@ export default class ZubyRenderer {
             return;
         // If handler returned a response, we can immediately return it
         if (handlerResult instanceof Response) {
-            return handlerResult;
+            return this.injectHeaders(handlerResult, pageContext);
         }
         // If handler returned string,
         // we'll assume that user wants to return html response
         if (typeof handlerResult === 'string') {
-            return new Response(handlerResult.toString(), {
+            return this.injectHeaders(new Response(handlerResult.toString(), {
                 status: pageContext.statusCode || 200,
                 headers: {
                     'Content-Type': 'text/html;charset=UTF-8',
                 },
-            });
+            }), pageContext);
         }
         // We'll try to serialize everything else as JSON
-        return new Response(JSON.stringify(handlerResult, null, 2), {
+        return this.injectHeaders(new Response(JSON.stringify(handlerResult, null, 2), {
             status: pageContext.statusCode || 200,
             headers: {
                 'Content-Type': 'application/json;charset=UTF-8',
             },
-        });
+        }), pageContext);
     }
     async executeProps(pageContext) {
-        const propsHeader = pageContext.request?.headers.get('x-zuby-props');
+        const propsHeader = pageContext.request?.headers.get(HTTP_HEADERS.XZubyProps);
         if (propsHeader !== 'true')
             return;
-        return new Response(JSON.stringify(pageContext.props, null, 2), {
+        return this.injectHeaders(new Response(JSON.stringify(pageContext.props, null, 2), {
             status: pageContext.statusCode || 200,
             headers: {
                 'Content-Type': 'application/json',
             },
-        });
+        }), pageContext);
     }
     async executeEntry(pageContext) {
         // Load page template component
@@ -119,6 +119,7 @@ export default class ZubyRenderer {
         const layoutChildren = layoutComponent({
             children: innerLayoutComponent({
                 innerHtml: entryHtml,
+                context: pageContext,
             }),
             context: pageContext,
         });
@@ -148,12 +149,12 @@ export default class ZubyRenderer {
         jsImports.forEach((imp) => {
             html = html.replace(/(<\/head>)/, `<script type="module" src="${imp}" defer></script>$1`);
         });
-        return new Response(html, {
+        return this.injectHeaders(new Response(html, {
             status: pageContext.statusCode || 200,
             headers: {
                 'Content-Type': 'text/html;charset=UTF-8',
             },
-        });
+        }), pageContext);
     }
     createPageContext(req) {
         // Paths starting with /_props are special case.
@@ -162,7 +163,7 @@ export default class ZubyRenderer {
         const pageUrl = new URL(req.url);
         if (pageUrl.pathname.startsWith('/_props/')) {
             pageUrl.pathname = pageUrl.pathname.replace(/^\/_props\//, '/');
-            req.headers.set('x-zuby-props', 'true');
+            req.headers.set(HTTP_HEADERS.XZubyProps, 'true');
         }
         return new ZubyPageContext({
             url: pageUrl,
@@ -170,6 +171,9 @@ export default class ZubyRenderer {
             statusCode: 200,
             props: {},
             zubyContext: this.zubyContext,
+            headers: new Headers({
+                [HTTP_HEADERS.XPoweredBy]: 'Zuby.js',
+            }),
         });
     }
     async render(req) {
@@ -178,4 +182,15 @@ export default class ZubyRenderer {
             (await this.executeProps(pageContext)) ||
             (await this.executeEntry(pageContext)));
     }
+    injectHeaders(res, pageContext) {
+        pageContext.headers.forEach((value, key) => {
+            if (res.headers.has(key))
+                return;
+            res.headers.set(key, value);
+        });
+        if (pageContext.cache) {
+            res.headers.set(HTTP_HEADERS.XZubyCacheTTL, pageContext.cache.toString());
+        }
+        return res;
+    }
 }

package/server/zubyServer.d.ts

@@ -11,14 +11,16 @@ export default class ZubyServer {
     protected logger: ZubyLogger;
     protected renderer: ZubyRenderer;
     protected middlewares: ZubyMiddleware[];
+    protected cache: Map<string, Response>;
     constructor(options: ZubyServerOptions);
     handle(nodeReq: NodeRequest, nodeRes: NodeResponse): Promise<void>;
-    clientDirMiddleware(req: NodeRequest, res: NodeResponse, next: () => void): Promise<void | NodeResponse>;
-    serverDirMiddleware(nodeReq: NodeRequest, nodeRes: NodeResponse): Promise<void>;
+    clientDirMiddleware(req: NodeRequest, res: NodeResponse, next: () => any | Promise<any>): Promise<any>;
+    serverDirMiddleware(nodeReq: NodeRequest, nodeRes: NodeResponse, _next: () => any | Promise<any>): Promise<void>;
+    cacheRead(key: string): Response | undefined;
+    cacheWrite(key: string, response: Response): Response;
     listen(): Promise<void>;
     close(): Promise<void>;
-    defaultHeadersMiddleware(_req: NodeRequest, res: NodeResponse, next: () => void): void;
-    trailingSlashMiddleware(req: NodeRequest, res: NodeResponse, next: () => void): void;
+    trailingSlashMiddleware(req: NodeRequest, res: NodeResponse, next: () => any | Promise<any>): any;
     toRequest(nodeReq: NodeRequest): Promise<Request>;
     toNodeResponse(res: Response, nodeRes: ServerResponse): Promise<void>;
     use(middleware: ZubyMiddleware): void;

package/server/zubyServer.js

@@ -7,14 +7,15 @@ import { createReadStream, existsSync, statSync } from 'fs';
 import { mimeTypes } from './mimeTypes.js';
 import { createLogger } from '../logger/index.js';
 import ZubyRenderer from './zubyRenderer.js';
+import { HTTP_HEADERS } from '../constants.js';
 export default class ZubyServer {
     constructor(options) {
+        this.cache = new Map();
         this.options = options;
         this.options.responseHeaders = this.options.responseHeaders || {};
         this.logger = options.logger || createLogger('info');
         this.renderer = options.renderer || new ZubyRenderer(options.outDir);
         this.middlewares = [
-            this.defaultHeadersMiddleware.bind(this),
             this.trailingSlashMiddleware.bind(this),
             this.clientDirMiddleware.bind(this),
             this.serverDirMiddleware.bind(this),
@@ -103,11 +104,38 @@ export default class ZubyServer {
             res.end();
         });
     }
-    async serverDirMiddleware(nodeReq, nodeRes) {
+    async serverDirMiddleware(nodeReq, nodeRes, _next) {
         const req = await this.toRequest(nodeReq);
-        const res = await this.renderer.render(req);
+        const cacheKey = new URL(req.url, 'http://localhost').pathname;
+        const res = this.cacheRead(cacheKey) || this.cacheWrite(cacheKey, await this.renderer.render(req));
         return this.toNodeResponse(res, nodeRes);
     }
+    cacheRead(key) {
+        const cachedResponse = this.cache.get(key)?.clone();
+        if (!cachedResponse)
+            return undefined;
+        const cachedTime = Number(cachedResponse.headers.get(HTTP_HEADERS.XZubyCachedTime));
+        const cacheTTL = Number(cachedResponse.headers.get(HTTP_HEADERS.XZubyCacheTTL));
+        const age = Math.ceil((new Date().getTime() - cachedTime) / 1000);
+        if (age > cacheTTL) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        cachedResponse.headers.set(HTTP_HEADERS.Age, age.toString());
+        cachedResponse.headers.set(HTTP_HEADERS.XZubyCache, 'HIT');
+        return cachedResponse;
+    }
+    cacheWrite(key, response) {
+        const cacheTTL = Number(response.headers.get(HTTP_HEADERS.XZubyCacheTTL));
+        if (!cacheTTL) {
+            response.headers.set(HTTP_HEADERS.XZubyCache, 'BYPASS');
+            return response;
+        }
+        response.headers.set(HTTP_HEADERS.XZubyCachedTime, new Date().getTime().toString());
+        response.headers.set(HTTP_HEADERS.XZubyCache, 'MISS');
+        this.cache.set(key, response.clone());
+        return response;
+    }
     async listen() {
         const serverPromise = new Promise((resolve, reject) => {
             this.server.listen(this.options.port, this.options.host, 511, () => {
@@ -129,10 +157,6 @@ export default class ZubyServer {
             });
         });
     }
-    defaultHeadersMiddleware(_req, res, next) {
-        res.setHeader('X-Powered-By', 'Zuby.js');
-        next();
-    }
     trailingSlashMiddleware(req, res, next) {
         // Redirect to path with trailing slash for consistency
         const [path, query] = req.url?.split('?') || [];