Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

4.3 KB
Raw Blame
import { useState } from "react";
import { t } from "ttag";

import {
  Description,
  Error,
  Label,
} from "metabase/admin/databases/components/DatabaseFeatureComponents";
import { DatabaseInfoSection } from "metabase/admin/databases/components/DatabaseInfoSection";
import { findErrorMessage } from "metabase/api/utils/errors";
import { hasDbRoutingEnabled } from "metabase/common/utils/database";
import { ALLOWED_ENGINES_FOR_TABLE_EDITING } from "metabase/databases/constants";
import { Alert, Box, Flex, Icon, Switch } from "metabase/ui";
import type {
  Database,
  DatabaseData,
  DatabaseId,
  DatabaseLocalSettingAvailability,
} from "metabase-types/api";

import {
  DATABASE_TABLE_EDITING_SETTING,
  isDatabaseTableEditingEnabled,
} from "../settings";

import { trackTableEditingSettingsToggled } from "./analytics";

enum DisabledReasonKey {
  MissingDriverFeature = "driver-feature-missing",
  NoWriteableTable = "permissions/no-writable-table",
  SyncInProgress = "database-metadata/sync-in-progress",
  DatabaseEmpty = "database-metadata/not-populated",
}

const VISIBLE_REASONS: string[] = [
  DisabledReasonKey.NoWriteableTable,
  DisabledReasonKey.SyncInProgress,
  DisabledReasonKey.DatabaseEmpty,
];

export function AdminDatabaseTableEditingSection({
  database,
  settingsAvailable,
  updateDatabase,
}: {
  database: Database;
  settingsAvailable?: Record<string, DatabaseLocalSettingAvailability>;
  updateDatabase: (
    database: { id: DatabaseId } & Partial<DatabaseData>,
  ) => Promise<void>;
}) {
  const [error, setError] = useState<string | null>(null);

  const handleToggle = async (enabled: boolean) => {
    try {
      setError(null);

      trackTableEditingSettingsToggled(enabled, database.id);

      await updateDatabase({
        id: database.id,
        settings: { [DATABASE_TABLE_EDITING_SETTING]: enabled },
      });
    } catch (err) {
      setError(getResponseErrorMessageReason(err) || t`An error occurred`);
    }
  };

  // Only Postgres and MySQL support table data editing
  const allowedToEnableTableEditing =
    database.engine &&
    ALLOWED_ENGINES_FOR_TABLE_EDITING.includes(database.engine);

  const databaseHasRouting = hasDbRoutingEnabled(database);

  const dataEditingSetting =
    settingsAvailable?.[DATABASE_TABLE_EDITING_SETTING];
  const isSettingDisabled =
    !dataEditingSetting || dataEditingSetting.enabled === false;

  const firstDisabledReason =
    dataEditingSetting?.enabled === false
      ? dataEditingSetting?.reasons?.[0]
      : undefined;

  const shouldShowSection =
    !firstDisabledReason || VISIBLE_REASONS.includes(firstDisabledReason.key);

  if (
    !dataEditingSetting ||
    !shouldShowSection ||
    !allowedToEnableTableEditing
  ) {
    return null;
  }

  const isEnabled = isDatabaseTableEditingEnabled(database);

  return (
    <DatabaseInfoSection
      name={t`Editable table data`}
      description={t`Allow the data within tables of this database to be edited by Admin users.`}
      data-testid="database-table-editing-section"
    >
      <Flex align="center" justify="space-between" mb="xxs">
        <Label htmlFor="table-editing-toggle">{t`Editable tables`}</Label>
        <Switch
          id="table-editing-toggle"
          checked={isEnabled}
          onChange={(e) => handleToggle(e.currentTarget.checked)}
          disabled={isSettingDisabled || (!isEnabled && databaseHasRouting)}
        />
      </Flex>
      <Box maw="22.5rem">
        {error ? <Error>{error}</Error> : null}
        <Description>
          {firstDisabledReason?.message ??
            t`Your database connection will need Write permissions.`}
        </Description>
      </Box>

      {databaseHasRouting && (
        <Alert
          size="compact"
          variant="light"
          icon={<Icon name="info" />}
          mb="lg"
        >
          {t`Table editing can't be enabled when database routing is enabled.`}
        </Alert>
      )}
    </DatabaseInfoSection>
  );
}

function getResponseErrorMessageReason(error: unknown): string | undefined {
  if (
    error &&
    typeof error === "object" &&
    "data" in error &&
    typeof error.data === "object" &&
    error.data &&
    "reasons" in error.data &&
    Array.isArray(error.data.reasons)
  ) {
    return error.data.reasons[0]?.message ?? undefined;
  }

  return findErrorMessage(error);
}