Domain redirects

.changeset/swift-monkeys-turn.md

@@ -0,0 +1,8 @@
+---
+"@comet/cms-admin": major
+"@comet/cms-api": major
+---
+
+Redirects: add `domain` source type
+
+To fully support domain redirects, additional handling is required in the site middleware.

demo/api/schema.gql

@@ -1996,6 +1996,7 @@ input RedirectFilter {
   generationType: StringFilter
   or: [RedirectFilter!]
   source: StringFilter
+  sourceType: RedirectSourceTypeEnumFilter
   target: StringFilter
   updatedAt: DateTimeFilter
 }
@@ -2033,7 +2034,14 @@ enum RedirectSortField {
   updatedAt
 }
 
+input RedirectSourceTypeEnumFilter {
+  equal: RedirectSourceTypeValues
+  isAnyOf: [RedirectSourceTypeValues!]
+  notEqual: RedirectSourceTypeValues
+}
+
 enum RedirectSourceTypeValues {
+  domain
   path
 }
 

demo/site-configs/main.ts

@@ -9,6 +9,7 @@ export default ((env) => {
         name: "Comet Site Main",
         domains: {
             main: envToDomainMap[env],
+            additional: ["test.localhost:3000"],
         },
         public: {
             scope: {

demo/site/src/app/[visibility]/[domain]/[language]/[[...path]]/page.tsx

@@ -91,10 +91,9 @@ export default async function Page({ params }: PageProps<"/[visibility]/[domain]
                         break;
                     }
                 }
-            }
-
-            if (destination) {
-                redirect(destination);
+                if (destination) {
+                    redirect(destination);
+                }
             }
         }
         notFound();

demo/site/src/middleware/redirectToMainHost.ts

@@ -1,40 +1,175 @@
+import { gql } from "@comet/site-nextjs";
+import { type ExternalLinkBlockData, type InternalLinkBlockData, type NewsLinkBlockData, type RedirectsLinkBlockData } from "@src/blocks.generated";
+import { type GQLPageTreeNodeScope, type GQLRedirectScopeInput } from "@src/graphql.generated";
 import type { PublicSiteConfig } from "@src/site-configs";
+import { createSitePath } from "@src/util/createSitePath";
+import { createGraphQLFetchMiddleware } from "@src/util/graphQLClientMiddleware";
 import { getHostByHeaders, getSiteConfigForHost, getSiteConfigs } from "@src/util/siteConfig";
 import { type NextRequest, NextResponse } from "next/server";
 
+import { memoryCache } from "./cache";
 import { type CustomMiddleware } from "./chain";
+import { type GQLDomainRedirectsQuery, type GQLDomainRedirectsQueryVariables } from "./redirectToMainHost.generated";
+
+const domainRedirectsQuery = gql`
+    query DomainRedirects($scope: RedirectScopeInput!, $filter: RedirectFilter, $offset: Int, $limit: Int) {
+        paginatedRedirects(scope: $scope, filter: $filter, offset: $offset, limit: $limit) {
+            nodes {
+                id
+                source
+                target
+                sourceType
+                scope {
+                    domain
+                }
+            }
+            totalCount
+        }
+    }
+`;
+
+const graphQLFetch = createGraphQLFetchMiddleware();
+
+type Redirect = GQLDomainRedirectsQuery["paginatedRedirects"]["nodes"][number];
+
+async function fetchDomainRedirects(scope: GQLRedirectScopeInput) {
+    const key = `domainRedirects-${scope.domain}`;
+    return memoryCache.wrap(key, async () => {
+        const limit = 50;
+
+        let allNodes: Redirect[] = [];
+        let totalCount = 0;
+        let currentCount = 0;
+        do {
+            const data = await graphQLFetch<GQLDomainRedirectsQuery, GQLDomainRedirectsQueryVariables>(domainRedirectsQuery, {
+                scope: { domain: scope.domain },
+                filter: { sourceType: { equal: "domain" } },
+                offset: currentCount,
+                limit,
+            });
+            const nodes = data?.paginatedRedirects?.nodes || [];
+            totalCount = data?.paginatedRedirects?.totalCount || 0;
+            currentCount += nodes.length;
+            allNodes = allNodes.concat(nodes);
+        } while (currentCount < totalCount);
+        return allNodes;
+    });
+}
+
+async function fetchDomainRedirectsForAllScopes() {
+    return (await Promise.all(getSiteConfigs().map((config) => fetchDomainRedirects(config.scope)))).flat();
+}
+
+function normalizeHost(value: string): string {
+    return value.replace(/^https?:\/\//, "");
+}
 
 const normalizeDomain = (host: string) => (host.startsWith("www.") ? host.substring(4) : host);
 
 const matchesHostWithAdditionalDomain = (siteConfig: PublicSiteConfig, host: string) => {
-    if (normalizeDomain(siteConfig.domains.main) === normalizeDomain(host)) return true; // non-www redirect
-    if (siteConfig.domains.additional?.map(normalizeDomain).includes(normalizeDomain(host))) return true;
+    if (normalizeDomain(siteConfig.domains.main) === normalizeDomain(host)) {
+        return true; // non-www redirect
+    }
+    if (siteConfig.domains.additional?.map(normalizeDomain).includes(normalizeDomain(host))) {
+        return true;
+    }
     return false;
 };
 
 const matchesHostWithPattern = (siteConfig: PublicSiteConfig, host: string) => {
-    if (!siteConfig.domains.pattern) return false;
+    if (!siteConfig.domains.pattern) {
+        return false;
+    }
     return new RegExp(siteConfig.domains.pattern).test(host);
 };
 
-/**
- * When http host isn't siteConfig.domains.main (instead .pattern or .additional match), redirect to main host.
- */
+function getRedirectTargetUrl(block: RedirectsLinkBlockData["block"], targetBaseUrl: string): string | undefined {
+    if (!block) {
+        return undefined;
+    }
+    switch (block.type) {
+        case "internal": {
+            const internalLink = block.props as InternalLinkBlockData;
+            if (internalLink.targetPage) {
+                return `${targetBaseUrl}${createSitePath({
+                    path: internalLink.targetPage.path,
+                    scope: internalLink.targetPage.scope as GQLPageTreeNodeScope,
+                })}`;
+            }
+            break;
+        }
+        case "external":
+            return (block.props as ExternalLinkBlockData).targetUrl;
+        case "news": {
+            const newsLink = block.props as NewsLinkBlockData;
+            if (newsLink.news) {
+                return createSitePath({
+                    path: `/news/${newsLink.news.slug}`,
+                    scope: newsLink.news.scope,
+                });
+            }
+            break;
+        }
+    }
+    return undefined;
+}
+
 export function withRedirectToMainHostMiddleware(middleware: CustomMiddleware) {
     return async (request: NextRequest) => {
         const headers = request.headers;
         const host = getHostByHeaders(headers);
         const siteConfig = await getSiteConfigForHost(host);
 
         if (!siteConfig) {
-            // Redirect to Main Host
             const redirectSiteConfig =
                 getSiteConfigs().find((siteConfig) => matchesHostWithAdditionalDomain(siteConfig, host)) ||
                 getSiteConfigs().find((siteConfig) => matchesHostWithPattern(siteConfig, host));
+
             if (redirectSiteConfig) {
-                return NextResponse.redirect(`https://${redirectSiteConfig.domains.main}${request.nextUrl.pathname}${request.nextUrl.search}`, {
-                    status: 301,
-                });
+                const { scope } = redirectSiteConfig;
+
+                const domainRedirects = await fetchDomainRedirects(scope);
+
+                const redirect = domainRedirects.find((redirect) => normalizeHost(redirect.source) === normalizeHost(host));
+
+                if (redirect) {
+                    const destination = getRedirectTargetUrl(redirect.target.block, `https://${redirectSiteConfig.domains.main}`);
+                    if (destination) {
+                        if (normalizeHost(new URL(destination).host) === normalizeHost(host)) {
+                            throw new Error(`Redirect loop detected: ${host} -> ${destination}`);
+                        }
+                        return NextResponse.redirect(destination, { status: 301 });
+                    }
+                }
+                // Redirect to Main Host
+                const mainHost = normalizeHost(redirectSiteConfig.domains.main);
+                if (mainHost === normalizeHost(host)) {
+                    throw new Error(`Redirect loop detected: main host ${mainHost} equals current host`);
+                } else {
+                    return NextResponse.redirect(`https://${redirectSiteConfig.domains.main}${request.nextUrl.pathname}${request.nextUrl.search}`, {
+                        status: 301,
+                    });
+                }
+            }
+
+            const domainRedirects = await fetchDomainRedirectsForAllScopes();
+
+            const redirect = domainRedirects.find((redirect) => normalizeHost(redirect.source) === normalizeHost(host));
+            if (redirect) {
+                const scopedSiteConfig = getSiteConfigs().find((config) => config.scope.domain === redirect.scope.domain);
+
+                if (!scopedSiteConfig) {
+                    throw new Error(`Got redirect to domain ${redirect.scope.domain}, but couldn't find corresponding site-config.`);
+                }
+
+                const destination = getRedirectTargetUrl(redirect.target.block, `https://${scopedSiteConfig.domains.main}`);
+
+                if (destination) {
+                    if (normalizeHost(new URL(destination).host) === normalizeHost(host)) {
+                        throw new Error(`Redirect loop detected: ${host} -> ${destination}`);
+                    }
+                    return NextResponse.redirect(destination, { status: 301 });
+                }
             }
 
             return NextResponse.json({ error: `Cannot resolve domain: ${host}` }, { status: 404 });

docs/docs/7-migration-guide/migration-from-v8-to-v9.md

@@ -672,6 +672,29 @@ Review the [migration guide](https://nextjs.org/docs/app/guides/upgrading/versio
 mv site/src/middleware.ts site/src/proxy.ts
 ```
 
+:::note
+
+If you're using Knip, you may need to add `proxy.ts` as entry point:
+
+```diff title="site/knip.json"
+{
+    "$schema": "https://unpkg.com/knip@5/schema.json",
+    "entry": [
+        "./src/app/**",
+        "./cache-handler.ts",
+        "./tracing.ts",
++       "./src/proxy.ts"
+    ],
+    "project": ["./src/**/*.{ts,tsx}"]
+}
+```
+
+:::
+
+### Domain Redirects
+
+Domain redirects can now be set in the admin. It is necessary to update your middleware — most likely the `redirectToMainHost` middleware — to handle domain redirects. See example in the demo here: https://github.com/vivid-planet/comet/blob/main/demo/site/src/middleware/redirectToMainHost.ts
+
 ### Add `cache: "force-cache"` to GraphQL fetch
 
 Next.js no longer caches `fetch` requests by default.

packages/admin/cms-admin/src/redirects/RedirectForm.tsx

@@ -1,5 +1,6 @@
 import { gql, useApolloClient, useQuery } from "@apollo/client";
 import {
+    Alert,
     Field,
     FillSpace,
     FinalForm,
@@ -14,14 +15,14 @@ import {
     ToolbarTitleItem,
     useStackSwitchApi,
 } from "@comet/admin";
-import { MenuItem } from "@mui/material";
+import { Box, MenuItem } from "@mui/material";
+import { isFQDN } from "class-validator";
 import isEqual from "lodash.isequal";
 import { type JSX, useMemo } from "react";
 import { FormattedMessage, useIntl } from "react-intl";
 
 import { createFinalFormBlock } from "../blocks/form/createFinalFormBlock";
 import { type BlockInterface, type BlockState } from "../blocks/types";
-import { isValidUrl } from "../blocks/validators/isValidUrl";
 import { ContentScopeIndicator } from "../contentScope/ContentScopeIndicator";
 import { type GQLRedirectSourceTypeValues } from "../graphql.generated";
 import { type GQLRedirectSourceAvailableQuery, type GQLRedirectSourceAvailableQueryVariables } from "./RedirectForm.generated";
@@ -97,6 +98,13 @@ export const RedirectForm = ({ mode, id, linkBlock, scope }: Props): JSX.Element
                 defaultMessage: "Path",
             }),
         },
+        {
+            value: "domain",
+            label: intl.formatMessage({
+                id: "comet.pages.redirects.redirect.source.type.domain",
+                defaultMessage: "Domain",
+            }),
+        },
     ];
 
     const [submit] = useSubmitMutation(mode, id, linkBlock, scope);
@@ -149,10 +157,10 @@ export const RedirectForm = ({ mode, id, linkBlock, scope }: Props): JSX.Element
     };
 
     const validateDomain = (value: string) => {
-        if (!isValidUrl(value)) {
+        if (!isFQDN(value)) {
             return intl.formatMessage({
                 id: "comet.pages.redirects.validate.domain.error",
-                defaultMessage: "Needs to start with http:// or https://",
+                defaultMessage: "Needs to be a valid domain (e.g. example.com)",
             });
         }
     };
@@ -209,6 +217,16 @@ export const RedirectForm = ({ mode, id, linkBlock, scope }: Props): JSX.Element
                                 </FinalFormSelect>
                             )}
                         </Field>
+                        {values.sourceType === "domain" && (
+                            <Box sx={{ marginBottom: 4 }}>
+                                <Alert severity="warning">
+                                    <FormattedMessage
+                                        id="comet.pages.redirects.redirect.source.type.domain.warning"
+                                        defaultMessage="This only works if the domain is configured correctly."
+                                    />
+                                </Alert>
+                            </Box>
+                        )}
                         <Field
                             label={intl.formatMessage({ id: "comet.pages.redirects.redirect.source", defaultMessage: "Source" })}
                             name="source"
@@ -219,7 +237,7 @@ export const RedirectForm = ({ mode, id, linkBlock, scope }: Props): JSX.Element
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
                             validate={validateSource as any}
                             fullWidth
-                            placeholder="/example-path"
+                            placeholder={values.sourceType === "domain" ? "example.com" : "/example-path"}
                             disableContentTranslation
                         />
                         <Field

packages/api/cms-api/schema.gql

@@ -357,6 +357,7 @@ type Redirect {
 
 enum RedirectSourceTypeValues {
   path
+  domain
 }
 
 enum RedirectGenerationType {
@@ -514,6 +515,7 @@ input RedirectFilter {
   source: StringFilter
   target: StringFilter
   active: BooleanFilter
+  sourceType: RedirectSourceTypeEnumFilter
   activatedAt: DateTimeFilter
   createdAt: DateTimeFilter
   updatedAt: DateTimeFilter
@@ -537,6 +539,12 @@ input BooleanFilter {
   equal: Boolean
 }
 
+input RedirectSourceTypeEnumFilter {
+  isAnyOf: [RedirectSourceTypeValues!]
+  equal: RedirectSourceTypeValues
+  notEqual: RedirectSourceTypeValues
+}
+
 input DateTimeFilter {
   equal: DateTime
   lowerThan: DateTime

packages/api/cms-api/src/mikro-orm/migrations/Migration20251126093305.ts

@@ -0,0 +1,10 @@
+import { Migration } from "@mikro-orm/migrations";
+
+export class Migration20251126093305 extends Migration {
+    override async up(): Promise<void> {
+        this.addSql(`ALTER TABLE "Redirect" DROP CONSTRAINT IF EXISTS "Redirect_sourceType_check";`);
+        this.addSql(`ALTER TABLE "Redirect" ADD CONSTRAINT "Redirect_sourceType_check" CHECK ("sourceType" IN ('path', 'domain'));`);
+    }
+
+    override async down(): Promise<void> {}
+}