URL Redirects

// src/components/blocks/RedirectRule/index.tsx
// One row per redirect. Data-only - renders nothing.

import { contentType } from "@optimizely/cms-sdk";

export const RedirectRuleType = contentType({
  key: "RedirectRule",
  baseType: "_component",
  compositionBehaviors: ["elementEnabled"],
  displayName: "Redirect Rule",
  properties: {
    fromPath:      { type: "string",  displayName: "From path (old URL)",  indexingType: "queryable" },
    toPath:        { type: "string",  displayName: "To path (new URL)",    indexingType: "queryable" },
    permanent:     { type: "boolean", displayName: "Permanent (308). Off = temporary (307).", indexingType: "queryable" },
    matchSubpaths: { type: "boolean", displayName: "Also redirect everything under this path" },
    enabled:       { type: "boolean", displayName: "Enabled", indexingType: "queryable" },
    note:          { type: "string",  displayName: "Internal note" },
  },
});

export default function RedirectRule() { return null; }


// src/components/blocks/RedirectConfig/index.tsx
// The singleton every editor opens - a content area of RedirectRule rows.
// sectionEnabled (not elementEnabled) because it owns a content area.

export const RedirectConfigType = contentType({
  key: "RedirectConfig",
  baseType: "_component",
  compositionBehaviors: ["sectionEnabled"],
  displayName: "Redirect Config",
  properties: {
    rules: { type: "array", displayName: "Redirect rules",
             items: { type: "content", allowedTypes: [RedirectRuleType] } },
    notes: { type: "string", displayName: "Notes for editors" },
  },
});

export default function RedirectConfig() { return null; }

// src/lib/graphql/queries/GetRedirectRules.ts

// Fetch the singleton by type, newest first. No where-clause on 'enabled' -
// filtering a field the Graph schema has not synced as queryable errors the
// whole query, so the enabled check happens in JS (same as GetSiteBanner).
const GET_REDIRECT_RULES_QUERY = /* GraphQL */ `
  query GetRedirectRules {
    RedirectConfig(orderBy: { _metadata: { lastModified: DESC } }, limit: 10) {
      items {
        rules {
          ... on RedirectRule { fromPath toPath permanent matchSubpaths enabled }
        }
      }
    }
  }
`;

export async function getRedirectRules() {
  const result = await graphqlFetch(GET_REDIRECT_RULES_QUERY, {},
    { next: { revalidate: 3600, tags: ["redirects"] } });
  return (result.data?.RedirectConfig?.items?.[0]?.rules ?? [])
    .filter((r) => r && r.enabled !== false && r.fromPath && r.toPath)
    .sort((a, b) => b.fromPath.length - a.fromPath.length); // exact beats prefix
}

// src/app/api/redirects/route.ts
// Middleware has no Data Cache. This route does: the Graph call is cached with
// tags: ["redirects"], and the publish webhook busts it with
// revalidateTag("redirects"). Middleware reads this small JSON instead of Graph.

import { NextResponse } from "next/server";
import { getRedirectRules } from "@/lib/graphql/queries/GetRedirectRules";

export const revalidate = 3600;

export async function GET() {
  return NextResponse.json({ rules: await getRedirectRules() });
}

// src/lib/redirects.ts - edge-safe, mirrors datafile.ts

const TTL_MS = 30_000;
let cache = null; // best-effort: a cold worker just does the subrequest

export async function loadRedirectRules(origin) {
  if (cache && Date.now() - cache.at < TTL_MS) return cache.rules;
  try {
    const res = await fetch(`${origin}/api/redirects`, { signal: AbortSignal.timeout(2000) });
    if (!res.ok) return cache?.rules ?? [];
    cache = { at: Date.now(), rules: (await res.json()).rules ?? [] };
    return cache.rules;
  } catch { return cache?.rules ?? []; }
}


// src/middleware.ts - after the /api, /preview, /demo, __v_ and .segments/
// guards, BEFORE the Feature Experimentation rewrite (which would append a
// /__v_ segment and break the plain-path match).

import { loadRedirectRules, matchRedirect } from "@/lib/redirects";

export async function middleware(request) {
  const response = NextResponse.next();
  // ... existing userId cookie logic ...

  if (request.nextUrl.pathname.startsWith("/api/")) return response;
  if (request.nextUrl.pathname.startsWith("/preview")) return response;
  if (/^\/demo(\/|$)/.test(request.nextUrl.pathname)) return response;
  if (request.nextUrl.pathname.includes("__v_")) return response;
  if (request.nextUrl.pathname.includes(".segments/")) return response;

  try {
    const rules = await loadRedirectRules(request.nextUrl.origin);
    const hit = rules.length ? matchRedirect(request.nextUrl.pathname, rules) : null;
    if (hit) {
      const dest = /^https?:\/\//i.test(hit.toPath)
        ? new URL(hit.toPath)
        : new URL(hit.toPath, request.nextUrl.origin);
      if (!dest.search && request.nextUrl.search) dest.search = request.nextUrl.search;
      return NextResponse.redirect(dest, hit.status); // 308 permanent, 307 temporary
    }
  } catch {
    // Never fail a request due to redirect lookup errors.
  }

  // ... existing Feature Experimentation variation rewrite logic ...
}

// Add "redirects" to the publish webhook handler (src/app/api/webhooks/route.ts):
//   revalidateTag("redirects");  // alongside "page" and "navigation"