@wular/pnext 0.0.4 → 0.0.6

package/src/compat/image-optimizer/source.ts

@@ -8,36 +8,36 @@
 // Next's fetchExternalImage / fetchInternalImage exactly.
 // ---------------------------------------------------------------------------
 
-import { lookup } from 'node:dns/promises';
-import { isIP } from 'node:net';
-import { getHash } from './cache';
+import { lookup } from 'node:dns/promises'
+import { isIP } from 'node:net'
+import { getHash } from './cache'
 
 export class ImageError extends Error {
-  statusCode: number;
+  statusCode: number
   constructor(statusCode: number, message: string) {
-    super(message);
+    super(message)
     // Ensure an error status is used > 400 (Next normalizes 1xx-3xx to 500).
-    this.statusCode = statusCode >= 400 ? statusCode : 500;
+    this.statusCode = statusCode >= 400 ? statusCode : 500
   }
 }
 
 export interface ImageUpstream {
-  buffer: Buffer;
-  contentType: string | null;
-  cacheControl: string | null;
-  etag: string;
+  buffer: Buffer
+  contentType: string | null
+  cacheControl: string | null
+  etag: string
 }
 
 /** Upstream etag when present (base64url so it is filename-safe), else a content hash. */
 export function extractEtag(etag: string | null | undefined, buffer: Buffer): string {
-  if (etag) return Buffer.from(etag).toString('base64url');
-  return getHash([buffer]);
+  if (etag) return Buffer.from(etag).toString('base64url')
+  return getHash([buffer])
 }
 
 function isPrivateIp(ip: string): boolean {
   if (isIP(ip) === 4) {
-    const parts = ip.split('.').map(Number);
-    const [a = -1, b = -1] = parts;
+    const parts = ip.split('.').map(Number)
+    const [a = -1, b = -1] = parts
     return (
       a === 0 ||
       a === 10 ||
@@ -46,9 +46,9 @@ function isPrivateIp(ip: string): boolean {
       (a === 172 && b >= 16 && b <= 31) ||
       (a === 192 && b === 168) ||
       (a === 169 && b === 254)
-    );
+    )
   }
-  const lower = ip.toLowerCase();
+  const lower = ip.toLowerCase()
   return (
     lower === '::' ||
     lower === '::1' ||
@@ -60,11 +60,11 @@ function isPrivateIp(ip: string): boolean {
     lower.startsWith('feb') ||
     lower.startsWith('::ffff:127.') ||
     lower === 'localhost'
-  );
+  )
 }
 
 function isRedirect(status: number): boolean {
-  return [301, 302, 303, 307, 308].includes(status);
+  return [301, 302, 303, 307, 308].includes(status)
 }
 
 async function readBodyWithLimit(
@@ -72,21 +72,21 @@ async function readBodyWithLimit(
   maximumResponseBody: number,
   onExceeded: () => never,
 ): Promise<Buffer> {
-  const chunks: Buffer[] = [];
-  let totalSize = 0;
-  const reader = body.getReader();
+  const chunks: Buffer[] = []
+  let totalSize = 0
+  const reader = body.getReader()
   for (;;) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    const chunk = Buffer.from(value);
-    totalSize += chunk.byteLength;
+    const { done, value } = await reader.read()
+    if (done) break
+    const chunk = Buffer.from(value)
+    totalSize += chunk.byteLength
     if (totalSize > maximumResponseBody) {
-      await reader.cancel().catch(() => undefined);
-      onExceeded();
+      await reader.cancel().catch(() => undefined)
+      onExceeded()
     }
-    chunks.push(chunk);
+    chunks.push(chunk)
   }
-  return Buffer.concat(chunks);
+  return Buffer.concat(chunks)
 }
 
 export async function fetchExternalImage(
@@ -96,15 +96,15 @@ export async function fetchExternalImage(
   count: number,
 ): Promise<ImageUpstream> {
   if (!dangerouslyAllowLocalIP) {
-    const { hostname } = new URL(href);
-    let ips = [hostname];
+    const { hostname } = new URL(href)
+    let ips = [hostname]
     if (!isIP(hostname)) {
       const records = await lookup(hostname, { family: 0, all: true }).catch(() => [
         { address: hostname },
-      ]);
-      ips = records.map(record => record.address);
+      ])
+      ips = records.map(record => record.address)
     }
-    const privateIps = ips.filter(ip => isPrivateIp(ip));
+    const privateIps = ips.filter(ip => isPrivateIp(ip))
     if (privateIps.length > 0) {
       console.error(
         'upstream image',
@@ -112,60 +112,57 @@ export async function fetchExternalImage(
         'hostname resolved to private IP',
         JSON.stringify(privateIps),
         'If this is expected and you understand SSRF risk, use images.dangerouslyAllowLocalIP = true to continue.',
-      );
-      throw new ImageError(400, '"url" parameter is not allowed');
+      )
+      throw new ImageError(400, '"url" parameter is not allowed')
     }
   }
 
   const res = await fetch(href, {
     signal: AbortSignal.timeout(7_000),
     redirect: 'manual',
-  }).catch(err => err as Error);
+  }).catch(err => err as Error)
 
   if (res instanceof Error) {
-    const err = res;
+    const err = res
     if (err.name === 'TimeoutError' || err.name === 'AbortError') {
-      console.error('upstream image response timed out for', href);
-      throw new ImageError(504, '"url" parameter is valid but upstream response timed out');
+      console.error('upstream image response timed out for', href)
+      throw new ImageError(504, '"url" parameter is valid but upstream response timed out')
     }
-    throw err;
+    throw err
   }
 
-  const locationHeader = res.headers.get('Location');
+  const locationHeader = res.headers.get('Location')
   if (isRedirect(res.status) && locationHeader && URL.canParse(locationHeader, href)) {
-    await res.body?.cancel().catch(() => undefined);
+    await res.body?.cancel().catch(() => undefined)
     if (count === 0) {
-      console.error('upstream image response had too many redirects', href);
-      throw new ImageError(508, '"url" parameter is valid but upstream response is invalid');
+      console.error('upstream image response had too many redirects', href)
+      throw new ImageError(508, '"url" parameter is valid but upstream response is invalid')
     }
-    const redirect = new URL(locationHeader, href).href;
-    return fetchExternalImage(redirect, dangerouslyAllowLocalIP, maximumResponseBody, count - 1);
+    const redirect = new URL(locationHeader, href).href
+    return fetchExternalImage(redirect, dangerouslyAllowLocalIP, maximumResponseBody, count - 1)
   }
 
   if (!res.ok) {
-    console.error('upstream image response failed for', href, res.status);
-    throw new ImageError(
-      res.status,
-      '"url" parameter is valid but upstream response is invalid',
-    );
+    console.error('upstream image response failed for', href, res.status)
+    throw new ImageError(res.status, '"url" parameter is valid but upstream response is invalid')
   }
 
   if (!res.body) {
-    console.error('upstream image response is empty for', href);
-    throw new ImageError(400, '"url" parameter is valid but upstream response is invalid');
+    console.error('upstream image response is empty for', href)
+    throw new ImageError(400, '"url" parameter is valid but upstream response is invalid')
   }
 
   const buffer = await readBodyWithLimit(res.body, maximumResponseBody, () => {
-    console.error('upstream image response exceeded maximum size for', href);
-    throw new ImageError(413, '"url" parameter is valid but upstream response is invalid');
-  });
+    console.error('upstream image response exceeded maximum size for', href)
+    throw new ImageError(413, '"url" parameter is valid but upstream response is invalid')
+  })
 
   return {
     buffer,
     contentType: res.headers.get('Content-Type'),
     cacheControl: res.headers.get('Cache-Control'),
     etag: extractEtag(res.headers.get('ETag'), buffer),
-  };
+  }
 }
 
 /**
@@ -182,27 +179,27 @@ export async function readPublicFile(
   publicDirs: string[],
   href: string,
 ): Promise<Buffer | undefined> {
-  let decoded: string;
+  let decoded: string
   try {
-    decoded = decodeURIComponent(href.split('?', 1)[0] ?? href);
+    decoded = decodeURIComponent(href.split('?', 1)[0] ?? href)
   } catch {
-    return undefined;
+    return undefined
   }
-  if (decoded.includes('..') || decoded.includes('\0')) return undefined;
-  const fs = await import('node:fs/promises');
-  const path = await import('node:path');
+  if (decoded.includes('..') || decoded.includes('\0')) return undefined
+  const fs = await import('node:fs/promises')
+  const path = await import('node:path')
   for (const dir of publicDirs) {
     for (const form of ['NFC', 'NFD'] as const) {
-      const candidate = path.join(dir, ...decoded.normalize(form).split('/').filter(Boolean));
-      if (!candidate.startsWith(dir)) continue;
+      const candidate = path.join(dir, ...decoded.normalize(form).split('/').filter(Boolean))
+      if (!candidate.startsWith(dir)) continue
       try {
-        return await fs.readFile(candidate);
+        return await fs.readFile(candidate)
       } catch {
         // try next candidate
       }
     }
   }
-  return undefined;
+  return undefined
 }
 
 export async function fetchInternalImage(
@@ -214,19 +211,19 @@ export async function fetchInternalImage(
     const res = await fetch(new URL(href, origin), {
       redirect: 'follow',
       headers: { 'x-pnext-internal-image': '1' },
-    });
+    })
 
     if (!res.body) {
-      console.error('internal image response is empty for', href);
-      throw new ImageError(400, '"url" parameter is valid but internal response is invalid');
+      console.error('internal image response is empty for', href)
+      throw new ImageError(400, '"url" parameter is valid but internal response is invalid')
     }
     const buffer = await readBodyWithLimit(res.body, maximumResponseBody, () => {
-      console.error('internal image response exceeded maximum size for', href);
-      throw new ImageError(413, '"url" parameter is valid but internal response is invalid');
-    });
+      console.error('internal image response exceeded maximum size for', href)
+      throw new ImageError(413, '"url" parameter is valid but internal response is invalid')
+    })
     if (buffer.byteLength === 0) {
-      console.error('internal image response is empty for', href);
-      throw new ImageError(400, '"url" parameter is valid but internal response is invalid');
+      console.error('internal image response is empty for', href)
+      throw new ImageError(400, '"url" parameter is valid but internal response is invalid')
     }
 
     return {
@@ -234,10 +231,10 @@ export async function fetchInternalImage(
       contentType: res.headers.get('Content-Type'),
       cacheControl: res.headers.get('Cache-Control'),
       etag: extractEtag(res.headers.get('ETag'), buffer),
-    };
+    }
   } catch (err) {
-    if (err instanceof ImageError) throw err;
-    console.error('upstream image response failed for', href, err);
-    throw new ImageError(500, '"url" parameter is valid but upstream response is invalid');
+    if (err instanceof ImageError) throw err
+    console.error('upstream image response failed for', href, err)
+    throw new ImageError(500, '"url" parameter is valid but upstream response is invalid')
   }
 }

package/src/compat/lifecycle/after-scope.ts

@@ -8,37 +8,37 @@
 //
 // The route pathname is stashed on the work unit at request start so the detached callback can name it.
 
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { currentRequest, getWorkUnit } from '../../request/context';
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { currentRequest, getWorkUnit } from '../../request/context'
 
-const REQUEST_PATH_KEY = Symbol.for('pnext.requestPath');
-const INSPECT_CUSTOM = Symbol.for('nodejs.util.inspect.custom');
-const requestApiScope = new AsyncLocalStorage<boolean>();
+const REQUEST_PATH_KEY = Symbol.for('pnext.requestPath')
+const INSPECT_CUSTOM = Symbol.for('nodejs.util.inspect.custom')
+const requestApiScope = new AsyncLocalStorage<boolean>()
 
 /** Run one after() task with its request-API capability. */
 export function runWithAfterRequestApiScope<T>(allowed: boolean, callback: () => T): T {
-  return requestApiScope.run(allowed, callback);
+  return requestApiScope.run(allowed, callback)
 }
 
 /** Whether the current after() task may use request APIs. */
 export function afterRequestApisAllowed(): boolean {
-  return requestApiScope.getStore() === true;
+  return requestApiScope.getStore() === true
 }
 
 /** Stash the request pathname on the active work unit for after() diagnostics. */
 export function recordRequestPath(pathname: string): void {
-  const unit = getWorkUnit();
-  if (unit) (unit.compat ??= {})[REQUEST_PATH_KEY] = pathname;
+  const unit = getWorkUnit()
+  if (unit) (unit.compat ??= {})[REQUEST_PATH_KEY] = pathname
 }
 
 function currentRoutePath(): string {
-  const recorded = getWorkUnit()?.compat?.[REQUEST_PATH_KEY] as string | undefined;
-  if (recorded) return recorded;
+  const recorded = getWorkUnit()?.compat?.[REQUEST_PATH_KEY] as string | undefined
+  if (recorded) return recorded
   try {
-    const request = currentRequest();
-    return request ? new URL(request.url).pathname : '';
+    const request = currentRequest()
+    return request ? new URL(request.url).pathname : ''
   } catch {
-    return '';
+    return ''
   }
 }
 
@@ -47,14 +47,14 @@ function currentRoutePath(): string {
 // with no misleading pnext-internal stack frame (the suite matches the message
 // text exactly). Typed as Error so throw sites satisfy `only-throw-error`.
 export function lifecycleError(message: string): Error {
-  const formatted = `Error: ${message}`;
+  const formatted = `Error: ${message}`
   return {
     name: 'Error',
     message,
     stack: formatted,
     toString: () => formatted,
     [INSPECT_CUSTOM]: () => formatted,
-  } as unknown as Error;
+  } as unknown as Error
 }
 
 /**
@@ -62,16 +62,16 @@ export function lifecycleError(message: string): Error {
  * detached after() callback (render phase, no live request scope). Returns
  * without throwing in every legal case so callers proceed to the normal path.
  */
-export function assertRequestApiAllowedInAfter(api: 'headers()' | 'cookies()' | 'connection()'): void {
-  const unit = getWorkUnit();
-  if (unit?.phase !== 'after') return;
+export function assertRequestApiAllowedInAfter(
+  api: 'headers()' | 'cookies()' | 'connection()',
+): void {
+  const unit = getWorkUnit()
+  if (unit?.phase !== 'after') return
   // Rendering keeps a synthetic request context during prerendering, so the
   // explicit after-task capability—not merely currentRequest()—defines this.
-  if (afterRequestApisAllowed() && currentRequest()) return;
-  const suffix = api === 'connection()' ? '' : ' This is not supported.';
-  throw lifecycleError(
-    `Route ${currentRoutePath()} used \`${api}\` inside \`after()\`.${suffix}`,
-  );
+  if (afterRequestApisAllowed() && currentRequest()) return
+  const suffix = api === 'connection()' ? '' : ' This is not supported.'
+  throw lifecycleError(`Route ${currentRoutePath()} used \`${api}\` inside \`after()\`.${suffix}`)
 }
 
 /**
@@ -79,8 +79,8 @@ export function assertRequestApiAllowedInAfter(api: 'headers()' | 'cookies()' |
  * every context (Next's exact message names the route + method).
  */
 export function assertDraftModeToggleAllowedInAfter(method: 'enable' | 'disable'): void {
-  if (getWorkUnit()?.phase !== 'after') return;
+  if (getWorkUnit()?.phase !== 'after') return
   throw lifecycleError(
     `Route ${currentRoutePath()} used "draftMode().${method}()" inside \`after()\``,
-  );
+  )
 }

package/src/compat/lifecycle/after.ts

@@ -10,42 +10,41 @@
 // handed to it so a serverless platform keeps the invocation alive until it settles. When no work unit
 // is active, the task runs on the microtask queue as a best-effort fallback.
 
-import { captureCacheScope } from '../../cache/context';
+import { captureCacheScope } from '../../request/cache'
 import {
   captureRequestScope,
   currentRequest,
   getWorkUnit,
   queueAfterTask,
   setPhase,
-} from '../../request/context';
-import { currentRenderCacheMeta } from '../cache/revalidate';
+} from '../../request/context'
+import { currentRenderCacheMeta } from '../cache/revalidate'
 import {
   afterRequestApisAllowed,
   recordRequestPath,
   runWithAfterRequestApiScope,
-} from './after-scope';
+} from './after-scope'
 
-type AfterTask<T> = Promise<T> | (() => T | Promise<T>);
+type AfterTask<T> = Promise<T> | (() => T | Promise<T>)
 
-const requestContextSymbol = Symbol.for('@next/request-context');
+const requestContextSymbol = Symbol.for('@next/request-context')
 
 /**
  * Marks an error that escaped an after() task during a BUILD prerender. The build's per-route
  * skip-and-warn catch reads it to fail the build instead of silently degrading the route to dynamic -
  * Next fails the build when after() throws while prerendering.
  */
-export const AFTER_PRERENDER_ERROR = Symbol.for('pnext.afterPrerenderError');
+export const AFTER_PRERENDER_ERROR = Symbol.for('pnext.afterPrerenderError')
 
 interface VercelRequestContext {
-  get?: () => { waitUntil?: (promise: Promise<unknown>) => void } | undefined;
+  get?: () => { waitUntil?: (promise: Promise<unknown>) => void } | undefined
 }
 
 /** The platform waitUntil, when a Vercel-style request context is present. */
 function platformWaitUntil(): ((promise: Promise<unknown>) => void) | undefined {
   const holder = (globalThis as Record<symbol, unknown>)[requestContextSymbol] as
-    | VercelRequestContext
-    | undefined;
-  return holder?.get?.()?.waitUntil;
+    VercelRequestContext | undefined
+  return holder?.get?.()?.waitUntil
 }
 
 /**
@@ -62,13 +61,15 @@ async function runAfterTask<T>(task: AfterTask<T>): Promise<void> {
       error => {
         console.error(
           `An error occurred in a function passed to \`after()\`: ${
-            error instanceof Error ? (error.stack ?? `${error.name}: ${error.message}`) : String(error)
+            error instanceof Error
+              ? (error.stack ?? `${error.name}: ${error.message}`)
+              : String(error)
           }`,
-        );
+        )
       },
-    );
-  platformWaitUntil()?.(promise);
-  await promise;
+    )
+  platformWaitUntil()?.(promise)
+  await promise
 }
 
 /**
@@ -79,20 +80,23 @@ async function runAfterTask<T>(task: AfterTask<T>): Promise<void> {
  * rejection) so a serverless platform keeps the invocation alive until it ends.
  */
 async function settleAfterTask<T>(task: AfterTask<T>): Promise<void> {
-  const promise = Promise.resolve().then(() =>
-    typeof task === 'function' ? task() : task,
-  );
-  platformWaitUntil()?.(promise.then(() => undefined, () => undefined));
+  const promise = Promise.resolve().then(() => (typeof task === 'function' ? task() : task))
+  platformWaitUntil()?.(
+    promise.then(
+      () => undefined,
+      () => undefined,
+    ),
+  )
   try {
-    await promise;
+    await promise
   } catch (error) {
     // Tag so the build's per-route catch fails the build rather than degrading
     // the route to dynamic. The tag rides the same error object up through the
     // static after-drain (which re-throws it) to cli/build.ts.
     if (error && typeof error === 'object') {
-      (error as Record<symbol, unknown>)[AFTER_PRERENDER_ERROR] = true;
+      ;(error as Record<symbol, unknown>)[AFTER_PRERENDER_ERROR] = true
     }
-    throw error;
+    throw error
   }
 }
 
@@ -108,9 +112,9 @@ function runInPrerenderAfterPhase<T>(
   requestApisAllowed: boolean,
   fn: () => T,
 ): T {
-  setPhase('after');
-  if (route) recordRequestPath(route);
-  return runWithAfterRequestApiScope(requestApisAllowed, fn);
+  setPhase('after')
+  if (route) recordRequestPath(route)
+  return runWithAfterRequestApiScope(requestApisAllowed, fn)
 }
 
 /**
@@ -124,50 +128,49 @@ export function after<T>(task: AfterTask<T>): void {
   // its after() callbacks run detached, so headers()/cookies()/connection() throw Next's "used inside
   // after()" error. The phase distinguishes them - renders stay 'render', handlers set routeKind,
   // actions set phase 'action'.
-  const unit = getWorkUnit();
+  const unit = getWorkUnit()
   const isHandlerOrAction =
-    unit?.phase === 'action' ||
-    unit?.phase === 'middleware' ||
-    unit?.routeKind === 'route-handler';
+    unit?.phase === 'action' || unit?.phase === 'middleware' || unit?.routeKind === 'route-handler'
   const isNestedRequestAfter =
-    unit?.phase === 'after' && Boolean(currentRequest()) && afterRequestApisAllowed();
+    unit?.phase === 'after' && Boolean(currentRequest()) && afterRequestApisAllowed()
   // Handlers and actions capture the live request scope so headers()/cookies() keep working inside their
   // after() callbacks. A page render (or generateMetadata) instead captures only the React cache()
   // scope, so cache() shares the render's memo cache in the callback while the request scope stays
   // detached and headers()/cookies()/connection() still throw Next's "used inside after()" error.
   const withScope =
-    isHandlerOrAction || isNestedRequestAfter
-      ? captureRequestScope()
-      : captureCacheScope();
+    isHandlerOrAction || isNestedRequestAfter ? captureRequestScope() : captureCacheScope()
   // Static-generation render (build prerender or ISR regeneration): there is
   // no response close to flush against, so the task queues on the render's
   // cache meta and the render drains it once produce settles (Next waits for
   // after() during prerendering). Build prerenders propagate rejections so a
   // throwing after() fails the page's prerender (next-after-app-static);
   // runtime regenerations log-and-continue like every other runtime path.
-  const meta = currentRenderCacheMeta();
+  const meta = currentRenderCacheMeta()
   if (meta && (meta.prerender === true || meta.blockingStaleFetches === true)) {
     // A build/ISR prerender runs with no work unit, so the top-level routeKind check above cannot tell a
     // route-handler prerender from a page one - meta.handler does. A handler prerender captures the live
     // request scope so request APIs resolve inside after(); a page prerender keeps only the cache scope
     // so they throw "used inside after()".
-    const prerenderScope = meta.handler ? captureRequestScope() : withScope;
-    const route = meta.route;
-    const requestApisAllowed = Boolean(meta.handler);
+    const prerenderScope = meta.handler ? captureRequestScope() : withScope
+    const route = meta.route
+    const requestApisAllowed = Boolean(meta.handler)
     const run = meta.prerender
       ? () =>
           prerenderScope(() =>
             runInPrerenderAfterPhase(route, requestApisAllowed, () => settleAfterTask(task)),
           )
-      : () => prerenderScope(() => runWithAfterRequestApiScope(requestApisAllowed, () => runAfterTask(task)));
-    (meta.afterTasks ??= []).push(run);
-    return;
+      : () =>
+          prerenderScope(() =>
+            runWithAfterRequestApiScope(requestApisAllowed, () => runAfterTask(task)),
+          )
+    ;(meta.afterTasks ??= []).push(run)
+    return
   }
-  const requestApisAllowed = Boolean(isHandlerOrAction || isNestedRequestAfter);
+  const requestApisAllowed = Boolean(isHandlerOrAction || isNestedRequestAfter)
   const queued = queueAfterTask(() =>
     withScope(() => runWithAfterRequestApiScope(requestApisAllowed, () => runAfterTask(task))),
-  );
-  if (queued) return;
+  )
+  if (queued) return
   // No active work unit (e.g. called at module scope): best-effort microtask.
-  void withScope(() => runWithAfterRequestApiScope(requestApisAllowed, () => runAfterTask(task)));
+  void withScope(() => runWithAfterRequestApiScope(requestApisAllowed, () => runAfterTask(task)))
 }