Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

7.1 KB
Raw Blame
import { useState } from "react";
import { useStore } from "@nanostores/react";
import { ZodError } from "zod";
import {
  Flex,
  Grid,
  InfoTooltip,
  LinkButton,
  ProChip,
  Text,
  Tooltip,
  theme,
} from "@webstudio-is/design-system";
import {
  customResponseHeader,
  customResponseHeaderKey,
  editCustomResponseHeaders,
  type CustomResponseHeader,
} from "@webstudio-is/sdk";
import { validatePathnamePattern } from "@webstudio-is/wsauth";
import { $pages, $projectSettings } from "~/shared/sync/data-stores";
import { $permissions } from "~/shared/nano-states";
import { executeRuntimeMutation } from "~/shared/instance-utils/data";
import {
  ProjectSettingsDeleteRuleButton,
  ProjectSettingsRuleList,
} from "./rule-list";
import {
  getResponseHeaderName,
  getResponseHeaderValueSuggestions,
  responseHeaderNames,
} from "./response-header-suggestions";
import { getExistingRoutePaths, sectionSpacing } from "./utils";

export const SectionHeaders = ({
  executeMutation = executeRuntimeMutation,
}: {
  projectId?: string;
  executeMutation?: (
    args: Parameters<typeof executeRuntimeMutation>[0]
  ) => ReturnType<typeof executeRuntimeMutation>;
} = {}) => {
  const { allowDynamicData } = useStore($permissions);
  const settings = useStore($projectSettings);
  const pages = useStore($pages);
  const [saveError, setSaveError] = useState("");
  const configured = settings?.meta.customHeaders ?? [];
  const routeSuggestions = [
    ...new Set(["/*", "/", ...Array.from(getExistingRoutePaths(pages)).sort()]),
  ];

  const save = (
    next: CustomResponseHeader | undefined,
    previousKey: string
  ) => {
    let headers: CustomResponseHeader[];
    try {
      headers = editCustomResponseHeaders(
        $projectSettings.get()?.meta.customHeaders ?? [],
        previousKey,
        next
      );
    } catch (error) {
      setSaveError(
        error instanceof ZodError
          ? error.issues.map((issue) => issue.message).join(". ")
          : "Invalid response header"
      );
      return false;
    }
    try {
      const mutation = executeMutation({
        id: "projectSettings.update",
        input: {
          meta: { customHeaders: headers.length ? headers : null },
        },
      });
      if (mutation !== undefined) {
        setSaveError("");
        return true;
      }
    } catch {
      // Keep the form values or existing row available for retry.
    }
    setSaveError("Changes could not be saved. Please try again.");
    return false;
  };

  return (
    <Grid gap={3} css={sectionSpacing}>
      <Flex align="center" gap={1}>
        <Text variant="titles">Headers</Text>
        {allowDynamicData === false && <ProChip>Pro</ProChip>}
        <InfoTooltip
          label="About response headers"
          content={
            <>
              <Text>
                Set response headers for all paths or a route. Routes use the
                same syntax as Authentication, including :params and *. If
                multiple rules set the same header on a path, the last matching
                rule in this list wins.
              </Text>
              <br />
              <Text>
                /* applies to every path; / applies only to the root. Webstudio
                Cloud supplies CSP, X-Frame-Options, and Referrer-Policy when
                they are not set. X-Powered-By, X-Content-Type-Options, and
                Strict-Transport-Security are managed by the platform and cannot
                be configured here. Cookie, connection, and response-body
                framing headers are also unavailable. Publish to apply changes.
              </Text>
              {allowDynamicData === false && (
                <>
                  <br />
                  <Text>
                    Custom headers on a custom domain require Pro. Defaults and
                    staging are free.
                  </Text>
                  <LinkButton
                    color="primary"
                    css={{ marginTop: theme.spacing[5], width: "100%" }}
                    href="https://webstudio.is/pricing"
                    target="_blank"
                  >
                    Upgrade
                  </LinkButton>
                </>
              )}
            </>
          }
        />
      </Flex>
      {saveError && <Text color="destructive">{saveError}</Text>}
      <ProjectSettingsRuleList
        fields={[
          {
            name: "route",
            placeholder: "/* or /private/*",
            suggestions: routeSuggestions,
          },
          {
            name: "name",
            placeholder: "Header name",
            suggestions: responseHeaderNames,
          },
          {
            name: "value",
            placeholder: "Header value",
            suggestions: (values) =>
              getResponseHeaderValueSuggestions(values.name ?? ""),
          },
        ]}
        validate={(values) => {
          const route = values.route?.trim() ?? "";
          const name = values.name?.trim() ?? "";
          const value = values.value?.trim() ?? "";
          const errors: Record<string, string[]> = {};
          const routeError = validatePathnamePattern(route);
          if (routeError) {
            errors.route = [routeError];
          }
          if (value === "") {
            errors.value = ["Enter a header value"];
          }
          const result = customResponseHeader.safeParse({
            route,
            name,
            value,
          });
          if (!result.success) {
            for (const issue of result.error.issues) {
              const field = String(issue.path[0] ?? "value");
              (errors[field] ??= []).push(issue.message);
            }
          }
          return errors;
        }}
        onSubmit={(values) => {
          const route = values.route.trim();
          const value = values.value?.trim() ?? "";
          const name =
            getResponseHeaderName(values.name.trim()) ?? values.name.trim();
          const next: CustomResponseHeader = {
            ...(route === "/*" ? {} : { route }),
            name,
            value,
          };
          return save(next, customResponseHeaderKey({ route, name }));
        }}
        columns="1fr 1.5fr 1.5fr"
        columnLabels={["Path", "Header", "Value"]}
        label="Response header rules"
        rules={configured.map((header) => {
          const route = header.route ?? "/*";
          const key = customResponseHeaderKey(header);
          return {
            key,
            values: [
              <Tooltip content={route} key="route">
                <Text truncate>{route}</Text>
              </Tooltip>,
              <Tooltip content={header.name} key="name">
                <Text truncate>{header.name}</Text>
              </Tooltip>,
              <Tooltip content={header.value} key="value">
                <Text truncate>{header.value}</Text>
              </Tooltip>,
            ],
            actions: (
              <ProjectSettingsDeleteRuleButton
                label={`Remove ${header.name} for ${route}`}
                description={`${header.name} for ${route}`}
                onDelete={() => save(undefined, key)}
              />
            ),
          };
        })}
      />
    </Grid>
  );
};