idcmd 0.0.1 → 0.0.2

package/src/seo/server.ts

@@ -0,0 +1,103 @@
+import { loadSiteConfig } from "@/site/config";
+import { resolveCanonicalBaseUrl } from "@/site/urls";
+
+import {
+  collectSitemapPagesFromContent,
+  generateRobotsTxt,
+  generateSitemapXml,
+} from "./files";
+
+export interface SeoHandlerEnv {
+  distDir: string;
+  isDev: boolean;
+  staticCacheHeaders: HeadersInit;
+}
+
+const tryServeDistFile = async (
+  filePath: string,
+  contentType: string,
+  env: SeoHandlerEnv
+): Promise<Response | null> => {
+  if (env.isDev) {
+    return null;
+  }
+
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) {
+    return null;
+  }
+
+  return new Response(file, {
+    headers: {
+      "Content-Type": contentType,
+      ...env.staticCacheHeaders,
+    },
+  });
+};
+
+export const handleRobotsTxt = async (
+  url: URL,
+  env: SeoHandlerEnv
+): Promise<Response | undefined> => {
+  if (url.pathname !== "/robots.txt") {
+    return undefined;
+  }
+
+  const served = await tryServeDistFile(
+    `${env.distDir}/robots.txt`,
+    "text/plain; charset=utf-8",
+    env
+  );
+  if (served) {
+    return served;
+  }
+
+  const siteConfig = await loadSiteConfig();
+  const baseUrl =
+    resolveCanonicalBaseUrl({
+      configuredBaseUrl: siteConfig.baseUrl,
+      isDev: env.isDev,
+      requestOrigin: url.origin,
+    }) ?? url.origin;
+
+  return new Response(generateRobotsTxt(baseUrl), {
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8",
+      ...env.staticCacheHeaders,
+    },
+  });
+};
+
+export const handleSitemapXml = async (
+  url: URL,
+  env: SeoHandlerEnv
+): Promise<Response | undefined> => {
+  if (url.pathname !== "/sitemap.xml") {
+    return undefined;
+  }
+
+  const served = await tryServeDistFile(
+    `${env.distDir}/sitemap.xml`,
+    "application/xml; charset=utf-8",
+    env
+  );
+  if (served) {
+    return served;
+  }
+
+  const siteConfig = await loadSiteConfig();
+  const baseUrl =
+    resolveCanonicalBaseUrl({
+      configuredBaseUrl: siteConfig.baseUrl,
+      isDev: env.isDev,
+      requestOrigin: url.origin,
+    }) ?? url.origin;
+  const pages = await collectSitemapPagesFromContent();
+
+  return new Response(generateSitemapXml(pages, baseUrl), {
+    headers: {
+      "Content-Type": "application/xml; charset=utf-8",
+      ...env.staticCacheHeaders,
+    },
+  });
+};

package/src/server/headers.ts

@@ -0,0 +1,10 @@
+export const createHtmlCacheHeaders = (isDev: boolean): HeadersInit => ({
+  "Cache-Control": isDev
+    ? "no-cache"
+    : "s-maxage=60, stale-while-revalidate=3600",
+  "Content-Type": "text/html; charset=utf-8",
+});
+
+export const createStaticCacheHeaders = (isDev: boolean): HeadersInit => ({
+  "Cache-Control": isDev ? "no-cache" : "public, max-age=31536000, immutable",
+});

package/src/server/live-reload.ts

@@ -0,0 +1,121 @@
+import type { Server } from "bun";
+
+import { getContentDir, scanContentFiles } from "@/content/paths";
+
+interface LiveReloadClient {
+  close: () => void;
+  send: (msg: string) => void;
+}
+
+type ServerInstance = Server<undefined>;
+
+export interface LiveReloadEnv {
+  isDev: boolean;
+  pollMs: number;
+  websocketPath: string;
+}
+
+export interface LiveReloadController {
+  maybeHandleUpgrade: (
+    req: Request,
+    server: ServerInstance,
+    pathname: string
+  ) => "handled" | Response | undefined;
+  startWatcher: () => Promise<void>;
+  websocket: {
+    close: (ws: LiveReloadClient) => void;
+    message: () => void;
+    open: (ws: LiveReloadClient) => void;
+  };
+}
+
+export const createLiveReload = (env: LiveReloadEnv): LiveReloadController => {
+  const clients = new Set<LiveReloadClient>();
+
+  const notify = (message: string): void => {
+    for (const client of clients) {
+      try {
+        client.send(message);
+      } catch {
+        clients.delete(client);
+      }
+    }
+  };
+
+  const getContentSnapshot = async (): Promise<string> => {
+    const contentDir = await getContentDir();
+    const entries: string[] = [];
+    for await (const file of scanContentFiles()) {
+      const filePath = `${contentDir}/${file}`;
+      const { lastModified } = Bun.file(filePath);
+      entries.push(`${file}:${lastModified}`);
+    }
+
+    return entries.toSorted().join("|");
+  };
+
+  const startWatcher = async (): Promise<void> => {
+    if (!env.isDev) {
+      return;
+    }
+
+    console.log("Watching content/ for changes...");
+    let snapshot = await getContentSnapshot();
+
+    const poll = async (): Promise<void> => {
+      const nextSnapshot = await getContentSnapshot();
+      if (nextSnapshot !== snapshot) {
+        snapshot = nextSnapshot;
+        console.log("[live-reload] Content updated");
+        notify("reload");
+      }
+    };
+
+    setInterval(async () => {
+      try {
+        await poll();
+      } catch (error) {
+        console.warn("[live-reload] Polling error", error);
+      }
+    }, env.pollMs);
+  };
+
+  const maybeHandleUpgrade = (
+    req: Request,
+    server: ServerInstance,
+    pathname: string
+  ): "handled" | Response | undefined => {
+    // Backward compatible: accept both legacy and new websocket paths.
+    if (
+      !env.isDev ||
+      (pathname !== env.websocketPath && pathname !== "/__live-reload")
+    ) {
+      return undefined;
+    }
+
+    const upgraded = server.upgrade(req);
+    if (upgraded) {
+      return "handled";
+    }
+
+    return new Response("WebSocket upgrade failed", { status: 400 });
+  };
+
+  return {
+    maybeHandleUpgrade,
+    startWatcher,
+    websocket: {
+      close(ws) {
+        clients.delete(ws);
+        console.log("[live-reload] Client disconnected");
+      },
+      message() {
+        // No messages expected from client.
+      },
+      open(ws) {
+        clients.add(ws);
+        console.log("[live-reload] Client connected");
+      },
+    },
+  };
+};

package/src/server/static.ts

@@ -0,0 +1,59 @@
+const mimeTypes: Record<string, string> = {
+  ".css": "text/css",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+};
+
+export interface ServeStaticEnv {
+  distDir: string;
+  isDev: boolean;
+  publicDir: string;
+  staticCacheHeaders: HeadersInit;
+}
+
+const tryServeFileFromRoot = async (
+  rootDir: string,
+  pathname: string,
+  env: ServeStaticEnv
+): Promise<Response | null> => {
+  const filePath = `${rootDir}${pathname}`;
+  const file = Bun.file(filePath);
+
+  if (!(await file.exists())) {
+    return null;
+  }
+
+  const ext = pathname.slice(pathname.lastIndexOf("."));
+  const contentType = mimeTypes[ext] || "application/octet-stream";
+
+  return new Response(file, {
+    headers: {
+      "Content-Type": contentType,
+      ...env.staticCacheHeaders,
+    },
+  });
+};
+
+export const serveStaticFile = async (
+  pathname: string,
+  env: ServeStaticEnv
+): Promise<Response | null> => {
+  const roots = env.isDev ? [env.publicDir] : [env.distDir, env.publicDir];
+
+  for (const root of roots) {
+    const served = await tryServeFileFromRoot(root, pathname, env);
+    if (served) {
+      return served;
+    }
+  }
+
+  return null;
+};

package/src/server/user-routes.ts

@@ -0,0 +1,209 @@
+import type { ProjectPaths } from "@/project/paths";
+
+import { isFileLikePathname, toCanonicalHtmlPathname } from "@/site/url-policy";
+
+export type RouteHandler = (req: Request) => Response | Promise<Response>;
+
+export interface RouteModule {
+  DELETE?: RouteHandler;
+  GET?: RouteHandler;
+  HEAD?: RouteHandler;
+  OPTIONS?: RouteHandler;
+  PATCH?: RouteHandler;
+  POST?: RouteHandler;
+  PUT?: RouteHandler;
+}
+
+export interface UserRoutesEnv {
+  isDev: boolean;
+  routesDir: ProjectPaths["routesDir"];
+}
+
+interface LoadedRoute {
+  handlers: RouteModule;
+  pathname: string;
+}
+
+const SUPPORTED_EXTENSIONS = [".ts", ".js", ".mjs"] as const;
+
+const isSupportedRouteFile = (relativePath: string): boolean =>
+  SUPPORTED_EXTENSIONS.some((ext) => relativePath.endsWith(ext));
+
+const normalizeRelativePath = (relativePath: string): string =>
+  relativePath.replaceAll("\\", "/").replaceAll(/^\/+/g, "");
+
+const stripExtension = (relativePath: string): string => {
+  for (const ext of SUPPORTED_EXTENSIONS) {
+    if (relativePath.endsWith(ext)) {
+      return relativePath.slice(0, -ext.length);
+    }
+  }
+  return relativePath;
+};
+
+const stripTrailingIndex = (value: string): string => {
+  if (value === "index") {
+    return "";
+  }
+  if (value.endsWith("/index")) {
+    return value.slice(0, -"/index".length);
+  }
+  return value;
+};
+
+const hasUnsupportedDynamicSegment = (pathname: string): boolean =>
+  pathname.includes("[") || pathname.includes("]") || pathname.includes(":");
+
+const pathnameFromRouteRelativePath = (relativePath: string): string => {
+  const normalized = normalizeRelativePath(relativePath);
+  const withoutExt = stripExtension(normalized);
+  const withoutIndex = stripTrailingIndex(withoutExt);
+  if (!withoutIndex) {
+    return "/";
+  }
+  return `/${withoutIndex}`;
+};
+
+export const routePathnameFromFile = (
+  filePath: string,
+  routesDir: string
+): string => {
+  const normalizedDir = routesDir.replaceAll("\\", "/").replaceAll(/\/+$/g, "");
+  const normalizedFile = filePath.replaceAll("\\", "/");
+  const prefix = `${normalizedDir}/`;
+  const relative = normalizedFile.startsWith(prefix)
+    ? normalizedFile.slice(prefix.length)
+    : normalizedFile;
+  return pathnameFromRouteRelativePath(relative);
+};
+
+const loadRouteModule = async (filePath: string): Promise<RouteModule> => {
+  const url = Bun.pathToFileURL(filePath);
+  const mod = (await import(url.toString())) as unknown;
+  return mod as RouteModule;
+};
+
+const scanRouteFiles = async (routesDir: string): Promise<string[]> => {
+  const routes: string[] = [];
+  const glob = new Bun.Glob("**/*");
+
+  try {
+    for await (const relativePath of glob.scan(routesDir)) {
+      if (!isSupportedRouteFile(relativePath)) {
+        continue;
+      }
+      routes.push(relativePath);
+    }
+  } catch {
+    return [];
+  }
+
+  return routes;
+};
+
+const cacheByDir = new Map<string, LoadedRoute[]>();
+
+const loadAllRoutes = async (env: UserRoutesEnv): Promise<LoadedRoute[]> => {
+  const cached = cacheByDir.get(env.routesDir);
+  if (cached) {
+    return cached;
+  }
+
+  const files = await scanRouteFiles(env.routesDir);
+  const loaded = await loadRoutesFromFiles(env.routesDir, files);
+  cacheByDir.set(env.routesDir, loaded);
+  return loaded;
+};
+
+const loadRoutesFromFiles = async (
+  routesDir: string,
+  files: readonly string[]
+): Promise<LoadedRoute[]> => {
+  if (files.length === 0) {
+    return [];
+  }
+
+  const loaded: LoadedRoute[] = [];
+  for (const relativeFile of files) {
+    // eslint-disable-next-line no-await-in-loop
+    loaded.push(await loadOneRoute(routesDir, relativeFile));
+  }
+  return loaded;
+};
+
+const loadOneRoute = async (
+  routesDir: string,
+  relativeFile: string
+): Promise<LoadedRoute> => {
+  const pathname = pathnameFromRouteRelativePath(relativeFile);
+  if (hasUnsupportedDynamicSegment(pathname)) {
+    throw new Error(
+      `Unsupported dynamic route segment in ${routesDir}/${relativeFile} (computed pathname: ${pathname}). V1 does not support [param] or :param routes.`
+    );
+  }
+
+  const handlers = await loadRouteModule(`${routesDir}/${relativeFile}`);
+  return { handlers, pathname };
+};
+
+const handlerFor = (
+  handlers: RouteModule,
+  method: string
+): RouteHandler | null => {
+  const value = (handlers as Record<string, unknown>)[method];
+  return typeof value === "function" ? (value as RouteHandler) : null;
+};
+
+const candidatePathnamesForRequest = (rawPathname: string): Set<string> => {
+  const canonical = isFileLikePathname(rawPathname)
+    ? rawPathname
+    : toCanonicalHtmlPathname(rawPathname);
+
+  const trimmedRaw =
+    rawPathname.endsWith("/") && rawPathname !== "/"
+      ? rawPathname.slice(0, -1)
+      : rawPathname;
+  const trimmedCanonical =
+    canonical.endsWith("/") && canonical !== "/"
+      ? canonical.slice(0, -1)
+      : canonical;
+
+  return new Set([rawPathname, canonical, trimmedRaw, trimmedCanonical]);
+};
+
+export const handleUserRouteRequest = async (
+  url: URL,
+  req: Request,
+  env: UserRoutesEnv
+): Promise<Response | undefined> => {
+  const match = await findMatchingRoute(url.pathname, env);
+  if (!match) {
+    return undefined;
+  }
+
+  const handler = handlerFor(match.handlers, req.method);
+  if (!handler) {
+    return createMethodNotAllowedResponse(match.handlers);
+  }
+
+  return handler(req);
+};
+
+const findMatchingRoute = async (
+  pathname: string,
+  env: UserRoutesEnv
+): Promise<LoadedRoute | null> => {
+  const routes = await loadAllRoutes(env);
+  if (routes.length === 0) {
+    return null;
+  }
+
+  const candidates = candidatePathnamesForRequest(pathname);
+  return routes.find((r) => candidates.has(r.pathname)) ?? null;
+};
+
+const createMethodNotAllowedResponse = (handlers: RouteModule): Response =>
+  new Response("Method Not Allowed", {
+    headers: { Allow: Object.keys(handlers).join(", ") },
+    status: 405,
+  });