Skip to content

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

fix(studio): wrappers install state + one-click install (#46697)

Francesco Sansalvadorec71313538481
diff --git a/apps/studio/components/interfaces/Integrations/Landing/useIntegrationDetail.ts b/apps/studio/components/interfaces/Integrations/Landing/useIntegrationDetail.ts
index 2edaa1804a1..f9d8e5cb46d 100644
--- a/apps/studio/components/interfaces/Integrations/Landing/useIntegrationDetail.ts
+++ b/apps/studio/components/interfaces/Integrations/Landing/useIntegrationDetail.ts
@@ -4,6 +4,13 @@ import { useEffect, useMemo } from 'react'
import { useAvailableIntegrations } from './useAvailableIntegrations'
import { useInstalledIntegrations } from './useInstalledIntegrations'
+import {
+ areRequiredExtensionsInstalledFor,
+ getFilteredNavItems,
+ getInstallActionType,
+ type InstallActionType,
+} from './useIntegrationDetail.utils'
+import { useIsMarketplaceEnabled } from '@/components/interfaces/App/FeaturePreview/FeaturePreviewContext'
import { useDatabaseExtensionsQuery } from '@/data/database-extensions/database-extensions-query'
import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'
@@ -19,6 +26,7 @@ export const useIntegrationDetail = () => {
const { ref, id, pageId, childId } = useParams()
const { integrationsWrappers } = useIsFeatureEnabled(['integrations:wrappers'])
+ const isMarketplaceEnabled = useIsMarketplaceEnabled()
const { data: project } = useSelectedProjectQuery()
const { data: extensions } = useDatabaseExtensionsQuery({
@@ -36,21 +44,23 @@ export const useIntegrationDetail = () => {
[installedIntegrations, id]
)
- const installableExtensions = (extensions ?? []).filter((ext) =>
- (integration?.requiredExtensions ?? []).includes(ext.name)
- )
- const extensionsInstalled = installableExtensions.every((x) => x.installed_version)
+ const isInstalled = !!integration && !!installation
- // installedIntegrations doesn't return wrappers unless there's a wrapper created
- const isInstalled =
- !!integration && (!!installation || (integration.type === 'wrapper' && extensionsInstalled))
+ const areRequiredExtensionsInstalled = useMemo(
+ () => areRequiredExtensionsInstalledFor(integration, extensions),
+ [integration, extensions]
+ )
- const navItems = useMemo(() => {
- if (!integration?.navigation) return []
- return isInstalled
- ? integration.navigation
- : integration.navigation.filter((nav) => nav.route === 'overview')
- }, [integration, isInstalled])
+ const navItems = useMemo(
+ () =>
+ getFilteredNavItems({
+ integration,
+ isInstalled,
+ isMarketplaceEnabled,
+ areRequiredExtensionsInstalled,
+ }),
+ [integration, isInstalled, isMarketplaceEnabled, areRequiredExtensionsInstalled]
+ )
const activeRoute = pageId ?? 'overview'
@@ -77,6 +87,22 @@ export const useIntegrationDetail = () => {
[integration, id, pageId, childId]
)
+ const wrappersTabHref = useMemo(
+ () => tabs.find((tab) => tab.href.endsWith('/wrappers'))?.href,
+ [tabs]
+ )
+
+ const installActionType: InstallActionType = useMemo(
+ () =>
+ getInstallActionType({
+ integration,
+ isMarketplaceEnabled,
+ areRequiredExtensionsInstalled,
+ isInstalled,
+ }),
+ [integration, isMarketplaceEnabled, areRequiredExtensionsInstalled, isInstalled]
+ )
+
const isReady = !!router?.isReady
const isWrapperBlocked = !integrationsWrappers && !!id?.endsWith('_wrapper')
@@ -115,6 +141,9 @@ export const useIntegrationDetail = () => {
integration,
installation,
isInstalled,
+ areRequiredExtensionsInstalled,
+ installActionType,
+ wrappersTabHref,
isAvailableLoading,
isInstalledLoading,
Component,
diff --git a/apps/studio/components/interfaces/Integrations/Landing/useIntegrationDetail.utils.ts b/apps/studio/components/interfaces/Integrations/Landing/useIntegrationDetail.utils.ts
new file mode 100644
index 00000000000..a21552f9ad6
--- /dev/null
+++ b/apps/studio/components/interfaces/Integrations/Landing/useIntegrationDetail.utils.ts
@@ -0,0 +1,65 @@
+import type { IntegrationDefinition, Navigation } from './Integrations.constants'
+
+export type InstallActionType = 'oauth' | 'add-wrapper' | 'installed' | 'install-sheet' | null
+
+export type DatabaseExtension = {
+ name: string
+ installed_version: string | null
+}
+
+/**
+ * Returns whether all required extensions for an integration are enabled in the database.
+ */
+export function areRequiredExtensionsInstalledFor(
+ integration: IntegrationDefinition | undefined,
+ extensions: DatabaseExtension[] | undefined
+): boolean {
+ if (!integration?.requiredExtensions?.length || !extensions) return false
+ return integration.requiredExtensions.every(
+ (name) => !!extensions.find((ext) => ext.name === name)?.installed_version
+ )
+}
+
+/**
+ * Returns the filtered navigation items for an integration based on install / feature-flag state.
+ * If the marketplace flag is off, only expose the Wrappers tab once extensions are installed
+ */
+export function getFilteredNavItems({
+ integration,
+ isInstalled,
+ isMarketplaceEnabled,
+ areRequiredExtensionsInstalled,
+}: {
+ integration: IntegrationDefinition | undefined
+ isInstalled: boolean
+ isMarketplaceEnabled: boolean
+ areRequiredExtensionsInstalled: boolean
+}): Navigation[] {
+ if (!integration?.navigation) return []
+ if (isInstalled || integration.type !== 'wrapper') return integration.navigation
+ if (isMarketplaceEnabled || areRequiredExtensionsInstalled) return integration.navigation
+ return integration.navigation.filter((nav) => nav.route !== 'wrappers')
+}
+
+/**
+ * Returns which install action type to render for an integration.
+ */
+export function getInstallActionType({
+ integration,
+ isMarketplaceEnabled,
+ areRequiredExtensionsInstalled,
+ isInstalled,
+}: {
+ integration: IntegrationDefinition | undefined
+ isMarketplaceEnabled: boolean
+ areRequiredExtensionsInstalled: boolean
+ isInstalled: boolean
+}): InstallActionType {
+ if (!integration) return null
+ if (integration.type === 'oauth') return 'oauth'
+ if (integration.type === 'wrapper' && (isMarketplaceEnabled || areRequiredExtensionsInstalled)) {
+ return 'add-wrapper'
+ }
+ if (isInstalled) return 'installed'
+ return 'install-sheet'
+}
diff --git a/apps/studio/components/interfaces/Integrations/Marketplace/MarketplaceDetail.tsx b/apps/studio/components/interfaces/Integrations/Marketplace/MarketplaceDetail.tsx
index 0562b10799e..df2ff449db8 100644
--- a/apps/studio/components/interfaces/Integrations/Marketplace/MarketplaceDetail.tsx
+++ b/apps/studio/components/interfaces/Integrations/Marketplace/MarketplaceDetail.tsx
@@ -1,4 +1,5 @@
import { ArrowUpRight, BookOpen } from 'lucide-react'
+import { useRouter } from 'next/router'
import { Button, cn } from 'ui'
import { GenericSkeletonLoader, ShimmeringLoader } from 'ui-patterns'
import { Admonition } from 'ui-patterns/admonition'
@@ -10,11 +11,13 @@ import { IntegrationDetailTabShortcuts } from '@/components/interfaces/Integrati
import { InstallIntegrationSheet } from '@/components/interfaces/Integrations/Integration/IntegrationOverviewTabV2/InstallIntegrationSheet/InstallIntegrationSheet'
import { InstallOAuthIntegrationButton } from '@/components/interfaces/Integrations/Integration/IntegrationOverviewTabV2/InstallIntegrationSheet/InstallOAuthIntegrationButton'
import { useIntegrationDetail } from '@/components/interfaces/Integrations/Landing/useIntegrationDetail'
+import { AddWrapperButton } from '@/components/interfaces/Integrations/Wrappers/AddWrapperButton'
import { UnknownInterface } from '@/components/ui/UnknownInterface'
export const centeredContentClass = 'mx-auto w-full max-w-6xl px-6 xl:px-10'
export const MarketplaceDetail = () => {
+ const router = useRouter()
const {
ref,
activeRoute,
@@ -27,6 +30,8 @@ export const MarketplaceDetail = () => {
pageSubTitle,
integration,
isInstalled,
+ installActionType,
+ wrappersTabHref,
isAvailableLoading,
isInstalledLoading,
Component,
@@ -66,17 +71,27 @@ export const MarketplaceDetail = () => {
}
const renderInstallAction = () => {
- if (integration.type === 'oauth') {
- return <InstallOAuthIntegrationButton integration={integration} />
- }
- if (isInstalled) {
- return (
- <Button type="outline" disabled>
- Installed
- </Button>
- )
+ switch (installActionType) {
+ case 'oauth':
+ return <InstallOAuthIntegrationButton integration={integration} />
+ case 'add-wrapper':
+ return (
+ <AddWrapperButton
+ type="primary"
+ onClick={() => {
+ if (wrappersTabHref) router.push(`${wrappersTabHref}?new=true`)
+ }}
+ />
+ )
+ case 'installed':
+ return (
+ <Button type="outline" disabled>
+ Installed
+ </Button>
+ )
+ default:
+ return <InstallIntegrationSheet integration={integration} />
}
- return <InstallIntegrationSheet integration={integration} />
}
// For overview route, get the integration-specific overview component if available
diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/AddWrapperButton.tsx b/apps/studio/components/interfaces/Integrations/Wrappers/AddWrapperButton.tsx
new file mode 100644
index 00000000000..0b0369d4f61
--- /dev/null
+++ b/apps/studio/components/interfaces/Integrations/Wrappers/AddWrapperButton.tsx
@@ -0,0 +1,52 @@
+import { PermissionAction } from '@supabase/shared-types/out/constants'
+import { useMemo } from 'react'
+
+import { ButtonTooltip } from '@/components/ui/ButtonTooltip'
+import { useDatabaseExtensionsQuery } from '@/data/database-extensions/database-extensions-query'
+import { useAsyncCheckPermissions } from '@/hooks/misc/useCheckPermissions'
+import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'
+
+const WRAPPER_REQUIRED_EXTENSION_NAMES = ['wrappers', 'supabase_vault']
+
+interface AddWrapperButtonProps {
+ type?: 'default' | 'primary' | 'outline'
+ onClick: () => void
+}
+
+export const AddWrapperButton = ({ type = 'default', onClick }: AddWrapperButtonProps) => {
+ const { can: canCreateWrapper } = useAsyncCheckPermissions(
+ PermissionAction.TENANT_SQL_ADMIN_WRITE,
+ 'wrappers'
+ )
+
+ const { data: project } = useSelectedProjectQuery()
+ const { data: extensions } = useDatabaseExtensionsQuery({
+ projectRef: project?.ref,
+ connectionString: project?.connectionString,
+ })
+
+ const needsExtensions = useMemo(
+ () =>
+ WRAPPER_REQUIRED_EXTENSION_NAMES.some(
+ (name) => !extensions?.find((ext) => ext.name === name)?.installed_version
+ ),
+ [extensions]
+ )
+
+ return (
+ <ButtonTooltip
+ type={type}
+ onClick={onClick}
+ disabled={!canCreateWrapper}
+ tooltip={{
+ content: {
+ text: !canCreateWrapper
+ ? 'You need additional permissions to create a foreign data wrapper'
+ : undefined,
+ },
+ }}
+ >
+ {needsExtensions ? 'Install wrapper' : 'Add new wrapper'}
+ </ButtonTooltip>
+ )
+}
diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/CreateWrapperSheet.tsx b/apps/studio/components/interfaces/Integrations/Wrappers/CreateWrapperSheet.tsx
index a2baee892c1..e37d9d645a8 100644
--- a/apps/studio/components/interfaces/Integrations/Wrappers/CreateWrapperSheet.tsx
+++ b/apps/studio/components/interfaces/Integrations/Wrappers/CreateWrapperSheet.tsx
@@ -1,7 +1,7 @@
import { zodResolver } from '@hookform/resolvers/zod'
import { useQueryClient } from '@tanstack/react-query'
import { Edit, Trash } from 'lucide-react'
-import { useEffect, useState } from 'react'
+import { useEffect, useMemo, useState } from 'react'
import { SubmitHandler, useFieldArray, useForm, useWatch } from 'react-hook-form'
import { toast } from 'sonner'
import {
@@ -18,24 +18,37 @@ import {
SheetTitle,
WarningIcon,
} from 'ui'
+import { Admonition } from 'ui-patterns/admonition'
import { FormItemLayout } from 'ui-patterns/form/FormItemLayout/FormItemLayout'
import * as z from 'zod'
import InputField from './InputField'
import { WrapperMeta } from './Wrappers.types'
-import { FormattedWrapperTable, getWrapperCreationFormSchema, NewTable } from './Wrappers.utils'
+import {
+ FormattedWrapperTable,
+ getRequiredExtensionsToInstall,
+ getWrapperCreationFormSchema,
+ hasForeignSchemaSupport,
+ NewTable,
+} from './Wrappers.utils'
import WrapperTableEditor from './WrapperTableEditor'
+import { useIsMarketplaceEnabled } from '@/components/interfaces/App/FeaturePreview/FeaturePreviewContext'
+import { getExtensionDefaultSchema } from '@/components/interfaces/Integrations/Integration/IntegrationOverviewTabV2/IntegrationOverviewTabV2.utils'
+import { RequiredExtensionsSection } from '@/components/interfaces/Integrations/Integration/RequiredExtensionsSection'
+import { useIntegrationDetail } from '@/components/interfaces/Integrations/Landing/useIntegrationDetail'
import {
FormSection,
FormSectionContent,
FormSectionLabel,
} from '@/components/ui/Forms/FormSection'
+import { useDatabaseExtensionEnableMutation } from '@/data/database-extensions/database-extension-enable-mutation'
import { useDatabaseExtensionsQuery } from '@/data/database-extensions/database-extensions-query'
import { useSchemaCreateMutation } from '@/data/database/schema-create-mutation'
import { invalidateSchemasQuery, useSchemasQuery } from '@/data/database/schemas-query'
import { useFDWCreateMutation } from '@/data/fdw/fdw-create-mutation'
import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'
import { useTrack } from '@/lib/telemetry/track'
+import type { ResponseError } from '@/types'
const FORM_ID = 'create-wrapper-form'
@@ -53,24 +66,27 @@ export const CreateWrapperSheet = ({
onCloseWithConfirmation,
}: CreateWrapperSheetProps) => {
const queryClient = useQueryClient()
+ const isMarketplaceEnabled = useIsMarketplaceEnabled()
+ const { integration } = useIntegrationDetail()
const { data: project } = useSelectedProjectQuery()
const track = useTrack()
- const [selectedTableToEdit, setSelectedTableToEdit] = useState<
- FormattedWrapperTable | undefined
- >()
-
const { data: extensions } = useDatabaseExtensionsQuery({
projectRef: project?.ref,
connectionString: project?.connectionString,
})
+ // null while the query is in flight — distinct from [] which means "all installed"
+ const requiredExtensionsToInstall = useMemo(
+ () => getRequiredExtensionsToInstall(extensions, integration?.requiredExtensions ?? []),
+ [extensions, integration?.requiredExtensions]
+ )
+
const wrappersExtension = extensions?.find((ext) => ext.name === 'wrappers')
- // The import foreign schema requires a minimum extension version of 0.5.0
- const hasRequiredVersionForeignSchema = wrappersExtension?.installed_version
- ? wrappersExtension?.installed_version >= '0.5.0'
- : false
+ const hasRequiredVersionForeignSchema = hasForeignSchemaSupport(wrappersExtension)
+ const needsExtensions = isMarketplaceEnabled && (requiredExtensionsToInstall?.length ?? 0) > 0
+ const isExtensionDataLoading = isMarketplaceEnabled && requiredExtensionsToInstall === null
const { data: schemas } = useSchemasQuery({
projectRef: project?.ref!,
@@ -113,7 +129,34 @@ export const CreateWrapperSheet = ({
name: 'tables',
})
- const { mutateAsync: createSchema, isPending: isCreatingSchema } = useSchemaCreateMutation()
+ const [selectedTableToEdit, setSelectedTableToEdit] = useState<FormattedWrapperTable | undefined>(
+ undefined
+ )
+
+ const { mutateAsync: enableExtension } = useDatabaseExtensionEnableMutation({ onError: () => {} })
+ const { mutateAsync: createSchema } = useSchemaCreateMutation({ onError: () => {} })
+ const { mutateAsync: createFDW } = useFDWCreateMutation({ onError: () => {} })
+
+ const installRequiredExtensions = async () => {
+ if (!project) return
+ const { ref: projectRef, connectionString } = project
+ const results = await Promise.allSettled(
+ (requiredExtensionsToInstall ?? []).map((ext) => {
+ const schema = getExtensionDefaultSchema(ext) ?? 'extensions'
+ return enableExtension({
+ projectRef,
+ connectionString,
+ schema,
+ name: ext.name,
+ version: ext.default_version,
+ cascade: true,
+ createSchema: false,
+ })
+ })
+ )
+ const failure = results.find((r) => r.status === 'rejected')
+ if (failure) throw new Error((failure as PromiseRejectedResult).reason.message)
+ }
const onUpdateTable = (values: FormattedWrapperTable) => {
if (values.index !== undefined) {
@@ -125,19 +168,6 @@ export const CreateWrapperSheet = ({
setSelectedTableToEdit(undefined)
}
- const { mutateAsync: createFDW, isPending: isCreatingWrapper } = useFDWCreateMutation({
- onSuccess: () => {
- toast.success(`Successfully created ${wrapperMeta?.label} foreign data wrapper`)
-
- const { tables } = getValues()
- const hasNewSchema = (tables as Record<string, any>[]).some((table) => table.is_new_schema)
- if (hasNewSchema) invalidateSchemasQuery(queryClient, project?.ref)
-
- onClose()
- form.reset()
- },
- })
-
const onSubmit: SubmitHandler<FormSchema> = async (values) => {
const { mode, tables = [], ...wrapperValues } = values
if (mode === 'tables' && tables.length === 0) {
@@ -158,13 +188,28 @@ export const CreateWrapperSheet = ({
}
}
+ if (isExtensionDataLoading) return
+
+ const toastId = toast.loading(
+ needsExtensions
+ ? `Installing extensions ${(requiredExtensionsToInstall ?? []).map((e) => e.name).join(', ')}…`
+ : `Creating ${wrapperMeta.label} wrapper…`
+ )
+
try {
+ if (needsExtensions) {
+ await installRequiredExtensions()
+ toast.loading(`Creating ${wrapperMeta.label} wrapper…`, { id: toastId })
+ }
+
if (mode === 'schema') {
+ toast.loading(`Creating schema "${wrapperValues.target_schema}"…`, { id: toastId })
await createSchema({
projectRef: project?.ref,
connectionString: project?.connectionString,
name: wrapperValues.target_schema,
})
+ toast.loading(`Creating ${wrapperMeta.label} wrapper…`, { id: toastId })
}
await createFDW({
@@ -182,14 +227,24 @@ export const CreateWrapperSheet = ({
targetSchema: wrapperValues.target_schema,
})
+ const { tables: formTables } = getValues()
+ const hasNewSchema = (formTables as Record<string, any>[]).some((t) => t.is_new_schema)
+ if (hasNewSchema) invalidateSchemasQuery(queryClient, project?.ref)
+
track('foreign_data_wrapper_created', { wrapperType: wrapperMeta.label })
+ toast.success(`Successfully created ${wrapperMeta.label} foreign data wrapper`, {
+ id: toastId,
+ })
+ onClose()
+ form.reset()
} catch (error) {
- console.error(error)
- // The error will be handled by the mutation onError callback (toast.error)
+ toast.error(
+ `Failed to create ${wrapperMeta.label} wrapper: ${(error as ResponseError).message}`,
+ { id: toastId }
+ )
}
}
- const isLoading = isCreatingWrapper || isCreatingSchema
const wrapper_name = useWatch({ name: 'wrapper_name', control: form.control })
const mode = useWatch({ name: 'mode', control: form.control })
@@ -205,7 +260,19 @@ export const CreateWrapperSheet = ({
<SheetHeader>
<SheetTitle>Create a {wrapperMeta.label} wrapper</SheetTitle>
</SheetHeader>
- <div className="flex-grow overflow-y-auto">
+ <div className="grow overflow-y-auto">
+ {isMarketplaceEnabled && (
+ <div className="px-5 py-5 flex flex-col gap-y-4 border-b">
+ {needsExtensions && (
+ <Admonition
+ type="warning"
+ title="Required extensions will be installed"
+ description="Proceeding will also install the extensions required by this wrapper."
+ />
+ )}
+ <RequiredExtensionsSection hideSeparator />
+ </div>
+ )}
<FormSection header={<FormSectionLabel>Wrapper Configuration</FormSectionLabel>}>
<FormSectionContent className="flex flex-col space-y-2" loading={false}>
<FormField
@@ -443,7 +510,7 @@ export const CreateWrapperSheet = ({
type="default"
htmlType="button"
onClick={onCloseWithConfirmation}
- disabled={isLoading}
+ disabled={isSubmitting}
>
Cancel
</Button>
@@ -452,8 +519,8 @@ export const CreateWrapperSheet = ({
type="primary"
form={FORM_ID}
htmlType="submit"
- disabled={isSubmitting || isLoading}
- loading={isLoading}
+ disabled={isSubmitting || isExtensionDataLoading}
+ loading={isSubmitting}
>
Create wrapper
</Button>
diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/Wrappers.utils.test.ts b/apps/studio/components/interfaces/Integrations/Wrappers/Wrappers.utils.test.ts
index cd1436abd14..e962a44b3a4 100644
--- a/apps/studio/components/interfaces/Integrations/Wrappers/Wrappers.utils.test.ts
+++ b/apps/studio/components/interfaces/Integrations/Wrappers/Wrappers.utils.test.ts
@@ -4,8 +4,10 @@ import { SUPABASE_TARGET_SCHEMA_OPTION, WRAPPER_HANDLERS } from './Wrappers.cons
import { Table } from './Wrappers.types'
import {
getEditionFormSchema,
+ getRequiredExtensionsToInstall,
getTableFormSchema,
getWrapperCreationFormSchema,
+ hasForeignSchemaSupport,
} from './Wrappers.utils'
const stripe_wrapper = {
@@ -207,3 +209,82 @@ describe('getTableFormSchema', () => {
).toBeDefined()
})
})
+
+// ─── getRequiredExtensionsToInstall ──────────────────────────────────────────
+
+describe('getRequiredExtensionsToInstall', () => {
+ const wrappers = { name: 'wrappers', installed_version: null }
+ const vault = { name: 'supabase_vault', installed_version: null }
+ const wrappersInstalled = { name: 'wrappers', installed_version: '0.4.1' }
+ const vaultInstalled = { name: 'supabase_vault', installed_version: '0.2.8' }
+ const unrelated = { name: 'pgmq', installed_version: null }
+
+ it('returns null when extensions are undefined (still loading)', () => {
+ expect(getRequiredExtensionsToInstall(undefined, ['wrappers'])).toBeNull()
+ })
+
+ it('returns empty array when required list is empty', () => {
+ expect(getRequiredExtensionsToInstall([wrappers], [])).toEqual([])
+ })
+
+ it('returns empty array when all required extensions are already installed', () => {
+ expect(
+ getRequiredExtensionsToInstall(
+ [wrappersInstalled, vaultInstalled],
+ ['wrappers', 'supabase_vault']
+ )
+ ).toEqual([])
+ })
+
+ it('returns extensions that are required but not installed', () => {
+ const result = getRequiredExtensionsToInstall(
+ [wrappers, vaultInstalled],
+ ['wrappers', 'supabase_vault']
+ )
+ expect(result).toHaveLength(1)
+ expect(result![0].name).toBe('wrappers')
+ })
+
+ it('returns all required extensions when none are installed', () => {
+ const result = getRequiredExtensionsToInstall([wrappers, vault], ['wrappers', 'supabase_vault'])
+ expect(result).toHaveLength(2)
+ })
+
+ it('excludes extensions that are not in the required list', () => {
+ const result = getRequiredExtensionsToInstall([wrappers, unrelated], ['wrappers'])
+ expect(result).toHaveLength(1)
+ expect(result![0].name).toBe('wrappers')
+ })
+
+ it('returns empty array when extensions list is empty', () => {
+ expect(getRequiredExtensionsToInstall([], ['wrappers'])).toEqual([])
+ })
+})
+
+// ─── hasForeignSchemaSupport ──────────────────────────────────────────────────
+
+describe('hasForeignSchemaSupport', () => {
+ it('returns false when extension is undefined', () => {
+ expect(hasForeignSchemaSupport(undefined)).toBe(false)
+ })
+
+ it('returns false when installed_version is null (not installed)', () => {
+ expect(hasForeignSchemaSupport({ installed_version: null })).toBe(false)
+ })
+
+ it('returns false for version below 0.5.0', () => {
+ expect(hasForeignSchemaSupport({ installed_version: '0.4.9' })).toBe(false)
+ expect(hasForeignSchemaSupport({ installed_version: '0.3.0' })).toBe(false)
+ expect(hasForeignSchemaSupport({ installed_version: '0.1.0' })).toBe(false)
+ })
+
+ it('returns true for exactly version 0.5.0', () => {
+ expect(hasForeignSchemaSupport({ installed_version: '0.5.0' })).toBe(true)
+ })
+
+ it('returns true for version above 0.5.0', () => {
+ expect(hasForeignSchemaSupport({ installed_version: '0.6.0' })).toBe(true)
+ expect(hasForeignSchemaSupport({ installed_version: '0.5.1' })).toBe(true)
+ expect(hasForeignSchemaSupport({ installed_version: '1.0.0' })).toBe(true)
+ })
+})
diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/Wrappers.utils.ts b/apps/studio/components/interfaces/Integrations/Wrappers/Wrappers.utils.ts
index 76834ea78e1..2ff003648c5 100644
--- a/apps/studio/components/interfaces/Integrations/Wrappers/Wrappers.utils.ts
+++ b/apps/studio/components/interfaces/Integrations/Wrappers/Wrappers.utils.ts
@@ -239,3 +239,30 @@ export function wrapperMetaComparator(
export function getWrapperMetaForWrapper(wrapper: FDW | undefined) {
return WRAPPERS.find((w) => wrapperMetaComparator(w, wrapper))
}
+
+/**
+ * Returns the subset of extensions that are required but not yet installed.
+ * Returns `null` when the extensions list is still loading (undefined),
+ * so callers can distinguish "loading" from "nothing to install".
+ * Generic so the full extension type (including `default_version`) is preserved.
+ */
+export function getRequiredExtensionsToInstall<
+ T extends { name: string; installed_version: string | null },
+>(extensions: T[] | undefined, requiredExtensionNames: string[]): T[] | null {
+ if (extensions === undefined) return null
+ return extensions.filter(
+ (ext) => requiredExtensionNames.includes(ext.name) && !ext.installed_version
+ )
+}
+
+/**
+ * Returns true when the wrappers extension is installed at >= 0.5.0,
+ * which is the minimum version required for IMPORT FOREIGN SCHEMA support.
+ */
+export function hasForeignSchemaSupport(
+ wrappersExtension: { installed_version: string | null } | undefined
+): boolean {
+ return wrappersExtension?.installed_version
+ ? wrappersExtension.installed_version >= '0.5.0'
+ : false
+}
diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/WrappersTab.tsx b/apps/studio/components/interfaces/Integrations/Wrappers/WrappersTab.tsx
index c52a6df134c..154f8783e73 100644
--- a/apps/studio/components/interfaces/Integrations/Wrappers/WrappersTab.tsx
+++ b/apps/studio/components/interfaces/Integrations/Wrappers/WrappersTab.tsx
@@ -4,12 +4,12 @@ import { parseAsBoolean, useQueryState } from 'nuqs'
import { useCallback, useState } from 'react'
import { Sheet, SheetContent } from 'ui'
+import { AddWrapperButton } from './AddWrapperButton'
import { CreateWrapperSheet } from './CreateWrapperSheet'
import { WRAPPERS } from './Wrappers.constants'
import { wrapperMetaComparator } from './Wrappers.utils'
import { WrapperTable } from './WrapperTable'
import { DiscardChangesConfirmationDialog } from '@/components/ui-patterns/Dialogs/DiscardChangesConfirmationDialog'
-import { ButtonTooltip } from '@/components/ui/ButtonTooltip'
import { DocsButton } from '@/components/ui/DocsButton'
import { useFDWsQuery } from '@/data/fdw/fdws-query'
import { useAsyncCheckPermissions } from '@/hooks/misc/useCheckPermissions'
@@ -70,44 +70,19 @@ export const WrappersTab = () => {
<p className="text-sm text-foreground-light">
No {wrapperMeta.label} wrappers have been installed
</p>
- <ButtonTooltip
- type="default"
- onClick={() => setIsCreating(true)}
- disabled={!canCreateWrapper}
- tooltip={{
- content: {
- text: !canCreateWrapper
- ? 'You need additional permissions to create a foreign data wrapper'
- : undefined,
- },
- }}
- >
- Add new wrapper
- </ButtonTooltip>
+ <AddWrapperButton onClick={() => setIsCreating(true)} />
</div>
</div>
) : (
- <div className="max-w-5xl flex items-center gap-x-2 justify-end mb-4">
- <DocsButton href={wrapperMeta.docsUrl} />
- <ButtonTooltip
- type="primary"
- onClick={() => setIsCreating(true)}
- disabled={!canCreateWrapper}
- tooltip={{
- content: {
- text: !canCreateWrapper
- ? 'You need additional permissions to create a foreign data wrapper'
- : undefined,
- },
- }}
- >
- Add new wrapper
- </ButtonTooltip>
- </div>
+ <>
+ <div className="max-w-5xl flex items-center gap-x-2 justify-end mb-4">
+ <DocsButton href={wrapperMeta.docsUrl} />
+ <AddWrapperButton type="primary" onClick={() => setIsCreating(true)} />
+ </div>
+ <WrapperTable />
+ </>
)}
- {createdWrappers.length > 0 && <WrapperTable />}
-
<Sheet open={!!isCreating} onOpenChange={handleOpenChange}>
<SheetContent size="lg" tabIndex={undefined}>
{wrapperMeta && (
diff --git a/apps/studio/tests/components/Integrations/Landing/useIntegrationDetail.utils.test.ts b/apps/studio/tests/components/Integrations/Landing/useIntegrationDetail.utils.test.ts
new file mode 100644
index 00000000000..ef3e01da8ef
--- /dev/null
+++ b/apps/studio/tests/components/Integrations/Landing/useIntegrationDetail.utils.test.ts
@@ -0,0 +1,266 @@
+import { describe, expect, it } from 'vitest'
+
+import type { IntegrationDefinition } from '@/components/interfaces/Integrations/Landing/Integrations.constants'
+import {
+ areRequiredExtensionsInstalledFor,
+ getFilteredNavItems,
+ getInstallActionType,
+} from '@/components/interfaces/Integrations/Landing/useIntegrationDetail.utils'
+
+// Minimal stubs — only fields exercised by the utils
+const oauthIntegration = {
+ id: 'github',
+ type: 'oauth' as const,
+ requiredExtensions: [],
+ navigation: [{ route: 'overview', label: 'Overview' }],
+} as unknown as IntegrationDefinition
+
+const wrapperIntegration = {
+ id: 'stripe_wrapper',
+ type: 'wrapper' as const,
+ requiredExtensions: ['wrappers', 'supabase_vault'],
+ navigation: [
+ { route: 'overview', label: 'Overview' },
+ { route: 'wrappers', label: 'Wrappers' },
+ ],
+} as unknown as IntegrationDefinition
+
+const extensionIntegration = {
+ id: 'queues',
+ type: 'postgres_extension' as const,
+ requiredExtensions: ['pgmq'],
+ navigation: [{ route: 'overview', label: 'Overview' }],
+} as unknown as IntegrationDefinition
+
+// ─── areRequiredExtensionsInstalledFor ───────────────────────────────────────
+
+describe('areRequiredExtensionsInstalledFor', () => {
+ it('returns false when integration is undefined', () => {
+ expect(areRequiredExtensionsInstalledFor(undefined, [])).toBe(false)
+ })
+
+ it('returns false when extensions list is undefined', () => {
+ expect(areRequiredExtensionsInstalledFor(extensionIntegration, undefined)).toBe(false)
+ })
+
+ it('returns false when integration has no required extensions', () => {
+ const noExts = {
+ ...extensionIntegration,
+ requiredExtensions: [],
+ } as unknown as IntegrationDefinition
+ expect(
+ areRequiredExtensionsInstalledFor(noExts, [{ name: 'pgmq', installed_version: '1.0' }])
+ ).toBe(false)
+ })
+
+ it('returns false when a required extension is not installed', () => {
+ expect(
+ areRequiredExtensionsInstalledFor(extensionIntegration, [
+ { name: 'pgmq', installed_version: null },
+ ])
+ ).toBe(false)
+ })
+
+ it('returns false when a required extension is missing from list entirely', () => {
+ expect(areRequiredExtensionsInstalledFor(extensionIntegration, [])).toBe(false)
+ })
+
+ it('returns true when all required extensions are installed', () => {
+ expect(
+ areRequiredExtensionsInstalledFor(extensionIntegration, [
+ { name: 'pgmq', installed_version: '1.4.4' },
+ ])
+ ).toBe(true)
+ })
+
+ it('returns true only when every required extension is installed (multiple)', () => {
+ expect(
+ areRequiredExtensionsInstalledFor(wrapperIntegration, [
+ { name: 'wrappers', installed_version: '0.4.1' },
+ { name: 'supabase_vault', installed_version: '0.2.8' },
+ ])
+ ).toBe(true)
+ })
+
+ it('returns false when only some of multiple required extensions are installed', () => {
+ expect(
+ areRequiredExtensionsInstalledFor(wrapperIntegration, [
+ { name: 'wrappers', installed_version: '0.4.1' },
+ { name: 'supabase_vault', installed_version: null },
+ ])
+ ).toBe(false)
+ })
+})
+
+// ─── getFilteredNavItems ─────────────────────────────────────────────────────
+
+describe('getFilteredNavItems', () => {
+ it('returns empty array when integration is undefined', () => {
+ expect(
+ getFilteredNavItems({
+ integration: undefined,
+ isInstalled: false,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ })
+ ).toEqual([])
+ })
+
+ it('returns empty array when integration has no navigation', () => {
+ const noNav = {
+ ...wrapperIntegration,
+ navigation: undefined,
+ } as unknown as IntegrationDefinition
+ expect(
+ getFilteredNavItems({
+ integration: noNav,
+ isInstalled: false,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ })
+ ).toEqual([])
+ })
+
+ it('returns full navigation for non-wrapper integrations regardless of flags', () => {
+ const result = getFilteredNavItems({
+ integration: extensionIntegration,
+ isInstalled: false,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ })
+ expect(result).toEqual(extensionIntegration.navigation)
+ })
+
+ it('returns full navigation for installed wrapper integrations', () => {
+ const result = getFilteredNavItems({
+ integration: wrapperIntegration,
+ isInstalled: true,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ })
+ expect(result).toEqual(wrapperIntegration.navigation)
+ })
+
+ it('hides wrappers tab for uninstalled wrapper when marketplace is off and extensions missing', () => {
+ const result = getFilteredNavItems({
+ integration: wrapperIntegration,
+ isInstalled: false,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ })
+ expect(result.some((nav) => nav.route === 'wrappers')).toBe(false)
+ expect(result.some((nav) => nav.route === 'overview')).toBe(true)
+ })
+
+ it('shows wrappers tab when marketplace flag is enabled', () => {
+ const result = getFilteredNavItems({
+ integration: wrapperIntegration,
+ isInstalled: false,
+ isMarketplaceEnabled: true,
+ areRequiredExtensionsInstalled: false,
+ })
+ expect(result).toEqual(wrapperIntegration.navigation)
+ })
+
+ it('shows wrappers tab when required extensions are installed', () => {
+ const result = getFilteredNavItems({
+ integration: wrapperIntegration,
+ isInstalled: false,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: true,
+ })
+ expect(result).toEqual(wrapperIntegration.navigation)
+ })
+})
+
+// ─── getInstallActionType ────────────────────────────────────────────────────
+
+describe('getInstallActionType', () => {
+ it('returns null when integration is undefined', () => {
+ expect(
+ getInstallActionType({
+ integration: undefined,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ isInstalled: false,
+ })
+ ).toBeNull()
+ })
+
+ it('returns "oauth" for OAuth integrations', () => {
+ expect(
+ getInstallActionType({
+ integration: oauthIntegration,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ isInstalled: false,
+ })
+ ).toBe('oauth')
+ })
+
+ it('returns "oauth" for installed OAuth integrations (type check takes priority)', () => {
+ expect(
+ getInstallActionType({
+ integration: oauthIntegration,
+ isMarketplaceEnabled: true,
+ areRequiredExtensionsInstalled: true,
+ isInstalled: true,
+ })
+ ).toBe('oauth')
+ })
+
+ it('returns "add-wrapper" for wrapper when marketplace is enabled', () => {
+ expect(
+ getInstallActionType({
+ integration: wrapperIntegration,
+ isMarketplaceEnabled: true,
+ areRequiredExtensionsInstalled: false,
+ isInstalled: false,
+ })
+ ).toBe('add-wrapper')
+ })
+
+ it('returns "add-wrapper" for wrapper when required extensions are installed', () => {
+ expect(
+ getInstallActionType({
+ integration: wrapperIntegration,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: true,
+ isInstalled: false,
+ })
+ ).toBe('add-wrapper')
+ })
+
+ it('returns "installed" for a non-wrapper installed integration when marketplace is off', () => {
+ expect(
+ getInstallActionType({
+ integration: extensionIntegration,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ isInstalled: true,
+ })
+ ).toBe('installed')
+ })
+
+ it('returns "install-sheet" for an uninstalled non-wrapper integration', () => {
+ expect(
+ getInstallActionType({
+ integration: extensionIntegration,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ isInstalled: false,
+ })
+ ).toBe('install-sheet')
+ })
+
+ it('returns "install-sheet" for wrapper when marketplace off and extensions missing and not installed', () => {
+ expect(
+ getInstallActionType({
+ integration: wrapperIntegration,
+ isMarketplaceEnabled: false,
+ areRequiredExtensionsInstalled: false,
+ isInstalled: false,
+ })
+ ).toBe('install-sheet')
+ })
+})