@reckona/mreact-router 0.0.65 → 0.0.67

package/src/session.ts

@@ -0,0 +1,238 @@
+import { deleteCookie, parseCookieHeader, setCookie } from "./cookies.js";
+
+export interface SessionRecord<TData = unknown> {
+  createdAt: number;
+  data: TData;
+  expiresAt: number;
+  id: string;
+  rotatedAt?: number;
+}
+
+export interface SessionStore<TData = unknown> {
+  delete(id: string): void | Promise<void>;
+  get(id: string): SessionRecord<TData> | undefined | Promise<SessionRecord<TData> | undefined>;
+  set(record: SessionRecord<TData>): void | Promise<void>;
+}
+
+export interface MemorySessionStoreOptions {
+  maxEntries?: number;
+  sweepIntervalMs?: number;
+}
+
+export interface SessionCookieOptions {
+  cookieName?: string;
+  maxAgeSeconds?: number;
+  path?: string;
+  sameSite?: "Strict" | "Lax" | "None";
+  secure?: boolean;
+}
+
+const DEFAULT_MAX_AGE_SECONDS = 7 * 24 * 60 * 60;
+const SESSION_COOKIE_DEV = "mreact.session";
+const SESSION_COOKIE_PROD = "__Host-mreact.session";
+
+function isProduction(): boolean {
+  return process.env.NODE_ENV === "production";
+}
+
+function defaultCookieName(): string {
+  return isProduction() ? SESSION_COOKIE_PROD : SESSION_COOKIE_DEV;
+}
+
+function sessionCookieOptions(options: SessionCookieOptions = {}) {
+  const production = isProduction();
+
+  return {
+    httpOnly: true,
+    maxAge: options.maxAgeSeconds ?? DEFAULT_MAX_AGE_SECONDS,
+    path: production ? "/" : options.path ?? "/",
+    sameSite: options.sameSite ?? "Lax",
+    secure: options.secure ?? production,
+  } as const;
+}
+
+function readSessionId(
+  request: Request,
+  options: SessionCookieOptions = {},
+): string | undefined {
+  const values = parseCookieHeader(request.headers.get("cookie"));
+  return values.get(options.cookieName ?? defaultCookieName());
+}
+
+function createSessionId(): string {
+  const bytes = new Uint8Array(32);
+
+  globalThis.crypto.getRandomValues(bytes);
+
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+export function createMemorySessionStore<TData>(
+  options: MemorySessionStoreOptions = {},
+): SessionStore<TData> {
+  const maxEntries = positiveIntegerOrDefault(options.maxEntries, 100_000);
+  const sweepIntervalMs = nonNegativeIntegerOrDefault(options.sweepIntervalMs, 60_000);
+  const records = new Map<string, SessionRecord<TData>>();
+  let nextSweepAt = 0;
+
+  function sweepExpired(now: number): void {
+    for (const [id, value] of records) {
+      if (value.expiresAt <= now) {
+        records.delete(id);
+      }
+    }
+
+    nextSweepAt = now + sweepIntervalMs;
+  }
+
+  function maybeSweepExpired(now: number): void {
+    if (sweepIntervalMs === 0 || now >= nextSweepAt) {
+      sweepExpired(now);
+    }
+  }
+
+  function evictOldestEntries(): void {
+    while (records.size > maxEntries) {
+      const oldestId = records.keys().next().value;
+
+      if (oldestId === undefined) {
+        return;
+      }
+
+      records.delete(oldestId);
+    }
+  }
+
+  return {
+    delete(id) {
+      records.delete(id);
+    },
+    get(id) {
+      const now = Date.now();
+      maybeSweepExpired(now);
+      const record = records.get(id);
+
+      if (record !== undefined && record.expiresAt <= now) {
+        records.delete(id);
+        return undefined;
+      }
+
+      if (record !== undefined) {
+        records.delete(id);
+        records.set(id, record);
+      }
+
+      return record;
+    },
+    set(record) {
+      const now = Date.now();
+      maybeSweepExpired(now);
+
+      records.delete(record.id);
+      records.set(record.id, record);
+
+      if (records.size > maxEntries) {
+        sweepExpired(now);
+        evictOldestEntries();
+      }
+    },
+  };
+}
+
+function positiveIntegerOrDefault(value: number | undefined, fallback: number): number {
+  return value === undefined || !Number.isInteger(value) || value < 1 ? fallback : value;
+}
+
+function nonNegativeIntegerOrDefault(value: number | undefined, fallback: number): number {
+  return value === undefined || !Number.isInteger(value) || value < 0 ? fallback : value;
+}
+
+export async function getSession<TData>(
+  request: Request,
+  store: SessionStore<TData>,
+  options: SessionCookieOptions = {},
+): Promise<SessionRecord<TData> | undefined> {
+  const id = readSessionId(request, options);
+
+  if (id === undefined || id.length === 0) {
+    return undefined;
+  }
+
+  const record = await store.get(id);
+
+  if (record === undefined) {
+    return undefined;
+  }
+
+  if (record.expiresAt <= Date.now()) {
+    await store.delete(id);
+    return undefined;
+  }
+
+  return record;
+}
+
+export async function createSession<TData>(
+  response: Response,
+  store: SessionStore<TData>,
+  data: TData,
+  options: SessionCookieOptions = {},
+): Promise<SessionRecord<TData>> {
+  const now = Date.now();
+  const maxAgeSeconds = options.maxAgeSeconds ?? DEFAULT_MAX_AGE_SECONDS;
+  const record: SessionRecord<TData> = {
+    createdAt: now,
+    data,
+    expiresAt: now + maxAgeSeconds * 1000,
+    id: createSessionId(),
+  };
+
+  await store.set(record);
+  setCookie(response, options.cookieName ?? defaultCookieName(), record.id, {
+    ...sessionCookieOptions({ ...options, maxAgeSeconds }),
+  });
+
+  return record;
+}
+
+export async function destroySession<TData>(
+  request: Request,
+  response: Response,
+  store: SessionStore<TData>,
+  options: SessionCookieOptions = {},
+): Promise<void> {
+  const id = readSessionId(request, options);
+
+  if (id !== undefined) {
+    await store.delete(id);
+  }
+
+  deleteCookie(response, options.cookieName ?? defaultCookieName(), {
+    path: isProduction() ? "/" : options.path ?? "/",
+    sameSite: options.sameSite ?? "Lax",
+    secure: options.secure ?? isProduction(),
+  });
+}
+
+export async function rotateSession<TData>(
+  request: Request,
+  response: Response,
+  store: SessionStore<TData>,
+  options: SessionCookieOptions = {},
+): Promise<SessionRecord<TData> | undefined> {
+  const current = await getSession(request, store, options);
+
+  if (current === undefined) {
+    return undefined;
+  }
+
+  await store.delete(current.id);
+  const next = await createSession(response, store, current.data, options);
+
+  return { ...next, rotatedAt: Date.now() };
+}

package/src/source-jsx.ts

@@ -0,0 +1,30 @@
+export function hasJsxSyntax(node: unknown): boolean {
+  if (Array.isArray(node)) {
+    return node.some(hasJsxSyntax);
+  }
+
+  if (node === null || typeof node !== "object") {
+    return false;
+  }
+
+  const object = node as Record<string, unknown>;
+  if (
+    object.type === "JSXElement" ||
+    object.type === "JSXFragment" ||
+    object.type === "JSXExpressionContainer"
+  ) {
+    return true;
+  }
+
+  for (const [key, value] of Object.entries(object)) {
+    if (key === "type" || key === "start" || key === "end" || key === "loc") {
+      continue;
+    }
+
+    if (hasJsxSyntax(value)) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/source-modules.ts

@@ -0,0 +1,69 @@
+import { extname, join } from "node:path";
+
+export function sourceModuleCandidates(base: string): string[] {
+  if (hasSourceModuleExtension(base)) {
+    return [base, ...typescriptSourceModuleCandidates(base)];
+  }
+
+  if (/\.(?:client|compat)$/.test(base)) {
+    return [
+      `${base}.ts`,
+      `${base}.tsx`,
+      `${base}.js`,
+      `${base}.jsx`,
+      `${base}.mjs`,
+      `${base}.mts`,
+      `${base}.cjs`,
+      `${base}.cts`,
+    ];
+  }
+
+  if (extname(base) !== "") {
+    return [];
+  }
+
+  return [
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.mreact.tsx`,
+    `${base}.js`,
+    `${base}.jsx`,
+    `${base}.mjs`,
+    `${base}.mts`,
+    `${base}.cjs`,
+    `${base}.cts`,
+    join(base, "index.ts"),
+    join(base, "index.tsx"),
+    join(base, "index.mreact.tsx"),
+    join(base, "index.js"),
+    join(base, "index.jsx"),
+    join(base, "index.mjs"),
+    join(base, "index.mts"),
+    join(base, "index.cjs"),
+    join(base, "index.cts"),
+  ];
+}
+
+function hasSourceModuleExtension(path: string): boolean {
+  return /\.(?:mreact\.tsx|tsx?|jsx?|mjs|mts|cjs|cts)$/.test(path);
+}
+
+function typescriptSourceModuleCandidates(path: string): string[] {
+  if (path.endsWith(".js")) {
+    return [`${path.slice(0, -3)}.ts`, `${path.slice(0, -3)}.tsx`];
+  }
+
+  if (path.endsWith(".jsx")) {
+    return [`${path.slice(0, -4)}.tsx`];
+  }
+
+  if (path.endsWith(".mjs")) {
+    return [`${path.slice(0, -4)}.mts`];
+  }
+
+  if (path.endsWith(".cjs")) {
+    return [`${path.slice(0, -4)}.cts`];
+  }
+
+  return [];
+}

package/src/stream-list.ts

@@ -0,0 +1,45 @@
+export interface StreamListBatch<TItem> {
+  index: number;
+  items: TItem[];
+  size: number;
+  start: number;
+}
+
+export interface StreamListPendingBatch<TItem> {
+  index: number;
+  size: number;
+  start: number;
+  value: Promise<StreamListBatch<TItem>>;
+}
+
+export interface StreamListOptions<TInput, TItem> {
+  batchSize: number;
+  loadBatch: (
+    items: readonly TInput[],
+    batch: { index: number; size: number; start: number },
+  ) => PromiseLike<readonly TItem[]> | readonly TItem[];
+}
+
+export function streamList<TInput, TItem = TInput>(
+  items: readonly TInput[],
+  options: StreamListOptions<TInput, TItem>,
+): Array<StreamListPendingBatch<TItem>> {
+  const requestedBatchSize = Math.floor(options.batchSize);
+  const batchSize = Number.isFinite(requestedBatchSize) ? Math.max(1, requestedBatchSize) : 1;
+  const batches: Array<StreamListPendingBatch<TItem>> = [];
+
+  for (let start = 0; start < items.length; start += batchSize) {
+    const batchItems = items.slice(start, start + batchSize);
+    const index = batches.length;
+    const meta = { index, size: batchItems.length, start };
+    batches.push({
+      ...meta,
+      value: Promise.resolve(options.loadBatch(batchItems, meta)).then((loaded) => ({
+        ...meta,
+        items: [...loaded],
+      })),
+    });
+  }
+
+  return batches;
+}

package/src/trace.ts

@@ -0,0 +1,114 @@
+export interface RouterTraceContext {
+  parentSpanId: string;
+  sampled: boolean;
+  traceId: string;
+  traceparent: string;
+  tracestate?: string;
+}
+
+export interface RouterRequestInstrumentationEvent {
+  method: string;
+  path: string;
+  request: Request;
+  trace?: RouterTraceContext;
+}
+
+export interface RouterRequestEndInstrumentationEvent
+  extends RouterRequestInstrumentationEvent {
+  status: number;
+}
+
+export interface RouterRouteInstrumentationEvent
+  extends RouterRequestInstrumentationEvent {
+  routeId: string;
+  routePath: string;
+}
+
+export interface RouterRouteEndInstrumentationEvent
+  extends RouterRouteInstrumentationEvent {
+  error?: unknown;
+}
+
+export interface RouterMiddlewareInstrumentationEvent
+  extends RouterRequestInstrumentationEvent {
+  name: string;
+}
+
+export interface RouterMiddlewareEndInstrumentationEvent
+  extends RouterMiddlewareInstrumentationEvent {
+  error?: unknown;
+}
+
+export interface RouterInstrumentation {
+  onLoaderEnd?: (event: RouterRouteEndInstrumentationEvent) => void | Promise<void>;
+  onLoaderStart?: (event: RouterRouteInstrumentationEvent) => void | Promise<void>;
+  onMiddlewareEnd?: (event: RouterMiddlewareEndInstrumentationEvent) => void | Promise<void>;
+  onMiddlewareStart?: (event: RouterMiddlewareInstrumentationEvent) => void | Promise<void>;
+  onRequestEnd?: (event: RouterRequestEndInstrumentationEvent) => void | Promise<void>;
+  onRequestStart?: (event: RouterRequestInstrumentationEvent) => void | Promise<void>;
+}
+
+export function parseTraceContext(
+  traceparent: string | null | undefined,
+  tracestate: string | null | undefined,
+): RouterTraceContext | undefined {
+  if (traceparent === null || traceparent === undefined) {
+    return undefined;
+  }
+
+  const match = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/i.exec(
+    traceparent,
+  );
+
+  if (match === null) {
+    return undefined;
+  }
+
+  const traceId = match[2]?.toLowerCase() ?? "";
+  const parentSpanId = match[3]?.toLowerCase() ?? "";
+  const flags = Number.parseInt(match[4] ?? "00", 16);
+
+  if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId)) {
+    return undefined;
+  }
+
+  return {
+    parentSpanId,
+    sampled: (flags & 1) === 1,
+    traceId,
+    traceparent: traceparent.toLowerCase(),
+    ...(tracestate === null || tracestate === undefined ? {} : { tracestate }),
+  };
+}
+
+export function traceContextFromRequest(request: Request): RouterTraceContext | undefined {
+  return parseTraceContext(request.headers.get("traceparent"), request.headers.get("tracestate"));
+}
+
+export function invokeRouterInstrumentation<Event>(
+  callback: ((event: Event) => void | Promise<void>) | undefined,
+  event: Event,
+): void {
+  if (callback === undefined) {
+    return;
+  }
+
+  try {
+    const result = callback(event);
+
+    if (isPromiseLike(result)) {
+      result.catch(() => {});
+    }
+  } catch {
+    // Instrumentation is best-effort and must never affect request handling.
+  }
+}
+
+function isPromiseLike(value: unknown): value is Promise<void> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "catch" in value &&
+    typeof value.catch === "function"
+  );
+}

package/src/types.ts

@@ -0,0 +1,155 @@
+import type { ReactCompatNode } from "@reckona/mreact-compat";
+import type { QueryClient } from "@reckona/mreact-query";
+
+export type InferLoaderData<TLoader extends (...args: never[]) => unknown> = Awaited<
+  ReturnType<TLoader>
+>;
+
+export type RouteParams = Record<string, readonly string[] | string>;
+
+export interface LoaderContext<TParams extends RouteParams = RouteParams> {
+  params: TParams;
+  queryClient: QueryClient;
+  request: Request;
+}
+
+export interface GenerateMetadataContext<
+  TData = unknown,
+  TParams extends RouteParams = RouteParams,
+> {
+  data: TData;
+  params: TParams;
+  request: Request;
+}
+
+export interface RouteHandlerContext<TParams extends RouteParams = RouteParams> {
+  params: TParams;
+  request: Request;
+}
+
+export interface PageProps<TData = unknown, TParams extends RouteParams = RouteParams> {
+  data: TData;
+  params: TParams;
+  request: Request;
+}
+
+export interface LayoutProps<TParams extends RouteParams = RouteParams> {
+  children: ReactCompatNode;
+  params: TParams;
+  request: Request;
+}
+
+export type MReactNode = ReactCompatNode;
+
+export type MetadataScalar = boolean | number | string;
+
+export interface MetadataImage {
+  alt?: MetadataScalar;
+  height?: MetadataScalar;
+  type?: MetadataScalar;
+  url: MetadataScalar;
+  width?: MetadataScalar;
+}
+
+export interface RouteMetadata {
+  alternates?: {
+    canonical?: MetadataScalar;
+  };
+  csp?: {
+    disable?: boolean;
+    directives?: Record<string, readonly string[] | string>;
+    nonce?: string;
+    remove?: readonly string[];
+    replace?: Record<string, readonly string[] | string>;
+  };
+  description?: MetadataScalar;
+  head?: readonly RouteHeadDescriptor[];
+  icons?: {
+    apple?: MetadataScalar;
+    icon?: MetadataScalar;
+  };
+  openGraph?: {
+    description?: MetadataScalar;
+    image?: MetadataImage | MetadataScalar;
+    images?: readonly (MetadataImage | MetadataScalar)[];
+    title?: MetadataScalar;
+  };
+  lang?: MetadataScalar;
+  robots?:
+    | string
+    | {
+        follow?: boolean;
+        index?: boolean;
+      };
+  security?: RouteSecurityHeaders;
+  themeColor?: MetadataScalar | MetadataThemeColor;
+  title?: MetadataScalar;
+  viewport?: MetadataScalar | MetadataViewport;
+}
+
+export type MetadataViewport = Record<string, MetadataScalar | null | undefined>;
+
+export interface MetadataThemeColor {
+  color?: MetadataScalar;
+  media?: MetadataScalar;
+}
+
+export interface RouteHeadDescriptor {
+  attrs?: Record<string, boolean | number | string | undefined>;
+  content?: string;
+  nonce?: boolean | string;
+  tag: "base" | "link" | "meta" | "script" | "style";
+}
+
+export interface RouteSecurityHeaders {
+  contentTypeOptions?: "nosniff" | null | undefined;
+  frameOptions?: "DENY" | "SAMEORIGIN" | null | undefined;
+  hsts?: RouteStrictTransportSecurity | false | null | undefined;
+  permissionsPolicy?: Record<string, readonly string[] | null | undefined> | null | undefined;
+  referrerPolicy?: string | null | undefined;
+}
+
+export interface RouteStrictTransportSecurity {
+  includeSubDomains?: boolean | undefined;
+  maxAge: number;
+  preload?: boolean | undefined;
+}
+
+export interface RobotsContext {
+  baseUrl: string;
+  host: string;
+  request: Request;
+}
+
+export interface RobotsManifest {
+  host?: string | undefined;
+  rules?: RobotsRule | readonly RobotsRule[] | undefined;
+  sitemap?: string | readonly string[] | undefined;
+}
+
+export interface RobotsRule {
+  allow?: string | readonly string[] | undefined;
+  disallow?: string | readonly string[] | undefined;
+  userAgent: string | readonly string[];
+}
+
+export interface SitemapContext {
+  baseUrl: string;
+  host: string;
+  request: Request;
+}
+
+export interface SitemapEntry {
+  changeFrequency?: string | undefined;
+  lastModified?: Date | string | number | undefined;
+  priority?: number | undefined;
+  url: string;
+}
+
+export interface ManifestContext {
+  baseUrl: string;
+  host: string;
+  request: Request;
+}
+
+export type ManifestDescriptor = Record<string, unknown>;

package/src/upgrade.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage } from "node:http";
+import type { Duplex } from "node:stream";
+
+export type HttpUpgradeHandler = (
+  request: IncomingMessage,
+  socket: Duplex,
+  head: Buffer,
+) => void;