@richie-router/server 0.0.1 → 0.1.1

package/dist/cjs/index.cjs

@@ -0,0 +1,237 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/server/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  handleRequest: () => handleRequest,
+  defineHeadTags: () => defineHeadTags
+});
+module.exports = __toCommonJS(exports_src);
+var import_core = require("@richie-router/core");
+function defineHeadTags(routeManifest, headTagSchema, definitions) {
+  return {
+    routeManifest,
+    headTagSchema,
+    definitions
+  };
+}
+var HEAD_PLACEHOLDER = "<!--richie-router-head-->";
+var MANAGED_HEAD_ATTRIBUTE = "data-richie-router-head";
+function routeHasRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createHeadSnapshotScript(href, head) {
+  const payload = JSON.stringify({ href, head }).replaceAll("</script>", "<\\/script>");
+  return `<script ${MANAGED_HEAD_ATTRIBUTE}="true">window.__RICHIE_ROUTER_HEAD__=${payload}</script>`;
+}
+async function renderTemplate(html, ctx) {
+  const template = html.template;
+  if (typeof template === "function") {
+    return await template(ctx);
+  }
+  if (!template.includes(HEAD_PLACEHOLDER)) {
+    throw new Error(`HTML template is missing required Richie Router placeholder: ${HEAD_PLACEHOLDER}`);
+  }
+  return template.replace(HEAD_PLACEHOLDER, ctx.richieRouterHead);
+}
+function jsonResponse(data, init) {
+  return new Response(JSON.stringify(data), {
+    ...init,
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      ...init?.headers ?? {}
+    }
+  });
+}
+function resolveSearch(route, rawSearch) {
+  const fromSchema = route.searchSchema ? route.searchSchema.parse(rawSearch) : {};
+  if (routeHasRecord(fromSchema)) {
+    return fromSchema;
+  }
+  return rawSearch;
+}
+function buildMatches(routeManifest, location) {
+  const matched = import_core.matchRouteTree(routeManifest, location.pathname);
+  if (!matched) {
+    return [];
+  }
+  const rawSearch = location.search;
+  let accumulatedSearch = { ...rawSearch };
+  return matched.map(({ route, params }) => {
+    const nextSearch = resolveSearch(route, rawSearch);
+    if (routeHasRecord(nextSearch)) {
+      accumulatedSearch = {
+        ...accumulatedSearch,
+        ...nextSearch
+      };
+    }
+    return {
+      id: route.fullPath,
+      pathname: location.pathname,
+      params,
+      route,
+      search: accumulatedSearch,
+      to: route.to
+    };
+  });
+}
+async function executeHeadTag(request, headTags, headTagName, params, rawSearch) {
+  const definition = headTags.definitions[headTagName];
+  const schemaEntry = headTags.headTagSchema[headTagName];
+  if (!definition) {
+    throw new Error(`Unknown head tag "${headTagName}".`);
+  }
+  const search = schemaEntry?.searchSchema ? schemaEntry.searchSchema.parse(rawSearch) : rawSearch;
+  const head = await definition.head({
+    request,
+    params,
+    search
+  });
+  return {
+    head,
+    staleTime: definition.staleTime
+  };
+}
+async function resolveMatchedHead(request, headTags, matches) {
+  const resolvedHeadByRoute = new Map;
+  for (const match of matches) {
+    const headOption = match.route.options.head;
+    if (typeof headOption !== "string") {
+      continue;
+    }
+    const result = await executeHeadTag(request, headTags, headOption, match.params, match.search);
+    resolvedHeadByRoute.set(match.route.fullPath, result.head);
+  }
+  return import_core.resolveHeadConfig(matches, resolvedHeadByRoute);
+}
+async function handleRequest(request, options) {
+  const url = new URL(request.url);
+  const headBasePath = options.headBasePath ?? "/head-api";
+  const routeBasePath = options.routeBasePath ?? "/";
+  if (url.pathname.startsWith(`${headBasePath}/`)) {
+    const headTagName = decodeURIComponent(url.pathname.slice(headBasePath.length + 1));
+    const params = JSON.parse(url.searchParams.get("params") ?? "{}");
+    const search = JSON.parse(url.searchParams.get("search") ?? "{}");
+    try {
+      const result = await executeHeadTag(request, options.headTags, headTagName, params, search);
+      return {
+        matched: true,
+        response: jsonResponse(result)
+      };
+    } catch (error) {
+      if (error instanceof Response) {
+        return {
+          matched: true,
+          response: error
+        };
+      }
+      if (import_core.isNotFound(error)) {
+        return {
+          matched: true,
+          response: jsonResponse({ message: "Not Found" }, { status: 404 })
+        };
+      }
+      throw error;
+    }
+  }
+  if (!url.pathname.startsWith(routeBasePath)) {
+    return {
+      matched: false,
+      response: new Response("Not Found", { status: 404 })
+    };
+  }
+  const location = import_core.createParsedLocation(`${url.pathname}${url.search}${url.hash}`, null, import_core.defaultParseSearch);
+  const matches = buildMatches(options.routeManifest, location);
+  if (matches.length === 0) {
+    return {
+      matched: false,
+      response: new Response("Not Found", { status: 404 })
+    };
+  }
+  try {
+    const head = await resolveMatchedHead(request, options.headTags, matches);
+    const headHtml = import_core.serializeHeadConfig(head, {
+      managedAttribute: MANAGED_HEAD_ATTRIBUTE
+    });
+    const richieRouterHead = `${headHtml}${createHeadSnapshotScript(location.href, head)}`;
+    const html = await renderTemplate(options.html, {
+      request,
+      richieRouterHead,
+      head
+    });
+    return {
+      matched: true,
+      response: new Response(html, {
+        status: 200,
+        headers: {
+          "content-type": "text/html; charset=utf-8"
+        }
+      })
+    };
+  } catch (error) {
+    if (import_core.isRedirect(error)) {
+      const redirectPath = import_core.buildPath(error.options.to, error.options.params ?? {});
+      const redirectSearch = import_core.defaultStringifySearch(error.options.search === true ? {} : error.options.search ?? {});
+      const redirectHash = error.options.hash ? `#${error.options.hash.replace(/^#/, "")}` : "";
+      const redirectUrl = `${redirectPath}${redirectSearch}${redirectHash}`;
+      return {
+        matched: true,
+        response: new Response(null, {
+          status: error.options.replace ? 307 : 302,
+          headers: {
+            location: redirectUrl
+          }
+        })
+      };
+    }
+    if (error instanceof Response) {
+      return {
+        matched: true,
+        response: error
+      };
+    }
+    if (import_core.isNotFound(error)) {
+      return {
+        matched: true,
+        response: new Response("Not Found", { status: 404 })
+      };
+    }
+    throw error;
+  }
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/esm/index.mjs

@@ -0,0 +1,207 @@
+// packages/server/src/index.ts
+import {
+  buildPath,
+  createParsedLocation,
+  defaultParseSearch,
+  defaultStringifySearch,
+  isNotFound,
+  isRedirect,
+  matchRouteTree,
+  resolveHeadConfig,
+  serializeHeadConfig
+} from "@richie-router/core";
+function defineHeadTags(routeManifest, headTagSchema, definitions) {
+  return {
+    routeManifest,
+    headTagSchema,
+    definitions
+  };
+}
+var HEAD_PLACEHOLDER = "<!--richie-router-head-->";
+var MANAGED_HEAD_ATTRIBUTE = "data-richie-router-head";
+function routeHasRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createHeadSnapshotScript(href, head) {
+  const payload = JSON.stringify({ href, head }).replaceAll("</script>", "<\\/script>");
+  return `<script ${MANAGED_HEAD_ATTRIBUTE}="true">window.__RICHIE_ROUTER_HEAD__=${payload}</script>`;
+}
+async function renderTemplate(html, ctx) {
+  const template = html.template;
+  if (typeof template === "function") {
+    return await template(ctx);
+  }
+  if (!template.includes(HEAD_PLACEHOLDER)) {
+    throw new Error(`HTML template is missing required Richie Router placeholder: ${HEAD_PLACEHOLDER}`);
+  }
+  return template.replace(HEAD_PLACEHOLDER, ctx.richieRouterHead);
+}
+function jsonResponse(data, init) {
+  return new Response(JSON.stringify(data), {
+    ...init,
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      ...init?.headers ?? {}
+    }
+  });
+}
+function resolveSearch(route, rawSearch) {
+  const fromSchema = route.searchSchema ? route.searchSchema.parse(rawSearch) : {};
+  if (routeHasRecord(fromSchema)) {
+    return fromSchema;
+  }
+  return rawSearch;
+}
+function buildMatches(routeManifest, location) {
+  const matched = matchRouteTree(routeManifest, location.pathname);
+  if (!matched) {
+    return [];
+  }
+  const rawSearch = location.search;
+  let accumulatedSearch = { ...rawSearch };
+  return matched.map(({ route, params }) => {
+    const nextSearch = resolveSearch(route, rawSearch);
+    if (routeHasRecord(nextSearch)) {
+      accumulatedSearch = {
+        ...accumulatedSearch,
+        ...nextSearch
+      };
+    }
+    return {
+      id: route.fullPath,
+      pathname: location.pathname,
+      params,
+      route,
+      search: accumulatedSearch,
+      to: route.to
+    };
+  });
+}
+async function executeHeadTag(request, headTags, headTagName, params, rawSearch) {
+  const definition = headTags.definitions[headTagName];
+  const schemaEntry = headTags.headTagSchema[headTagName];
+  if (!definition) {
+    throw new Error(`Unknown head tag "${headTagName}".`);
+  }
+  const search = schemaEntry?.searchSchema ? schemaEntry.searchSchema.parse(rawSearch) : rawSearch;
+  const head = await definition.head({
+    request,
+    params,
+    search
+  });
+  return {
+    head,
+    staleTime: definition.staleTime
+  };
+}
+async function resolveMatchedHead(request, headTags, matches) {
+  const resolvedHeadByRoute = new Map;
+  for (const match of matches) {
+    const headOption = match.route.options.head;
+    if (typeof headOption !== "string") {
+      continue;
+    }
+    const result = await executeHeadTag(request, headTags, headOption, match.params, match.search);
+    resolvedHeadByRoute.set(match.route.fullPath, result.head);
+  }
+  return resolveHeadConfig(matches, resolvedHeadByRoute);
+}
+async function handleRequest(request, options) {
+  const url = new URL(request.url);
+  const headBasePath = options.headBasePath ?? "/head-api";
+  const routeBasePath = options.routeBasePath ?? "/";
+  if (url.pathname.startsWith(`${headBasePath}/`)) {
+    const headTagName = decodeURIComponent(url.pathname.slice(headBasePath.length + 1));
+    const params = JSON.parse(url.searchParams.get("params") ?? "{}");
+    const search = JSON.parse(url.searchParams.get("search") ?? "{}");
+    try {
+      const result = await executeHeadTag(request, options.headTags, headTagName, params, search);
+      return {
+        matched: true,
+        response: jsonResponse(result)
+      };
+    } catch (error) {
+      if (error instanceof Response) {
+        return {
+          matched: true,
+          response: error
+        };
+      }
+      if (isNotFound(error)) {
+        return {
+          matched: true,
+          response: jsonResponse({ message: "Not Found" }, { status: 404 })
+        };
+      }
+      throw error;
+    }
+  }
+  if (!url.pathname.startsWith(routeBasePath)) {
+    return {
+      matched: false,
+      response: new Response("Not Found", { status: 404 })
+    };
+  }
+  const location = createParsedLocation(`${url.pathname}${url.search}${url.hash}`, null, defaultParseSearch);
+  const matches = buildMatches(options.routeManifest, location);
+  if (matches.length === 0) {
+    return {
+      matched: false,
+      response: new Response("Not Found", { status: 404 })
+    };
+  }
+  try {
+    const head = await resolveMatchedHead(request, options.headTags, matches);
+    const headHtml = serializeHeadConfig(head, {
+      managedAttribute: MANAGED_HEAD_ATTRIBUTE
+    });
+    const richieRouterHead = `${headHtml}${createHeadSnapshotScript(location.href, head)}`;
+    const html = await renderTemplate(options.html, {
+      request,
+      richieRouterHead,
+      head
+    });
+    return {
+      matched: true,
+      response: new Response(html, {
+        status: 200,
+        headers: {
+          "content-type": "text/html; charset=utf-8"
+        }
+      })
+    };
+  } catch (error) {
+    if (isRedirect(error)) {
+      const redirectPath = buildPath(error.options.to, error.options.params ?? {});
+      const redirectSearch = defaultStringifySearch(error.options.search === true ? {} : error.options.search ?? {});
+      const redirectHash = error.options.hash ? `#${error.options.hash.replace(/^#/, "")}` : "";
+      const redirectUrl = `${redirectPath}${redirectSearch}${redirectHash}`;
+      return {
+        matched: true,
+        response: new Response(null, {
+          status: error.options.replace ? 307 : 302,
+          headers: {
+            location: redirectUrl
+          }
+        })
+      };
+    }
+    if (error instanceof Response) {
+      return {
+        matched: true,
+        response: error
+      };
+    }
+    if (isNotFound(error)) {
+      return {
+        matched: true,
+        response: new Response("Not Found", { status: 404 })
+      };
+    }
+    throw error;
+  }
+}
+export {
+  handleRequest,
+  defineHeadTags
+};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/types/index.d.ts

@@ -0,0 +1,39 @@
+import { type AnyRoute, type HeadConfig, type HeadTagSchemaShape, type InferHeadTagSearchSchema } from '@richie-router/core';
+export interface HeadTagContext<TSearch> {
+    request: Request;
+    params: Record<string, string>;
+    search: TSearch;
+}
+export interface HeadTagDefinition<TSearch> {
+    staleTime?: number;
+    head: (ctx: HeadTagContext<TSearch>) => Promise<HeadConfig> | HeadConfig;
+}
+export interface DefinedHeadTags<TRouteManifest extends AnyRoute, THeadTagSchema extends HeadTagSchemaShape, TDefinitions extends Partial<{
+    [THeadTagName in keyof THeadTagSchema]: HeadTagDefinition<InferHeadTagSearchSchema<THeadTagSchema, THeadTagName>>;
+}>> {
+    routeManifest: TRouteManifest;
+    headTagSchema: THeadTagSchema;
+    definitions: TDefinitions;
+}
+export declare function defineHeadTags<TRouteManifest extends AnyRoute, THeadTagSchema extends HeadTagSchemaShape, TDefinitions extends Partial<{
+    [THeadTagName in keyof THeadTagSchema]: HeadTagDefinition<InferHeadTagSearchSchema<THeadTagSchema, THeadTagName>>;
+}>>(routeManifest: TRouteManifest, headTagSchema: THeadTagSchema, definitions: TDefinitions): DefinedHeadTags<TRouteManifest, THeadTagSchema, TDefinitions>;
+export interface HtmlOptions {
+    template: string | ((ctx: {
+        request: Request;
+        richieRouterHead: string;
+        head: HeadConfig;
+    }) => string | Promise<string>);
+}
+export interface HandleRequestOptions<TRouteManifest extends AnyRoute, THeadTagSchema extends HeadTagSchemaShape, TDefinitions extends Partial<Record<keyof THeadTagSchema, HeadTagDefinition<any>>>> {
+    routeManifest: TRouteManifest;
+    headTags: DefinedHeadTags<TRouteManifest, THeadTagSchema, TDefinitions>;
+    html: HtmlOptions;
+    headBasePath?: string;
+    routeBasePath?: string;
+}
+export interface HandleRequestResult {
+    matched: boolean;
+    response: Response;
+}
+export declare function handleRequest<TRouteManifest extends AnyRoute, THeadTagSchema extends HeadTagSchemaShape, TDefinitions extends Partial<Record<keyof THeadTagSchema, HeadTagDefinition<any>>>>(request: Request, options: HandleRequestOptions<TRouteManifest, THeadTagSchema, TDefinitions>): Promise<HandleRequestResult>;

package/package.json

@@ -1,10 +1,46 @@
 {
   "name": "@richie-router/server",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @richie-router/server",
+  "version": "0.1.1",
+  "description": "Server helpers for Richie Router head tags and document handling",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/esm/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@richie-router/core": "^0.1.1"
+  },
+  "author": "Richie <oss@ricsam.dev>",
+  "homepage": "https://docs.ricsam.dev/richie-router",
+  "bugs": {
+    "url": "https://github.com/ricsam/richie-router/issues"
+  },
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+    "router",
+    "react",
+    "typescript",
+    "bun",
+    "file-based-routing",
+    "type-safe"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/richie-router.git",
+    "directory": "packages/server"
+  },
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# @richie-router/server
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@richie-router/server`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**