blodemd 0.0.15 → 0.2.0

package/docs/lib/navigation.ts

@@ -1,288 +0,0 @@
-import { normalizePath } from "@repo/common";
-import type { DocsNavigation } from "@repo/models";
-import type { PageMetadata } from "@repo/previewing";
-
-import type { OpenApiRegistry } from "./openapi";
-import { resolveHref, toDocHref } from "./routes";
-
-export interface NavPage {
-  type: "page";
-  title: string;
-  path: string;
-  source: "mdx" | "openapi";
-  identifier?: string;
-  sidebarTitle?: string;
-  icon?: string;
-  iconType?: string;
-  tag?: string;
-  hidden?: boolean;
-  deprecated?: boolean;
-  url?: string;
-  hideApiMarker?: boolean;
-}
-
-export interface NavGroup {
-  type: "group";
-  title: string;
-  items: NavPage[];
-  expanded?: boolean;
-  hidden?: boolean;
-}
-
-export type NavEntry = NavGroup | NavPage;
-
-export const getNavPageTitle = (page: NavPage): string =>
-  page.sidebarTitle ?? page.title;
-
-export const getNavPageHref = (page: NavPage, basePath: string): string =>
-  page.url ? resolveHref(page.url, basePath) : toDocHref(page.path, basePath);
-
-const titleFromSlug = (slug: string) => {
-  const clean = slug.replaceAll("-", " ").split("/").pop() ?? slug;
-  if (clean === "index") {
-    return "Overview";
-  }
-  return clean.replaceAll(/\b\w/g, (char) => char.toUpperCase());
-};
-
-const createPageItem = (
-  page: string,
-  registry: OpenApiRegistry,
-  slugPrefix: string
-): NavPage => {
-  const entry = registry.byIdentifier.get(page);
-  if (entry) {
-    return {
-      identifier: entry.identifier,
-      path: entry.slug,
-      source: "openapi",
-      title: entry.operation.summary ?? entry.identifier,
-      type: "page",
-    };
-  }
-
-  const normalized = normalizePath(page);
-  const path = slugPrefix
-    ? normalizePath(`${slugPrefix}/${normalized}`)
-    : normalized;
-
-  return {
-    path,
-    source: "mdx",
-    title: titleFromSlug(page),
-    type: "page",
-  };
-};
-
-// oxlint-disable-next-line eslint/complexity
-export const buildNavigation = (
-  navigation: DocsNavigation | undefined,
-  registry: OpenApiRegistry,
-  slugPrefix = ""
-) => {
-  const entries: NavEntry[] = [];
-  const groups = navigation?.groups ?? [];
-  const hiddenPages = new Set(navigation?.hidden);
-
-  for (const group of groups) {
-    const title = group.group ?? "Untitled";
-    const items: NavPage[] = [];
-    const groupHidden = group.hidden === true;
-
-    if (group.pages?.length) {
-      for (const page of group.pages) {
-        const item = createPageItem(page, registry, slugPrefix);
-        if (groupHidden || hiddenPages.has(page)) {
-          item.hidden = true;
-        }
-        items.push(item);
-      }
-    } else if (group.openapi) {
-      const sourceKey =
-        typeof group.openapi === "string"
-          ? `${group.openapi}::::`
-          : `${group.openapi.source}::${group.openapi.directory ?? ""}::${(
-              group.openapi.include ?? []
-            ).join("|")}`;
-      const sourceEntries = registry.bySource.get(sourceKey) ?? [];
-      for (const entry of sourceEntries) {
-        items.push({
-          hidden: groupHidden || undefined,
-          identifier: entry.identifier,
-          path: entry.slug,
-          source: "openapi",
-          title: entry.operation.summary ?? entry.identifier,
-          type: "page",
-        });
-      }
-    }
-
-    if (items.length) {
-      entries.push({
-        expanded: group.expanded,
-        hidden: groupHidden || undefined,
-        items,
-        title,
-        type: "group",
-      });
-    }
-  }
-
-  const topPages = navigation?.pages ?? [];
-  for (const page of topPages) {
-    const item = createPageItem(page, registry, slugPrefix);
-    if (hiddenPages.has(page)) {
-      item.hidden = true;
-    }
-    entries.push(item);
-  }
-
-  return entries;
-};
-
-const enrichPage = (
-  page: NavPage,
-  metadataMap: Map<string, PageMetadata>
-): NavPage => {
-  const meta = metadataMap.get(page.path);
-  if (!meta) {
-    return page;
-  }
-  return {
-    ...page,
-    deprecated: meta.deprecated ?? page.deprecated,
-    hidden: meta.hidden ?? page.hidden,
-    hideApiMarker: meta.hideApiMarker ?? page.hideApiMarker,
-    icon: meta.icon ?? page.icon,
-    iconType: meta.iconType ?? page.iconType,
-    sidebarTitle: meta.sidebarTitle ?? page.sidebarTitle,
-    tag: meta.tag ?? page.tag,
-    title: meta.title ?? page.title,
-    url: meta.url ?? page.url,
-  };
-};
-
-export const enrichNavWithMetadata = (
-  entries: NavEntry[],
-  metadataMap: Map<string, PageMetadata>
-): NavEntry[] =>
-  entries.map((entry) => {
-    if (entry.type === "page") {
-      return enrichPage(entry, metadataMap);
-    }
-    return {
-      ...entry,
-      items: entry.items.map((item) => enrichPage(item, metadataMap)),
-    };
-  });
-
-export const getVisibleNavigation = (entries: NavEntry[]): NavEntry[] => {
-  const visible: NavEntry[] = [];
-  for (const entry of entries) {
-    if (entry.hidden) {
-      continue;
-    }
-    if (entry.type === "group") {
-      const visibleItems = entry.items.filter((item) => !item.hidden);
-      if (visibleItems.length) {
-        visible.push({ ...entry, items: visibleItems });
-      }
-    } else {
-      visible.push(entry);
-    }
-  }
-  return visible;
-};
-
-export const flattenNav = (entries: NavEntry[]): NavPage[] => {
-  const pages: NavPage[] = [];
-  for (const entry of entries) {
-    if (entry.type === "page") {
-      pages.push(entry);
-    } else {
-      pages.push(...entry.items);
-    }
-  }
-  return pages;
-};
-
-export interface NavTab {
-  label: string;
-  icon?: string;
-  href?: string;
-  entries: NavEntry[];
-  slugPrefix?: string;
-}
-
-export const buildTabbedNavigation = (
-  navigation: DocsNavigation | undefined,
-  registry: OpenApiRegistry,
-  slugPrefix = ""
-): NavTab[] | null => {
-  if (!navigation?.tabs?.length) {
-    return null;
-  }
-  const { tabs } = navigation;
-
-  return tabs.map((tab) => {
-    if (tab.href) {
-      return {
-        entries: [],
-        href: tab.href,
-        icon: tab.icon,
-        label: tab.label,
-      };
-    }
-
-    const tabNav: DocsNavigation = {
-      groups: tab.groups,
-      hidden: navigation.hidden,
-      pages: tab.pages,
-    };
-    const entries = buildNavigation(tabNav, registry, slugPrefix);
-    const [firstPage] = flattenNav(entries);
-
-    return {
-      entries,
-      icon: tab.icon,
-      label: tab.label,
-      slugPrefix: firstPage?.path,
-    };
-  });
-};
-
-export const findActiveTabIndex = (
-  tabs: NavTab[],
-  currentPath: string
-): number => {
-  const normalized = normalizePath(currentPath);
-  for (const [index, tab] of tabs.entries()) {
-    if (tab.href) {
-      continue;
-    }
-    const pages = flattenNav(tab.entries);
-    if (pages.some((page) => page.path === normalized)) {
-      return index;
-    }
-  }
-  return 0;
-};
-
-export const findBreadcrumbs = (entries: NavEntry[], path: string) => {
-  const normalized = normalizePath(path);
-  for (const entry of entries) {
-    if (entry.type === "page" && entry.path === normalized) {
-      return [{ label: getNavPageTitle(entry), path: entry.path }];
-    }
-    if (entry.type === "group") {
-      const found = entry.items.find((item) => item.path === normalized);
-      if (found) {
-        return [
-          { label: entry.title, path: "" },
-          { label: getNavPageTitle(found), path: found.path },
-        ];
-      }
-    }
-  }
-  return [] as { label: string; path: string }[];
-};

package/docs/lib/openapi-proxy.ts

@@ -1,88 +0,0 @@
-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/openapi.ts

@@ -1,158 +0,0 @@
-import { ensureArray, normalizePath } from "@repo/common";
-import type { CollectionConfig, DocsOpenApiSource } from "@repo/models";
-import {
-  extractOpenApiOperations,
-  openApiIdentifier,
-  openApiSlug,
-  parseOpenApiSpec,
-} from "@repo/prebuild";
-import type { OpenApiOperation, OpenApiSpec } from "@repo/prebuild";
-import { loadPrebuiltOpenApiIndex } from "@repo/previewing";
-import type { ContentSource, PrebuiltOpenApiEntry } from "@repo/previewing";
-
-export interface OpenApiEntry {
-  slug: string;
-  identifier: string;
-  operation: OpenApiOperation;
-  spec: OpenApiSpec;
-  source: DocsOpenApiSource;
-  sourceKey: string;
-}
-
-export interface OpenApiRegistry {
-  entries: OpenApiEntry[];
-  bySlug: Map<string, OpenApiEntry>;
-  byIdentifier: Map<string, OpenApiEntry>;
-  bySource: Map<string, OpenApiEntry[]>;
-}
-
-const toRegistry = (entries: OpenApiEntry[]): OpenApiRegistry => {
-  const bySlug = new Map<string, OpenApiEntry>();
-  const byIdentifier = new Map<string, OpenApiEntry>();
-  const bySource = new Map<string, OpenApiEntry[]>();
-
-  for (const entry of entries) {
-    bySlug.set(entry.slug, entry);
-    byIdentifier.set(entry.identifier, entry);
-    if (!bySource.has(entry.sourceKey)) {
-      bySource.set(entry.sourceKey, []);
-    }
-    bySource.get(entry.sourceKey)?.push(entry);
-  }
-
-  return { byIdentifier, bySlug, bySource, entries };
-};
-
-export const fromPrebuiltOpenApiEntries = (
-  entries: PrebuiltOpenApiEntry[]
-): OpenApiRegistry => toRegistry(entries);
-
-const getOpenApiSourceKey = (source: DocsOpenApiSource): string =>
-  `${source.source}::${source.directory ?? ""}::${(source.include ?? []).join(
-    "|"
-  )}`;
-
-const toSourceObject = (
-  value: string | DocsOpenApiSource
-): DocsOpenApiSource => {
-  if (typeof value === "string") {
-    return { source: value };
-  }
-  return value;
-};
-
-const collectOpenApiSources = (collection?: CollectionConfig) => {
-  const sources: DocsOpenApiSource[] = [];
-
-  for (const item of ensureArray(collection?.openapi)) {
-    if (!item) {
-      continue;
-    }
-    sources.push(toSourceObject(item));
-  }
-
-  const groups = collection?.navigation?.groups ?? [];
-  for (const group of groups) {
-    if (!group.openapi) {
-      continue;
-    }
-    sources.push(toSourceObject(group.openapi));
-  }
-
-  const seen = new Set<string>();
-  return sources.filter((source) => {
-    const key = getOpenApiSourceKey(source);
-    if (seen.has(key)) {
-      return false;
-    }
-    seen.add(key);
-    return true;
-  });
-};
-
-export const buildOpenApiRegistry = async (
-  collection: CollectionConfig | undefined,
-  contentSource: ContentSource
-): Promise<OpenApiRegistry> => {
-  if (!collection || collection.type !== "docs") {
-    return toRegistry([]);
-  }
-
-  const entries: OpenApiEntry[] = [];
-  const slugPrefix = normalizePath(collection.slugPrefix ?? "");
-
-  const sources = collectOpenApiSources(collection);
-  const resolved = await Promise.all(
-    sources.map(async (source) => {
-      const rawSpec = await contentSource.readFile(source.source);
-      const spec = parseOpenApiSpec(rawSpec, source.source);
-      const directory = source.directory ?? "api";
-      const { operations } = extractOpenApiOperations(spec, directory);
-      return { directory, operations, source, spec };
-    })
-  );
-
-  for (const { directory, operations, source, spec } of resolved) {
-    const sourceKey = getOpenApiSourceKey(source);
-    const includeIdentifiers = source.include?.length
-      ? new Set(source.include)
-      : null;
-
-    for (const operation of operations) {
-      const identifier = openApiIdentifier(operation.method, operation.path);
-      if (includeIdentifiers && !includeIdentifiers.has(identifier)) {
-        continue;
-      }
-
-      const baseSlug = normalizePath(
-        openApiSlug(operation.method, operation.path, directory)
-      );
-      const slug = slugPrefix
-        ? normalizePath(`${slugPrefix}/${baseSlug}`)
-        : baseSlug;
-      const entry: OpenApiEntry = {
-        identifier,
-        operation,
-        slug: normalizePath(slug),
-        source,
-        sourceKey,
-        spec,
-      };
-      entries.push(entry);
-    }
-  }
-
-  return toRegistry(entries);
-};
-
-export const loadOpenApiRegistry = async (
-  collection: CollectionConfig | undefined,
-  contentSource: ContentSource
-): Promise<OpenApiRegistry> => {
-  const prebuilt = await loadPrebuiltOpenApiIndex(contentSource);
-  if (prebuilt) {
-    return fromPrebuiltOpenApiEntries(prebuilt);
-  }
-
-  return await buildOpenApiRegistry(collection, contentSource);
-};

package/docs/lib/platform-config.ts

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

package/docs/lib/project-authz.ts

@@ -1,46 +0,0 @@
-import type { ProjectRecord, UserRecord } from "@repo/db";
-import { cache } from "react";
-
-import { getDashboardSession } from "./dashboard-session";
-import { projectDao, userDao } from "./db";
-
-export interface AuthorizedProjectContext {
-  accessToken: string;
-  project: ProjectRecord;
-  user: UserRecord;
-}
-
-export const resolveCurrentUser = cache(
-  async (): Promise<{
-    accessToken: string;
-    user: UserRecord;
-  } | null> => {
-    const session = await getDashboardSession();
-    if (!session) {
-      return null;
-    }
-    const user = await userDao.getByAuthId(session.authId);
-    if (!user) {
-      return null;
-    }
-    return { accessToken: session.accessToken, user };
-  }
-);
-
-export const getAuthorizedProjectBySlug = cache(
-  async (slug: string): Promise<AuthorizedProjectContext | null> => {
-    const session = await getDashboardSession();
-    if (!session) {
-      return null;
-    }
-    const result = await projectDao.getAuthorizedBySlug(session.authId, slug);
-    if (!result) {
-      return null;
-    }
-    return {
-      accessToken: session.accessToken,
-      project: result.project,
-      user: result.user,
-    };
-  }
-);

package/docs/lib/routes.ts

@@ -1,103 +0,0 @@
-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);
-  const base = basePath ? withLeadingSlash(basePath) : "";
-  if (!clean || clean === "index") {
-    return base || "/";
-  }
-  return `${base}/${clean}`.replaceAll(/\/+/g, "/");
-};
-
-export const toMarkdownDocHref = (path: string, basePath = "") => {
-  const href = toDocHref(path, basePath);
-  // Index pages use /index.md, not just .md appended to the path
-  if (href === "/" || href === basePath) {
-    return `${href}/index.md`.replaceAll(/\/+/g, "/");
-  }
-  return `${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("//");
-
-const isDotRelativeHref = (href: string) =>
-  href.startsWith("./") || href.startsWith("../");
-
-const resolveDotRelativePath = (pathPart: string, currentPath: string) => {
-  const cleanCurrentPath = normalizePath(currentPath);
-  const currentDirectory = cleanCurrentPath.includes("/")
-    ? cleanCurrentPath.slice(0, cleanCurrentPath.lastIndexOf("/") + 1)
-    : "";
-  const resolved = new URL(pathPart, `https://docs.local/${currentDirectory}`);
-  return normalizePath(resolved.pathname) || "index";
-};
-
-export const resolveHref = (href: string, basePath = "", currentPath = "") => {
-  if (
-    !href ||
-    href.startsWith("#") ||
-    href.startsWith("?") ||
-    isExternalHref(href)
-  ) {
-    return href;
-  }
-
-  const suffixIndex = href.search(/[?#]/);
-  const pathPart = suffixIndex === -1 ? href : href.slice(0, suffixIndex);
-  const suffix = suffixIndex === -1 ? "" : href.slice(suffixIndex);
-  const resolvedPath =
-    currentPath && isDotRelativeHref(pathPart)
-      ? resolveDotRelativePath(pathPart, currentPath)
-      : pathPart;
-  const normalizedBase = basePath
-    ? withLeadingSlash(basePath).replaceAll(/\/+$/g, "")
-    : "";
-  const normalizedPath = withLeadingSlash(resolvedPath || "/");
-
-  if (
-    normalizedBase &&
-    (normalizedPath === normalizedBase ||
-      normalizedPath.startsWith(`${normalizedBase}/`))
-  ) {
-    return `${normalizedPath}${suffix}`;
-  }
-
-  return `${toDocHref(resolvedPath || "index", basePath)}${suffix}`;
-};