@lownoise-studio/rendershield 1.0.0 → 1.1.0

package/src/core/loadConfig.ts

@@ -2,8 +2,11 @@ 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";
+import {
+  resolveConfigFile,
+  DEFAULT_CONFIG_NAME,
+  type CommandOptions,
+} from "../configPath.js";
 
 const DEFAULT_SITEMAP_PATH = "/sitemap.xml";
 const DEFAULT_ROBOTS_PATH = "/robots.txt";
@@ -30,10 +33,8 @@ function coerceBoolFlag(
   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(
@@ -51,40 +52,44 @@ function coerceBoolFlag(
   return { enabled };
 }
 
+function readSpaOrigin(worker: Record<string, unknown>): string | undefined {
+  const spa = worker.spaOrigin ?? worker.lovableOrigin;
+  return typeof spa === "string" && spa.trim() !== "" ? spa.trim() : undefined;
+}
+
 /**
- * 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.
+ * Worker config policy: strict mode when enabled.
+ * spaOrigin (or deprecated lovableOrigin) must be http(s).
  */
 function validateWorkerWhenEnabled(parsed: Record<string, unknown>): void {
   const worker = parsed.worker as Record<string, unknown> | undefined;
-  if (!worker?.lovableOrigin || typeof worker.lovableOrigin !== "string") {
+  const spaOrigin = worker ? readSpaOrigin(worker) : undefined;
+
+  if (!spaOrigin) {
     throw renderShieldError(
       "CONFIG_INVALID",
-      `worker.lovableOrigin is required when worker.enabled is true. Example: "https://your-site.lovable.app"`
+      `worker.spaOrigin is required when worker.enabled is true. Example: "https://app.example.com" (lovableOrigin is accepted as a deprecated alias).`
     );
   }
+
   let url: URL;
   try {
-    url = new URL(worker.lovableOrigin);
+    url = new URL(spaOrigin);
   } catch {
     throw renderShieldError(
       "CONFIG_INVALID",
-      `worker.lovableOrigin must be a valid URL. Got: "${worker.lovableOrigin}"`
+      `worker.spaOrigin must be a valid URL. Got: "${spaOrigin}"`
     );
   }
   const scheme = url.protocol.toLowerCase();
   if (scheme !== "http:" && scheme !== "https:") {
     throw renderShieldError(
       "CONFIG_INVALID",
-      `worker.lovableOrigin must use http or https. Got: "${url.protocol}"`
+      `worker.spaOrigin must use http or https. Got: "${url.protocol}"`
     );
   }
   if (
-    !Array.isArray(worker.rewriteRouteBases) ||
+    !Array.isArray(worker?.rewriteRouteBases) ||
     worker.rewriteRouteBases.length === 0
   ) {
     throw renderShieldError(
@@ -93,7 +98,7 @@ function validateWorkerWhenEnabled(parsed: Record<string, unknown>): void {
     );
   }
   if (
-    !Array.isArray(worker.botUserAgentPatterns) ||
+    !Array.isArray(worker?.botUserAgentPatterns) ||
     worker.botUserAgentPatterns.length === 0
   ) {
     throw renderShieldError(
@@ -101,7 +106,6 @@ function validateWorkerWhenEnabled(parsed: Record<string, unknown>): void {
       `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() === "") {
@@ -113,27 +117,54 @@ function validateWorkerWhenEnabled(parsed: Record<string, unknown>): void {
   }
 }
 
+function normalizeWorker(
+  parsed: Record<string, unknown>,
+  enabled: boolean
+): void {
+  if (!enabled) {
+    parsed.worker = {
+      enabled: false,
+      spaOrigin: "",
+      rewriteRouteBases: [],
+      botUserAgentPatterns: [],
+      debugHeaders: false,
+    };
+    return;
+  }
+
+  validateWorkerWhenEnabled(parsed);
+  const worker = parsed.worker as Record<string, unknown>;
+  parsed.worker = {
+    enabled: true,
+    spaOrigin: readSpaOrigin(worker) as string,
+    rewriteRouteBases: worker.rewriteRouteBases,
+    botUserAgentPatterns: worker.botUserAgentPatterns,
+    debugHeaders: worker.debugHeaders === true,
+  };
+}
+
 export async function loadConfig(
-  cwd = process.cwd()
+  cwd = process.cwd(),
+  options?: CommandOptions
 ): Promise<RenderShieldConfig> {
-  const p = path.join(cwd, CONFIG_NAME);
-  const exists = await fs.pathExists(p);
+  const configFile = resolveConfigFile(cwd, options?.configPath);
+  const configName = path.basename(configFile);
+  const exists = await fs.pathExists(configFile);
   if (!exists) {
     throw renderShieldError(
       "CONFIG_MISSING",
-      `Missing ${CONFIG_NAME}. Run: rendershield init`
+      `Missing ${configName}. Run: rendershield init`
     );
   }
 
-  const raw = await fs.readFile(p, "utf8");
+  const raw = await fs.readFile(configFile, "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`);
+    throw renderShieldError("CONFIG_INVALID", `${configName} is not valid JSON`);
   }
 
-  // Minimal validation (v0)
   if (parsed?.version !== 1) {
     throw renderShieldError("CONFIG_INVALID", "Config version must be 1");
   }
@@ -169,7 +200,6 @@ export async function loadConfig(
     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;
@@ -189,22 +219,13 @@ export async function loadConfig(
   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,
-    };
-  }
+  normalizeWorker(parsed, workerFlag.enabled);
 
   return parsed as RenderShieldConfig;
 }
 
+export { DEFAULT_CONFIG_NAME };
+
 function normalizeCollections(collections: unknown[]): RenderShieldConfig["content"]["markdown"]["collections"] {
   return collections.map((raw, index) => {
     if (!isObject(raw)) {

package/src/index.ts

@@ -9,10 +9,11 @@ export { cmdInit } from "./commands/init.js";
 export { cmdBuild } from "./commands/build.js";
 export {
   cmdVerify,
-  type VerifyProdOptions,
+  type VerifyOptions,
   type VerifyLocalResult,
   type VerifyProdResult,
   type VerifyResult,
+  type VerifyPageResult,
 } from "./commands/verify.js";
 
 export { loadConfig } from "./core/loadConfig.js";
@@ -28,6 +29,8 @@ export { generateSitemapXml } from "./core/generateSitemap.js";
 export { generateRobotsTxt } from "./core/generateRobots.js";
 export { generateWorkerJs } from "./core/generateWorker.js";
 
+export type { CommandOptions } from "./configPath.js";
+export { DEFAULT_CONFIG_NAME, resolveConfigFile } from "./configPath.js";
 export type { RenderShieldConfig, MarkdownDoc, SchemaType } from "./types.js";
 export { SCHEMA_TYPES } from "./types.js";
 

package/src/types.ts

@@ -34,7 +34,7 @@ export type RenderShieldConfig = {
     };
     worker: {
       enabled: boolean;
-      lovableOrigin: string; // https://YOUR_SITE.lovable.app
+      spaOrigin: string; // https://app.example.com — human SPA / hosting origin
       rewriteRouteBases: string[]; // ["/blog/"]
       botUserAgentPatterns: string[];
       debugHeaders: boolean;