initial commit

lib/vultr-api.ts

@@ -0,0 +1,231 @@
+'use client';
+
+// Types for Vultr API responses
+export interface VultrDomain {
+  domain: string;
+  date_created: string;
+}
+
+export interface VultrDNSRecord {
+  id: string;
+  type: string;
+  name: string;
+  data: string;
+  priority?: number;
+  ttl: number;
+}
+
+// Class to interact with Vultr API through our server-side proxy
+export class VultrAPI {
+  private apiKey: string | null = null;
+
+  constructor() {
+    // Check if we're in a browser environment
+    if (typeof window !== 'undefined') {
+      // Try to get API key from cookie
+      this.apiKey = this.getCookie('vultr_api_key');
+    }
+  }
+
+  // Helper to get cookie value
+  private getCookie(name: string): string | null {
+    if (typeof document === 'undefined') return null;
+    
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) return parts.pop()?.split(';').shift() || null;
+    return null;
+  }
+
+  // Set API key and store in cookie
+  async setApiKey(apiKey: string): Promise<void> {
+    try {
+      // Validate API key by making a test request to our server proxy
+      const response = await fetch('/api/vultr', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ apiKey }),
+      });
+
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || 'Invalid API key');
+      }
+
+      this.apiKey = apiKey;
+      return;
+    } catch (error) {
+      console.error('Error setting API key:', error);
+      throw error;
+    }
+  }
+
+  // Clear API key and cookie
+  async logout(): Promise<void> {
+    try {
+      await fetch('/api/vultr', {
+        method: 'DELETE',
+      });
+      
+      this.apiKey = null;
+      return;
+    } catch (error) {
+      console.error('Error logging out:', error);
+      throw error;
+    }
+  }
+
+  // Check if API key is set
+  isAuthenticated(): boolean {
+    return !!this.apiKey;
+  }
+
+  // Get all domains
+  async getDomains(): Promise<VultrDomain[]> {
+    try {
+      const response = await fetch('/api/vultr/domains');
+      
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || 'Failed to fetch domains');
+      }
+      
+      const data = await response.json();
+      return data.domains;
+    } catch (error) {
+      console.error('Error fetching domains:', error);
+      throw error;
+    }
+  }
+
+  // Create a new domain
+  async createDomain(domain: string, serverIp: string): Promise<VultrDomain> {
+    try {
+      const response = await fetch('/api/vultr/domains', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          domain,
+          serverip: serverIp,
+        }),
+      });
+      
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || 'Failed to create domain');
+      }
+      
+      const data = await response.json();
+      return data.domain;
+    } catch (error) {
+      console.error('Error creating domain:', error);
+      throw error;
+    }
+  }
+
+  // Get DNS records for a domain
+  async getDNSRecords(domain: string): Promise<VultrDNSRecord[]> {
+    try {
+      const response = await fetch(`/api/vultr/domains/${domain}/records`);
+      
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || `Failed to fetch DNS records for ${domain}`);
+      }
+      
+      const data = await response.json();
+      return data.records;
+    } catch (error) {
+      console.error(`Error fetching DNS records for ${domain}:`, error);
+      throw error;
+    }
+  }
+
+  // Create a new DNS record
+  async createDNSRecord(
+    domain: string, 
+    record: Omit<VultrDNSRecord, 'id'>
+  ): Promise<VultrDNSRecord> {
+    try {
+      const response = await fetch(`/api/vultr/domains/${domain}/records`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(record),
+      });
+      
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || `Failed to create DNS record for ${domain}`);
+      }
+      
+      const data = await response.json();
+      return data.record;
+    } catch (error) {
+      console.error(`Error creating DNS record for ${domain}:`, error);
+      throw error;
+    }
+  }
+
+  // Update an existing DNS record
+  async updateDNSRecord(
+    domain: string,
+    recordId: string,
+    record: Omit<VultrDNSRecord, 'id'>
+  ): Promise<VultrDNSRecord> {
+    try {
+      const response = await fetch(`/api/vultr/domains/${domain}/records/${recordId}`, {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(record),
+      });
+      
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || `Failed to update DNS record ${recordId}`);
+      }
+      
+      const data = await response.json();
+      return data.record;
+    } catch (error) {
+      console.error(`Error updating DNS record ${recordId}:`, error);
+      throw error;
+    }
+  }
+
+  // Delete a DNS record
+  async deleteDNSRecord(domain: string, recordId: string): Promise<void> {
+    try {
+      const response = await fetch(`/api/vultr/domains/${domain}/records/${recordId}`, {
+        method: 'DELETE',
+      });
+      
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || `Failed to delete DNS record ${recordId}`);
+      }
+      
+      return;
+    } catch (error) {
+      console.error(`Error deleting DNS record ${recordId}:`, error);
+      throw error;
+    }
+  }
+}
+
+// Singleton instance
+let vultrApiInstance: VultrAPI | null = null;
+
+export function getVultrApi(): VultrAPI {
+  if (!vultrApiInstance) {
+    vultrApiInstance = new VultrAPI();
+  }
+  return vultrApiInstance;
+}