@lownoise-studio/rendershield 0.3.0 → 1.0.0

package/src/core/generateWorker.ts

@@ -1,87 +1,97 @@
-import { RenderShieldConfig } from "../types.js";
-
-function jsStringArray(arr: string[]): string {
-  return `[${arr.map((s) => JSON.stringify(s)).join(", ")}]`;
-}
-
-export function generateWorkerJs(cfg: RenderShieldConfig): string {
-  const patterns = cfg.worker.botUserAgentPatterns.map((p) => p.toLowerCase());
-  const rewriteBases = cfg.worker.rewriteRouteBases;
-
-  return `/**
- * RenderShield Worker (generated)
- * Serves prerendered /index.html to bots on selected route bases.
- */
-
-const BOT_SUBSTRINGS = ${jsStringArray(patterns)};
-const REWRITE_BASES = ${jsStringArray(rewriteBases)};
-
-function isBot(ua) {
-  const s = (ua || "").toLowerCase();
-  return BOT_SUBSTRINGS.some((sub) => s.includes(sub));
-}
-
-function shouldRewrite(pathname) {
-  return REWRITE_BASES.some((base) => pathname.startsWith(base));
-}
-
-function toIndexHtml(pathname) {
-  let p = pathname;
-  if (!p.endsWith("/")) p += "/";
-  return p + "index.html";
-}
-
-export default {
-  async fetch(request, env, ctx) {
-    const url = new URL(request.url);
-    const ua = request.headers.get("User-Agent") || "";
-    const bot = isBot(ua);
-
-    const isGetLike = request.method === "GET" || request.method === "HEAD";
-    const rewrite = bot && isGetLike && shouldRewrite(url.pathname);
-
-    try {
-      if (!rewrite) {
-        const passResp = await fetch(request);
-        const out = new Response(passResp.body, passResp);
-        out.headers.set("x-rendershield", "pass-through");
-        return out;
-      }
-
-      const origin = ${JSON.stringify(cfg.worker.lovableOrigin)};
-      const finalPath = toIndexHtml(url.pathname);
-      const originUrl = origin + finalPath + url.search;
-
-      const headers = new Headers();
-      headers.set("Accept", "text/html");
-      headers.set("User-Agent", ua);
-
-      const resp = await fetch(originUrl, { method: "GET", headers });
-
-      if (!resp.ok) {
-        const fallbackUrl = origin + url.pathname + url.search;
-        const fb = await fetch(fallbackUrl, { method: "GET", headers });
-        const out = new Response(fb.body, fb);
-        out.headers.set("x-rendershield", "bot-fallback");
-        ${cfg.worker.debugHeaders ? `out.headers.set("X-Bot-Detected", "true");
-        out.headers.set("X-Prerender-Fallback", "true");
-        out.headers.set("X-Requested-Path", url.pathname);` : ""}
-        return out;
-      }
-
-      const out = new Response(resp.body, resp);
-      out.headers.set("x-rendershield", "bot-hit");
-      ${cfg.worker.debugHeaders ? `out.headers.set("X-Bot-Detected", "true");
-      out.headers.set("X-Prerender", "true");
-      out.headers.set("X-Final-Path", finalPath);` : ""}
-      return out;
-    } catch (err) {
-      return new Response("Worker error: " + (err && err.message ? err.message : String(err)), {
-        status: 500,
-        headers: { "Content-Type": "text/plain; charset=utf-8" }
-      });
-    }
-  }
-};
-`;
-}
+import { createRequire } from "node:module";
+import { RenderShieldConfig } from "../types.js";
+
+const require = createRequire(import.meta.url);
+let VERSION = "0.0.0";
+try {
+  const pkg = require("../../package.json") as { version?: string };
+  VERSION = pkg.version ?? "0.0.0";
+} catch {
+  VERSION = "unknown";
+}
+
+function jsStringArray(arr: string[]): string {
+  return `[${arr.map((s) => JSON.stringify(s)).join(", ")}]`;
+}
+
+export function generateWorkerJs(cfg: RenderShieldConfig): string {
+  const patterns = cfg.worker.botUserAgentPatterns.map((p) => p.toLowerCase());
+  const rewriteBases = cfg.worker.rewriteRouteBases;
+
+  return `/**
+ * RenderShield Worker (generated) v${VERSION}
+ * Serves prerendered /index.html to bots on selected route bases.
+ */
+
+const BOT_SUBSTRINGS = ${jsStringArray(patterns)};
+const REWRITE_BASES = ${jsStringArray(rewriteBases)};
+
+function isBot(ua) {
+  const s = (ua || "").toLowerCase();
+  return BOT_SUBSTRINGS.some((sub) => s.includes(sub));
+}
+
+function shouldRewrite(pathname) {
+  return REWRITE_BASES.some((base) => pathname.startsWith(base));
+}
+
+function toIndexHtml(pathname) {
+  let p = pathname;
+  if (!p.endsWith("/")) p += "/";
+  return p + "index.html";
+}
+
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+    const ua = request.headers.get("User-Agent") || "";
+    const bot = isBot(ua);
+
+    const isGetLike = request.method === "GET" || request.method === "HEAD";
+    const rewrite = bot && isGetLike && shouldRewrite(url.pathname);
+
+    try {
+      if (!rewrite) {
+        const passResp = await fetch(request);
+        const out = new Response(passResp.body, passResp);
+        out.headers.set("x-rendershield", "pass-through");
+        return out;
+      }
+
+      const origin = ${JSON.stringify(cfg.worker.lovableOrigin)};
+      const finalPath = toIndexHtml(url.pathname);
+      const originUrl = origin + finalPath + url.search;
+
+      const headers = new Headers();
+      headers.set("Accept", "text/html");
+      headers.set("User-Agent", ua);
+
+      const resp = await fetch(originUrl, { method: "GET", headers });
+
+      if (!resp.ok) {
+        const fallbackUrl = origin + url.pathname + url.search;
+        const fb = await fetch(fallbackUrl, { method: "GET", headers });
+        const out = new Response(fb.body, fb);
+        out.headers.set("x-rendershield", "bot-fallback");
+        ${cfg.worker.debugHeaders ? `out.headers.set("X-Bot-Detected", "true");
+        out.headers.set("X-Prerender-Fallback", "true");
+        out.headers.set("X-Requested-Path", url.pathname);` : ""}
+        return out;
+      }
+
+      const out = new Response(resp.body, resp);
+      out.headers.set("x-rendershield", "bot-hit");
+      ${cfg.worker.debugHeaders ? `out.headers.set("X-Bot-Detected", "true");
+      out.headers.set("X-Prerender", "true");
+      out.headers.set("X-Final-Path", finalPath);` : ""}
+      return out;
+    } catch (err) {
+      return new Response("Service temporarily unavailable.", {
+        status: 500,
+        headers: { "Content-Type": "text/plain; charset=utf-8" }
+      });
+    }
+  }
+};
+`;
+}

package/src/core/loadConfig.ts

@@ -1,142 +1,261 @@
-import fs from "fs-extra";
-import path from "node:path";
-import { RenderShieldConfig } from "../types.js";
-
-const CONFIG_NAME = "rendershield.config.json";
-
-type BoolFlag = { enabled: boolean };
-
-function isObject(v: unknown): v is Record<string, unknown> {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-function coerceBoolFlag(
-  parsed: any,
-  key: "sitemap" | "robots" | "worker",
-  defaultEnabled: boolean
-): BoolFlag {
-  // If missing, provide defaults (keeps older configs from exploding)
-  if (parsed?.[key] == null) return { enabled: defaultEnabled };
-
-  // If present, validate shape
-  const v = parsed[key];
-  if (!isObject(v)) {
-    throw new Error(`${key} must be an object like { "enabled": true }`);
-  }
-  if (typeof (v as any).enabled !== "boolean") {
-    throw new Error(`${key}.enabled must be a boolean`);
-  }
-  return { enabled: (v as any).enabled };
-}
-
-/**
- * Worker config policy: strict mode.
- * When worker.enabled is true, all of lovableOrigin, rewriteRouteBases, and
- * botUserAgentPatterns are required and must be non-empty. No defaults are
- * supplied — build fails with a crisp error.
- * lovableOrigin: must be http: or https: only (no file:, javascript:, protocol-relative).
- * botUserAgentPatterns: substring match only (not regex); empty strings rejected to avoid overmatching.
- */
-function validateWorkerWhenEnabled(parsed: any): void {
-  if (!parsed.worker?.lovableOrigin || typeof parsed.worker.lovableOrigin !== "string") {
-    throw new Error(
-      `worker.lovableOrigin is required when worker.enabled is true. Example: "https://your-site.lovable.app"`
-    );
-  }
-  let url: URL;
-  try {
-    url = new URL(parsed.worker.lovableOrigin);
-  } catch {
-    throw new Error(
-      `worker.lovableOrigin must be a valid URL. Got: "${parsed.worker.lovableOrigin}"`
-    );
-  }
-  const scheme = url.protocol.toLowerCase();
-  if (scheme !== "http:" && scheme !== "https:") {
-    throw new Error(
-      `worker.lovableOrigin must use http or https. Got: "${url.protocol}"`
-    );
-  }
-  if (
-    !Array.isArray(parsed.worker?.rewriteRouteBases) ||
-    parsed.worker.rewriteRouteBases.length === 0
-  ) {
-    throw new Error(
-      `worker.rewriteRouteBases must be a non-empty array when worker.enabled is true. Example: ["/blog/"]`
-    );
-  }
-  if (
-    !Array.isArray(parsed.worker?.botUserAgentPatterns) ||
-    parsed.worker.botUserAgentPatterns.length === 0
-  ) {
-    throw new Error(
-      `worker.botUserAgentPatterns must be a non-empty array when worker.enabled is true. Example: ["googlebot", "bingbot"]`
-    );
-  }
-  // Substring match only; empty string would match every User-Agent
-  for (let i = 0; i < parsed.worker.botUserAgentPatterns.length; i++) {
-    const p = parsed.worker.botUserAgentPatterns[i];
-    if (typeof p !== "string" || p.trim() === "") {
-      throw new Error(
-        `worker.botUserAgentPatterns[${i}] must be a non-empty string (substring match). Empty or invalid entry would overmatch.`
-      );
-    }
-  }
-}
-
-export async function loadConfig(
-  cwd = process.cwd()
-): Promise<RenderShieldConfig> {
-  const p = path.join(cwd, CONFIG_NAME);
-  const exists = await fs.pathExists(p);
-  if (!exists) {
-    throw new Error(`Missing ${CONFIG_NAME}. Run: rendershield init`);
-  }
-
-  const raw = await fs.readFile(p, "utf8");
-  let parsed: any;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`${CONFIG_NAME} is not valid JSON`);
-  }
-
-  // Minimal validation (v0)
-  if (parsed?.version !== 1) throw new Error(`Config version must be 1`);
-  if (!parsed?.site?.canonicalBase)
-    throw new Error(`site.canonicalBase is required`);
-  if (!parsed?.site?.siteName) throw new Error(`site.siteName is required`);
-  if (!parsed?.site?.defaultOgImage)
-    throw new Error(`site.defaultOgImage is required`);
-  if (!parsed?.site?.authorName)
-    throw new Error(`site.authorName is required`);
-  if (!parsed?.content?.markdown?.baseDir)
-    throw new Error(`content.markdown.baseDir is required`);
-  if (
-    !Array.isArray(parsed?.content?.markdown?.collections) ||
-    parsed.content.markdown.collections.length === 0
-  ) {
-    throw new Error(`content.markdown.collections must be a non-empty array`);
-  }
-  if (!parsed?.output?.outDir) throw new Error(`output.outDir is required`);
-
-  // Validate + default these optional sections to prevent TypeErrors later
-  parsed.sitemap = coerceBoolFlag(parsed, "sitemap", true);
-  parsed.robots = coerceBoolFlag(parsed, "robots", true);
-  const workerFlag = coerceBoolFlag(parsed, "worker", true);
-  parsed.worker = workerFlag;
-
-  if (parsed.worker.enabled) {
-    validateWorkerWhenEnabled(parsed);
-  } else {
-    parsed.worker = {
-      enabled: false,
-      lovableOrigin: "",
-      rewriteRouteBases: [],
-      botUserAgentPatterns: [],
-      debugHeaders: false,
-    };
-  }
-
-  return parsed as RenderShieldConfig;
-}
+import fs from "fs-extra";
+import path from "node:path";
+import { RenderShieldConfig, SCHEMA_TYPES, type SchemaType } from "../types.js";
+import { renderShieldError } from "../errors.js";
+
+const CONFIG_NAME = "rendershield.config.json";
+
+const DEFAULT_SITEMAP_PATH = "/sitemap.xml";
+const DEFAULT_ROBOTS_PATH = "/robots.txt";
+
+type BoolFlag = { enabled: boolean };
+
+/** Shape of config as read from JSON (before normalization). Used for validation only. */
+interface ParsedInput {
+  version?: unknown;
+  site?: { canonicalBase?: unknown; siteName?: unknown; defaultOgImage?: unknown; authorName?: unknown };
+  content?: { markdown?: { baseDir?: unknown; collections?: unknown[] } };
+  output?: { outDir?: unknown };
+  sitemap?: Record<string, unknown>;
+  robots?: Record<string, unknown>;
+  worker?: Record<string, unknown>;
+}
+
+function isObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function coerceBoolFlag(
+  parsed: Record<string, unknown>,
+  key: "sitemap" | "robots" | "worker",
+  defaultEnabled: boolean
+): BoolFlag {
+  // If missing, provide defaults (keeps older configs from exploding)
+  if (parsed?.[key] == null) return { enabled: defaultEnabled };
+
+  // If present, validate shape
+  const v = parsed[key];
+  if (!isObject(v)) {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      `${key} must be an object like { "enabled": true }`
+    );
+  }
+  const enabled = (v as Record<string, unknown>).enabled;
+  if (typeof enabled !== "boolean") {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      `${key}.enabled must be a boolean`
+    );
+  }
+  return { enabled };
+}
+
+/**
+ * Worker config policy: strict mode.
+ * When worker.enabled is true, all of lovableOrigin, rewriteRouteBases, and
+ * botUserAgentPatterns are required and must be non-empty. No defaults are
+ * supplied — build fails with a crisp error.
+ * lovableOrigin: must be http: or https: only (no file:, javascript:, protocol-relative).
+ * botUserAgentPatterns: substring match only (not regex); empty strings rejected to avoid overmatching.
+ */
+function validateWorkerWhenEnabled(parsed: Record<string, unknown>): void {
+  const worker = parsed.worker as Record<string, unknown> | undefined;
+  if (!worker?.lovableOrigin || typeof worker.lovableOrigin !== "string") {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      `worker.lovableOrigin is required when worker.enabled is true. Example: "https://your-site.lovable.app"`
+    );
+  }
+  let url: URL;
+  try {
+    url = new URL(worker.lovableOrigin);
+  } catch {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      `worker.lovableOrigin must be a valid URL. Got: "${worker.lovableOrigin}"`
+    );
+  }
+  const scheme = url.protocol.toLowerCase();
+  if (scheme !== "http:" && scheme !== "https:") {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      `worker.lovableOrigin must use http or https. Got: "${url.protocol}"`
+    );
+  }
+  if (
+    !Array.isArray(worker.rewriteRouteBases) ||
+    worker.rewriteRouteBases.length === 0
+  ) {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      `worker.rewriteRouteBases must be a non-empty array when worker.enabled is true. Example: ["/blog/"]`
+    );
+  }
+  if (
+    !Array.isArray(worker.botUserAgentPatterns) ||
+    worker.botUserAgentPatterns.length === 0
+  ) {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      `worker.botUserAgentPatterns must be a non-empty array when worker.enabled is true. Example: ["googlebot", "bingbot"]`
+    );
+  }
+  // Substring match only; empty string would match every User-Agent
+  for (let i = 0; i < worker.botUserAgentPatterns.length; i++) {
+    const p = worker.botUserAgentPatterns[i];
+    if (typeof p !== "string" || p.trim() === "") {
+      throw renderShieldError(
+        "CONFIG_INVALID",
+        `worker.botUserAgentPatterns[${i}] must be a non-empty string (substring match). Empty or invalid entry would overmatch.`
+      );
+    }
+  }
+}
+
+export async function loadConfig(
+  cwd = process.cwd()
+): Promise<RenderShieldConfig> {
+  const p = path.join(cwd, CONFIG_NAME);
+  const exists = await fs.pathExists(p);
+  if (!exists) {
+    throw renderShieldError(
+      "CONFIG_MISSING",
+      `Missing ${CONFIG_NAME}. Run: rendershield init`
+    );
+  }
+
+  const raw = await fs.readFile(p, "utf8");
+  let parsed: ParsedInput & Record<string, unknown>;
+  try {
+    parsed = JSON.parse(raw) as ParsedInput & Record<string, unknown>;
+  } catch {
+    throw renderShieldError("CONFIG_INVALID", `${CONFIG_NAME} is not valid JSON`);
+  }
+
+  // Minimal validation (v0)
+  if (parsed?.version !== 1) {
+    throw renderShieldError("CONFIG_INVALID", "Config version must be 1");
+  }
+  if (!parsed?.site?.canonicalBase) {
+    throw renderShieldError("CONFIG_INVALID", "site.canonicalBase is required");
+  }
+  if (!parsed?.site?.siteName) {
+    throw renderShieldError("CONFIG_INVALID", "site.siteName is required");
+  }
+  if (!parsed?.site?.defaultOgImage) {
+    throw renderShieldError("CONFIG_INVALID", "site.defaultOgImage is required");
+  }
+  if (!parsed?.site?.authorName) {
+    throw renderShieldError("CONFIG_INVALID", "site.authorName is required");
+  }
+  if (!parsed?.content?.markdown?.baseDir) {
+    throw renderShieldError("CONFIG_INVALID", "content.markdown.baseDir is required");
+  }
+  if (
+    !Array.isArray(parsed?.content?.markdown?.collections) ||
+    parsed.content.markdown.collections.length === 0
+  ) {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      "content.markdown.collections must be a non-empty array"
+    );
+  }
+  if (!parsed?.output?.outDir) {
+    throw renderShieldError("CONFIG_INVALID", "output.outDir is required");
+  }
+
+  parsed.content.markdown.collections = normalizeCollections(
+    parsed.content.markdown.collections
+  );
+
+  // Validate + default these optional sections (preserve path so it is not lost)
+  const sitemapFlag = coerceBoolFlag(parsed, "sitemap", true);
+  const sitemapObj = parsed.sitemap as Record<string, unknown> | undefined;
+  const sitemapPathVal = sitemapObj?.path;
+  const sitemapPath =
+    typeof sitemapPathVal === "string" && sitemapPathVal.trim().startsWith("/")
+      ? sitemapPathVal.trim()
+      : DEFAULT_SITEMAP_PATH;
+  parsed.sitemap = { enabled: sitemapFlag.enabled, path: sitemapPath };
+
+  const robotsFlag = coerceBoolFlag(parsed, "robots", true);
+  const robotsObj = parsed.robots as Record<string, unknown> | undefined;
+  const robotsPathVal = robotsObj?.path;
+  const robotsPath =
+    typeof robotsPathVal === "string" && robotsPathVal.trim().startsWith("/")
+      ? robotsPathVal.trim()
+      : DEFAULT_ROBOTS_PATH;
+  parsed.robots = { enabled: robotsFlag.enabled, path: robotsPath };
+
+  const workerFlag = coerceBoolFlag(parsed, "worker", true);
+  if (workerFlag.enabled) {
+    validateWorkerWhenEnabled(parsed);
+    // Keep parsed.worker as the full object from JSON (already validated)
+  } else {
+    parsed.worker = {
+      enabled: false,
+      lovableOrigin: "",
+      rewriteRouteBases: [],
+      botUserAgentPatterns: [],
+      debugHeaders: false,
+    };
+  }
+
+  return parsed as RenderShieldConfig;
+}
+
+function normalizeCollections(collections: unknown[]): RenderShieldConfig["content"]["markdown"]["collections"] {
+  return collections.map((raw, index) => {
+    if (!isObject(raw)) {
+      throw renderShieldError(
+        "CONFIG_INVALID",
+        `content.markdown.collections[${index}] must be an object`
+      );
+    }
+
+    const name = raw.name;
+    const pattern = raw.pattern;
+    const routeBase = raw.routeBase;
+    const schemaTypeRaw = raw.schemaType;
+
+    if (typeof name !== "string" || name.trim() === "") {
+      throw renderShieldError(
+        "CONFIG_INVALID",
+        `content.markdown.collections[${index}].name must be a non-empty string`
+      );
+    }
+    if (typeof pattern !== "string" || pattern.trim() === "") {
+      throw renderShieldError(
+        "CONFIG_INVALID",
+        `content.markdown.collections[${index}].pattern must be a non-empty string`
+      );
+    }
+    if (typeof routeBase !== "string" || routeBase.trim() === "") {
+      throw renderShieldError(
+        "CONFIG_INVALID",
+        `content.markdown.collections[${index}].routeBase must be a non-empty string`
+      );
+    }
+
+    const schemaType: SchemaType =
+      schemaTypeRaw === undefined ? "Article" : parseSchemaType(schemaTypeRaw, index);
+
+    return {
+      name: name.trim(),
+      pattern: pattern.trim(),
+      routeBase: routeBase.trim(),
+      schemaType,
+    };
+  });
+}
+
+function parseSchemaType(value: unknown, index: number): SchemaType {
+  if (typeof value !== "string" || !SCHEMA_TYPES.includes(value as SchemaType)) {
+    throw renderShieldError(
+      "CONFIG_INVALID",
+      `content.markdown.collections[${index}].schemaType must be one of: ${SCHEMA_TYPES.join(", ")}`
+    );
+  }
+  return value as SchemaType;
+}

package/src/core/loadMarkdown.ts

@@ -4,28 +4,33 @@ import fs from "fs-extra";
 import matter from "gray-matter";
 import MarkdownIt from "markdown-it";
 import { MarkdownDoc, RenderShieldConfig } from "../types.js";
+import { renderShieldError } from "../errors.js";
 
 const md = new MarkdownIt({ html: false, linkify: true, typographer: true });
 
 const REQUIRED_FIELDS = "title, excerpt, datePublished, coverImage, slug";
 
-function requireString(value: any, field: string, file: string): string {
+function requireString(value: unknown, field: string, file: string): string {
   if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(
+    throw renderShieldError(
+      "CONTENT_INVALID",
       `Missing required frontmatter field "${field}" in ${file}. Required fields: ${REQUIRED_FIELDS}`
     );
   }
   return value.trim();
 }
 
-function normalizeDate(value: any, file: string): string {
+function normalizeDate(value: unknown, file: string): string {
   if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value)) {
     return value;
   }
   if (value instanceof Date) {
     return value.toISOString().slice(0, 10);
   }
-  throw new Error(`Invalid datePublished in ${file}. Use format YYYY-MM-DD.`);
+  throw renderShieldError(
+    "CONTENT_INVALID",
+    `Invalid datePublished in ${file}. Use format YYYY-MM-DD.`
+  );
 }
 
 export async function loadAllMarkdownDocs(cfg: RenderShieldConfig, cwd = process.cwd()): Promise<MarkdownDoc[]> {
@@ -47,7 +52,8 @@ export async function loadAllMarkdownDocs(cfg: RenderShieldConfig, cwd = process
 
       const datePublishedRaw = parsed.data?.datePublished;
       if (datePublishedRaw === undefined || datePublishedRaw === null) {
-        throw new Error(
+        throw renderShieldError(
+          "CONTENT_INVALID",
           `Missing required frontmatter field "datePublished" in ${abs}. Required fields: ${REQUIRED_FIELDS}`
         );
       }