The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
import { useParams } from 'common'
import { useRouter } from 'next/router'
import { parseAsStringEnum, useQueryState } from 'nuqs'
import { useEffect, useRef, useState } from 'react'
import { useForm } from 'react-hook-form'
import { Form, Separator } from 'ui'
import { Admonition } from 'ui-patterns/Admonition'
import { DestinationLogo } from '../DestinationLogo'
import { BigQueryFields } from '../DestinationPanel/DestinationForm/BigQuery/Fields'
import { ClickHouseFields } from '../DestinationPanel/DestinationForm/ClickHouse/Fields'
import type { DestinationPanelSchemaType } from '../DestinationPanel/DestinationForm/DestinationForm.schema'
import { generateDefaultValues } from '../DestinationPanel/DestinationForm/DestinationForm.utils'
import { DuckLakeFields } from '../DestinationPanel/DestinationForm/DuckLake/Fields'
import { NewPublicationPanel } from '../DestinationPanel/DestinationForm/NewPublicationPanel'
import { SnowflakeFields } from '../DestinationPanel/DestinationForm/Snowflake/Fields'
import { DESTINATION_DOCS_PATHS } from '../DestinationPanel/DestinationPanel.constants'
import type { FlowDestination } from '../DestinationPanel/DestinationPanel.types'
import { PipelineConnectionSection } from './PipelineConnectionSection'
import { PIPELINE_CREATION_STEPS as steps } from './PipelineCreationFlow.constants'
import { PipelineCreationHeader } from './PipelineCreationHeader'
import { PipelineDataReview } from './PipelineDataReview'
import { PipelineDataSection } from './PipelineDataSection'
import { PipelineDestinationReview } from './PipelineDestinationReview'
import { PipelineDestinationSelection } from './PipelineDestinationSelection'
import { PipelineReviewCosts } from './PipelineReviewCosts'
import {
PipelineValidationAdmonition,
SANDWICHED_ADMONITION_CLASS,
} from './PipelineValidationAdmonition'
import { usePipelineConnectionValidation } from './usePipelineConnectionValidation'
import { usePipelineCreationSubmission } from './usePipelineCreationSubmission'
import { usePipelineDataValidation } from './usePipelineDataValidation'
import { usePipelineNavigationGuard } from './usePipelineNavigationGuard'
import { usePipelineReviewCosts } from './usePipelineReviewCosts'
import { DiscardChangesConfirmationDialog } from '@/components/ui-patterns/Dialogs/DiscardChangesConfirmationDialog'
import { DocsButton } from '@/components/ui/DocsButton'
import { SteppedFlow, SteppedFlowHeader } from '@/components/ui/SteppedFlow/SteppedFlow'
import { useReplicationSourceId } from '@/data/replication/sources-query'
import { DOCS_URL } from '@/lib/constants'
const getDocsUrl = (step: string, destination: FlowDestination) => {
if (step === 'connection') return `${DOCS_URL}${DESTINATION_DOCS_PATHS[destination]}`
if (step === 'data')
return `${DOCS_URL}/guides/database/replication/pipelines#choosing-which-tables-to-copy`
return undefined
}
const stepParser = parseAsStringEnum(steps.map(({ id }) => id))
.withDefault('destination')
.withOptions({ history: 'push', shallow: true, clearOnDefault: true })
export const PipelineCreationFlow = ({
availableDestinations,
onClose,
}: {
availableDestinations: FlowDestination[]
onClose: () => void
}) => {
const router = useRouter()
const [step, setStep] = useQueryState('step', stepParser)
const hasInitializedStepRef = useRef(false)
const [type, setType] = useState<FlowDestination>(availableDestinations[0] ?? 'BigQuery')
const [isPublicationPanelVisible, setIsPublicationPanelVisible] = useState(false)
const form = useForm<DestinationPanelSchemaType>({
defaultValues: generateDefaultValues({ catalogToken: '', editMode: false }),
shouldUnregister: false,
})
const initialTypeRef = useRef(type)
const { isDirty } = form.formState
const { requestNavigation, completeNavigation, modalProps } = usePipelineNavigationGuard(
isDirty || type !== initialTypeRef.current,
() => isSubmitting
)
const handleClose = () => {
if (!isSubmitting) requestNavigation(onClose)
}
const { ref: projectRef } = useParams()
const { validateConnection, resetValidation, isValidating, isConnectionVerified, failures } =
usePipelineConnectionValidation({ projectRef, type, form })
const sourceId = useReplicationSourceId({ projectRef })
const {
validateData,
isValidatingData,
isDataVerified,
dataError,
hasPublicationLoadError,
publication,
} = usePipelineDataValidation({ projectRef, sourceId, type, form })
const {
handleSubmit,
isSubmitting,
destinationValidationFailures,
pipelineValidationFailures,
submitLabel,
} = usePipelineCreationSubmission({
type,
form,
validateData,
onCreated: () => completeNavigation(onClose),
})
const submissionFailures = [...destinationValidationFailures, ...pipelineValidationFailures]
const hasCriticalFailures = submissionFailures.some(
({ failure_type }) => failure_type === 'critical'
)
const hasWarnings = submissionFailures.some(({ failure_type }) => failure_type === 'warning')
let validationMessage = 'Review the warnings above before starting the pipeline.'
if (hasCriticalFailures) {
validationMessage = hasWarnings
? 'Fix the above issues and review warnings before starting the pipeline.'
: 'Fix the above issues before starting the pipeline.'
}
const isBusy = isValidating || isValidatingData || isSubmitting
const accessibleStep = (() => {
if (isSubmitting) return step
if ((step === 'data' || step === 'review') && !isConnectionVerified) return 'connection'
if (step === 'review' && !isDataVerified) return 'data'
return step
})()
const costs = usePipelineReviewCosts({
control: form.control,
publication,
enabled: accessibleStep === 'review',
})
const handleNext = async () => {
if (accessibleStep === 'connection' && !isConnectionVerified && !(await validateConnection()))
return
if (accessibleStep === 'data' && !(await validateData())) return
const next = steps[steps.findIndex(({ id }) => id === accessibleStep) + 1]
if (next) void setStep(next.id)
}
const currentStep = steps.find((item) => item.id === accessibleStep) ?? steps[0]
const docsUrl = getDocsUrl(accessibleStep, type)
const canSelectDestination = availableDestinations.includes(type)
useEffect(() => {
if (!hasInitializedStepRef.current) {
hasInitializedStepRef.current = true
void setStep('destination', { history: 'replace' })
return
}
if (step !== accessibleStep) void setStep(accessibleStep, { history: 'replace' })
}, [step, accessibleStep, setStep])
return (
<div className="flex min-h-screen flex-col bg-dash-sidebar">
<PipelineCreationHeader
onClose={handleClose}
onNavigate={(href) => {
if (!isSubmitting) requestNavigation(() => void router.push(href))
}}
/>
<main className="flex-1">
<Form {...form}>
<fieldset disabled={isSubmitting} className="contents">
<SteppedFlow
steps={steps}
currentStep={accessibleStep}
onStepChange={setStep}
onNext={handleNext}
nextLoading={isBusy}
navigationDisabled={isBusy}
nextLabel="Continue"
nextDisabled={accessibleStep === 'destination' && !canSelectDestination}
onCancel={handleClose}
finalAction={{
label: submitLabel,
onClick: handleSubmit,
loading: isSubmitting,
disabled: costs.isInitialCostEstimateLoading,
}}
>
<SteppedFlowHeader
title={currentStep.title}
description={currentStep.description(type)}
actions={docsUrl && <DocsButton href={docsUrl} />}
/>
{accessibleStep === 'destination' && (
<div className="p-5">
<PipelineDestinationSelection
availableDestinations={availableDestinations}
value={type}
onChange={(value) => {
const next = availableDestinations.find((item) => item === value)
if (next) {
resetValidation()
setType(next)
}
}}
renderLogo={(value) => <DestinationLogo type={value} />}
/>
</div>
)}
{accessibleStep === 'connection' && (
<>
<PipelineConnectionSection type={type} form={form} revealInvalidSettings>
{type === 'BigQuery' && <BigQueryFields form={form} editMode={false} />}
{type === 'DuckLake' && <DuckLakeFields form={form} editMode={false} />}
{type === 'Snowflake' && <SnowflakeFields form={form} editMode={false} />}
{type === 'ClickHouse' && <ClickHouseFields form={form} editMode={false} />}
</PipelineConnectionSection>
<PipelineValidationAdmonition failures={failures} />
</>
)}
{accessibleStep === 'data' && (
<>
<PipelineDataSection
type={type}
form={form}
onSelectNewPublication={() => setIsPublicationPanelVisible(true)}
revealInvalidSettings
showLoadError={false}
/>
{(hasPublicationLoadError || dataError) && (
<Admonition
type="danger"
title={
hasPublicationLoadError
? 'Publication tables could not be loaded'
: 'Check data settings'
}
description={
hasPublicationLoadError ? 'Click Continue to try again.' : dataError
}
className={SANDWICHED_ADMONITION_CLASS}
/>
)}
</>
)}
{accessibleStep === 'review' && (
<>
<PipelineDestinationReview
type={type}
control={form.control}
onEditDestination={() => void setStep('destination')}
onEditConnection={() => void setStep('connection')}
validationFailures={destinationValidationFailures}
/>
<Separator />
<PipelineDataReview
type={type}
control={form.control}
publication={publication}
onEdit={() => void setStep('data')}
validationFailures={pipelineValidationFailures}
/>
<Separator />
<PipelineReviewCosts control={form.control} publication={publication} />
<div role="status" aria-label="Pipeline validation status">
{submissionFailures.length > 0 && (
<Admonition
className={SANDWICHED_ADMONITION_CLASS}
type={hasCriticalFailures ? 'danger' : 'warning'}
description={validationMessage}
/>
)}
</div>
</>
)}
</SteppedFlow>
</fieldset>
</Form>
</main>
<NewPublicationPanel
visible={isPublicationPanelVisible}
onClose={(name) => {
if (name) {
form.setValue('publicationName', name, { shouldDirty: true, shouldValidate: true })
form.setValue('tableSyncCopyMode', 'include_all_tables', {
shouldDirty: true,
shouldValidate: true,
})
form.setValue('tableSyncCopyTableIds', [], { shouldDirty: true, shouldValidate: true })
form.setValue('tableOptions', [], { shouldDirty: true, shouldValidate: true })
}
setIsPublicationPanelVisible(false)
}}
/>
<DiscardChangesConfirmationDialog {...modalProps} />
</div>
)
}