Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

11.0 KB
Raw Blame
import { create } from "@bufbuild/protobuf";
import dayjs from "dayjs";
import { CircleHelp } from "lucide-react";
import { useCallback, useEffect, useMemo, useState } from "react";
import { useTranslation } from "react-i18next";
import { router } from "@/app/router";
import { AccountMultiSelect } from "@/components/AccountMultiSelect";
import { DatabaseResourceSelector } from "@/components/DatabaseResourceSelector";
import { ExprEditor } from "@/components/ExprEditor";
import { FeatureAttention } from "@/components/FeatureAttention";
import { FeatureBadge } from "@/components/FeatureBadge";
import { Button } from "@/components/ui/button";
import { ExpirationPicker } from "@/components/ui/expiration-picker";
import { FeatureModal } from "@/components/ui/feature-modal";
import { FormControlGroup, FormField } from "@/components/ui/form";
import { Input } from "@/components/ui/input";
import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group";
import { StickyActionFooter } from "@/components/ui/sticky-action-footer";
import { Tooltip } from "@/components/ui/tooltip";
import { useProjectByName } from "@/hooks/useProjectByName";
import {
  buildMaskingExemption,
  useMaskingExemptionExprConfig,
} from "@/lib/sensitive-data/maskingExemption";
import type { ConditionGroupExpr } from "@/modules/cel";
import {
  emptySimpleExpr,
  validateSimpleExpr,
  wrapAsGroup,
} from "@/modules/cel";
import { pushNotification } from "@/stores";
import { useAppStore } from "@/stores/app";
import { projectNamePrefix } from "@/stores/modules/v1/common";
import type { DatabaseResource } from "@/types";
import {
  MaskingExemptionPolicySchema,
  PolicyResourceType,
  PolicyType,
} from "@/types/proto-es/v1/org_policy_service_pb";
import { Setting_SettingName } from "@/types/proto-es/v1/setting_service_pb";
import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";

type RadioValue = "ALL" | "EXPRESSION" | "SELECT";

export function ProjectMaskingExemptionCreatePage({
  projectId,
}: {
  projectId: string;
}) {
  const { t } = useTranslation();
  const projectsByName = useAppStore((s) => s.projectsByName);
  const workspaceResourceName = useAppStore((s) => s.workspaceResourceName());

  const projectName = `${projectNamePrefix}${projectId}`;
  const accountParents = useMemo(
    () => [...new Set([workspaceResourceName, projectName].filter(Boolean))],
    [workspaceResourceName, projectName]
  );
  // subscribe to re-render on project cache change
  void projectsByName;
  const project = useProjectByName(projectName);

  // Ensure classification config is loaded
  useEffect(() => {
    useAppStore
      .getState()
      .getOrFetchSettingByName(Setting_SettingName.DATA_CLASSIFICATION, true);
  }, []);

  const hasRequiredFeature = useAppStore((s) =>
    s.hasFeature(PlanFeature.FEATURE_DATA_MASKING)
  );

  // Form state
  const [radioValue, setRadioValue] = useState<RadioValue>("ALL");
  const [databaseResources, setDatabaseResources] = useState<
    DatabaseResource[]
  >([]);
  const [expr, setExpr] = useState<ConditionGroupExpr>(
    wrapAsGroup(emptySimpleExpr())
  );
  const [description, setDescription] = useState("");
  const [expirationTimestamp, setExpirationTimestamp] = useState<
    string | undefined
  >();
  const [memberList, setMemberList] = useState<string[]>([]);
  const [processing, setProcessing] = useState(false);
  const [showFeatureModal, setShowFeatureModal] = useState(false);

  // Validation
  const isValid = useMemo(() => {
    switch (radioValue) {
      case "SELECT":
        return databaseResources.length > 0;
      case "EXPRESSION":
        return validateSimpleExpr(expr);
      default:
        return true;
    }
  }, [radioValue, databaseResources, expr]);

  const submitDisabled = useMemo(
    () => memberList.length === 0 || !isValid,
    [memberList, isValid]
  );

  const { factorList, factorOperatorOverrideMap, factorOptionConfigMap } =
    useMaskingExemptionExprConfig(projectName);

  const onRadioChange = useCallback(
    (value: RadioValue) => {
      if (!hasRequiredFeature && value !== "ALL") {
        setShowFeatureModal(true);
        return;
      }
      setRadioValue(value);
    },
    [hasRequiredFeature]
  );

  const onDismiss = useCallback(() => {
    router.back();
  }, []);

  const onSubmit = useCallback(async () => {
    if (processing) return;
    setProcessing(true);

    try {
      const exemption = await buildMaskingExemption({
        radioValue,
        expr,
        databaseResources,
        memberList,
        description,
        expirationTimestamp,
      });

      const policy = await useAppStore
        .getState()
        .getOrFetchPolicyByParentAndType({
          parentPath: projectName,
          policyType: PolicyType.MASKING_EXEMPTION,
          refresh: true,
        });
      const existed =
        policy?.policy?.case === "maskingExemptionPolicy"
          ? policy.policy.value.exemptions
          : [];

      await useAppStore.getState().upsertPolicy({
        parentPath: projectName,
        policy: {
          name: policy?.name,
          type: PolicyType.MASKING_EXEMPTION,
          resourceType: PolicyResourceType.PROJECT,
          policy: {
            case: "maskingExemptionPolicy",
            value: create(MaskingExemptionPolicySchema, {
              exemptions: [...existed, exemption],
            }),
          },
        },
      });

      pushNotification({
        module: "bytebase",
        style: "SUCCESS",
        title: t("common.created"),
      });
      onDismiss();
    } catch (error) {
      pushNotification({
        module: "bytebase",
        style: "CRITICAL",
        title: `${error}`,
      });
    } finally {
      setProcessing(false);
    }
  }, [
    processing,
    expirationTimestamp,
    radioValue,
    expr,
    databaseResources,
    memberList,
    description,
    projectName,
    t,
    onDismiss,
  ]);

  // Min datetime for expiration picker (today start of day)
  const minDatetime = useMemo(() => {
    return dayjs().startOf("day").format("YYYY-MM-DDTHH:mm");
  }, []);

  return (
    <div className="h-full flex flex-col">
      {/* Header */}
      <div className="px-4 pt-4">
        <h2 className="text-lg font-medium">
          {t("project.masking-exemption.grant-exemption")}
        </h2>
        <div className="border-b border-block-border mt-3" />
      </div>

      {/* Body */}
      <div className="flex-1 mb-6 px-4 overflow-y-auto">
        <div className="flex flex-col gap-y-8 pt-4">
          <FeatureAttention feature={PlanFeature.FEATURE_DATA_MASKING} />

          {/* Resources */}
          <div className="w-full">
            <div className="flex items-center gap-x-1 mb-2">
              <span className="text-main">{t("common.resources")}</span>
              <span className="text-error">*</span>
            </div>

            {/* Radio group */}
            <div className="w-full mb-2">
              <RadioGroup
                className="flex-col items-start gap-2 sm:flex-row sm:items-center sm:gap-4"
                value={radioValue}
                onValueChange={(value) => onRadioChange(value as RadioValue)}
              >
                <Tooltip content={t("issue.role-grant.all-databases-tip")}>
                  <RadioGroupItem value="ALL">
                    {t("issue.role-grant.all-databases")}
                  </RadioGroupItem>
                </Tooltip>

                <RadioGroupItem value="EXPRESSION" disabled={!project}>
                  <div className="flex items-center gap-x-1">
                    <FeatureBadge
                      feature={PlanFeature.FEATURE_DATA_MASKING}
                      clickable={false}
                    />
                    <span>{t("issue.role-grant.use-cel")}</span>
                  </div>
                </RadioGroupItem>

                <RadioGroupItem value="SELECT" disabled={!project}>
                  <div className="flex items-center gap-x-1">
                    <FeatureBadge
                      feature={PlanFeature.FEATURE_DATA_MASKING}
                      clickable={false}
                    />
                    <span>{t("issue.role-grant.manually-select")}</span>
                  </div>
                </RadioGroupItem>
              </RadioGroup>
            </div>

            {/* Resource selector content */}
            {radioValue === "SELECT" && (
              <DatabaseResourceSelector
                projectName={projectName}
                value={databaseResources}
                includeColumns
                onChange={setDatabaseResources}
              />
            )}
            {radioValue === "EXPRESSION" && (
              <ExprEditor
                expr={expr}
                factorList={factorList}
                optionConfigMap={factorOptionConfigMap}
                factorOperatorOverrideMap={factorOperatorOverrideMap}
                onUpdate={setExpr}
              />
            )}
          </div>

          {/* Reason */}
          <FormField className="w-full" title={t("common.reason")}>
            <Input
              value={description}
              onChange={(e) => setDescription(e.target.value)}
              placeholder={t("common.description")}
            />
          </FormField>

          {/* Expiration */}
          <FormField className="w-full" title={t("common.expiration")}>
            <FormControlGroup>
              <ExpirationPicker
                value={expirationTimestamp}
                onChange={setExpirationTimestamp}
                minDate={minDatetime}
              />
              {!expirationTimestamp && (
                <span className="textinfolabel">
                  {t("settings.sensitive-data.never-expires")}
                </span>
              )}
            </FormControlGroup>
          </FormField>

          {/* Members */}
          <FormField
            className="w-full"
            title={
              <span className="flex items-center gap-x-1">
                {t("settings.members.select-account", { count: 2 })}
                <span className="text-error">*</span>
                <Tooltip content={t("settings.members.select-account-hint")}>
                  <CircleHelp className="size-4 textinfolabel" />
                </Tooltip>
              </span>
            }
          >
            <AccountMultiSelect
              value={memberList}
              onChange={setMemberList}
              accountParents={accountParents}
            />
          </FormField>
        </div>
      </div>

      {/* Footer */}
      <StickyActionFooter
        left={
          <Button appearance="outline" onClick={onDismiss}>
            {t("common.cancel")}
          </Button>
        }
        right={
          <Button disabled={submitDisabled || processing} onClick={onSubmit}>
            {t("common.confirm")}
          </Button>
        }
      />

      {/* Feature paywall — shared FeatureModal so the dialog content is
          driven by the subscription dynamic feature copy + plan info. */}
      <FeatureModal
        open={showFeatureModal}
        feature={PlanFeature.FEATURE_DATA_MASKING}
        onOpenChange={setShowFeatureModal}
      />
    </div>
  );
}