@blacklizard/inertia-express 0.1.0

package/dist/express/index.d.ts

@@ -0,0 +1,495 @@
+import { AlwaysProp, ComputeCacheKeyInput, DeepMergeProp, DeferredProp, INERTIA_HEADERS, INERTIA_LOCATION_STATUS, INERTIA_REDIRECT_STATUS, InertiaPage, InertiaRequestInfo, LazyProp, MergeProp, OptionalProp, PageProps, RenderOptions, SharedPropsInput, SsrCacheEntry, SsrCacheStore, ValidationErrors, VersionResolver, always, canonicalStringify, computeSsrCacheKey, deepMerge, defer, encodePageScript, lazy, merge, optional } from "../core/index.js";
+import { NextFunction, Request, Response } from "express";
+
+//#region src/express/edge-cache.d.ts
+/**
+ * Decision returned by an `edgeCache` policy. Returning `null` (or a
+ * negative number) opts out of edge caching — no `Cache-Control` is set
+ * beyond what your handler set itself.
+ */
+interface EdgeCacheDecision {
+  /** `s-maxage` value for shared/CDN caches, in seconds. */
+  sMaxAge: number;
+  /** `max-age` for the browser cache. Default 0 (revalidate immediately). */
+  maxAge?: number;
+  /**
+   * `stale-while-revalidate` window. Lets CDNs serve a slightly stale
+   * response while fetching a fresh one in the background.
+   */
+  staleWhileRevalidate?: number;
+  /**
+   * Additional `Vary` values. The middleware always emits `Vary: Accept,
+   * X-Inertia` — this lets you append more (e.g. `Cookie`, `Accept-Language`).
+   */
+  vary?: string[];
+}
+/**
+ * Per-response edge-cache decision: receives the request, response, and
+ * resolved page, returns an {@link EdgeCacheDecision} or `null` to opt out.
+ */
+type EdgeCachePolicy = (input: {
+  req: Request;
+  res: Response;
+  page: InertiaPage;
+}) => EdgeCacheDecision | null;
+/**
+ * Apply an edge-cache decision to the response. Called automatically by
+ * the middleware when an `edgeCache` policy is configured. Exported so
+ * you can call it from custom code paths too.
+ *
+ * No-op when `decision` is `null`, when `sMaxAge <= 0`, or when the response
+ * is 3xx+ (4xx/5xx must not be cached at the edge). The middleware also skips
+ * Inertia XHR responses before calling this — that filter lives at the call
+ * site, not here, since `applyEdgeCache` only sees the decision + status.
+ *
+ * `Vary` values from the decision are merged into the existing header,
+ * de-duplicated by trimmed string.
+ *
+ * @param decision Policy output (or `null` to opt out).
+ * @param res Outgoing Express response (mutated: sets `Cache-Control`, `Vary`).
+ */
+declare function applyEdgeCache(decision: EdgeCacheDecision | null, res: Response): void;
+//#endregion
+//#region src/express/types.d.ts
+/**
+ * Pluggable hook for rendering the page object into the final HTTP body
+ * for non-Inertia (i.e. first-load HTML) requests.
+ *
+ * Adapters can wire this to a template engine. When omitted, a minimal
+ * default HTML shell is used.
+ */
+type RootViewRenderer = (input: RootViewInput) => string | Promise<string>;
+/**
+ * Argument passed to a {@link RootViewRenderer}.
+ */
+interface RootViewInput {
+  page: InertiaPage;
+  req: Request;
+  res: Response;
+}
+/**
+ * Output shape from an SSR renderer. Compatible with the format used by the
+ * official `@inertiajs/{vue3,react,svelte}/server` packages.
+ *
+ * `body` may contain either:
+ *   - the *inner* HTML of the root element (recommended), or
+ *   - the full root element plus the page `<script>` tag (what the Inertia v3
+ *     SSR servers emit) — in which case set `bodyIsFullRoot: true` so the
+ *     default root view does not wrap it again.
+ *
+ * `head` may be a string of `<meta>`/`<title>`/`<link>` tags, or an array
+ * of strings (Inertia's standard SSR servers return arrays).
+ */
+interface SsrResult {
+  body: string;
+  head?: string | string[];
+  bodyIsFullRoot?: boolean;
+}
+/**
+ * Pluggable SSR renderer. Return `null` to skip SSR for this request (e.g.
+ * client-only fallback while the SSR server is unavailable).
+ */
+type SsrRenderer = (input: SsrRendererInput) => Promise<SsrResult | null>;
+/**
+ * Argument passed to an {@link SsrRenderer}.
+ */
+interface SsrRendererInput {
+  page: InertiaPage;
+  req: Request;
+  res: Response;
+}
+/**
+ * Configuration for the SSR view cache.
+ *
+ * On a non-Inertia GET that produces a cache hit, the middleware skips the
+ * SSR call entirely and reuses the stored `{ head, body }`. On a miss, the
+ * SSR renderer runs and the result is written back to the store.
+ *
+ * Cache writes are fire-and-forget — failures are logged via `onError` (if
+ * provided) but never block the response.
+ */
+interface InertiaCacheOptions {
+  /** The store implementation. See `createMemoryCacheStore` and `@blacklizard/inertia-cache-redis`. */
+  store: SsrCacheStore;
+  /** TTL for cache entries in seconds. Default 300. */
+  ttlSeconds?: number;
+  /** Cache key prefix / namespace. Default `"inertia:ssr"`. */
+  keyPrefix?: string;
+  /**
+   * Decide per request whether the response is cacheable. Return `false`
+   * to bypass cache entirely (no read, no write). Default: cache only
+   * non-Inertia GET requests on 200 responses. Auth-bound responses,
+   * flash data, error Pages should typically opt out here.
+   */
+  vary?: (input: {
+    req: Request;
+    page: InertiaPage;
+  }) => boolean;
+  /**
+   * Optional extra discriminator added to the cache key — useful for
+   * locale, theme, A/B bucket, etc. Two requests with the same component
+   * + props but different discriminators get separate cache entries.
+   */
+  discriminator?: (req: Request) => string | undefined;
+  /** Called when a cache get/set/delete operation throws. Cache failures are non-fatal. */
+  onError?: (op: 'get' | 'set' | 'delete', err: unknown) => void;
+}
+/**
+ * Configuration for the Inertia Express middleware. All fields optional.
+ */
+interface InertiaMiddlewareOptions {
+  /**
+   * Asset version. When the client sends a stale `X-Inertia-Version`
+   * header on a GET, the middleware responds with 409 + `X-Inertia-Location`
+   * to force a full reload.
+   *
+   * Also incorporated into SSR cache keys so a deploy that bumps the
+   * version atomically retires every existing cache entry.
+   */
+  version?: VersionResolver<Request>;
+  /**
+   * Globally shared props merged into every page's props. May be a static
+   * object or a function that receives the current request.
+   *
+   * Per-page props passed to `res.inertia(component, props)` override
+   * shared props on key collisions.
+   */
+  sharedProps?: SharedPropsInput<Request>;
+  /**
+   * Custom root-view renderer for non-Inertia (first-load) responses.
+   * Receives the resolved page object and must return a complete HTML doc.
+   */
+  rootView?: RootViewRenderer;
+  /**
+   * Optional SSR hook. When provided, the middleware calls it on
+   * non-Inertia (HTML) responses to obtain a pre-rendered `{ head, body }`
+   * which is exposed to `rootView` via `res.locals.ssr` and inlined into
+   * the default root view if no custom `rootView` is set.
+   *
+   * Returning `null` from the hook skips SSR for that request — useful
+   * for client-only fallback when SSR is unavailable.
+   */
+  ssr?: SsrRenderer;
+  /**
+   * Optional view cache. Layered on top of the SSR hook so cached HTML can
+   * be served without invoking the SSR renderer at all. See
+   * {@link InertiaCacheOptions}.
+   */
+  cache?: InertiaCacheOptions;
+  /**
+   * Optional CDN edge-cache policy. Applies `Cache-Control` headers to
+   * non-Inertia responses according to the returned decision. Always
+   * skipped for Inertia (XHR) responses. Default: no edge caching.
+   */
+  edgeCache?: EdgeCachePolicy;
+  /**
+   * If true, merge session-stored validation errors and flash data into the
+   * shared props automatically, exposed as the `errors` and `flash` props.
+   * Both are read-once — cleared from the session after being read. Explicit
+   * `sharedProps` keys win on collision. Off by default.
+   */
+  flashFromSession?: boolean;
+}
+/**
+ * Per-response options accepted as the third argument to `res.inertia()`.
+ * Extends the core {@link RenderOptions} (clearHistory / encryptHistory).
+ */
+interface InertiaResponseOptions extends RenderOptions {
+  /**
+   * Override the URL used in the page object. Defaults to `req.originalUrl`.
+   */
+  url?: string;
+}
+/**
+ * Render an Inertia page. Returns Promise so handlers can `await` it,
+ * but it also calls the underlying Express response methods so
+ * `return res.inertia(...)` works in Express handlers.
+ */
+type ResInertiaApi = <TProps extends PageProps>(component: string, props?: TProps, options?: InertiaResponseOptions) => Promise<void>;
+/** Helper to declare typed redirects on the response. */
+type InertiaLocation = (url: string) => void;
+declare module 'express-serve-static-core' {
+  interface Request {
+    /** Parsed Inertia request info, populated by the middleware. */
+    inertia?: InertiaRequestInfo;
+    /**
+     * `connect-flash`-compatible flash API. This package replaces
+     * `connect-flash` — see {@link InertiaMiddlewareOptions.flashFromSession}.
+     *
+     * - `req.flash()` — read and clear every flash bucket.
+     * - `req.flash(type)` — read and clear one type's bucket.
+     * - `req.flash(type, msg)` — append a message, return the new count.
+     * - `req.flash(type, format, ...args)` — append a `util.format`ed message.
+     */
+    flash: {
+      (): Record<string, string[]>;
+      (type: string): string[];
+      (type: string, message: string | string[]): number;
+      (type: string, format: string, ...args: unknown[]): number;
+    };
+  }
+  interface Response {
+    /**
+     * Render an Inertia page. See {@link ResInertiaApi}.
+     */
+    inertia: ResInertiaApi;
+    /**
+     * Trigger an external redirect via the Inertia-Location protocol.
+     * Sends 409 with `X-Inertia-Location` for Inertia requests; sends a
+     * normal 302 for plain browser requests.
+     */
+    inertiaLocation: InertiaLocation;
+    /**
+     * Share validation errors with the client. Helper around setting
+     * `req.session.errors`, but framework-agnostic (no session required).
+     */
+    inertiaErrors: (errors: ValidationErrors, bag?: string) => void;
+    /**
+     * Stash flash data for the next request. Stored in `req.session.flash`
+     * and surfaced as the `flash` shared prop when `flashFromSession` is
+     * enabled. Replaces any flash already queued for this redirect.
+     * No-ops when no session is wired.
+     */
+    inertiaFlash: (data: Record<string, unknown>) => void;
+  }
+}
+//#endregion
+//#region src/express/middleware.d.ts
+/**
+ * Create the Inertia.js Express middleware.
+ *
+ * The middleware:
+ *   - Parses Inertia headers into `req.inertia`.
+ *   - Adds `req.flash(type?, msg?)` — a `connect-flash`-compatible API.
+ *   - Adds `res.inertia(component, props, options)`.
+ *   - Adds `res.inertiaLocation(url)` for external redirects.
+ *   - Adds `res.inertiaErrors(errors, bag?)` to flash validation errors.
+ *   - Adds `res.inertiaFlash(data)` to flash arbitrary data.
+ *   - Auto-promotes redirects after PUT/PATCH/DELETE to 303 for Inertia visits.
+ *
+ * Mount before your route handlers:
+ *
+ * ```ts
+ * app.use(inertia({ rootView: ..., sharedProps: ... }));
+ * ```
+ *
+ * @param options Middleware configuration; defaults to an empty object.
+ */
+declare function inertia(options?: InertiaMiddlewareOptions): (req: Request, res: Response, next: NextFunction) => void;
+//#endregion
+//#region src/express/memory-store.d.ts
+/**
+ * In-process LRU + TTL cache for SSR responses.
+ *
+ * Suitable as L1 cache in front of Redis (`@blacklizard/inertia-cache-redis`)
+ * or by itself for low-traffic / single-instance deployments.
+ *
+ * Notes:
+ *   - Bounded by entry count (`max`), not bytes. Keep it conservative.
+ *   - TTL is enforced lazily on `get()` — expired entries are removed at
+ *     read time and never returned.
+ *   - Not safe across processes. For multi-pod web tiers, layer Redis on top.
+ */
+interface MemoryCacheStoreOptions {
+  /** Maximum number of entries before LRU eviction kicks in. Default 500. */
+  max?: number;
+}
+/**
+ * Build an in-process LRU + TTL {@link SsrCacheStore}. See
+ * {@link MemoryCacheStoreOptions} for the full contract.
+ *
+ * @param options Store configuration; defaults applied when omitted.
+ */
+declare function createMemoryCacheStore(options?: MemoryCacheStoreOptions): SsrCacheStore;
+//#endregion
+//#region src/express/prerender.d.ts
+/**
+ * Inputs to {@link prerender}.
+ */
+interface PrerenderOptions {
+  /** Origin to fetch from, e.g. `http://127.0.0.1:3000`. */
+  baseUrl: string;
+  /** List of paths to render. Each must start with `/`. */
+  routes: string[];
+  /** Output mode. Default `"warmup"`. */
+  mode?: 'static' | 'warmup' | 'both';
+  /** Output directory for static HTML. Required when mode includes `"static"`. */
+  outDir?: string;
+  /** Concurrency limit. Default 4. */
+  concurrency?: number;
+  /** Per-request timeout, ms. Default 30000. */
+  timeoutMs?: number;
+  /** Extra request headers (auth, host override, A/B bucket pinning, etc.). */
+  headers?: Record<string, string>;
+  /** Optional fetch override (for testing). */
+  fetch?: typeof fetch;
+}
+/**
+ * Per-route outcome from a prerender run. `status` is `null` and `error` is
+ * populated when the request failed before producing a response.
+ */
+interface PrerenderRouteResult {
+  route: string;
+  status: number | null;
+  bytes: number;
+  outputPath?: string;
+  error?: string;
+  durationMs: number;
+}
+/**
+ * Aggregate result returned by {@link prerender}. `ok + failed === total`;
+ * a route counts as `ok` when it returned a 2xx/3xx status and no error.
+ */
+interface PrerenderSummary {
+  total: number;
+  ok: number;
+  failed: number;
+  results: PrerenderRouteResult[];
+}
+/**
+ * Run the prerender pipeline. Programmatic entry-point for the
+ * `bin/inertia-prerender` CLI.
+ *
+ * Two output modes (which can be combined via `"both"`):
+ *
+ * - **`warmup`** (default) — fetches each route, discards the body. Use to
+ *   populate the SSR view cache after a deploy so the first real visitor
+ *   doesn't pay the SSR latency cost.
+ * - **`static`** — fetches each route and writes the response body to
+ *   `<outDir>/<route>/index.html`. Serve those files directly via
+ *   nginx/CDN, bypassing Express entirely.
+ *
+ * Bounded-concurrency: `concurrency` workers consume routes from a shared
+ * counter; the returned `results` preserve input order. Failures on
+ * individual routes never halt the run — the per-route summary lets a CI
+ * step choose to fail-loud.
+ *
+ * @param options Pipeline configuration — see {@link PrerenderOptions}.
+ */
+declare function prerender(options: PrerenderOptions): Promise<PrerenderSummary>;
+//#endregion
+//#region src/express/response.d.ts
+interface RenderContext {
+  options: InertiaMiddlewareOptions;
+}
+/**
+ * Send the Inertia version-mismatch response: 409 with `X-Inertia-Location`
+ * pointing back at the same URL so the client performs a hard reload.
+ *
+ * @param res Outgoing Express response.
+ * @param url Location to send the client to (typically the requested URL).
+ */
+declare function sendVersionMismatch(res: Response, url: string): void;
+/**
+ * Send an external Inertia redirect. For Inertia (XHR) requests this returns
+ * 409 + `X-Inertia-Location` so the client performs a window.location nav.
+ * For plain browser requests it falls back to a normal 302 redirect.
+ *
+ * @param req Incoming Express request; `req.inertia` is reused when present.
+ * @param res Outgoing Express response.
+ * @param target Destination URL.
+ */
+declare function sendInertiaLocation(req: Request, res: Response, target: string): void;
+/**
+ * Build and send an Inertia response. Handles version-mismatch detection,
+ * partial-reload filtering, JSON vs HTML, SSR, view caching, and edge
+ * cache headers. The status code already on `res` (e.g. `res.status(404)`)
+ * is preserved on both the JSON and HTML branches.
+ *
+ * @param req Incoming Express request.
+ * @param res Outgoing Express response.
+ * @param ctx Render context carrying the middleware options.
+ * @param component Inertia component name to render.
+ * @param props Page-specific props (merged with shared props).
+ * @param options Optional per-response overrides (url, clearHistory, encryptHistory).
+ */
+declare function sendInertiaResponse(req: Request, res: Response, ctx: RenderContext, component: string, props: PageProps, options?: InertiaResponseOptions): Promise<void>;
+//#endregion
+//#region src/express/ssr-fetcher.d.ts
+/**
+ * Inputs to {@link createInertiaSsrFetcher}.
+ */
+interface InertiaSsrFetcherOptions {
+  /** SSR endpoint URL — typically your internal LB DNS, e.g. `http://ssr.internal/render`. */
+  url: string;
+  /** Per-attempt timeout in milliseconds. Default 5000. */
+  timeoutMs?: number;
+  /** Number of retry attempts after the first failure. Default 2 (so up to 3 total tries). */
+  retries?: number;
+  /** Initial backoff in ms; doubles per retry. Default 100. */
+  retryBaseMs?: number;
+  /**
+   * Circuit breaker: open after this many consecutive failures.
+   * Set to `0` (or `Infinity`) to disable. Default 5.
+   */
+  breakerThreshold?: number;
+  /** How long the breaker stays open before allowing one probe. Default 30000. */
+  breakerCooldownMs?: number;
+  /** Failure mode. Default `"client"`. */
+  fallback?: 'client' | 'throw';
+  /** Override fetch implementation (testing). */
+  fetch?: typeof fetch;
+  /** Extra headers sent with each render request. */
+  headers?: Record<string, string>;
+}
+/**
+ * Build an {@link SsrRenderer} that POSTs the page object to a separate Node
+ * SSR process (or load-balanced pool) and returns the rendered
+ * `{ head, body }`.
+ *
+ * Matches the wire protocol used by `@inertiajs/{vue3,react,svelte}/server`
+ * `createServer()`: `POST <url>` with `application/json` body containing the
+ * page object, response is `{ head: string[], body: string }`.
+ *
+ * Adds production hardening on top of the bare protocol:
+ *   - Per-attempt timeout (default 5000ms) via `AbortController`.
+ *   - Recursive retry with exponential backoff (`retryBaseMs * 2^attempt`).
+ *   - Circuit breaker — opens after `breakerThreshold` consecutive failed
+ *     *requests* (not attempts); half-opens after `breakerCooldownMs` so a
+ *     probe request can re-close it on success.
+ *   - `fallback`: `"client"` returns an empty SSR result so the client
+ *     renders alone; `"throw"` rethrows so Express's error handler can react.
+ *
+ * @param options Fetcher configuration — see {@link InertiaSsrFetcherOptions}.
+ */
+declare function createInertiaSsrFetcher(options: InertiaSsrFetcherOptions): SsrRenderer;
+//#endregion
+//#region src/express/vite-manifest.d.ts
+/**
+ * Inputs to {@link viteManifestVersion}.
+ */
+interface ViteManifestVersionOptions {
+  /** Path to `manifest.json`. */
+  manifestPath: string;
+  /**
+   * If `true` (default), the manifest is re-read on every call when its
+   * mtime has advanced. Set to `false` to read once on boot — slightly
+   * faster but requires a process restart to pick up new builds.
+   */
+  watchMtime?: boolean;
+}
+/**
+ * Build a stable asset version from a Vite-generated `manifest.json`.
+ *
+ * Compatible with both `@inertiajs/vite-plugin` output and the standard
+ * `--manifest` option from `vite build`. The returned function is suitable
+ * to pass directly as the `version` option of the Inertia middleware.
+ *
+ * Strategy:
+ *   - Read the manifest file.
+ *   - Hash a canonicalized list of `(key -> file)` entries (only the `file`
+ *     field per entry, so unrelated manifest metadata never perturbs the hash).
+ *   - Cache the result; re-read only after the file's mtime changes (when
+ *     `watchMtime` is true) or never re-read (when false).
+ *   - Returns `null` when the manifest file is absent or unparseable.
+ *
+ * A new manifest (different hashed output paths) yields a new version, which
+ * the middleware embeds in the SSR cache key — so a deploy atomically
+ * invalidates every existing cache entry.
+ *
+ * @param options Path to the manifest plus the mtime-watch flag.
+ */
+declare function viteManifestVersion(options: ViteManifestVersionOptions): () => Promise<string | null>;
+//#endregion
+export { type AlwaysProp, type ComputeCacheKeyInput, type DeepMergeProp, type DeferredProp, type EdgeCacheDecision, type EdgeCachePolicy, INERTIA_HEADERS, INERTIA_LOCATION_STATUS, INERTIA_REDIRECT_STATUS, type InertiaCacheOptions, type InertiaMiddlewareOptions, type InertiaPage, type InertiaRequestInfo, type InertiaResponseOptions, type InertiaSsrFetcherOptions, type LazyProp, type MemoryCacheStoreOptions, type MergeProp, type OptionalProp, type PageProps, type PrerenderOptions, type PrerenderRouteResult, type PrerenderSummary, type RootViewInput, type RootViewRenderer, type SharedPropsInput, type SsrCacheEntry, type SsrCacheStore, type SsrRenderer, type SsrRendererInput, type SsrResult, type ValidationErrors, type VersionResolver, type ViteManifestVersionOptions, always, applyEdgeCache, canonicalStringify, computeSsrCacheKey, createInertiaSsrFetcher, createMemoryCacheStore, deepMerge, inertia as default, inertia, defer, encodePageScript, lazy, merge, optional, prerender, sendInertiaLocation, sendInertiaResponse, sendVersionMismatch, viteManifestVersion };
+//# sourceMappingURL=index.d.ts.map

package/dist/express/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/express/edge-cache.ts","../../src/express/types.ts","../../src/express/middleware.ts","../../src/express/memory-store.ts","../../src/express/prerender.ts","../../src/express/response.ts","../../src/express/ssr-fetcher.ts","../../src/express/vite-manifest.ts"],"mappings":"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"}