Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

22.1 KB
Raw Blame
import { zodResolver } from '@hookform/resolvers/zod'
import { useQuery } from '@tanstack/react-query'
import { useParams } from 'common'
import { useEffect, useRef, useState } from 'react'
import { useForm, useWatch, type SubmitHandler } from 'react-hook-form'
import { toast } from 'sonner'
import {
  Button,
  Dialog,
  DialogContent,
  DialogFooter,
  DialogHeader,
  DialogSection,
  DialogSectionSeparator,
  DialogTitle,
  Form,
  FormControl,
  FormField,
  FormMessage,
  Input,
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
  Switch,
} from 'ui'
import { Admonition } from 'ui-patterns/Admonition'
import { ConfirmationModal } from 'ui-patterns/Dialogs/ConfirmationModal'
import { FormItemLayout } from 'ui-patterns/form/FormItemLayout/FormItemLayout'

import { BucketVersioningFields } from './BucketVersioningFields/BucketVersioningFields'
import {
  fromLifecycleRules,
  hasLifecyclePolicyChanged,
  hasUnsupportedLifecycleRules,
  toLifecycleRules,
} from './BucketVersioningFields/BucketVersioningFields.lifecycle'
import {
  getNextVersioningState,
  getVersioningFormDefaults,
  isEnablingVersioning,
  isSuspendingVersioning,
  toVersioningStatusUpdate,
  type BucketVersioningSettings,
} from './EditBucketModal.utils'
import { EditBucketFormSchema, type BucketFormValues } from './FilesBucket.schema'
import { useIsStorageVersioningEnabled } from '@/components/interfaces/App/FeaturePreview/FeaturePreviewContext'
import { StorageSizeUnits } from '@/components/interfaces/Storage/StorageSettings/StorageSettings.constants'
import {
  convertFromBytes,
  convertToBytes,
} from '@/components/interfaces/Storage/StorageSettings/StorageSettings.utils'
import { getBucketVersioningState } from '@/components/interfaces/Storage/StorageVersioning.constants'
import { InlineLink } from '@/components/ui/InlineLink'
import { useProjectStorageConfigQuery } from '@/data/config/project-storage-config-query'
import { bucketLifecycleQueryOptions } from '@/data/storage/bucket-lifecycle-query'
import { useBucketLifecycleUpdateMutation } from '@/data/storage/bucket-lifecycle-update-mutation'
import { useBucketUpdateMutation } from '@/data/storage/bucket-update-mutation'
import { Bucket } from '@/data/storage/buckets-query'
import { DOCS_URL, IS_PLATFORM } from '@/lib/constants'
import { useTrack } from '@/lib/telemetry/track'

export interface EditBucketModalProps {
  visible: boolean
  bucket: Bucket
  onClose: () => void
}

const formId = 'edit-storage-bucket-form'

export const EditBucketModal = ({ visible, bucket, onClose }: EditBucketModalProps) => {
  const { ref } = useParams()

  const { data } = useProjectStorageConfigQuery({ projectRef: ref }, { enabled: IS_PLATFORM })
  const { value, unit } = convertFromBytes(data?.fileSizeLimit ?? 0)
  const formattedGlobalUploadLimit = `${value} ${unit}`

  const bucketIdRef = useRef<string | null>(null)
  const [selectedUnit, setSelectedUnit] = useState<string>(StorageSizeUnits.MB)
  const { value: fileSizeLimit } = convertFromBytes(bucket?.file_size_limit ?? 0)

  const isStorageVersioningEnabled = useIsStorageVersioningEnabled()

  const {
    data: lifecycle,
    isLoading: isLoadingLifecycle,
    error: lifecycleError,
  } = useQuery({
    ...bucketLifecycleQueryOptions({ projectRef: ref, bucketId: bucket?.id }),
    enabled: isStorageVersioningEnabled && visible && !!ref && !!bucket?.id,
  })
  const storedPolicy = fromLifecycleRules(lifecycle)
  const isUnsupportedPolicy = hasUnsupportedLifecycleRules(lifecycle)
  // Still loading, or the fetch failed: either way the form is seeded from a policy
  // nobody has read, and the update endpoint would replace the real one with it.
  const hasUnreadPolicy = isLoadingLifecycle || !!lifecycleError

  const versioningSettings: BucketVersioningSettings = {
    versioning: getBucketVersioningState(bucket),
    versionExpiryDays: storedPolicy.versionExpiryDays,
    maxNoncurrentVersions: storedPolicy.maxNoncurrentVersions,
    expirationMode: storedPolicy.expirationMode,
  }

  // Held while the suspend confirmation is open, so confirming completes the save.
  const [pendingSuspendValues, setPendingSuspendValues] = useState<BucketFormValues | null>(null)

  const track = useTrack()
  // Stashed at submit time and only reported once the save actually succeeds.
  const enabledVersioningRef = useRef<{ hasLifecyclePolicy: boolean } | null>(null)

  const { mutateAsync: updateLifecycle, isPending: isUpdatingLifecycle } =
    useBucketLifecycleUpdateMutation()

  const { mutate: updateBucket, isPending: isUpdatingBucket } = useBucketUpdateMutation({
    onSuccess: () => {
      setPendingSuspendValues(null)
      if (enabledVersioningRef.current !== null) {
        track('storage_bucket_versioning_enabled', enabledVersioningRef.current)
        enabledVersioningRef.current = null
      }
      toast.success(`Successfully updated bucket "${bucket?.name}"`)
      onClose()
    },
    onError: (error) => {
      // Release the suspend dialog too, so a failed save doesn't trap the user in it.
      setPendingSuspendValues(null)

      // Handle specific error cases for inline display
      const errorMessage = error.message?.toLowerCase() || ''

      if (
        errorMessage.includes('exceeded the maximum allowed size') ||
        errorMessage.includes('maximum allowed size') ||
        errorMessage.includes('entity too large') ||
        errorMessage.includes('payload too large')
      ) {
        // Set form error for the file size limit field
        form.setError('formatted_size_limit', {
          type: 'manual',
          message: `Exceeds global limit of ${formattedGlobalUploadLimit}.`,
        })
      } else if (
        errorMessage.includes('mime type') &&
        (errorMessage.includes('is not supported') || errorMessage.includes('not supported'))
      ) {
        // Set form error for the MIME types field
        form.setError('allowed_mime_types', {
          type: 'manual',
          message: 'Invalid MIME type format. Please check your input.',
        })
      } else {
        // For other errors, show a toast as fallback
        toast.error(`Failed to update bucket: ${error.message || 'Unknown error'}`)
      }
    },
  })

  const isUpdating = isUpdatingBucket || isUpdatingLifecycle

  const defaultValues = {
    name: bucket?.name ?? '',
    public: bucket?.public,
    has_file_size_limit: Boolean(bucket?.file_size_limit),
    formatted_size_limit: bucket?.file_size_limit ? (fileSizeLimit ?? 0) : undefined,
    allowed_mime_types: (bucket?.allowed_mime_types ?? []).join(', '),
    ...getVersioningFormDefaults(versioningSettings),
  }

  const form = useForm<BucketFormValues>({
    resolver: zodResolver(EditBucketFormSchema),
    defaultValues,
    values: defaultValues,
    // Show numeric versioning bounds as the user types, not only on submit.
    mode: 'onChange',
  })
  const { formatted_size_limit: formattedSizeLimitError } = form.formState.errors

  const isPublicBucket = useWatch({ control: form.control, name: 'public' })
  const hasFileSizeLimit = useWatch({ control: form.control, name: 'has_file_size_limit' })
  const [hasAllowedMimeTypes, setHasAllowedMimeTypes] = useState(
    Boolean(bucket?.allowed_mime_types?.length)
  )

  const isChangingBucketVisibility = bucket?.public !== isPublicBucket
  const isMakingBucketPrivate = bucket?.public && !isPublicBucket
  const isMakingBucketPublic = !bucket?.public && isPublicBucket

  const closeModal = () => {
    form.reset()
    onClose()
  }

  const persistChanges = async (values: BucketFormValues) => {
    if (bucket === undefined) return console.error('Bucket is required')
    if (ref === undefined) return console.error('Project ref is required')

    enabledVersioningRef.current =
      isStorageVersioningEnabled &&
      isEnablingVersioning(versioningSettings.versioning, values.enable_versioning)
        ? {
            hasLifecyclePolicy:
              values.version_expiry_days !== '' || values.max_noncurrent_versions !== '',
          }
        : null

    const nextVersioningState = getNextVersioningState(
      versioningSettings.versioning,
      values.enable_versioning
    )
    const versioningStatus = isStorageVersioningEnabled
      ? toVersioningStatusUpdate(nextVersioningState)
      : undefined

    // Saved first, so a rejected policy leaves the bucket untouched. Skipped for a policy
    // the form never fully read, since the update endpoint replaces the whole of it.
    if (
      isStorageVersioningEnabled &&
      nextVersioningState !== 'disabled' &&
      !isUnsupportedPolicy &&
      !hasUnreadPolicy &&
      hasLifecyclePolicyChanged(storedPolicy, values)
    ) {
      try {
        await updateLifecycle({
          projectRef: ref,
          bucketId: bucket.id,
          rules: toLifecycleRules(values),
        })
      } catch {
        // The mutation raises its own toast; leave the modal open to retry.
        return
      }
    }

    updateBucket({
      projectRef: ref,
      id: bucket.id,
      isPublic: values.public,
      versioning_status: versioningStatus,
      file_size_limit:
        values.has_file_size_limit && values.formatted_size_limit
          ? convertToBytes(values.formatted_size_limit, selectedUnit as StorageSizeUnits)
          : null,
      allowed_mime_types: hasAllowedMimeTypes
        ? values.allowed_mime_types.length > 0
          ? values.allowed_mime_types.split(',').map((x: string) => x.trim())
          : null
        : null,
    })
  }

  const onSubmit: SubmitHandler<BucketFormValues> = async (values) => {
    if (bucket === undefined) return console.error('Bucket is required')
    if (ref === undefined) return console.error('Project ref is required')

    // Client-side validation: Check if bucket limit exceeds global limit
    // [Joshen] Should shift this into superRefine in the form schema
    if (
      values.has_file_size_limit &&
      values.formatted_size_limit !== undefined &&
      data?.fileSizeLimit
    ) {
      const bucketLimitInBytes = convertToBytes(
        values.formatted_size_limit,
        selectedUnit as StorageSizeUnits
      )

      if (bucketLimitInBytes > data.fileSizeLimit) {
        return form.setError('formatted_size_limit', {
          type: 'manual',
          message: 'exceed_global_limit',
        })
      }
    }

    // Future uploads stop producing recoverable versions, so confirm first.
    if (
      isStorageVersioningEnabled &&
      isSuspendingVersioning(versioningSettings.versioning, values.enable_versioning)
    ) {
      return setPendingSuspendValues(values)
    }

    await persistChanges(values)
  }

  useEffect(() => {
    if (visible && bucket) {
      // Only set the selectedUnit when the bucket changes (different bucket ID)
      // This preserves the user's unit selection when reopening the modal for the same bucket
      if (bucketIdRef.current !== bucket.id && bucket.file_size_limit) {
        const { unit } = convertFromBytes(bucket.file_size_limit)
        setSelectedUnit(unit)
        bucketIdRef.current = bucket.id
      }
    }
  }, [visible, bucket, form])

  return (
    <>
      <Dialog
        open={visible}
        onOpenChange={(open) => {
          if (!open) closeModal()
        }}
      >
        <DialogContent>
          <DialogHeader>
            <DialogTitle>{`Edit bucket “${bucket?.name}”`}</DialogTitle>
          </DialogHeader>

          <DialogSectionSeparator />

          <Form {...form}>
            <form id={formId} onSubmit={form.handleSubmit(onSubmit)}>
              <DialogSection className="space-y-6">
                <FormField
                  key="name"
                  name="name"
                  control={form.control}
                  render={({ field }) => (
                    <FormItemLayout
                      hideMessage
                      label="Bucket name"
                      labelOptional="Cannot be changed after creation"
                    >
                      <FormControl>
                        <Input {...field} disabled />
                      </FormControl>
                    </FormItemLayout>
                  )}
                />

                <div className="flex flex-col gap-y-3">
                  <FormField
                    key="public"
                    name="public"
                    control={form.control}
                    render={({ field }) => (
                      <FormItemLayout
                        hideMessage
                        label="Public bucket"
                        description="Allow anyone to read objects without authorization"
                        layout="flex"
                      >
                        <FormControl>
                          <Switch
                            size="large"
                            checked={field.value}
                            onCheckedChange={field.onChange}
                          />
                        </FormControl>
                      </FormItemLayout>
                    )}
                  />

                  {isChangingBucketVisibility && (
                    <Admonition
                      type="warning"
                      title={`Warning: Making bucket ${isMakingBucketPublic ? 'public' : 'private'}`}
                      description={
                        <>
                          {isMakingBucketPublic && (
                            <p>This will make all objects in your bucket publicly accessible.</p>
                          )}

                          {isMakingBucketPrivate && (
                            <>
                              <p className="mb-2 leading-normal!">
                                All objects in your bucket will only accessible via signed URLs, or
                                downloaded with the right authorization headers.
                              </p>
                              <p className="leading-normal!">
                                Assets cached in the CDN may still be publicly accessible. You can
                                consider{' '}
                                <InlineLink
                                  href={`${DOCS_URL}/guides/storage/cdn/smart-cdn#cache-eviction`}
                                >
                                  purging the cache
                                </InlineLink>{' '}
                                or moving your assets to a new bucket.
                              </p>
                            </>
                          )}
                        </>
                      }
                    />
                  )}
                </div>
              </DialogSection>

              <DialogSectionSeparator />

              <DialogSection className="space-y-2">
                <FormField
                  key="has_file_size_limit"
                  name="has_file_size_limit"
                  control={form.control}
                  render={({ field }) => (
                    <FormItemLayout
                      label="Restrict file size"
                      description="Prevent uploading of files larger than a specified limit"
                      layout="flex"
                    >
                      <FormControl>
                        <Switch
                          size="large"
                          checked={field.value}
                          onCheckedChange={field.onChange}
                        />
                      </FormControl>
                    </FormItemLayout>
                  )}
                />
                {hasFileSizeLimit && (
                  <div>
                    <FormField
                      key="formatted_size_limit"
                      name="formatted_size_limit"
                      control={form.control}
                      render={({ field }) => (
                        <FormItemLayout hideMessage label="File size limit">
                          <div className="grid grid-cols-12 gap-x-2">
                            <div className="col-span-8">
                              <FormControl>
                                <Input
                                  aria-label="File size limit"
                                  type="number"
                                  min={0}
                                  placeholder="0"
                                  {...field}
                                />
                              </FormControl>
                            </div>
                            <div className="col-span-4">
                              <Select value={selectedUnit} onValueChange={setSelectedUnit}>
                                <SelectTrigger aria-label="File size limit unit" size="small">
                                  <SelectValue>{selectedUnit}</SelectValue>
                                </SelectTrigger>
                                <SelectContent>
                                  {Object.values(StorageSizeUnits).map((unit: string) => (
                                    <SelectItem key={unit} value={unit} className="text-xs">
                                      {unit}
                                    </SelectItem>
                                  ))}
                                </SelectContent>
                              </Select>
                            </div>
                          </div>
                        </FormItemLayout>
                      )}
                    />
                    {formattedSizeLimitError?.message === 'exceed_global_limit' && (
                      <FormMessage className="mt-2">
                        Exceeds global limit of {formattedGlobalUploadLimit}. Increase limit in{' '}
                        <InlineLink
                          className="text-destructive decoration-destructive-500 hover:decoration-destructive"
                          href={`/project/${ref}/storage/settings`}
                          onClick={onClose}
                        >
                          Storage Settings
                        </InlineLink>{' '}
                        first.
                      </FormMessage>
                    )}

                    {IS_PLATFORM && (
                      <p className="text-sm text-foreground-lighter mt-2">
                        This project has a{' '}
                        <InlineLink
                          className="text-foreground-light hover:text-foreground"
                          href={`/project/${ref}/storage/settings`}
                          onClick={onClose}
                        >
                          global file size limit
                        </InlineLink>{' '}
                        of {formattedGlobalUploadLimit}.
                      </p>
                    )}
                  </div>
                )}
              </DialogSection>

              <DialogSectionSeparator />

              <DialogSection className="space-y-2">
                <FormItemLayout
                  label="Restrict MIME types"
                  description="Allow only certain types of files to be uploaded"
                  layout="flex"
                >
                  <FormControl>
                    <Switch
                      size="large"
                      checked={hasAllowedMimeTypes}
                      onCheckedChange={setHasAllowedMimeTypes}
                    />
                  </FormControl>
                </FormItemLayout>
                {hasAllowedMimeTypes && (
                  <FormField
                    key="allowed_mime_types"
                    name="allowed_mime_types"
                    control={form.control}
                    render={({ field }) => (
                      <FormItemLayout
                        label="Allowed MIME types"
                        labelOptional="Comma separated values"
                        description="Wildcards are allowed, e.g. image/*."
                      >
                        <FormControl>
                          <Input
                            {...field}
                            placeholder="e.g image/jpeg, image/png, audio/mpeg, video/mp4, etc"
                          />
                        </FormControl>
                      </FormItemLayout>
                    )}
                  />
                )}
              </DialogSection>

              {isStorageVersioningEnabled && (
                <BucketVersioningFields
                  form={form}
                  initialVersioningState={versioningSettings.versioning}
                  initialRetentionDays={versioningSettings.versionExpiryDays}
                  initialMaxVersions={versioningSettings.maxNoncurrentVersions}
                  isPublicBucket={isPublicBucket}
                  isLoadingPolicy={isLoadingLifecycle}
                  isUnsupportedPolicy={isUnsupportedPolicy}
                  policyError={lifecycleError}
                />
              )}
            </form>
          </Form>

          <DialogFooter>
            <Button disabled={isUpdating} onClick={closeModal}>
              Cancel
            </Button>
            <Button
              variant="primary"
              form={formId}
              type="submit"
              loading={isUpdating}
              // Saving now would write the empty policy the form is still seeded with.
              disabled={hasUnreadPolicy}
            >
              Save
            </Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>

      <ConfirmationModal
        variant="warning"
        visible={pendingSuspendValues !== null}
        title="Suspend object versioning?"
        confirmLabel="Suspend versioning"
        confirmLabelLoading="Suspending versioning..."
        loading={isUpdating}
        onCancel={() => setPendingSuspendValues(null)}
        // Cleared by the mutation, so the dialog keeps its loading state while the save runs.
        onConfirm={() => {
          if (pendingSuspendValues !== null) persistChanges(pendingSuspendValues)
        }}
      >
        <p className="text-sm text-foreground-light">
          Overwriting or deleting an object in{' '}
          <span className="text-foreground">{bucket?.name}</span> will no longer keep a recoverable
          copy. Every version already retained stays until you delete it or a lifecycle policy
          expires it, and you can re-enable versioning at any time.
        </p>
      </ConfirmationModal>
    </>
  )
}