blodemd 0.0.7 → 0.0.9

package/docs/lib/openapi-proxy.ts

@@ -0,0 +1,88 @@
+import type { Tenant } from "@repo/models";
+import { loadSiteConfig } from "@repo/previewing";
+
+import { getTenantContentSource } from "@/lib/content-source";
+import { getDocsCollectionWithNavigation } from "@/lib/docs-collection";
+import { loadOpenApiRegistry } from "@/lib/openapi";
+import { createTimedPromiseCache } from "@/lib/server-cache";
+
+const OPENAPI_PROXY_CACHE_TTL_MS = 30 * 60 * 1000;
+
+interface OpenApiProxyConfig {
+  allowedHosts: string[];
+  enabled: boolean;
+}
+
+const openApiProxyConfigCache = createTimedPromiseCache<
+  string,
+  OpenApiProxyConfig | null
+>({
+  maxEntries: 512,
+  ttlMs: OPENAPI_PROXY_CACHE_TTL_MS,
+});
+
+const getOpenApiProxyCacheKey = (tenant: Tenant) =>
+  [
+    tenant.id,
+    tenant.slug,
+    tenant.activeDeploymentId ?? "",
+    tenant.activeDeploymentManifestUrl ?? "",
+    tenant.docsPath ?? "",
+  ].join(":");
+
+const normalizeAllowedHosts = (hosts: string[]): string[] => [
+  ...new Set(hosts.map((host) => host.trim().toLowerCase()).filter(Boolean)),
+];
+
+export const clearOpenApiProxyConfigCache = () => {
+  openApiProxyConfigCache.clear();
+};
+
+export const clearOpenApiProxyConfigCacheForTenant = (tenantId: string) => {
+  openApiProxyConfigCache.deleteByPrefix(tenantId);
+};
+
+export const loadOpenApiProxyConfig = async (
+  tenant: Tenant
+): Promise<OpenApiProxyConfig | null> => {
+  const cacheKey = getOpenApiProxyCacheKey(tenant);
+
+  return await openApiProxyConfigCache.getOrCreate(cacheKey, async () => {
+    const contentSource = getTenantContentSource(tenant);
+    const configResult = await loadSiteConfig(contentSource);
+    if (!configResult.ok) {
+      return null;
+    }
+
+    const configuredHosts = normalizeAllowedHosts(
+      configResult.config.openapiProxy?.allowedHosts ?? []
+    );
+    if (!configResult.config.openapiProxy?.enabled || configuredHosts.length) {
+      return {
+        allowedHosts: configuredHosts,
+        enabled: configResult.config.openapiProxy?.enabled === true,
+      };
+    }
+
+    const registry = await loadOpenApiRegistry(
+      getDocsCollectionWithNavigation(configResult.config),
+      contentSource
+    );
+    const derivedHosts = normalizeAllowedHosts(
+      registry.entries.flatMap((entry) =>
+        (entry.spec.servers ?? []).flatMap((server) => {
+          try {
+            return [new URL(server.url).hostname];
+          } catch {
+            return [];
+          }
+        })
+      )
+    );
+
+    return {
+      allowedHosts: derivedHosts,
+      enabled: true,
+    };
+  });
+};

package/docs/lib/platform-config.ts

@@ -0,0 +1,6 @@
+import { platformAssetPrefix, platformRootDomain } from "./env";
+
+export const platformConfig = {
+  assetPrefix: platformAssetPrefix,
+  rootDomain: platformRootDomain,
+};

package/docs/lib/routes.ts

@@ -1,6 +1,20 @@
 import { normalizePath, withLeadingSlash } from "@repo/common";
 
 const ABSOLUTE_URL_REGEX = /^[a-z][a-z\d+.-]*:/i;
+const MARKDOWN_EXPORT_EXTENSIONS = [".md", ".mdx"] as const;
+
+export const stripBasePath = (value: string, basePath: string) => {
+  if (!basePath) {
+    return value;
+  }
+  if (value === basePath) {
+    return "/";
+  }
+  if (value.startsWith(`${basePath}/`)) {
+    return value.slice(basePath.length) || "/";
+  }
+  return value;
+};
 
 export const toDocHref = (path: string, basePath = "") => {
   const clean = normalizePath(path);
@@ -11,6 +25,31 @@ export const toDocHref = (path: string, basePath = "") => {
   return `${base}/${clean}`.replaceAll(/\/+/g, "/");
 };
 
+export const toMarkdownDocHref = (path: string, basePath = "") => {
+  const href = toDocHref(path, basePath);
+  return href === "/" ? "/.md" : `${href}.md`;
+};
+
+export const getMarkdownExportSourcePath = (pathname: string) => {
+  for (const extension of MARKDOWN_EXPORT_EXTENSIONS) {
+    if (pathname.endsWith(extension)) {
+      return pathname.slice(0, -extension.length) || "/";
+    }
+  }
+
+  return null;
+};
+
+export const getMarkdownExportSlug = (pathname: string, basePath = "") => {
+  const sourcePath = getMarkdownExportSourcePath(pathname);
+  if (sourcePath === null) {
+    return null;
+  }
+
+  const relativePath = stripBasePath(sourcePath, basePath);
+  return relativePath === "/" ? "" : relativePath.slice(1);
+};
+
 export const isExternalHref = (href: string) =>
   ABSOLUTE_URL_REGEX.test(href) || href.startsWith("//");
 

package/docs/lib/supabase.ts

@@ -0,0 +1,13 @@
+import { createClient } from "@supabase/supabase-js";
+
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL ?? "";
+const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY ?? "";
+
+let client: ReturnType<typeof createClient> | null = null;
+
+export const createSupabaseClient = () => {
+  if (!client) {
+    client = createClient(supabaseUrl, supabaseAnonKey);
+  }
+  return client;
+};

package/docs/lib/tenancy.ts

@@ -0,0 +1,322 @@
+import { getLocalRootHostsFromEnv, normalizeHost } from "@repo/common";
+import type { Tenant } from "@repo/contracts";
+import { TenantResolutionSchema } from "@repo/contracts";
+
+import {
+  getTenantEdgeHostRecord,
+  getTenantEdgeSlugRecord,
+  isEdgeConfigEnabled,
+} from "./edge-config";
+import { docsApiBase } from "./env";
+import { platformConfig } from "./platform-config";
+import { createTimedPromiseCache } from "./server-cache";
+
+const DEFAULT_RESERVED_PATHS = [
+  "/_internal",
+  "/_next",
+  "/.well-known",
+  "/docs.json",
+  "/favicon.ico",
+  "/llms.txt",
+  "/oauth",
+  "/robots.txt",
+  "/sitemap.xml",
+  "/logos",
+  "/file-text.svg",
+  "/globe.svg",
+  "/next.svg",
+  "/turborepo-dark.svg",
+  "/turborepo-light.svg",
+  "/vercel.svg",
+  "/window.svg",
+];
+
+const LOCAL_ROOT_HOSTS = new Set(["localhost", "127.0.0.1"]);
+const TRAILING_SLASHES_REGEX = /\/+$/;
+const LEADING_SLASHES_REGEX = /^\/+/;
+const BACKSLASH_TO_SLASH_REGEX = /\\/g;
+const DEFAULT_DOCS_BASE_PATH = "/docs";
+const TENANT_RESOLUTION_REVALIDATE_SECONDS = 300;
+const ROOT_TENANT_UTILITY_PATHS = new Set([
+  "/llms-full.txt",
+  "/llms.txt",
+  "/robots.txt",
+  "/sitemap.xml",
+]);
+
+const slugifyPath = (value: string) => {
+  const trimmed = value
+    .replace(BACKSLASH_TO_SLASH_REGEX, "/")
+    .replace(TRAILING_SLASHES_REGEX, "");
+  return trimmed.replace(LEADING_SLASHES_REGEX, "");
+};
+
+const stripPrefix = (pathname: string, prefix: string | null) => {
+  if (!prefix) {
+    return slugifyPath(pathname);
+  }
+
+  const normalizedPath = slugifyPath(pathname);
+  const normalizedPrefix = slugifyPath(prefix);
+  if (!normalizedPrefix) {
+    return normalizedPath;
+  }
+
+  if (normalizedPath === normalizedPrefix) {
+    return "";
+  }
+
+  if (normalizedPath.startsWith(`${normalizedPrefix}/`)) {
+    return normalizedPath.slice(normalizedPrefix.length + 1);
+  }
+
+  return null;
+};
+
+const tenantResolutionCache = createTimedPromiseCache<
+  string,
+  Awaited<ReturnType<typeof fetchTenantResolution>>
+>({
+  maxEntries: 512,
+  ttlMs: TENANT_RESOLUTION_REVALIDATE_SECONDS * 1000,
+});
+
+export const getRequestHost = (headerSource: Pick<Headers, "get">) => {
+  const forwardedHost = headerSource.get("x-forwarded-host");
+  return normalizeHost(
+    forwardedHost?.split(",")[0]?.trim() || headerSource.get("host") || ""
+  );
+};
+
+export const getRequestProtocol = (headerSource: Pick<Headers, "get">) =>
+  headerSource.get("x-forwarded-proto")?.split(",")[0]?.trim() || "https";
+
+export const isRootRuntimeHost = (host: string) => {
+  const normalizedHost = normalizeHost(host);
+  return (
+    normalizedHost === platformConfig.rootDomain ||
+    LOCAL_ROOT_HOSTS.has(normalizedHost) ||
+    getLocalRootHostsFromEnv(process.env).has(normalizedHost)
+  );
+};
+
+export const isReservedPath = (pathname: string) => {
+  const { assetPrefix } = platformConfig;
+  if (assetPrefix && pathname.startsWith(assetPrefix)) {
+    return true;
+  }
+  return DEFAULT_RESERVED_PATHS.some((prefix) => pathname.startsWith(prefix));
+};
+
+const resolveSubdomainBasePath = (pathname: string): string => {
+  const normalizedPath = slugifyPath(pathname);
+
+  if (
+    normalizedPath === "docs" ||
+    normalizedPath.startsWith(`${slugifyPath(DEFAULT_DOCS_BASE_PATH)}/`)
+  ) {
+    return DEFAULT_DOCS_BASE_PATH;
+  }
+
+  return "";
+};
+
+const buildTenantPathResolution = (
+  tenant: Tenant,
+  strategy: "preview" | "subdomain" | "custom-domain",
+  host: string,
+  pathname: string,
+  basePath: string
+) => {
+  if (ROOT_TENANT_UTILITY_PATHS.has(pathname)) {
+    return {
+      basePath,
+      host,
+      rewrittenPath: `/sites/${tenant.slug}${pathname}`,
+      strategy,
+      tenant,
+    };
+  }
+
+  const slugPath = stripPrefix(pathname, basePath || null);
+  if (slugPath === null) {
+    return null;
+  }
+
+  const rewrittenPath = slugPath
+    ? `/sites/${tenant.slug}/${slugPath}`
+    : `/sites/${tenant.slug}/`;
+
+  return {
+    basePath,
+    host,
+    rewrittenPath,
+    strategy,
+    tenant,
+  };
+};
+
+const buildPathTenantResolution = (
+  tenant: Tenant,
+  host: string,
+  pathname: string
+) => {
+  const normalized = slugifyPath(pathname);
+  const parts = normalized ? normalized.split("/") : [];
+  const [projectSlug, ...rest] = parts;
+  if (!projectSlug || projectSlug !== tenant.slug) {
+    return null;
+  }
+
+  const remainder = rest.join("/");
+  return {
+    basePath: `/${tenant.slug}`,
+    host,
+    rewrittenPath: remainder
+      ? `/sites/${tenant.slug}/${remainder}`
+      : `/sites/${tenant.slug}/`,
+    strategy: "path" as const,
+    tenant,
+  };
+};
+
+const fetchTenantResolutionFromApi = async (host: string, pathname: string) => {
+  const url = new URL("/tenants/resolve", docsApiBase);
+  url.searchParams.set("host", normalizeHost(host));
+  url.searchParams.set("path", pathname);
+  let response: Response;
+  try {
+    response = await fetch(url.toString(), {
+      next: { revalidate: TENANT_RESOLUTION_REVALIDATE_SECONDS },
+    });
+  } catch {
+    return null;
+  }
+  if (!response.ok) {
+    return null;
+  }
+  const json = (await response.json()) as unknown;
+  const parsed = TenantResolutionSchema.safeParse(json);
+  if (!parsed.success) {
+    return null;
+  }
+  return parsed.data;
+};
+
+export const resolveTenantFromEdgeConfig = async (
+  host: string,
+  pathname: string
+) => {
+  const normalizedHost = normalizeHost(host);
+  const hostRecord = await getTenantEdgeHostRecord(normalizedHost);
+  if (hostRecord) {
+    const basePath =
+      hostRecord.strategy === "subdomain"
+        ? resolveSubdomainBasePath(pathname)
+        : (hostRecord.pathPrefix ?? "");
+
+    return buildTenantPathResolution(
+      hostRecord.tenant,
+      hostRecord.strategy,
+      normalizedHost,
+      pathname,
+      basePath
+    );
+  }
+
+  const previewPrefix = normalizedHost.includes("---")
+    ? normalizedHost.split("---")[0]
+    : null;
+  if (previewPrefix) {
+    const previewRecord = await getTenantEdgeSlugRecord(previewPrefix);
+    if (previewRecord) {
+      return buildTenantPathResolution(
+        previewRecord.tenant,
+        "preview",
+        normalizedHost,
+        pathname,
+        resolveSubdomainBasePath(pathname)
+      );
+    }
+  }
+
+  const localSuffixes = ["localhost", "127.0.0.1"];
+  const localRootHosts = getLocalRootHostsFromEnv(process.env);
+  const localSuffix = localRootHosts.has(normalizedHost)
+    ? null
+    : localSuffixes.find((suffix) => normalizedHost.endsWith(`.${suffix}`));
+  if (localSuffix) {
+    const subdomain = normalizedHost.slice(0, -1 * (localSuffix.length + 1));
+    if (subdomain) {
+      const subdomainRecord = await getTenantEdgeSlugRecord(subdomain);
+      if (subdomainRecord) {
+        return buildTenantPathResolution(
+          subdomainRecord.tenant,
+          "subdomain",
+          normalizedHost,
+          pathname,
+          resolveSubdomainBasePath(pathname)
+        );
+      }
+    }
+  }
+
+  if (normalizedHost.endsWith(`.${platformConfig.rootDomain}`)) {
+    const subdomain = normalizedHost.slice(
+      0,
+      -1 * (platformConfig.rootDomain.length + 1)
+    );
+    if (
+      subdomain &&
+      !["www", "app", "admin", "dashboard"].includes(subdomain)
+    ) {
+      const subdomainRecord = await getTenantEdgeSlugRecord(subdomain);
+      if (subdomainRecord) {
+        return buildTenantPathResolution(
+          subdomainRecord.tenant,
+          "subdomain",
+          normalizedHost,
+          pathname,
+          resolveSubdomainBasePath(pathname)
+        );
+      }
+    }
+  }
+
+  if (isRootRuntimeHost(normalizedHost)) {
+    const normalizedPath = slugifyPath(pathname);
+    const [projectSlug] = normalizedPath.split("/");
+    if (projectSlug) {
+      const pathRecord = await getTenantEdgeSlugRecord(projectSlug);
+      if (pathRecord) {
+        return buildPathTenantResolution(
+          pathRecord.tenant,
+          normalizedHost,
+          pathname
+        );
+      }
+    }
+  }
+
+  return null;
+};
+
+const fetchTenantResolution = async (host: string, pathname: string) => {
+  if (isEdgeConfigEnabled()) {
+    return await resolveTenantFromEdgeConfig(host, pathname);
+  }
+
+  return await fetchTenantResolutionFromApi(host, pathname);
+};
+
+export const clearTenantResolutionCache = () => {
+  tenantResolutionCache.clear();
+};
+
+export const resolveTenant = async (host: string, pathname: string) => {
+  const cacheKey = `${normalizeHost(host)}:${pathname}`;
+  return await tenantResolutionCache.getOrCreate(
+    cacheKey,
+    async () => await fetchTenantResolution(host, pathname)
+  );
+};

package/docs/lib/tenant-headers.ts

@@ -0,0 +1,14 @@
+export const TENANT_HEADERS = {
+  BASE_PATH: "x-tenant-base-path",
+  CUSTOM_DOMAINS: "x-tenant-custom-domains",
+  DEPLOYMENT_ID: "x-tenant-deployment-id",
+  DOMAIN: "x-tenant-domain",
+  ID: "x-tenant-id",
+  MANIFEST_URL: "x-tenant-manifest-url",
+  NAME: "x-tenant-name",
+  PATH_PREFIX: "x-tenant-path-prefix",
+  PRIMARY_DOMAIN: "x-tenant-primary-domain",
+  SLUG: "x-tenant-slug",
+  STRATEGY: "x-tenant-strategy",
+  SUBDOMAIN: "x-tenant-subdomain",
+} as const;