fix(stuff): bucket provisioning and more

Author: CodeMeAPixel

app/(main)/pricing/page.tsx

@@ -140,14 +140,16 @@ export default async function PricingPage() {
 
   // Only expose regions where an admin has provisioned an active storage pool.
   // This prevents selling a bucket in a region we can't actually deliver.
-  const activeVultrInstances = await prisma.objectStoragePool.findMany({
+  // Covers all providers: Vultr, Linode, OVHcloud.
+  const activeStoragePools = await prisma.objectStoragePool.findMany({
     where: { status: 'active' },
     select: { region: true, s3Hostname: true, tier: true },
     orderBy: { region: 'asc' },
   })
 
-  // Build per-tier region availability. `tier` stores the provider's sales name
-  // (e.g. "Standard", "Archival"). Match case-insensitively against our slug keywords.
+  // Build per-tier region availability. `tier` stores the normalised slug set
+  // at provision time (e.g. "standard", "premium", "high_performance").
+  // Tier keyword matching is substring-based so "high_performance" → "performance".
   const tierKeywords = [
     'archival',
     'standard',
@@ -156,19 +158,19 @@ export default async function PricingPage() {
     'accelerated',
   ] as const
   const tierRegions: Record<string, string[]> = {}
-  const hasTierInfo = activeVultrInstances.some(
+  const hasTierInfo = activeStoragePools.some(
     (v) => v.tier && v.tier !== 'standard'
   )
 
   for (const kw of tierKeywords) {
     const slug = `storage-bucket-${kw}`
     if (hasTierInfo) {
-      tierRegions[slug] = activeVultrInstances
+      tierRegions[slug] = activeStoragePools
         .filter((v) => v.tier?.toLowerCase().includes(kw))
         .map((v) => v.region)
     } else {
-      // Legacy: all instances provisioned before tier tracking — offer all regions for all tiers
-      tierRegions[slug] = activeVultrInstances.map((v) => v.region)
+      // Legacy: all pools provisioned before tier tracking — offer all regions for all tiers
+      tierRegions[slug] = activeStoragePools.map((v) => v.region)
     }
   }
 

app/api/admin/integrations/test/route.ts

@@ -1,3 +1,5 @@
+import { createHash } from 'crypto'
+
 import { HTTP_STATUS, apiError, apiResponse } from '@/packages/lib/api/response'
 import { requireAdmin } from '@/packages/lib/auth/api-auth'
 import { loggers } from '@/packages/lib/logger'
@@ -13,6 +15,8 @@ type IntegrationKey =
   | 'github'
   | 'smtp'
   | 'vultr'
+  | 'linode'
+  | 'ovhcloud'
 
 interface TestIntegrationBody {
   integration: IntegrationKey
@@ -328,6 +332,90 @@ async function testVultr(apiKey: string): Promise<TestResult> {
   }
 }
 
+async function testLinode(apiKey: string): Promise<TestResult> {
+  if (!apiKey) return { ok: false, message: 'API key is not configured' }
+  try {
+    const res = await fetch(
+      'https://api.linode.com/v4/object-storage/clusters',
+      {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(8000),
+      }
+    )
+    if (res.status === 401 || res.status === 400)
+      return { ok: false, message: 'Invalid API key' }
+    if (!res.ok)
+      return { ok: false, message: `Linode API error (${res.status})` }
+    const json = await res.json().catch(() => null)
+    const count = json?.data?.length ?? 0
+    return {
+      ok: true,
+      message: `Connected to Linode — ${count} cluster${count !== 1 ? 's' : ''} available`,
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      message: 'Failed to reach Linode API',
+      detail: String(err),
+    }
+  }
+}
+
+const OVH_ENDPOINTS: Record<string, string> = {
+  'ovh-eu': 'https://eu.api.ovh.com/v2',
+  'ovh-us': 'https://api.us.ovhcloud.com/v2',
+  'ovh-ca': 'https://ca.api.ovh.com/v2',
+}
+
+async function testOVHCloud(
+  appKey: string,
+  appSecret: string,
+  consumerKey: string,
+  endpoint: string
+): Promise<TestResult> {
+  if (!appKey || !appSecret || !consumerKey)
+    return { ok: false, message: 'All four OVH credentials are required' }
+  const baseUrl = OVH_ENDPOINTS[endpoint] ?? OVH_ENDPOINTS['ovh-eu']
+  try {
+    const url = `${baseUrl}/cloud/project`
+    const timestamp = Math.round(Date.now() / 1000)
+    const toSign = [
+      appSecret,
+      consumerKey,
+      'GET',
+      url,
+      '',
+      String(timestamp),
+    ].join('+')
+    const signature = '$1$' + createHash('sha1').update(toSign).digest('hex')
+    const res = await fetch(url, {
+      headers: {
+        'X-Ovh-Application': appKey,
+        'X-Ovh-Consumer': consumerKey,
+        'X-Ovh-Timestamp': String(timestamp),
+        'X-Ovh-Signature': signature,
+      },
+      signal: AbortSignal.timeout(8000),
+    })
+    if (res.status === 401 || res.status === 403)
+      return { ok: false, message: 'Invalid OVHcloud credentials' }
+    if (!res.ok)
+      return { ok: false, message: `OVHcloud API error (${res.status})` }
+    const json = await res.json().catch(() => null)
+    const count = Array.isArray(json) ? json.length : 0
+    return {
+      ok: true,
+      message: `Connected to OVHcloud — ${count} project${count !== 1 ? 's' : ''} accessible`,
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      message: 'Failed to reach OVHcloud API',
+      detail: String(err),
+    }
+  }
+}
+
 async function testSmtp(
   host: string,
   port: number,
@@ -402,6 +490,17 @@ export async function POST(req: Request) {
       case 'vultr':
         result = await testVultr(credentials.apiKey)
         break
+      case 'linode':
+        result = await testLinode(credentials.apiKey)
+        break
+      case 'ovhcloud':
+        result = await testOVHCloud(
+          credentials.appKey,
+          credentials.appSecret,
+          credentials.consumerKey,
+          credentials.endpoint ?? 'ovh-eu'
+        )
+        break
       default:
         return apiError('Unknown integration', HTTP_STATUS.BAD_REQUEST)
     }

app/api/admin/storage/linode/[id]/route.ts

@@ -173,7 +173,7 @@ export async function POST(req: Request, { params }: Params) {
     const newKey = await createLinodeKeys(
       newKeyLabel,
       undefined,
-      meta?.linodeClusterId ? [{ id: meta.linodeClusterId }] : undefined
+      meta?.linodeClusterId ? [meta.linodeClusterId] : undefined
     )
     logger.info(
       `[Admin] Created new Linode key ${newKey.id} for pool ${pool.id}`

app/api/admin/storage/linode/route.ts

@@ -106,17 +106,15 @@ export async function POST(req: Request) {
       )
     }
 
-    // Create an unrestricted access key for this cluster
+    // Create an unrestricted access key scoped to this cluster's region
     const keyLabel = `emberly-${clusterId}-${Date.now()}`
-    const linodeKey = await createLinodeKeys(keyLabel, undefined, [
-      { id: cluster.region },
-    ])
+    const linodeKey = await createLinodeKeys(keyLabel, undefined, [clusterId])
     logger.info(
       `[Admin] Created Linode access key ${linodeKey.id} for cluster ${clusterId}`
     )
 
     // Determine the S3 endpoint from the key's region list
-    const regionEntry = linodeKey.regions?.find((r) => r.id === cluster.region)
+    const regionEntry = linodeKey.regions?.find((r) => r.id === clusterId)
     const s3Hostname =
       regionEntry?.s3_endpoint ?? `${clusterId}.linodeobjects.com`