@stack-mode/site-manager-kit 0.0.0-stage → 1.44.1

package/src/redirects.ts

@@ -0,0 +1,57 @@
+import { after, NextResponse, type NextRequest } from "next/server";
+import { bp } from "./client";
+import type { Redirect } from "./types";
+
+const TTL_MS = 5 * 60 * 1000;
+let cache: { at: number; map: Map<string, Redirect> } | null = null;
+
+/** Exact path, no trailing slash (except "/"), query string ignored. */
+export function normalizePath(pathname: string): string {
+  const p = pathname.split("?")[0].replace(/\/{2,}/g, "/");
+  return p.length > 1 ? p.replace(/\/+$/, "") : p;
+}
+
+export function buildRedirectMap(list: Redirect[]): Map<string, Redirect> {
+  return new Map(list.map((r) => [normalizePath(r.from), r]));
+}
+
+/** Pure: the redirect for a path, if any. */
+export function matchRedirect(map: Map<string, Redirect>, pathname: string): Redirect | null {
+  return map.get(normalizePath(pathname)) ?? null;
+}
+
+/** Called by the revalidate route when Site Manager says redirects changed. */
+export function clearRedirectCache() {
+  cache = null;
+}
+
+async function redirectMap(): Promise<Map<string, Redirect>> {
+  if (cache && Date.now() - cache.at < TTL_MS) return cache.map;
+  // The proxy has no data cache, so this list is kept in memory here and cleared by the revalidate route.
+  const list = (await bp<Redirect[]>("/redirects", { cache: "no-store" })) ?? [];
+  cache = { at: Date.now(), map: buildRedirectMap(list) };
+  return cache.map;
+}
+
+/**
+ * For `src/proxy.ts`: returns a redirect response when Site Manager has one for this path, or undefined to carry
+ * on. The hit is counted after the response is sent. If Site Manager can't be reached, nothing redirects.
+ */
+export async function handleRedirect(request: NextRequest): Promise<NextResponse | undefined> {
+  let match: Redirect | null = null;
+  try {
+    match = matchRedirect(await redirectMap(), request.nextUrl.pathname);
+  } catch {
+    return undefined;
+  }
+  if (!match) return undefined;
+  const target = /^https?:\/\//i.test(match.to) ? new URL(match.to) : new URL(match.to, request.nextUrl.origin);
+  if (!/^https?:\/\//i.test(match.to)) target.search = request.nextUrl.search;
+  const from = match.from;
+  try {
+    after(() => bp("/redirects/hit", { method: "POST", body: { from } }).catch(() => {}));
+  } catch {
+    void bp("/redirects/hit", { method: "POST", body: { from } }).catch(() => {});
+  }
+  return NextResponse.redirect(target, match.status);
+}

package/src/residents.ts

@@ -0,0 +1,23 @@
+import type { Pickup, Weekday } from "./types";
+
+// Plain-language text for resident and policy facts. Formatting only: the site's own code decides where it shows.
+
+const DAY_NAMES: Record<Weekday, string> = { mon: "Monday", tue: "Tuesday", wed: "Wednesday", thu: "Thursday", fri: "Friday", sat: "Saturday", sun: "Sunday" };
+
+const list = (parts: string[], joiner: string) => (parts.length <= 1 ? (parts[0] ?? "") : `${parts.slice(0, -1).join(", ")} ${joiner} ${parts[parts.length - 1]}`);
+
+/** "Monday and Thursday by 7 am". Empty when no days are set. */
+export function pickupText(p: Pick<Pickup, "days" | "time">): string {
+  if (!p.days.length) return "";
+  const days = p.days.length === 7 ? "Every day" : list(p.days.map((d) => DAY_NAMES[d]), "and");
+  if (!p.time) return days;
+  const [h, m] = p.time.split(":").map(Number);
+  const hour = h % 12 === 0 ? 12 : h % 12;
+  return `${days} by ${hour}${m ? `:${String(m).padStart(2, "0")}` : ""} ${h < 12 ? "am" : "pm"}`;
+}
+
+/** "6, 12 or 15 months". Empty when no lengths are set. */
+export function leaseTermsText(months: number[]): string {
+  if (!months.length) return "";
+  return `${list(months.map(String), "or")} month${months.length === 1 && months[0] === 1 ? "" : "s"}`;
+}

package/src/revalidate-route.ts

@@ -0,0 +1,34 @@
+import { revalidateTag } from "next/cache";
+import { siteId } from "./client";
+import { clearRedirectCache } from "./redirects";
+import { SIGNATURE_HEADER, verify } from "./signature";
+
+/**
+ * Receives Site Manager's "content changed" requests. Put in app/api/blueprint/revalidate/route.ts:
+ *
+ *   export { POST } from "site-manager-kit/revalidate-route";
+ *
+ * Only signed requests from the last 5 minutes are accepted, and only this site's tags are refreshed. No visitor waits
+ * for a refresh: the first visit after a change still gets the cached page and starts its rebuild.
+ */
+export async function POST(req: Request): Promise<Response> {
+  const body = await req.text();
+  const check = verify(process.env.BLUEPRINT_REVALIDATE_SECRET, req.headers.get(SIGNATURE_HEADER), body);
+  if (!check.ok) return Response.json({ error: check.reason }, { status: 401 });
+
+  let tags: unknown;
+  try {
+    tags = (JSON.parse(body) as { tags?: unknown }).tags;
+  } catch {
+    return Response.json({ error: "bad_request" }, { status: 400 });
+  }
+  if (!Array.isArray(tags)) return Response.json({ error: "bad_request" }, { status: 400 });
+  const prefix = `bp:${siteId()}`;
+  const mine = tags.filter((t): t is string => typeof t === "string" && (t === prefix || t.startsWith(`${prefix}:`)) && t.length <= 256);
+  // Marked stale rather than expired: the next visitor gets the page as it was, instantly, while the page rebuilds in
+  // the background. A page rebuild waits for fresh reads before it is saved, so the visit after it shows the change.
+  // Expiring instead made the next visit to every affected page wait for the whole rebuild.
+  for (const t of mine) revalidateTag(t, "max");
+  if (mine.some((t) => t === prefix || t.endsWith(":redirects"))) clearRedirectCache();
+  return Response.json({ revalidated: mine.length });
+}

package/src/robots.ts

@@ -0,0 +1,26 @@
+import type { MetadataRoute } from "next";
+import { bp, tagsFor } from "./client";
+import { getSite } from "./data";
+import type { Robots } from "./types";
+
+/**
+ * Pure: the launch gate. Until the site is marked indexable in Site Manager, every crawler is asked to stay away,
+ * and no sitemap is advertised.
+ */
+export function buildRobots(r: Robots | null, websiteUrl: string | null): MetadataRoute.Robots {
+  if (!r || !r.indexable) return { rules: [{ userAgent: "*", disallow: "/" }] };
+  return {
+    rules: [{ userAgent: "*", allow: "/", ...(r.disallow.length ? { disallow: r.disallow } : {}) }],
+    ...(websiteUrl ? { sitemap: `${websiteUrl.replace(/\/+$/, "")}/sitemap.xml` } : {}),
+  };
+}
+
+/** For `app/robots.ts`. If Site Manager can't be reached, it errs on the side of not indexing. */
+export async function robots(): Promise<MetadataRoute.Robots> {
+  try {
+    const [r, site] = await Promise.all([bp<Robots>("/robots", { tags: tagsFor("seo") }), getSite()]);
+    return buildRobots(r, site?.websiteUrl ?? null);
+  } catch {
+    return buildRobots(null, null);
+  }
+}

package/src/rss-route.ts

@@ -0,0 +1,26 @@
+import { buildRss, getBlogFeed } from "./blog";
+import { BlueprintError } from "./client";
+
+/**
+ * The blog's RSS feed. Put in app/blog/rss.xml/route.ts (or wherever the feed should live):
+ *
+ *   import { rssRoute } from "site-manager-kit/rss-route";
+ *   export const GET = rssRoute();
+ *
+ * The feed's own address comes from the request. With the Blog section off in Site Manager the feed answers 404.
+ */
+export function rssRoute(opts: { limit?: number; title?: string; description?: string } = {}) {
+  return async function GET(req: Request): Promise<Response> {
+    let feed;
+    try {
+      feed = await getBlogFeed({ limit: opts.limit });
+    } catch (e) {
+      if (e instanceof BlueprintError && e.code === "module_off") return new Response("Not found", { status: 404 });
+      throw e;
+    }
+    if (!feed) return new Response("Not found", { status: 404 });
+    const url = new URL(req.url);
+    const body = buildRss(feed, { feedUrl: `${url.origin}${url.pathname}`, link: feed.link ?? url.origin, title: opts.title, description: opts.description });
+    return new Response(body, { headers: { "content-type": "application/rss+xml; charset=utf-8", "cache-control": "public, max-age=0, s-maxage=3600, stale-while-revalidate=86400" } });
+  };
+}

package/src/services.ts

@@ -0,0 +1,52 @@
+import type { Service, Site } from "./types";
+
+type Json = Record<string, unknown>;
+
+/**
+ * schema.org `Service` structured data for a service page, with the business as its provider. A price becomes an
+ * `Offer` (a range as a `PriceSpecification` with min and max); "call for pricing" and no price add no offer, so
+ * search engines are never told a price the business didn't give. Amounts stay decimal strings. Prices are in USD,
+ * the only currency Site Manager's sites use.
+ */
+export function serviceJsonLd(service: Service, site: Pick<Site, "name" | "business" | "websiteUrl">, url: string): Json {
+  const b = site.business;
+  const a = b.address;
+  const provider: Json = {
+    "@type": "LocalBusiness",
+    name: b.displayName || site.name,
+    ...(site.websiteUrl ? { url: site.websiteUrl } : {}),
+    ...(b.phone ? { telephone: b.phone } : {}),
+    ...(a.line1 || a.city
+      ? {
+          address: {
+            "@type": "PostalAddress",
+            ...(a.line1 ? { streetAddress: [a.line1, a.line2].filter(Boolean).join(", ") } : {}),
+            ...(a.city ? { addressLocality: a.city } : {}),
+            ...(a.region ? { addressRegion: a.region } : {}),
+            ...(a.postalCode ? { postalCode: a.postalCode } : {}),
+            ...(a.country ? { addressCountry: a.country } : {}),
+          },
+        }
+      : {}),
+  };
+  const p = service.price;
+  let offers: Json | null = null;
+  if (p.kind === "fixed" && p.from) offers = { "@type": "Offer", priceCurrency: "USD", price: p.from };
+  else if (p.kind === "starting_at" && p.from) {
+    offers = { "@type": "Offer", priceCurrency: "USD", price: p.from, priceSpecification: { "@type": "PriceSpecification", priceCurrency: "USD", minPrice: p.from } };
+  } else if (p.kind === "range" && p.from && p.to) {
+    offers = { "@type": "Offer", priceCurrency: "USD", priceSpecification: { "@type": "PriceSpecification", priceCurrency: "USD", minPrice: p.from, maxPrice: p.to } };
+  }
+  return {
+    "@context": "https://schema.org",
+    "@type": "Service",
+    name: service.name,
+    url,
+    ...(service.summary ? { description: service.summary } : {}),
+    ...(service.category ? { serviceType: service.category } : {}),
+    ...(service.photos.length ? { image: service.photos.map((ph) => ph.url) } : {}),
+    provider,
+    ...(a.city ? { areaServed: a.region ? `${a.city}, ${a.region}` : a.city } : {}),
+    ...(offers ? { offers } : {}),
+  };
+}

package/src/signature.ts

@@ -0,0 +1,23 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+// The same format Site Manager signs with: `t=<unix>,v1=<hex HMAC-SHA256 of "<t>.<body>">`.
+export const SIGNATURE_HEADER = "x-blueprint-signature";
+export const MAX_AGE_SECONDS = 300;
+
+export function sign(secret: string, body: string, timestamp = Math.floor(Date.now() / 1000)): string {
+  return `t=${timestamp},v1=${createHmac("sha256", secret).update(`${timestamp}.${body}`).digest("hex")}`;
+}
+
+export type VerifyResult = { ok: true } | { ok: false; reason: "missing" | "malformed" | "expired" | "mismatch" };
+
+/** Checks a signature and rejects anything older (or newer) than 5 minutes, so a captured request can't be replayed. */
+export function verify(secret: string | undefined, header: string | null, body: string, now = Math.floor(Date.now() / 1000)): VerifyResult {
+  if (!secret || !header) return { ok: false, reason: "missing" };
+  const m = header.match(/^t=(\d+),v1=([0-9a-f]{64})$/);
+  if (!m) return { ok: false, reason: "malformed" };
+  const t = Number(m[1]);
+  if (Math.abs(now - t) > MAX_AGE_SECONDS) return { ok: false, reason: "expired" };
+  const expected = Buffer.from(createHmac("sha256", secret).update(`${t}.${body}`).digest("hex"));
+  const given = Buffer.from(m[2]);
+  return expected.length === given.length && timingSafeEqual(expected, given) ? { ok: true } : { ok: false, reason: "mismatch" };
+}