@postgres.ai/shared 4.1.3 → 4.2.0

package/pages/Instance/Configuration/SimpleMode/index.tsx

@@ -0,0 +1,303 @@
+import { useState } from 'react'
+import { observer } from 'mobx-react-lite'
+import { Button, TextField, Typography } from '@material-ui/core'
+import Box from '@mui/material/Box'
+
+import { Spinner } from '@postgres.ai/shared/components/Spinner'
+import { useStores } from '@postgres.ai/shared/pages/Instance/context'
+import { SeImages } from '@postgres.ai/shared/types/api/endpoints/getSeImages'
+import { ProposedConfig } from '@postgres.ai/shared/types/api/endpoints/probeSource'
+
+import {
+  ResolvedImage,
+  providerKeyToImage,
+  resolveDockerImagePath,
+  selectSeImage,
+} from '../configOptions'
+import { FormValues } from '../useForm'
+import { PreviewCard } from './PreviewCard'
+
+type Props = {
+  instanceId: string
+  disabled?: boolean
+  onApplied?: () => void
+  onEdit?: (proposed: ProposedConfig, password: string) => void
+}
+
+// genericFallbackImage resolves the generic CE image for a probed source. Used
+// when no SE image is available (CE, or a managed provider with no SE image for
+// the detected major version).
+const genericFallbackImage = (proposed: ProposedConfig): ResolvedImage => {
+  const mapping = providerKeyToImage(
+    proposed.dockerImage,
+    proposed.pgMajorVersion,
+  )
+  const isGeneric = mapping.imageType === 'Generic Postgres'
+
+  return {
+    dockerPath: resolveDockerImagePath(
+      proposed.dockerImage,
+      proposed.pgMajorVersion,
+      proposed.dockerTag,
+    ),
+    dockerTag: isGeneric ? proposed.dockerTag || mapping.defaultTag || '' : '',
+    sharedPreloadLibraries: proposed.sharedPreloadLibraries,
+    isSe: false,
+  }
+}
+
+// Translates a ProposedConfig from POST /admin/probe-source into the
+// FormValues shape the Expert form uses. Both Apply (→ updateConfig) and
+// Edit (→ formik.setValues) consume it, so the engine receives the same
+// projection regardless of which flow the user picks. The resolved image (SE
+// or generic) is passed in so the preview and the applied config never diverge.
+export const buildProjectionFromProposed = (
+  proposed: ProposedConfig,
+  password: string,
+  resolved?: ResolvedImage,
+): FormValues => {
+  const mapping = providerKeyToImage(
+    proposed.dockerImage,
+    proposed.pgMajorVersion,
+  )
+  const isGeneric = mapping.imageType === 'Generic Postgres'
+  const image = resolved ?? genericFallbackImage(proposed)
+
+  return {
+    debug: false,
+    dockerImage: isGeneric
+      ? String(proposed.pgMajorVersion)
+      : mapping.imageType,
+    dockerImageType: mapping.imageType,
+    dockerPath: image.dockerPath,
+    dockerTag: image.dockerTag,
+    sharedBuffers: proposed.sharedBuffers,
+    sharedPreloadLibraries:
+      image.sharedPreloadLibraries ?? proposed.sharedPreloadLibraries,
+    // tuningParams is typed as string on FormValues but updateConfig.ts
+    // spreads it as a key-value object; cast matches the Expert form's
+    // formatTuningParamsToObj(...) as unknown as string pattern.
+    tuningParams: { ...proposed.queryTuning } as unknown as string,
+    timetable: '0 0 * * *',
+    dbname: proposed.source.dbname,
+    host: proposed.source.host,
+    port: String(proposed.source.port),
+    username: proposed.source.username,
+    password,
+    databases: proposed.databases.join(' '),
+    dumpParallelJobs: '',
+    dumpIgnoreErrors: false,
+    restoreParallelJobs: '',
+    // managed sources reference cloud-only extensions/objects (e.g. supabase_vault)
+    // that are absent from the clone image; best-effort restore skips them.
+    restoreIgnoreErrors: true,
+    restoreConfigs: '',
+    pgDumpCustomOptions: '',
+    // skip ownership and privileges on restore: managed sources (Supabase, RDS)
+    // reference roles that do not exist in the clone, which would abort pg_restore.
+    pgRestoreCustomOptions: '--no-owner --no-privileges --no-tablespaces',
+    retrievalMode: 'logical',
+    physicalTool: '',
+    physicalDockerImage: '',
+    physicalSyncEnabled: false,
+    physicalWalgBackupName: '',
+    physicalPgbackrestStanza: '',
+    physicalPgbackrestDelta: false,
+    physicalEnvs: [],
+  }
+}
+
+// resolveProbeImage selects the platform SE image for a managed provider when
+// the SE catalog is reachable — SE/Enterprise instances expose it (platformUrl
+// set), CE returns undefined. Falls back to the generic image for CE and for
+// managed providers with no SE image at the detected major version.
+export const resolveProbeImage = async (
+  proposed: ProposedConfig,
+  getSeImages: (args: {
+    packageGroup: string
+  }) => Promise<SeImages[] | null | undefined>,
+): Promise<ResolvedImage> => {
+  const mapping = providerKeyToImage(
+    proposed.dockerImage,
+    proposed.pgMajorVersion,
+  )
+
+  if (mapping.imageType !== 'Generic Postgres') {
+    const seImages = await getSeImages({ packageGroup: mapping.imageType })
+    const se = selectSeImage(seImages, proposed.pgMajorVersion)
+
+    if (se) {
+      return {
+        dockerPath: se.location,
+        dockerTag: se.tag,
+        sharedPreloadLibraries: se.pg_config_presets?.shared_preload_libraries,
+        isSe: true,
+      }
+    }
+  }
+
+  return genericFallbackImage(proposed)
+}
+
+export const SimpleMode = observer(
+  ({ instanceId, disabled, onApplied, onEdit }: Props) => {
+    const stores = useStores()
+    const main = stores.main
+
+    const [url, setUrl] = useState('')
+    const [password, setPassword] = useState('')
+    const [probing, setProbing] = useState(false)
+    const [probeError, setProbeError] = useState<string | null>(null)
+    const [proposed, setProposed] = useState<ProposedConfig | null>(null)
+    const [resolved, setResolved] = useState<ResolvedImage | null>(null)
+    const [applying, setApplying] = useState(false)
+    const [applyError, setApplyError] = useState<string | null>(null)
+
+    const onDetect = async () => {
+      setProbing(true)
+      setProbeError(null)
+      setProposed(null)
+      setResolved(null)
+      setApplyError(null)
+
+      const result = await main.probeSource({ url, password })
+
+      if (!result) {
+        setProbing(false)
+        setProbeError('Probe is not available on this instance.')
+        return
+      }
+      if (result.error) {
+        setProbing(false)
+        setProbeError(result.error.message)
+        return
+      }
+      if (result.response) {
+        const image = await resolveProbeImage(result.response, main.getSeImages)
+        setResolved(image)
+        setProposed(result.response)
+      }
+
+      setProbing(false)
+    }
+
+    const onApply = async () => {
+      if (!proposed || !resolved) return
+
+      setApplying(true)
+      setApplyError(null)
+
+      try {
+        const projection = buildProjectionFromProposed(proposed, password, resolved)
+        const response = await main.updateConfig(projection, instanceId)
+
+        if (!response) {
+          setApplyError(
+            main.configError ?? 'Could not apply the proposed configuration.',
+          )
+          return
+        }
+
+        const refresh = await main.fullRefresh(instanceId)
+
+        if (refresh?.error) {
+          setApplyError(
+            `Configuration applied, but starting data retrieval failed: ${refresh.error.message}`,
+          )
+          return
+        }
+
+        onApplied?.()
+      } catch (err) {
+        setApplyError(
+          err instanceof Error
+            ? err.message
+            : 'Could not apply the proposed configuration.',
+        )
+      } finally {
+        setApplying(false)
+      }
+    }
+
+    const handleEdit = () => {
+      if (proposed) onEdit?.(proposed, password)
+    }
+
+    const canDetect =
+      !probing && url.trim().length > 0 && password.length > 0 && !disabled
+
+    return (
+      <Box mt={2} mb={2} data-testid="simple-mode">
+        {!proposed && (
+          <Box>
+            <Typography variant="h6">Simple configuration</Typography>
+            <Typography variant="body2">
+              Paste your source connection string and password. We'll probe
+              the source, propose a configuration, and let you review before
+              starting retrieval.
+            </Typography>
+
+            <Box mt={2}>
+              <TextField
+                label="Connection string"
+                placeholder="postgres://user@host:5432/dbname"
+                value={url}
+                onChange={(e) => setUrl(e.target.value)}
+                fullWidth
+                disabled={probing || disabled}
+                inputProps={{ 'data-testid': 'simple-url' }}
+              />
+            </Box>
+
+            <Box mt={2}>
+              <TextField
+                label="Password"
+                type="password"
+                value={password}
+                onChange={(e) => setPassword(e.target.value)}
+                fullWidth
+                disabled={probing || disabled}
+                inputProps={{ 'data-testid': 'simple-password' }}
+              />
+            </Box>
+
+            <Box mt={2}>
+              <Button
+                variant="contained"
+                color="secondary"
+                onClick={onDetect}
+                disabled={!canDetect}
+                data-testid="simple-detect"
+              >
+                Detect &amp; preview
+                {probing && <Spinner size="sm" />}
+              </Button>
+            </Box>
+
+            {probeError && (
+              <Box
+                mt={1}
+                color="#d32f2f"
+                fontSize={13}
+                data-testid="probe-error"
+              >
+                {probeError}
+              </Box>
+            )}
+          </Box>
+        )}
+
+        {proposed && resolved && (
+          <PreviewCard
+            proposed={proposed}
+            resolved={resolved}
+            applying={applying}
+            applyError={applyError}
+            onApply={onApply}
+            onEdit={handleEdit}
+          />
+        )}
+      </Box>
+    )
+  },
+)

package/pages/Instance/Configuration/configMode.ts

@@ -0,0 +1,12 @@
+export type ConfigMode = 'simple' | 'expert'
+
+// Picks the default Configuration tab when the page first finishes loading
+// the server config. An unconfigured instance lands on Simple; an instance
+// that already has a source host filled in OR a non-logical retrieval mode
+// configured lands on Expert so the user sees the form they previously
+// interacted with. Physical-mode users do not have a host field but still
+// need to land on Expert because Simple-mode targets logical retrieval.
+export const getInitialConfigMode = (
+  host: string | undefined,
+  retrievalMode?: string,
+): ConfigMode => (host || retrievalMode === 'physical' ? 'expert' : 'simple')

package/pages/Instance/Configuration/configOptions.ts

@@ -1,3 +1,114 @@
+import { SeImages } from '@postgres.ai/shared/types/api/endpoints/getSeImages'
+
+import { dockerImagesConfig, genericImagePrefix } from './dockerCatalog'
+
+// Mapping from the engine probe's provider key (probe.Provider) to a
+// dockerImageOptions.type value the form already understands. Keys must
+// match the values defined in engine/internal/retrieval/probe/provider.go
+// (ProviderRDS, ProviderAurora, etc.) — see Task 18 in the plan.
+const providerKeyToImageType: Record<string, string> = {
+  generic: 'Generic Postgres',
+  rds: 'rds',
+  aurora: 'aurora',
+  cloudsql: 'google-cloud-sql',
+  supabase: 'supabase',
+  heroku: 'heroku',
+  timescale: 'timescale-cloud',
+}
+
+export type ProviderImageMapping = {
+  imageType: string
+  defaultTag?: string
+  fallback: boolean
+}
+
+// Reads the most recent tag for a given PG major from the shared catalog.
+// SE images (rds, aurora, etc.) require the platform-only getSeImages call
+// and have no entry here — they return defaultTag: undefined.
+const genericDefaultTag = (pgMajorVersion: number): string | undefined => {
+  if (!pgMajorVersion) return undefined
+  const version = String(pgMajorVersion)
+  const tags = dockerImagesConfig[version]
+  if (!tags || tags.length === 0) return undefined
+  return `${version}-${tags[0]}`
+}
+
+// genericImagePathForVersion returns a pullable generic extended-postgres
+// reference for a PG major version, or '' when the version is unknown. Simple
+// mode uses it as the CE fallback for managed providers, whose SE images are
+// only resolvable through the platform-only getSeImages call.
+export const genericImagePathForVersion = (pgMajorVersion: number): string => {
+  const tag = genericDefaultTag(pgMajorVersion)
+  return tag ? `${genericImagePrefix}:${tag}` : ''
+}
+
+// ResolvedImage is the concrete image Simple mode ships for a probed source:
+// either a platform SE image (carrying its curated preload-library preset) or
+// the generic CE fallback. Apply and the preview both consume it, so they show
+// and post the same thing.
+export type ResolvedImage = {
+  dockerPath: string
+  dockerTag: string
+  sharedPreloadLibraries?: string
+  isSe: boolean
+}
+
+// selectSeImage picks the SE catalog entry matching the detected major version.
+// Returns undefined when the catalog is empty (CE) or has no matching version,
+// which signals the caller to fall back to the generic image.
+export const selectSeImage = (
+  seImages: SeImages[] | null | undefined,
+  pgMajorVersion: number,
+): SeImages | undefined =>
+  seImages?.find((image) => image.pg_major_version === String(pgMajorVersion))
+
+// resolveDockerImagePath returns the concrete image reference Simple mode ships
+// for a probed source. Managed providers fall back to the generic image in CE,
+// so both the Apply payload and the preview show the same value.
+export const resolveDockerImagePath = (
+  providerKey: string,
+  pgMajorVersion: number,
+  dockerTag?: string,
+): string => {
+  const mapping = providerKeyToImage(providerKey, pgMajorVersion)
+  const tag = dockerTag || mapping.defaultTag || ''
+
+  if (mapping.imageType === 'Generic Postgres') {
+    return tag ? `${genericImagePrefix}:${tag}` : ''
+  }
+
+  return genericImagePathForVersion(pgMajorVersion)
+}
+
+// Resolves a probe provider key to a concrete docker image type the
+// Configuration form can write into the projection. Unknown keys (including
+// "azure", which has no matching SE image today) fall back to the generic
+// Postgres image and set fallback=true so the UI can warn.
+export const providerKeyToImage = (
+  providerKey: string,
+  pgMajorVersion: number,
+): ProviderImageMapping => {
+  const known = providerKeyToImageType[providerKey]
+
+  if (!known) {
+    return {
+      imageType: 'Generic Postgres',
+      defaultTag: genericDefaultTag(pgMajorVersion),
+      fallback: true,
+    }
+  }
+
+  if (known === 'Generic Postgres') {
+    return {
+      imageType: 'Generic Postgres',
+      defaultTag: genericDefaultTag(pgMajorVersion),
+      fallback: false,
+    }
+  }
+
+  return { imageType: known, defaultTag: undefined, fallback: false }
+}
+
 export const dockerImageOptions = [
   {
     name: 'Generic PostgreSQL (postgresai/extended-postgres)',

package/pages/Instance/Configuration/connectionString.ts

@@ -0,0 +1,157 @@
+// connectionString.ts — Expert-mode helper that converts between the
+// (host, port, username, dbname) shape stored in `server.yml` and the
+// single URL field the form exposes. The engine remains the source of
+// truth for actual probing (see engine/internal/retrieval/probe/parser.go);
+// this parser only powers the form's load/save round-trip.
+//
+// Accepts both URI form (postgres://user@host:5432/dbname) and DSN form
+// (host=db port=5432 user=app dbname=shop). Rejects any input that carries
+// a password — passwords belong in the masked field, never the URL field.
+
+export type ConnectionFields = {
+  host: string
+  port: string
+  username: string
+  dbname: string
+}
+
+export type ParseResult = {
+  fields: ConnectionFields
+  portWasExplicit: boolean
+}
+
+export class ConnectionStringError extends Error {}
+
+export const ErrPasswordInConnectionString = 'Password must be entered in the Password field, not the connection string.'
+export const ErrMultiHost = 'Multi-host connection strings are not supported.'
+export const ErrInvalidConnectionString = 'Could not parse the connection string.'
+
+const URI_SCHEMES = ['postgres:', 'postgresql:']
+
+const isUri = (s: string) => URI_SCHEMES.some((p) => s.toLowerCase().startsWith(p))
+
+const stripBrackets = (h: string) => (h.startsWith('[') && h.endsWith(']') ? h.slice(1, -1) : h)
+
+const parseUri = (s: string): ParseResult => {
+  let url: URL
+  try {
+    url = new URL(s)
+  } catch {
+    throw new ConnectionStringError(ErrInvalidConnectionString)
+  }
+
+  if (url.password) throw new ConnectionStringError(ErrPasswordInConnectionString)
+
+  if (!url.hostname) throw new ConnectionStringError(ErrInvalidConnectionString)
+  if (url.hostname.includes(',')) throw new ConnectionStringError(ErrMultiHost)
+
+  const portWasExplicit = url.port !== ''
+  const path = url.pathname.startsWith('/') ? url.pathname.slice(1) : url.pathname
+  const dbname = path.includes(',') ? '' : decodeURIComponent(path)
+
+  return {
+    fields: {
+      host: stripBrackets(url.hostname),
+      port: portWasExplicit ? url.port : '5432',
+      username: url.username ? decodeURIComponent(url.username) : '',
+      dbname,
+    },
+    portWasExplicit,
+  }
+}
+
+// Tokenizer for libpq DSN form: key=value pairs, values may be single-quoted
+// when they contain spaces (libpq spec). Throws on malformed input.
+const tokenizeDsn = (s: string): Record<string, string> => {
+  const out: Record<string, string> = {}
+  let i = 0
+
+  while (i < s.length) {
+    // skip leading whitespace
+    while (i < s.length && /\s/.test(s[i])) i++
+    if (i >= s.length) break
+
+    // read key
+    const keyStart = i
+    while (i < s.length && s[i] !== '=' && !/\s/.test(s[i])) i++
+    if (i >= s.length || s[i] !== '=') throw new ConnectionStringError(ErrInvalidConnectionString)
+    const key = s.slice(keyStart, i)
+    i++ // skip '='
+
+    // read value (possibly quoted)
+    let value = ''
+    if (s[i] === "'") {
+      i++
+      while (i < s.length && s[i] !== "'") {
+        if (s[i] === '\\' && i + 1 < s.length) {
+          value += s[i + 1]
+          i += 2
+          continue
+        }
+        value += s[i]
+        i++
+      }
+      if (i >= s.length) throw new ConnectionStringError(ErrInvalidConnectionString)
+      i++ // skip closing quote
+    } else {
+      while (i < s.length && !/\s/.test(s[i])) {
+        value += s[i]
+        i++
+      }
+    }
+
+    out[key.toLowerCase()] = value
+  }
+
+  return out
+}
+
+const parseDsn = (s: string): ParseResult => {
+  const tokens = tokenizeDsn(s)
+  if (tokens.password) throw new ConnectionStringError(ErrPasswordInConnectionString)
+
+  const host = tokens.host ?? tokens.hostaddr ?? ''
+  if (host.includes(',')) throw new ConnectionStringError(ErrMultiHost)
+
+  const portRaw = tokens.port ?? ''
+  const portWasExplicit = portRaw !== ''
+
+  return {
+    fields: {
+      host,
+      port: portWasExplicit ? portRaw : '5432',
+      username: tokens.user ?? tokens.username ?? '',
+      dbname: tokens.dbname ?? tokens.database ?? '',
+    },
+    portWasExplicit,
+  }
+}
+
+export const connectionStringToFields = (s: string): ParseResult => {
+  const trimmed = s.trim()
+  if (!trimmed) throw new ConnectionStringError(ErrInvalidConnectionString)
+
+  if (isUri(trimmed)) return parseUri(trimmed)
+  if (trimmed.includes('=')) return parseDsn(trimmed)
+  throw new ConnectionStringError(ErrInvalidConnectionString)
+}
+
+// formatHost wraps IPv6 literals in brackets so the resulting URI parses cleanly.
+const formatHost = (host: string) => (host.includes(':') ? `[${host}]` : host)
+
+export type SerializeOptions = {
+  // When true, omit `:5432` from the URI even if `fields.port === '5432'`.
+  // Used to preserve configs that originally had no `port:` key.
+  omitDefaultPort?: boolean
+}
+
+export const connectionStringFromFields = (
+  fields: ConnectionFields,
+  opts: SerializeOptions = {},
+): string => {
+  const userPart = fields.username ? `${encodeURIComponent(fields.username)}@` : ''
+  const showPort = fields.port && !(opts.omitDefaultPort && fields.port === '5432')
+  const portPart = showPort ? `:${fields.port}` : ''
+  const dbPart = fields.dbname ? `/${encodeURIComponent(fields.dbname)}` : ''
+  return `postgres://${userPart}${formatHost(fields.host)}${portPart}${dbPart}`
+}

package/pages/Instance/Configuration/dockerCatalog.ts

@@ -0,0 +1,21 @@
+// Shared image-catalog constants. Kept in its own module so both
+// `configOptions.ts` and `utils/index.ts` can read them without creating
+// an import cycle (utils → configOptions today).
+
+export const genericImagePrefix = 'postgresai/extended-postgres'
+
+// Predefined Docker image catalog for the Generic Postgres image. If a
+// user's config references a tag not listed here, createEnhancedDockerImages
+// in utils/index.ts appends it at runtime.
+export const dockerImagesConfig: Record<string, string[]> = {
+  '9.6': ['0.5.3', '0.5.2', '0.5.1'],
+  '10': ['0.5.3', '0.5.2', '0.5.1'],
+  '11': ['0.5.3', '0.5.2', '0.5.1'],
+  '12': ['0.5.3', '0.5.2', '0.5.1'],
+  '13': ['0.5.3', '0.5.2', '0.5.1'],
+  '14': ['0.5.3', '0.5.2', '0.5.1'],
+  '15': ['0.5.3', '0.5.2', '0.5.1'],
+  '16': ['0.5.3', '0.5.2', '0.5.1'],
+  '17': ['0.5.3', '0.5.2', '0.5.1'],
+  '18': ['0.6.1'],
+}