Skip to content

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

8.6 KB
Raw Blame
import { describe, expect, it } from 'vitest'

import { SUPABASE_TARGET_SCHEMA_OPTION, WRAPPER_HANDLERS } from './Wrappers.constants'
import { Table } from './Wrappers.types'
import {
  getEditionFormSchema,
  getRequiredExtensionsToInstall,
  getTableFormSchema,
  getWrapperCreationFormSchema,
  hasForeignSchemaSupport,
} from './Wrappers.utils'

const stripe_wrapper = {
  name: 'stripe_wrapper',
  handlerName: WRAPPER_HANDLERS.STRIPE,
  validatorName: 'stripe_fdw_validator',
  icon: '',
  description: 'Payment processing and subscription management',
  extensionName: 'StripeFdw',
  label: 'Stripe',
  docsUrl: '',
  server: {
    options: [
      {
        name: 'api_key_id',
        label: 'Stripe Secret Key',
        required: true,
        encrypted: true,
        secureEntry: true,
        urlHelper: 'https://stripe.com/docs/keys',
      },
      {
        name: 'api_url',
        label: 'Stripe API URL',
        defaultValue: 'https://api.stripe.com/v1',
        required: false,
        encrypted: false,
        secureEntry: false,
      },
      SUPABASE_TARGET_SCHEMA_OPTION,
    ],
  },
  tables: [],
}

describe('getWrapperCreationFormSchema', () => {
  it('should build a schema that validates tables mode and wrapper specific options', () => {
    const schema = getWrapperCreationFormSchema(stripe_wrapper)
    const result = schema.safeParse({ mode: 'tables' })

    expect(result.success).toEqual(false)
    // Common required field
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'server_name'))
    ).toBeDefined()
    // Table mode specific field
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'tables'))
    ).toBeDefined()
    // Required wrapper option
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'api_key_id'))
    ).toBeDefined()
    // Optional wrapper option
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'api_url'))
    ).toBeUndefined()
  })

  it('should build a schema that validates schema mode', () => {
    const schema = getWrapperCreationFormSchema(stripe_wrapper)
    const result = schema.safeParse({ mode: 'schema' })

    expect(result.success).toEqual(false)
    // Common required field
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'server_name'))
    ).toBeDefined()
    // Schema mode specific field
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'source_schema'))
    ).toBeDefined()
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'target_schema'))
    ).toBeDefined()
  })
})

describe('getEditionFormSchema', () => {
  it('should build a schema that validates wrapper specific options', () => {
    const schema = getEditionFormSchema(stripe_wrapper)
    const result = schema.safeParse({ mode: 'tables' })
    expect(result.success).toEqual(false)
    // Common required field
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'server_name'))
    ).toBeDefined()
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'tables'))
    ).toBeDefined()
    // Required option
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'api_key_id'))
    ).toBeDefined()
    // Optional option
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'api_url'))
    ).toBeUndefined()
  })
})

describe('getTableFormSchema', () => {
  const table_schema = {
    label: 'Accounts',
    description: 'List of accounts on your Stripe account',
    availableColumns: [
      {
        name: 'id',
        type: 'text',
      },
      {
        name: 'business_type',
        type: 'text',
      },
      {
        name: 'country',
        type: 'text',
      },
      {
        name: 'email',
        type: 'text',
      },
      {
        name: 'type',
        type: 'text',
      },
      {
        name: 'created',
        type: 'timestamp',
      },
      {
        name: 'attrs',
        type: 'jsonb',
      },
    ],
    options: [
      {
        name: 'object',
        defaultValue: 'accounts',
        editable: false,
        required: true,
        type: 'text',
      },
      {
        name: 'rowid_column',
        label: 'Row ID Column',
        defaultValue: 'id',
        editable: true,
        required: false,
        type: 'text',
      },
    ],
  } satisfies Table

  it('should build a schema that validates tables with existing schema', () => {
    const schema = getTableFormSchema(table_schema)
    const result = schema.safeParse({})
    expect(result.success).toEqual(false)
    // Common required field
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'table_name'))
    ).toBeDefined()
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'schema'))
    ).toBeDefined()
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'columns'))
    ).toBeDefined()
    // Required options
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'object'))
    ).toBeDefined()
    // Optional options
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'rowid_column'))
    ).toBeUndefined()
  })

  it('should build a schema that validates tables with custom schema', () => {
    const schema = getTableFormSchema(table_schema)
    // Because the schema_name is validated in zod superRefine, the normal validation
    // must have succeeded first
    const result = schema.safeParse({
      table_name: 'test',
      schema: 'custom',
      columns: [],
      object: 'acounts',
    })

    expect(result.success).toEqual(false)
    expect(
      result.error?.issues.find((issue) => issue.path.some((p) => p === 'schema_name'))
    ).toBeDefined()
  })
})

// ─── getRequiredExtensionsToInstall ──────────────────────────────────────────

describe('getRequiredExtensionsToInstall', () => {
  type Extension = { name: string; installed_version: string | null }
  const wrappers: Extension = { 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.each<{ case: string; extensions: Extension[]; required: string[] }>([
    { case: 'the required list is empty', extensions: [wrappers], required: [] },
    {
      case: 'all required extensions are already installed',
      extensions: [wrappersInstalled, vaultInstalled],
      required: ['wrappers', 'supabase_vault'],
    },
    { case: 'the extensions list is empty', extensions: [], required: ['wrappers'] },
  ])('returns an empty array when $case', ({ extensions, required }) => {
    expect(getRequiredExtensionsToInstall(extensions, required)).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')
  })
})

// ─── hasForeignSchemaSupport ──────────────────────────────────────────────────

describe('hasForeignSchemaSupport', () => {
  it('returns false when extension is undefined', () => {
    expect(hasForeignSchemaSupport(undefined)).toBe(false)
  })

  it.each([
    [null, false],
    ['0.1.0', false],
    ['0.4.9', false],
    ['0.5.0', true],
    ['0.5.1', true],
    ['1.0.0', true],
  ])('installed_version %s returns %s', (installed_version, expected) => {
    expect(hasForeignSchemaSupport({ installed_version })).toBe(expected)
  })
})