update

internal/api/handlers.go

···
 		"discovered_at": ep.DiscoveredAt,
 		"last_checked":  ep.LastChecked,
 		"status":        statusToString(ep.Status),
-		"user_count":    ep.UserCount,
+		// REMOVED: "user_count": ep.UserCount,  // No longer exists
 	}
 
 	// Add IP if available
···
 		response["ip"] = ep.IP
 	}
 
-	// Extract specific fields from ip_info
-	if ep.IPInfo != nil {
-		// Extract location info
-		if location, ok := ep.IPInfo["location"].(map[string]interface{}); ok {
-			if city, ok := location["city"].(string); ok {
-				response["city"] = city
-			}
-			if countryCode, ok := location["country_code"].(string); ok {
-				response["country_code"] = countryCode
-			}
-			if country, ok := location["country"].(string); ok {
-				response["country"] = country
-			}
-		}
-
-		// Extract ASN info
-		if asn, ok := ep.IPInfo["asn"].(map[string]interface{}); ok {
-			if asnNumber, ok := asn["asn"].(float64); ok {
-				response["asn"] = int(asnNumber)
-			}
-		}
-
-		// Optionally include full ip_info for detailed view
-		// response["ip_info"] = ep.IPInfo
-	}
+	// REMOVED: IP info extraction - no longer in Endpoint struct
+	// IPInfo is now in separate table, joined only in PDS handlers
 
 	return response
 }
···
 		Type:         r.URL.Query().Get("type"),
 		Status:       r.URL.Query().Get("status"),
 		MinUserCount: getQueryInt64(r, "min_user_count", 0),
-		Limit:        getQueryInt(r, "limit", 0),
+		Limit:        getQueryInt(r, "limit", 50),
 		Offset:       getQueryInt(r, "offset", 0),
 	}
 
···
 	resp.json(response)
 }
 
-func (s *Server) handleGetEndpoint(w http.ResponseWriter, r *http.Request) {
+func (s *Server) handleGetEndpointStats(w http.ResponseWriter, r *http.Request) {
+	resp := newResponse(w)
+	stats, err := s.db.GetEndpointStats(r.Context())
+	if err != nil {
+		resp.error(err.Error(), http.StatusInternalServerError)
+		return
+	}
+	resp.json(stats)
+}
+
+// ===== PDS HANDLERS =====
+
+func (s *Server) handleGetPDSList(w http.ResponseWriter, r *http.Request) {
+	resp := newResponse(w)
+
+	filter := &storage.EndpointFilter{
+		Type:         "pds",
+		Status:       r.URL.Query().Get("status"),
+		MinUserCount: getQueryInt64(r, "min_user_count", 0),
+		Limit:        getQueryInt(r, "limit", 50),
+		Offset:       getQueryInt(r, "offset", 0),
+	}
+
+	pdsServers, err := s.db.GetPDSList(r.Context(), filter)
+	if err != nil {
+		resp.error(err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	response := make([]map[string]interface{}, len(pdsServers))
+	for i, pds := range pdsServers {
+		response[i] = formatPDSListItem(pds)
+	}
+
+	resp.json(response)
+}
+
+func (s *Server) handleGetPDSDetail(w http.ResponseWriter, r *http.Request) {
 	resp := newResponse(w)
 	vars := mux.Vars(r)
-	endpoint := vars["endpoint"]
-	endpointType := r.URL.Query().Get("type")
-	if endpointType == "" {
-		endpointType = "pds"
-	}
+	endpoint := "https://" + normalizeEndpoint(vars["endpoint"])
 
-	endpoint = "https://" + normalizeEndpoint(endpoint)
-	ep, err := s.db.GetEndpoint(r.Context(), endpoint, endpointType)
+	// FIX: Use r.Context() instead of ctx
+	pds, err := s.db.GetPDSDetail(r.Context(), endpoint)
 	if err != nil {
-		resp.error("Endpoint not found", http.StatusNotFound)
+		resp.error("PDS not found", http.StatusNotFound)
 		return
 	}
 
-	scans, _ := s.db.GetEndpointScans(r.Context(), ep.ID, 10)
+	// Get recent scans
+	scans, _ := s.db.GetEndpointScans(r.Context(), pds.ID, 10)
 
-	result := formatEndpointResponse(ep)
-	result["recent_scans"] = scans
+	result := formatPDSDetail(pds)
+	result["recent_scans"] = formatScans(scans)
 
-	result["ipinfo"] = ep.IPInfo
 	resp.json(result)
 }
 
-func (s *Server) handleGetEndpointStats(w http.ResponseWriter, r *http.Request) {
+func (s *Server) handleGetPDSStats(w http.ResponseWriter, r *http.Request) {
 	resp := newResponse(w)
-	stats, err := s.db.GetEndpointStats(r.Context())
+	ctx := r.Context()
+
+	// Get PDS-specific stats
+	stats, err := s.db.GetPDSStats(ctx)
 	if err != nil {
 		resp.error(err.Error(), http.StatusInternalServerError)
 		return
 	}
+
 	resp.json(stats)
+}
+
+func formatPDSListItem(pds *storage.PDSListItem) map[string]interface{} {
+	response := map[string]interface{}{
+		"id":            pds.ID,
+		"endpoint":      pds.Endpoint,
+		"discovered_at": pds.DiscoveredAt,
+		"status":        statusToString(pds.Status),
+	}
+
+	// Add last_checked if available
+	if !pds.LastChecked.IsZero() {
+		response["last_checked"] = pds.LastChecked
+	}
+
+	// Add data from latest scan (if available)
+	if pds.LatestScan != nil {
+		response["user_count"] = pds.LatestScan.UserCount
+		response["response_time"] = pds.LatestScan.ResponseTime
+		if !pds.LatestScan.ScannedAt.IsZero() {
+			response["last_scan"] = pds.LatestScan.ScannedAt
+		}
+	}
+
+	// Add IP if available
+	if pds.IP != "" {
+		response["ip"] = pds.IP
+	}
+
+	// Add IP info (from ip_infos table via JOIN)
+	if pds.IPInfo != nil {
+		if pds.IPInfo.City != "" {
+			response["city"] = pds.IPInfo.City
+		}
+		if pds.IPInfo.Country != "" {
+			response["country"] = pds.IPInfo.Country
+		}
+		if pds.IPInfo.CountryCode != "" {
+			response["country_code"] = pds.IPInfo.CountryCode
+		}
+		if pds.IPInfo.ASN > 0 {
+			response["asn"] = pds.IPInfo.ASN
+		}
+	}
+
+	return response
+}
+
+func formatPDSDetail(pds *storage.PDSDetail) map[string]interface{} {
+	// Start with list item formatting
+	response := formatPDSListItem(&pds.PDSListItem)
+
+	// Add server_info from latest scan
+	if pds.LatestScan != nil && pds.LatestScan.ServerInfo != nil {
+		response["server_info"] = pds.LatestScan.ServerInfo
+	}
+
+	// Add full IP info
+	if pds.IPInfo != nil {
+		ipInfoMap := make(map[string]interface{})
+
+		if pds.IP != "" {
+			ipInfoMap["ip"] = pds.IP
+		}
+		if pds.IPInfo.City != "" {
+			ipInfoMap["city"] = pds.IPInfo.City
+		}
+		if pds.IPInfo.Country != "" {
+			ipInfoMap["country"] = pds.IPInfo.Country
+		}
+		if pds.IPInfo.CountryCode != "" {
+			ipInfoMap["country_code"] = pds.IPInfo.CountryCode
+		}
+		if pds.IPInfo.ASN > 0 {
+			ipInfoMap["asn"] = pds.IPInfo.ASN
+		}
+		if pds.IPInfo.ASNOrg != "" {
+			ipInfoMap["asn_org"] = pds.IPInfo.ASNOrg
+		}
+		ipInfoMap["is_datacenter"] = pds.IPInfo.IsDatacenter
+		ipInfoMap["is_vpn"] = pds.IPInfo.IsVPN
+
+		if pds.IPInfo.Latitude != 0 || pds.IPInfo.Longitude != 0 {
+			ipInfoMap["latitude"] = pds.IPInfo.Latitude
+			ipInfoMap["longitude"] = pds.IPInfo.Longitude
+		}
+
+		if len(ipInfoMap) > 0 {
+			response["ip_info"] = ipInfoMap
+		}
+	}
+
+	return response
+}
+
+func formatScans(scans []*storage.EndpointScan) []map[string]interface{} {
+	result := make([]map[string]interface{}, len(scans))
+	for i, scan := range scans {
+		scanMap := map[string]interface{}{
+			"id":         scan.ID,
+			"status":     statusToString(scan.Status),
+			"scanned_at": scan.ScannedAt,
+		}
+
+		if scan.ResponseTime > 0 {
+			scanMap["response_time"] = scan.ResponseTime
+		}
+
+		if scan.ScanData != nil {
+			// Metadata is already map[string]interface{}, no type assertion needed
+			if scan.ScanData.Metadata != nil {
+				// Extract user_count from metadata
+				if userCount, ok := scan.ScanData.Metadata["user_count"].(int); ok {
+					scanMap["user_count"] = userCount
+				} else if userCount, ok := scan.ScanData.Metadata["user_count"].(float64); ok {
+					scanMap["user_count"] = int(userCount)
+				}
+			}
+
+			// Include DID count if available
+			if scan.ScanData.DIDCount > 0 {
+				scanMap["did_count"] = scan.ScanData.DIDCount
+			}
+		}
+
+		result[i] = scanMap
+	}
+	return result
 }
 
 // ===== DID HANDLERS =====

internal/api/server.go

···
 func (s *Server) setupRoutes() {
 	api := s.router.PathPrefix("/api/v1").Subrouter()
 
-	// Endpoint routes (replaces PDS routes)
+	// Generic endpoints (keep as-is)
 	api.HandleFunc("/endpoints", s.handleGetEndpoints).Methods("GET")
 	api.HandleFunc("/endpoints/stats", s.handleGetEndpointStats).Methods("GET")
-	api.HandleFunc("/endpoints/{endpoint}", s.handleGetEndpoint).Methods("GET")
+
+	// NEW: PDS-specific endpoints (virtual, created via JOINs)
+	api.HandleFunc("/pds", s.handleGetPDSList).Methods("GET")
+	api.HandleFunc("/pds/{endpoint}", s.handleGetPDSDetail).Methods("GET")
+	api.HandleFunc("/pds/stats", s.handleGetPDSStats).Methods("GET")
 
 	// PLC Bundle routes
 	api.HandleFunc("/plc/bundles", s.handleGetPLCBundles).Methods("GET")

internal/pds/scanner.go

···
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"time"
 
···
 
 	// Worker pool
 	jobs := make(chan *storage.Endpoint, len(servers))
-	results := make(chan *PDSStatus, len(servers))
+	var wg sync.WaitGroup
 
-	var wg sync.WaitGroup
 	for i := 0; i < s.config.Workers; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			s.worker(ctx, jobs, results)
+			s.worker(ctx, jobs)
 		}()
 	}
 
-	go func() {
-		for _, server := range servers {
-			jobs <- server
-		}
-		close(jobs)
-	}()
-
-	go func() {
-		wg.Wait()
-		close(results)
-	}()
-
-	// Process results
-	successCount := 0
-	failureCount := 0
-	totalUsers := int64(0)
-
-	for status := range results {
-		// Determine status code
-		statusCode := storage.PDSStatusOffline
-		if status.Available {
-			statusCode = storage.PDSStatusOnline
-		}
+	// Send jobs
+	for _, server := range servers {
+		jobs <- server
+	}
+	close(jobs)
 
-		// Build scan data
-		scanData := &storage.EndpointScanData{
-			ServerInfo: status.Description,
-			DIDs:       status.DIDs,
-			DIDCount:   len(status.DIDs),
-		}
+	// Wait for completion
+	wg.Wait()
 
-		// Update using Endpoint ID
-		if err := s.db.UpdateEndpointStatus(ctx, status.EndpointID, &storage.EndpointUpdate{
-			Status:       statusCode,
-			LastChecked:  status.LastChecked,
-			ResponseTime: status.ResponseTime.Seconds() * 1000, // Convert to ms
-			ScanData:     scanData,
-		}); err != nil {
-			log.Error("Error updating endpoint ID %d: %v", status.EndpointID, err)
-		}
-
-		if status.Available {
-			successCount++
-			totalUsers += int64(len(status.DIDs))
-		} else {
-			failureCount++
-		}
-	}
-
-	log.Info("PDS scan completed: %d available, %d unavailable, %d total users in %v",
-		successCount, failureCount, totalUsers, time.Since(startTime))
+	log.Info("PDS scan completed in %v", time.Since(startTime))
 
 	return nil
 }
 
-func (s *Scanner) worker(ctx context.Context, jobs <-chan *storage.Endpoint, results chan<- *PDSStatus) {
+func (s *Scanner) worker(ctx context.Context, jobs <-chan *storage.Endpoint) {
 	for server := range jobs {
 		select {
 		case <-ctx.Done():
 			return
 		default:
-			status := s.scanPDS(ctx, server.ID, server.Endpoint)
-			results <- status
+			s.scanAndSaveEndpoint(ctx, server)
 		}
 	}
 }
 
-func (s *Scanner) scanPDS(ctx context.Context, endpointID int64, endpoint string) *PDSStatus {
-	status := &PDSStatus{
-		EndpointID:  endpointID,
-		Endpoint:    endpoint,
-		LastChecked: time.Now().UTC(),
+func (s *Scanner) scanAndSaveEndpoint(ctx context.Context, ep *storage.Endpoint) {
+	// STEP 1: Resolve IP (before any network call)
+	ip, err := ipinfo.ExtractIPFromEndpoint(ep.Endpoint)
+	if err != nil {
+		// Mark as offline due to DNS failure
+		s.saveScanResult(ctx, ep.ID, &ScanResult{
+			Status:       storage.EndpointStatusOffline,
+			ErrorMessage: fmt.Sprintf("DNS resolution failed: %v", err),
+		})
+		return
 	}
 
-	// Health check
-	available, responseTime, err := s.client.CheckHealth(ctx, endpoint)
-	status.Available = available
-	status.ResponseTime = responseTime
+	// Update IP immediately
+	s.db.UpdateEndpointIP(ctx, ep.ID, ip, time.Now())
+
+	// STEP 2: Health check
+	available, responseTime, err := s.client.CheckHealth(ctx, ep.Endpoint)
+	if err != nil || !available {
+		errMsg := "health check failed"
+		if err != nil {
+			errMsg = err.Error()
+		}
+		s.saveScanResult(ctx, ep.ID, &ScanResult{
+			Status:       storage.EndpointStatusOffline,
+			ResponseTime: responseTime,
+			ErrorMessage: errMsg,
+		})
+		return
+	}
 
+	// STEP 3: Fetch PDS-specific data
+	desc, err := s.client.DescribeServer(ctx, ep.Endpoint)
 	if err != nil {
-		status.ErrorMessage = err.Error()
-		return status
+		log.Verbose("Warning: failed to describe server %s: %v", stripansi.Strip(ep.Endpoint), err)
 	}
 
-	if !available {
-		status.ErrorMessage = "health check failed"
-		return status
+	dids, err := s.client.ListRepos(ctx, ep.Endpoint)
+	if err != nil {
+		log.Verbose("Warning: failed to list repos for %s: %v", ep.Endpoint, err)
+		dids = []string{}
 	}
 
-	// Fetch and update IP info if needed
-	s.updateIPInfoIfNeeded(ctx, endpointID, endpoint)
+	// STEP 4: SAVE IMMEDIATELY
+	s.saveScanResult(ctx, ep.ID, &ScanResult{
+		Status:       storage.EndpointStatusOnline,
+		ResponseTime: responseTime,
+		Description:  desc,
+		DIDs:         dids,
+	})
+
+	// STEP 5: Fetch IP info if needed (async, with backoff)
+	go s.updateIPInfoIfNeeded(ctx, ip)
+}
 
-	// Describe server
-	desc, err := s.client.DescribeServer(ctx, endpoint)
-	if err != nil {
-		log.Verbose("Warning: failed to describe server %s: %v", stripansi.Strip(endpoint), err)
-	} else {
-		status.Description = desc
+func (s *Scanner) saveScanResult(ctx context.Context, endpointID int64, result *ScanResult) {
+	// Build scan_data with PDS-specific info in Metadata
+	scanData := &storage.EndpointScanData{
+		DIDCount: len(result.DIDs),
+		Metadata: make(map[string]interface{}),
 	}
 
-	// Optionally list repos (DIDs) - commented out by default for performance
-	dids, err := s.client.ListRepos(ctx, endpoint)
-	if err != nil {
-		log.Verbose("Warning: failed to list repos for %s: %v", endpoint, err)
-		status.DIDs = []string{}
+	// Add PDS-specific metadata
+	if result.Status == storage.EndpointStatusOnline {
+		scanData.Metadata["user_count"] = len(result.DIDs)
+		if result.Description != nil {
+			scanData.Metadata["server_info"] = result.Description
+		}
 	} else {
-		status.DIDs = dids
-		log.Verbose("  → Found %d users on %s", len(dids), endpoint)
+		// Include error message for offline status
+		if result.ErrorMessage != "" {
+			scanData.Metadata["error"] = result.ErrorMessage
+		}
 	}
 
-	return status
+	// Save scan record
+	scan := &storage.EndpointScan{
+		EndpointID:   endpointID,
+		Status:       result.Status,
+		ResponseTime: result.ResponseTime.Seconds() * 1000, // Convert to ms
+		ScanData:     scanData,
+		ScannedAt:    time.Now(),
+	}
+
+	if err := s.db.SaveEndpointScan(ctx, scan); err != nil {
+		log.Error("Failed to save scan for endpoint %d: %v", endpointID, err)
+	}
+
+	// Update endpoint status
+	update := &storage.EndpointUpdate{
+		Status:       result.Status,
+		LastChecked:  time.Now(),
+		ResponseTime: result.ResponseTime.Seconds() * 1000,
+	}
+
+	if err := s.db.UpdateEndpointStatus(ctx, endpointID, update); err != nil {
+		log.Error("Failed to update endpoint status for %d: %v", endpointID, err)
+	}
 }
 
-func (s *Scanner) updateIPInfoIfNeeded(ctx context.Context, endpointID int64, endpoint string) {
+func (s *Scanner) updateIPInfoIfNeeded(ctx context.Context, ip string) {
 	// Check if IP info client is in backoff
 	if s.ipInfoClient.IsInBackoff() {
-		// Silently skip during backoff period
-		return
-	}
-
-	// Extract IP from endpoint
-	ip, err := ipinfo.ExtractIPFromEndpoint(endpoint)
-	if err != nil {
-		log.Verbose("Failed to extract IP from %s: %v", endpoint, err)
 		return
 	}
 
 	// Check if we need to update IP info
-	shouldUpdate, err := s.db.ShouldUpdateIPInfo(ctx, endpointID, ip)
+	exists, needsUpdate, err := s.db.ShouldUpdateIPInfo(ctx, ip)
 	if err != nil {
 		log.Verbose("Failed to check IP info status: %v", err)
 		return
 	}
 
-	if !shouldUpdate {
-		return // IP hasn't changed, no need to fetch
+	if exists && !needsUpdate {
+		return // IP info is fresh
 	}
 
 	// Fetch IP info from ipapi.is
-	log.Verbose("Fetching IP info for %s (%s)", endpoint, ip)
+	log.Verbose("Fetching IP info for %s", ip)
 	ipInfo, err := s.ipInfoClient.GetIPInfo(ctx, ip)
 	if err != nil {
 		// Log only once when backoff starts
···
 	}
 
 	// Update database
-	if err := s.db.UpdateEndpointIPInfo(ctx, endpointID, ip, ipInfo); err != nil {
-		log.Error("Failed to update IP info for endpoint %d: %v", endpointID, err)
+	if err := s.db.UpsertIPInfo(ctx, ip, ipInfo); err != nil {
+		log.Error("Failed to update IP info for %s: %v", ip, err)
 	} else {
-		log.Verbose("✓ Updated IP info for %s: %s", endpoint, ip)
+		log.Verbose("✓ Updated IP info for %s", ip)
 	}
 }

internal/pds/types.go

···
 	Description  *ServerDescription
 	DIDs         []string
 }
+
+type ScanResult struct {
+	Status       int
+	ResponseTime time.Duration
+	ErrorMessage string
+	Description  *ServerDescription
+	DIDs         []string
+}

internal/storage/db.go

···
 	UpsertEndpoint(ctx context.Context, endpoint *Endpoint) error
 	GetEndpoint(ctx context.Context, endpoint string, endpointType string) (*Endpoint, error)
 	GetEndpoints(ctx context.Context, filter *EndpointFilter) ([]*Endpoint, error)
-	UpdateEndpointStatus(ctx context.Context, endpointID int64, update *EndpointUpdate) error
 	EndpointExists(ctx context.Context, endpoint string, endpointType string) (bool, error)
 	GetEndpointIDByEndpoint(ctx context.Context, endpoint string, endpointType string) (int64, error)
 	GetEndpointScans(ctx context.Context, endpointID int64, limit int) ([]*EndpointScan, error)
+	UpdateEndpointIP(ctx context.Context, endpointID int64, ip string, resolvedAt time.Time) error
+	SaveEndpointScan(ctx context.Context, scan *EndpointScan) error
+	UpdateEndpointStatus(ctx context.Context, endpointID int64, update *EndpointUpdate) error
 
-	// IP info operations
-	ShouldUpdateIPInfo(ctx context.Context, endpointID int64, currentIP string) (bool, error)
-	UpdateEndpointIPInfo(ctx context.Context, endpointID int64, ip string, ipInfo map[string]interface{}) error
+	// PDS virtual endpoints (created via JOINs)
+	GetPDSList(ctx context.Context, filter *EndpointFilter) ([]*PDSListItem, error)
+	GetPDSDetail(ctx context.Context, endpoint string) (*PDSDetail, error)
+	GetPDSStats(ctx context.Context) (*PDSStats, error)
+
+	// IP operations (IP as primary key)
+	UpsertIPInfo(ctx context.Context, ip string, ipInfo map[string]interface{}) error
+	GetIPInfo(ctx context.Context, ip string) (*IPInfo, error)
+	ShouldUpdateIPInfo(ctx context.Context, ip string) (exists bool, needsUpdate bool, err error)
 
 	// Cursor operations
 	GetScanCursor(ctx context.Context, source string) (*ScanCursor, error)

internal/storage/postgres.go

···
 
 func (p *PostgresDB) Migrate() error {
 	schema := `
-    -- Endpoints table
+    -- Endpoints table (NO user_count, NO ip_info)
     CREATE TABLE IF NOT EXISTS endpoints (
         id BIGSERIAL PRIMARY KEY,
         endpoint_type TEXT NOT NULL DEFAULT 'pds',
···
         discovered_at TIMESTAMP NOT NULL,
         last_checked TIMESTAMP,
         status INTEGER DEFAULT 0,
-        user_count BIGINT DEFAULT 0,
         ip TEXT,
-        ip_info JSONB,
+        ip_resolved_at TIMESTAMP,
         updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         UNIQUE(endpoint_type, endpoint)
     );
···
     CREATE INDEX IF NOT EXISTS idx_endpoints_type_endpoint ON endpoints(endpoint_type, endpoint);
     CREATE INDEX IF NOT EXISTS idx_endpoints_status ON endpoints(status);
     CREATE INDEX IF NOT EXISTS idx_endpoints_type ON endpoints(endpoint_type);
-    CREATE INDEX IF NOT EXISTS idx_endpoints_user_count ON endpoints(user_count);
     CREATE INDEX IF NOT EXISTS idx_endpoints_ip ON endpoints(ip);
-    CREATE INDEX IF NOT EXISTS idx_endpoints_ip_info ON endpoints USING gin(ip_info);
 
-    CREATE TABLE IF NOT EXISTS pds_scans (
+    -- IP infos table (IP as PRIMARY KEY)
+    CREATE TABLE IF NOT EXISTS ip_infos (
+        ip TEXT PRIMARY KEY,
+        city TEXT,
+        country TEXT,
+        country_code TEXT,
+        asn INTEGER,
+        asn_org TEXT,
+        is_datacenter BOOLEAN,
+        is_vpn BOOLEAN,
+        latitude REAL,
+        longitude REAL,
+        raw_data JSONB,
+        fetched_at TIMESTAMP NOT NULL,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_ip_infos_country_code ON ip_infos(country_code);
+    CREATE INDEX IF NOT EXISTS idx_ip_infos_asn ON ip_infos(asn);
+
+    -- Endpoint scans (renamed from pds_scans)
+    CREATE TABLE IF NOT EXISTS endpoint_scans (
         id BIGSERIAL PRIMARY KEY,
-        pds_id BIGINT NOT NULL,
+        endpoint_id BIGINT NOT NULL,
         status INTEGER NOT NULL,
         response_time DOUBLE PRECISION,
         scan_data JSONB,
         scanned_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (pds_id) REFERENCES endpoints(id) ON DELETE CASCADE
+        FOREIGN KEY (endpoint_id) REFERENCES endpoints(id) ON DELETE CASCADE
     );
 
-    CREATE INDEX IF NOT EXISTS idx_pds_scans_pds_id ON pds_scans(pds_id);
-    CREATE INDEX IF NOT EXISTS idx_pds_scans_scanned_at ON pds_scans(scanned_at);
-    CREATE INDEX IF NOT EXISTS idx_pds_scans_scan_data ON pds_scans USING gin(scan_data);
+    CREATE INDEX IF NOT EXISTS idx_endpoint_scans_endpoint_status_scanned ON endpoint_scans(endpoint_id, status, scanned_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_endpoint_scans_scanned_at ON endpoint_scans(scanned_at);
 
     CREATE TABLE IF NOT EXISTS plc_metrics (
         id BIGSERIAL PRIMARY KEY,
···
     CREATE INDEX IF NOT EXISTS idx_mempool_did ON plc_mempool(did);
     CREATE UNIQUE INDEX IF NOT EXISTS idx_mempool_cid ON plc_mempool(cid);
 
-	-- Minimal dids table
-	CREATE TABLE IF NOT EXISTS dids (
-		did TEXT PRIMARY KEY,
-		bundle_numbers JSONB NOT NULL DEFAULT '[]'::jsonb,
-		created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
-	);
+    -- Minimal dids table
+    CREATE TABLE IF NOT EXISTS dids (
+        did TEXT PRIMARY KEY,
+        bundle_numbers JSONB NOT NULL DEFAULT '[]'::jsonb,
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
 
-	CREATE INDEX IF NOT EXISTS idx_dids_bundle_numbers ON dids USING gin(bundle_numbers);
-	CREATE INDEX IF NOT EXISTS idx_dids_created_at ON dids(created_at);
+    CREATE INDEX IF NOT EXISTS idx_dids_bundle_numbers ON dids USING gin(bundle_numbers);
+    CREATE INDEX IF NOT EXISTS idx_dids_created_at ON dids(created_at);
     `
 
 	_, err := p.db.Exec(schema)
 	return err
 }
 
+// ===== ENDPOINT OPERATIONS =====
+
+func (p *PostgresDB) UpsertEndpoint(ctx context.Context, endpoint *Endpoint) error {
+	query := `
+        INSERT INTO endpoints (endpoint_type, endpoint, discovered_at, last_checked, status, ip, ip_resolved_at)
+        VALUES ($1, $2, $3, $4, $5, $6, $7)
+        ON CONFLICT(endpoint_type, endpoint) DO UPDATE SET
+            last_checked = EXCLUDED.last_checked,
+            status = EXCLUDED.status,
+            ip = CASE 
+                WHEN EXCLUDED.ip IS NOT NULL AND EXCLUDED.ip != '' THEN EXCLUDED.ip 
+                ELSE endpoints.ip 
+            END,
+            ip_resolved_at = CASE
+                WHEN EXCLUDED.ip IS NOT NULL AND EXCLUDED.ip != '' THEN EXCLUDED.ip_resolved_at
+                ELSE endpoints.ip_resolved_at
+            END,
+            updated_at = CURRENT_TIMESTAMP
+        RETURNING id
+    `
+	err := p.db.QueryRowContext(ctx, query,
+		endpoint.EndpointType, endpoint.Endpoint, endpoint.DiscoveredAt,
+		endpoint.LastChecked, endpoint.Status, endpoint.IP, endpoint.IPResolvedAt).Scan(&endpoint.ID)
+	return err
+}
+
+func (p *PostgresDB) EndpointExists(ctx context.Context, endpoint string, endpointType string) (bool, error) {
+	query := "SELECT EXISTS(SELECT 1 FROM endpoints WHERE endpoint = $1 AND endpoint_type = $2)"
+	var exists bool
+	err := p.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(&exists)
+	return exists, err
+}
+
+func (p *PostgresDB) GetEndpointIDByEndpoint(ctx context.Context, endpoint string, endpointType string) (int64, error) {
+	query := "SELECT id FROM endpoints WHERE endpoint = $1 AND endpoint_type = $2"
+	var id int64
+	err := p.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(&id)
+	return id, err
+}
+
+func (p *PostgresDB) GetEndpoint(ctx context.Context, endpoint string, endpointType string) (*Endpoint, error) {
+	query := `
+        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, 
+               ip, ip_resolved_at, updated_at
+        FROM endpoints 
+        WHERE endpoint = $1 AND endpoint_type = $2
+    `
+
+	var ep Endpoint
+	var lastChecked, ipResolvedAt sql.NullTime
+	var ip sql.NullString
+
+	err := p.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(
+		&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
+		&ep.Status, &ip, &ipResolvedAt, &ep.UpdatedAt,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if lastChecked.Valid {
+		ep.LastChecked = lastChecked.Time
+	}
+	if ip.Valid {
+		ep.IP = ip.String
+	}
+	if ipResolvedAt.Valid {
+		ep.IPResolvedAt = ipResolvedAt.Time
+	}
+
+	return &ep, nil
+}
+
+func (p *PostgresDB) GetEndpoints(ctx context.Context, filter *EndpointFilter) ([]*Endpoint, error) {
+	query := `
+        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, 
+               ip, ip_resolved_at, updated_at
+        FROM endpoints
+        WHERE 1=1
+    `
+	args := []interface{}{}
+	argIdx := 1
+
+	if filter != nil {
+		if filter.Type != "" {
+			query += fmt.Sprintf(" AND endpoint_type = $%d", argIdx)
+			args = append(args, filter.Type)
+			argIdx++
+		}
+		if filter.Status != "" {
+			statusInt := EndpointStatusUnknown
+			switch filter.Status {
+			case "online":
+				statusInt = EndpointStatusOnline
+			case "offline":
+				statusInt = EndpointStatusOffline
+			}
+			query += fmt.Sprintf(" AND status = $%d", argIdx)
+			args = append(args, statusInt)
+			argIdx++
+		}
+	}
+
+	query += " ORDER BY id DESC"
+
+	if filter != nil && filter.Limit > 0 {
+		query += fmt.Sprintf(" LIMIT $%d OFFSET $%d", argIdx, argIdx+1)
+		args = append(args, filter.Limit, filter.Offset)
+	}
+
+	rows, err := p.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var endpoints []*Endpoint
+	for rows.Next() {
+		var ep Endpoint
+		var lastChecked, ipResolvedAt sql.NullTime
+		var ip sql.NullString
+
+		err := rows.Scan(
+			&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
+			&ep.Status, &ip, &ipResolvedAt, &ep.UpdatedAt,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		if lastChecked.Valid {
+			ep.LastChecked = lastChecked.Time
+		}
+		if ip.Valid {
+			ep.IP = ip.String
+		}
+		if ipResolvedAt.Valid {
+			ep.IPResolvedAt = ipResolvedAt.Time
+		}
+
+		endpoints = append(endpoints, &ep)
+	}
+
+	return endpoints, rows.Err()
+}
+
+func (p *PostgresDB) UpdateEndpointStatus(ctx context.Context, endpointID int64, update *EndpointUpdate) error {
+	query := `
+        UPDATE endpoints 
+        SET status = $1, last_checked = $2, updated_at = $3
+        WHERE id = $4
+    `
+	_, err := p.db.ExecContext(ctx, query, update.Status, update.LastChecked, time.Now().UTC(), endpointID)
+	return err
+}
+
+func (p *PostgresDB) UpdateEndpointIP(ctx context.Context, endpointID int64, ip string, resolvedAt time.Time) error {
+	query := `
+        UPDATE endpoints 
+        SET ip = $1, ip_resolved_at = $2, updated_at = $3
+        WHERE id = $4
+    `
+	_, err := p.db.ExecContext(ctx, query, ip, resolvedAt, time.Now(), endpointID)
+	return err
+}
+
+// ===== SCAN OPERATIONS =====
+
+func (p *PostgresDB) SaveEndpointScan(ctx context.Context, scan *EndpointScan) error {
+	var scanDataJSON []byte
+	if scan.ScanData != nil {
+		scanDataJSON, _ = json.Marshal(scan.ScanData)
+	}
+
+	query := `
+        INSERT INTO endpoint_scans (endpoint_id, status, response_time, scan_data, scanned_at)
+        VALUES ($1, $2, $3, $4, $5)
+    `
+	_, err := p.db.ExecContext(ctx, query, scan.EndpointID, scan.Status, scan.ResponseTime, scanDataJSON, scan.ScannedAt)
+	return err
+}
+
+func (p *PostgresDB) GetEndpointScans(ctx context.Context, endpointID int64, limit int) ([]*EndpointScan, error) {
+	query := `
+        SELECT id, endpoint_id, status, response_time, scan_data, scanned_at
+        FROM endpoint_scans
+        WHERE endpoint_id = $1
+        ORDER BY scanned_at DESC
+        LIMIT $2
+    `
+
+	rows, err := p.db.QueryContext(ctx, query, endpointID, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var scans []*EndpointScan
+	for rows.Next() {
+		var scan EndpointScan
+		var responseTime sql.NullFloat64
+		var scanDataJSON []byte
+
+		err := rows.Scan(&scan.ID, &scan.EndpointID, &scan.Status, &responseTime, &scanDataJSON, &scan.ScannedAt)
+		if err != nil {
+			return nil, err
+		}
+
+		if responseTime.Valid {
+			scan.ResponseTime = responseTime.Float64
+		}
+
+		if len(scanDataJSON) > 0 {
+			var scanData EndpointScanData
+			if err := json.Unmarshal(scanDataJSON, &scanData); err == nil {
+				scan.ScanData = &scanData
+			}
+		}
+
+		scans = append(scans, &scan)
+	}
+
+	return scans, rows.Err()
+}
+
+// ===== PDS VIRTUAL ENDPOINTS =====
+
+func (p *PostgresDB) GetPDSList(ctx context.Context, filter *EndpointFilter) ([]*PDSListItem, error) {
+	query := `
+        SELECT 
+            e.id, e.endpoint, e.discovered_at, e.last_checked, e.status, e.ip,
+            latest.user_count, latest.response_time, latest.scanned_at,
+            i.city, i.country, i.country_code, i.asn, i.asn_org,
+            i.is_datacenter, i.is_vpn, i.latitude, i.longitude
+        FROM endpoints e
+        LEFT JOIN LATERAL (
+            SELECT 
+                COALESCE((scan_data->'metadata'->>'user_count')::int, 0) as user_count,
+                response_time,
+                scanned_at
+            FROM endpoint_scans
+            WHERE endpoint_id = e.id AND status = 1
+            ORDER BY scanned_at DESC
+            LIMIT 1
+        ) latest ON true
+        LEFT JOIN ip_infos i ON e.ip = i.ip
+        WHERE e.endpoint_type = 'pds'
+    `
+
+	args := []interface{}{}
+	argIdx := 1
+
+	if filter != nil {
+		if filter.Status != "" {
+			statusInt := EndpointStatusUnknown
+			switch filter.Status {
+			case "online":
+				statusInt = EndpointStatusOnline
+			case "offline":
+				statusInt = EndpointStatusOffline
+			}
+			query += fmt.Sprintf(" AND e.status = $%d", argIdx)
+			args = append(args, statusInt)
+			argIdx++
+		}
+
+		if filter.MinUserCount > 0 {
+			query += fmt.Sprintf(" AND latest.user_count >= $%d", argIdx)
+			args = append(args, filter.MinUserCount)
+			argIdx++
+		}
+	}
+
+	query += " ORDER BY latest.user_count DESC NULLS LAST"
+
+	if filter != nil && filter.Limit > 0 {
+		query += fmt.Sprintf(" LIMIT $%d OFFSET $%d", argIdx, argIdx+1)
+		args = append(args, filter.Limit, filter.Offset)
+	}
+
+	rows, err := p.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var items []*PDSListItem
+	for rows.Next() {
+		item := &PDSListItem{}
+		var ip, city, country, countryCode, asnOrg sql.NullString
+		var asn sql.NullInt32
+		var isDatacenter, isVPN sql.NullBool
+		var lat, lon sql.NullFloat64
+		var userCount sql.NullInt32
+		var responseTime sql.NullFloat64
+		var scannedAt sql.NullTime
+
+		err := rows.Scan(
+			&item.ID, &item.Endpoint, &item.DiscoveredAt, &item.LastChecked, &item.Status, &ip,
+			&userCount, &responseTime, &scannedAt,
+			&city, &country, &countryCode, &asn, &asnOrg,
+			&isDatacenter, &isVPN, &lat, &lon,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		if ip.Valid {
+			item.IP = ip.String
+		}
+
+		// Add latest scan data if available
+		if userCount.Valid {
+			item.LatestScan = &struct {
+				UserCount    int
+				ResponseTime float64
+				ScannedAt    time.Time
+			}{
+				UserCount:    int(userCount.Int32),
+				ResponseTime: responseTime.Float64,
+				ScannedAt:    scannedAt.Time,
+			}
+		}
+
+		// Add IP info if available
+		if city.Valid || country.Valid {
+			item.IPInfo = &IPInfo{
+				IP:           ip.String,
+				City:         city.String,
+				Country:      country.String,
+				CountryCode:  countryCode.String,
+				ASN:          int(asn.Int32),
+				ASNOrg:       asnOrg.String,
+				IsDatacenter: isDatacenter.Bool,
+				IsVPN:        isVPN.Bool,
+				Latitude:     float32(lat.Float64),
+				Longitude:    float32(lon.Float64),
+			}
+		}
+
+		items = append(items, item)
+	}
+
+	return items, rows.Err()
+}
+
+func (p *PostgresDB) GetPDSDetail(ctx context.Context, endpoint string) (*PDSDetail, error) {
+	query := `
+        SELECT 
+            e.id, e.endpoint, e.discovered_at, e.last_checked, e.status, e.ip,
+            COALESCE((latest.scan_data->'metadata'->>'user_count')::int, 0) as user_count,
+            latest.response_time,
+            latest.scan_data->'metadata'->'server_info' as server_info,
+            latest.scanned_at,
+            i.city, i.country, i.country_code, i.asn, i.asn_org,
+            i.is_datacenter, i.is_vpn, i.latitude, i.longitude
+        FROM endpoints e
+        LEFT JOIN LATERAL (
+            SELECT scan_data, response_time, scanned_at
+            FROM endpoint_scans
+            WHERE endpoint_id = e.id
+            ORDER BY scanned_at DESC
+            LIMIT 1
+        ) latest ON true
+        LEFT JOIN ip_infos i ON e.ip = i.ip
+        WHERE e.endpoint = $1 AND e.endpoint_type = 'pds'
+    `
+
+	detail := &PDSDetail{}
+	var ip, city, country, countryCode, asnOrg sql.NullString
+	var asn sql.NullInt32
+	var isDatacenter, isVPN sql.NullBool
+	var lat, lon sql.NullFloat64
+	var userCount sql.NullInt32
+	var responseTime sql.NullFloat64
+	var serverInfoJSON []byte
+	var scannedAt sql.NullTime
+
+	err := p.db.QueryRowContext(ctx, query, endpoint).Scan(
+		&detail.ID, &detail.Endpoint, &detail.DiscoveredAt, &detail.LastChecked, &detail.Status, &ip,
+		&userCount, &responseTime, &serverInfoJSON, &scannedAt,
+		&city, &country, &countryCode, &asn, &asnOrg,
+		&isDatacenter, &isVPN, &lat, &lon,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if ip.Valid {
+		detail.IP = ip.String
+	}
+
+	// Parse latest scan data
+	if userCount.Valid {
+		var serverInfo interface{}
+		if len(serverInfoJSON) > 0 {
+			json.Unmarshal(serverInfoJSON, &serverInfo)
+		}
+
+		detail.LatestScan = &struct {
+			UserCount    int
+			ResponseTime float64
+			ServerInfo   interface{}
+			ScannedAt    time.Time
+		}{
+			UserCount:    int(userCount.Int32),
+			ResponseTime: responseTime.Float64,
+			ServerInfo:   serverInfo,
+			ScannedAt:    scannedAt.Time,
+		}
+	}
+
+	// Parse IP info
+	if city.Valid || country.Valid {
+		detail.IPInfo = &IPInfo{
+			IP:           ip.String,
+			City:         city.String,
+			Country:      country.String,
+			CountryCode:  countryCode.String,
+			ASN:          int(asn.Int32),
+			ASNOrg:       asnOrg.String,
+			IsDatacenter: isDatacenter.Bool,
+			IsVPN:        isVPN.Bool,
+			Latitude:     float32(lat.Float64),
+			Longitude:    float32(lon.Float64),
+		}
+	}
+
+	return detail, nil
+}
+
+func (p *PostgresDB) GetPDSStats(ctx context.Context) (*PDSStats, error) {
+	// PDS stats - aggregate from latest scans
+	query := `
+        WITH latest_scans AS (
+            SELECT DISTINCT ON (endpoint_id)
+                endpoint_id,
+                COALESCE((scan_data->'metadata'->>'user_count')::int, 0) as user_count,
+                status
+            FROM endpoint_scans
+            WHERE endpoint_id IN (SELECT id FROM endpoints WHERE endpoint_type = 'pds')
+            ORDER BY endpoint_id, scanned_at DESC
+        )
+        SELECT 
+            COUNT(*) as total,
+            SUM(CASE WHEN status = 1 THEN 1 ELSE 0 END) as online,
+            SUM(CASE WHEN status = 2 THEN 1 ELSE 0 END) as offline,
+            SUM(user_count) as total_users
+        FROM latest_scans
+    `
+
+	stats := &PDSStats{}
+	err := p.db.QueryRowContext(ctx, query).Scan(
+		&stats.TotalEndpoints, &stats.OnlineEndpoints, &stats.OfflineEndpoints, &stats.TotalDIDs,
+	)
+
+	return stats, err
+}
+
+func (p *PostgresDB) GetEndpointStats(ctx context.Context) (*EndpointStats, error) {
+	query := `
+        SELECT 
+            COUNT(*) as total_endpoints,
+            SUM(CASE WHEN status = 1 THEN 1 ELSE 0 END) as online_endpoints,
+            SUM(CASE WHEN status = 2 THEN 1 ELSE 0 END) as offline_endpoints
+        FROM endpoints
+    `
+
+	var stats EndpointStats
+	err := p.db.QueryRowContext(ctx, query).Scan(
+		&stats.TotalEndpoints, &stats.OnlineEndpoints, &stats.OfflineEndpoints,
+	)
+
+	// Get average response time from recent scans
+	avgQuery := `
+        SELECT AVG(response_time) 
+        FROM endpoint_scans 
+        WHERE response_time > 0 AND scanned_at > NOW() - INTERVAL '1 hour'
+    `
+	var avgResponseTime sql.NullFloat64
+	p.db.QueryRowContext(ctx, avgQuery).Scan(&avgResponseTime)
+	if avgResponseTime.Valid {
+		stats.AvgResponseTime = avgResponseTime.Float64
+	}
+
+	// Get counts by type
+	typeQuery := `
+        SELECT endpoint_type, COUNT(*) 
+        FROM endpoints 
+        GROUP BY endpoint_type
+    `
+	rows, err := p.db.QueryContext(ctx, typeQuery)
+	if err == nil {
+		defer rows.Close()
+		stats.ByType = make(map[string]int64)
+		for rows.Next() {
+			var typ string
+			var count int64
+			if err := rows.Scan(&typ, &count); err == nil {
+				stats.ByType[typ] = count
+			}
+		}
+	}
+
+	// Get total DIDs from latest PDS scans
+	didQuery := `
+        WITH latest_pds_scans AS (
+            SELECT DISTINCT ON (endpoint_id)
+                endpoint_id,
+                COALESCE((scan_data->'metadata'->>'user_count')::int, 0) as user_count
+            FROM endpoint_scans
+            WHERE endpoint_id IN (SELECT id FROM endpoints WHERE endpoint_type = 'pds')
+            ORDER BY endpoint_id, scanned_at DESC
+        )
+        SELECT SUM(user_count) FROM latest_pds_scans
+    `
+	var totalDIDs sql.NullInt64
+	p.db.QueryRowContext(ctx, didQuery).Scan(&totalDIDs)
+	if totalDIDs.Valid {
+		stats.TotalDIDs = totalDIDs.Int64
+	}
+
+	return &stats, err
+}
+
+// ===== IP INFO OPERATIONS =====
+
+func (p *PostgresDB) UpsertIPInfo(ctx context.Context, ip string, ipInfo map[string]interface{}) error {
+	rawDataJSON, _ := json.Marshal(ipInfo)
+
+	// Extract fields from ipInfo map
+	city := extractString(ipInfo, "location", "city")
+	country := extractString(ipInfo, "location", "country")
+	countryCode := extractString(ipInfo, "location", "country_code")
+	asn := extractInt(ipInfo, "asn", "asn")
+	asnOrg := extractString(ipInfo, "asn", "org")
+	isDatacenter := extractBool(ipInfo, "company", "type", "hosting")
+	isVPN := extractBool(ipInfo, "security", "vpn")
+	lat := extractFloat(ipInfo, "location", "latitude")
+	lon := extractFloat(ipInfo, "location", "longitude")
+
+	query := `
+        INSERT INTO ip_infos (ip, city, country, country_code, asn, asn_org, is_datacenter, is_vpn, latitude, longitude, raw_data, fetched_at)
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+        ON CONFLICT(ip) DO UPDATE SET
+            city = EXCLUDED.city,
+            country = EXCLUDED.country,
+            country_code = EXCLUDED.country_code,
+            asn = EXCLUDED.asn,
+            asn_org = EXCLUDED.asn_org,
+            is_datacenter = EXCLUDED.is_datacenter,
+            is_vpn = EXCLUDED.is_vpn,
+            latitude = EXCLUDED.latitude,
+            longitude = EXCLUDED.longitude,
+            raw_data = EXCLUDED.raw_data,
+            fetched_at = EXCLUDED.fetched_at,
+            updated_at = CURRENT_TIMESTAMP
+    `
+	_, err := p.db.ExecContext(ctx, query, ip, city, country, countryCode, asn, asnOrg, isDatacenter, isVPN, lat, lon, rawDataJSON, time.Now())
+	return err
+}
+
+func (p *PostgresDB) GetIPInfo(ctx context.Context, ip string) (*IPInfo, error) {
+	query := `
+        SELECT ip, city, country, country_code, asn, asn_org, is_datacenter, is_vpn, 
+               latitude, longitude, raw_data, fetched_at, updated_at
+        FROM ip_infos
+        WHERE ip = $1
+    `
+
+	info := &IPInfo{}
+	var rawDataJSON []byte
+
+	err := p.db.QueryRowContext(ctx, query, ip).Scan(
+		&info.IP, &info.City, &info.Country, &info.CountryCode, &info.ASN, &info.ASNOrg,
+		&info.IsDatacenter, &info.IsVPN, &info.Latitude, &info.Longitude,
+		&rawDataJSON, &info.FetchedAt, &info.UpdatedAt,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(rawDataJSON) > 0 {
+		json.Unmarshal(rawDataJSON, &info.RawData)
+	}
+
+	return info, nil
+}
+
+func (p *PostgresDB) ShouldUpdateIPInfo(ctx context.Context, ip string) (bool, bool, error) {
+	query := `SELECT fetched_at FROM ip_infos WHERE ip = $1`
+
+	var fetchedAt time.Time
+	err := p.db.QueryRowContext(ctx, query, ip).Scan(&fetchedAt)
+	if err == sql.ErrNoRows {
+		return false, true, nil // Doesn't exist, needs update
+	}
+	if err != nil {
+		return false, false, err
+	}
+
+	// Check if older than 30 days
+	needsUpdate := time.Since(fetchedAt) > 30*24*time.Hour
+	return true, needsUpdate, nil
+}
+
+// ===== HELPER FUNCTIONS =====
+
+func extractString(data map[string]interface{}, keys ...string) string {
+	current := data
+	for i, key := range keys {
+		if i == len(keys)-1 {
+			if val, ok := current[key].(string); ok {
+				return val
+			}
+			return ""
+		}
+		if nested, ok := current[key].(map[string]interface{}); ok {
+			current = nested
+		} else {
+			return ""
+		}
+	}
+	return ""
+}
+
+func extractInt(data map[string]interface{}, keys ...string) int {
+	current := data
+	for i, key := range keys {
+		if i == len(keys)-1 {
+			if val, ok := current[key].(float64); ok {
+				return int(val)
+			}
+			if val, ok := current[key].(int); ok {
+				return val
+			}
+			return 0
+		}
+		if nested, ok := current[key].(map[string]interface{}); ok {
+			current = nested
+		} else {
+			return 0
+		}
+	}
+	return 0
+}
+
+func extractFloat(data map[string]interface{}, keys ...string) float32 {
+	current := data
+	for i, key := range keys {
+		if i == len(keys)-1 {
+			if val, ok := current[key].(float64); ok {
+				return float32(val)
+			}
+			return 0
+		}
+		if nested, ok := current[key].(map[string]interface{}); ok {
+			current = nested
+		} else {
+			return 0
+		}
+	}
+	return 0
+}
+
+func extractBool(data map[string]interface{}, keys ...string) bool {
+	current := data
+	for i, key := range keys {
+		if i == len(keys)-1 {
+			if val, ok := current[key].(bool); ok {
+				return val
+			}
+			// Check if it's a string that matches (for type="hosting")
+			if val, ok := current[key].(string); ok {
+				// For cases like company.type == "hosting"
+				expectedValue := keys[len(keys)-1]
+				return val == expectedValue
+			}
+			return false
+		}
+		if nested, ok := current[key].(map[string]interface{}); ok {
+			current = nested
+		} else {
+			return false
+		}
+	}
+	return false
+}
+
 // ===== BUNDLE OPERATIONS =====
 
 func (p *PostgresDB) CreateBundle(ctx context.Context, bundle *PLCBundle) error {
···
 	var size int64
 	err := p.db.QueryRowContext(ctx, query).Scan(&size)
 	return size, err
-}
-
-// ===== ENDPOINT OPERATIONS =====
-
-func (p *PostgresDB) UpsertEndpoint(ctx context.Context, endpoint *Endpoint) error {
-	var ipInfoJSON []byte
-	var err error
-	if endpoint.IPInfo != nil {
-		ipInfoJSON, err = json.Marshal(endpoint.IPInfo)
-		if err != nil {
-			return fmt.Errorf("failed to marshal ip_info: %w", err)
-		}
-	}
-
-	query := `
-        INSERT INTO endpoints (endpoint_type, endpoint, discovered_at, last_checked, status, ip, ip_info)
-        VALUES ($1, $2, $3, $4, $5, $6, $7)
-        ON CONFLICT(endpoint_type, endpoint) DO UPDATE SET
-            last_checked = EXCLUDED.last_checked,
-            ip = CASE 
-                WHEN EXCLUDED.ip IS NOT NULL AND EXCLUDED.ip != '' THEN EXCLUDED.ip 
-                ELSE endpoints.ip 
-            END,
-            ip_info = CASE 
-                WHEN EXCLUDED.ip_info IS NOT NULL THEN EXCLUDED.ip_info 
-                ELSE endpoints.ip_info 
-            END
-        RETURNING id
-    `
-	err = p.db.QueryRowContext(ctx, query,
-		endpoint.EndpointType, endpoint.Endpoint, endpoint.DiscoveredAt,
-		endpoint.LastChecked, endpoint.Status, endpoint.IP, ipInfoJSON).Scan(&endpoint.ID)
-	return err
-}
-
-func (p *PostgresDB) EndpointExists(ctx context.Context, endpoint string, endpointType string) (bool, error) {
-	query := "SELECT EXISTS(SELECT 1 FROM endpoints WHERE endpoint = $1 AND endpoint_type = $2)"
-	var exists bool
-	err := p.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(&exists)
-	return exists, err
-}
-
-func (p *PostgresDB) GetEndpointIDByEndpoint(ctx context.Context, endpoint string, endpointType string) (int64, error) {
-	query := "SELECT id FROM endpoints WHERE endpoint = $1 AND endpoint_type = $2"
-	var id int64
-	err := p.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(&id)
-	return id, err
-}
-
-func (p *PostgresDB) GetEndpoint(ctx context.Context, endpoint string, endpointType string) (*Endpoint, error) {
-	query := `
-        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, 
-               ip, ip_info, updated_at
-        FROM endpoints 
-        WHERE endpoint = $1 AND endpoint_type = $2
-    `
-
-	var ep Endpoint
-	var lastChecked sql.NullTime
-	var ip sql.NullString
-	var ipInfoJSON []byte
-
-	err := p.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(
-		&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
-		&ep.Status, &ep.UserCount, &ip, &ipInfoJSON, &ep.UpdatedAt,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	if lastChecked.Valid {
-		ep.LastChecked = lastChecked.Time
-	}
-
-	if ip.Valid {
-		ep.IP = ip.String
-	}
-
-	if len(ipInfoJSON) > 0 {
-		var ipInfo map[string]interface{}
-		if err := json.Unmarshal(ipInfoJSON, &ipInfo); err == nil {
-			ep.IPInfo = ipInfo
-		}
-	}
-
-	return &ep, nil
-}
-
-func (p *PostgresDB) GetEndpoints(ctx context.Context, filter *EndpointFilter) ([]*Endpoint, error) {
-	query := `
-        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, 
-               ip, ip_info, updated_at
-        FROM endpoints
-        WHERE 1=1
-    `
-	args := []interface{}{}
-	argIdx := 1
-
-	if filter != nil {
-		if filter.Type != "" {
-			query += fmt.Sprintf(" AND endpoint_type = $%d", argIdx)
-			args = append(args, filter.Type)
-			argIdx++
-		}
-		if filter.Status != "" {
-			statusInt := EndpointStatusUnknown
-			switch filter.Status {
-			case "online":
-				statusInt = EndpointStatusOnline
-			case "offline":
-				statusInt = EndpointStatusOffline
-			}
-			query += fmt.Sprintf(" AND status = $%d", argIdx)
-			args = append(args, statusInt)
-			argIdx++
-		}
-		if filter.MinUserCount > 0 {
-			query += fmt.Sprintf(" AND user_count >= $%d", argIdx)
-			args = append(args, filter.MinUserCount)
-			argIdx++
-		}
-	}
-
-	query += " ORDER BY user_count DESC"
-
-	if filter != nil && filter.Limit > 0 {
-		query += fmt.Sprintf(" LIMIT $%d OFFSET $%d", argIdx, argIdx+1)
-		args = append(args, filter.Limit, filter.Offset)
-	}
-
-	rows, err := p.db.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var endpoints []*Endpoint
-	for rows.Next() {
-		var ep Endpoint
-		var lastChecked sql.NullTime
-		var ip sql.NullString
-		var ipInfoJSON []byte
-
-		err := rows.Scan(
-			&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
-			&ep.Status, &ep.UserCount, &ip, &ipInfoJSON, &ep.UpdatedAt,
-		)
-		if err != nil {
-			return nil, err
-		}
-
-		if lastChecked.Valid {
-			ep.LastChecked = lastChecked.Time
-		}
-
-		if ip.Valid {
-			ep.IP = ip.String
-		}
-
-		if len(ipInfoJSON) > 0 {
-			var ipInfo map[string]interface{}
-			if err := json.Unmarshal(ipInfoJSON, &ipInfo); err == nil {
-				ep.IPInfo = ipInfo
-			}
-		}
-
-		endpoints = append(endpoints, &ep)
-	}
-
-	return endpoints, rows.Err()
-}
-
-func (p *PostgresDB) UpdateEndpointStatus(ctx context.Context, endpointID int64, update *EndpointUpdate) error {
-	tx, err := p.db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer tx.Rollback()
-
-	userCount := 0
-	if update.ScanData != nil {
-		userCount = update.ScanData.DIDCount
-	}
-
-	query := `
-        UPDATE endpoints 
-        SET status = $1, last_checked = $2, user_count = $3, updated_at = $4
-        WHERE id = $5
-    `
-	_, err = tx.ExecContext(ctx, query, update.Status, update.LastChecked, userCount, time.Now().UTC(), endpointID)
-	if err != nil {
-		return err
-	}
-
-	var scanDataJSON []byte
-	if update.ScanData != nil {
-		scanDataJSON, _ = json.Marshal(update.ScanData)
-	}
-
-	scanQuery := `
-        INSERT INTO pds_scans (pds_id, status, response_time, scan_data)
-        VALUES ($1, $2, $3, $4)
-    `
-	_, err = tx.ExecContext(ctx, scanQuery, endpointID, update.Status, update.ResponseTime, scanDataJSON)
-	if err != nil {
-		return err
-	}
-
-	// Keep only the 3 most recent scans per endpoint
-	cleanupQuery := `
-        DELETE FROM pds_scans 
-        WHERE pds_id = $1 
-        AND id NOT IN (
-            SELECT id FROM pds_scans 
-            WHERE pds_id = $1 
-            ORDER BY scanned_at DESC 
-            LIMIT 3
-        )
-    `
-	_, err = tx.ExecContext(ctx, cleanupQuery, endpointID)
-	if err != nil {
-		return err
-	}
-
-	return tx.Commit()
-}
-
-func (p *PostgresDB) GetEndpointScans(ctx context.Context, endpointID int64, limit int) ([]*EndpointScan, error) {
-	query := `
-        SELECT id, pds_id, status, response_time, scan_data, scanned_at
-        FROM pds_scans
-        WHERE pds_id = $1
-        ORDER BY scanned_at DESC
-        LIMIT $2
-    `
-
-	rows, err := p.db.QueryContext(ctx, query, endpointID, limit)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	var scans []*EndpointScan
-	for rows.Next() {
-		var scan EndpointScan
-		var responseTime sql.NullFloat64
-		var scanDataJSON []byte
-
-		err := rows.Scan(&scan.ID, &scan.EndpointID, &scan.Status, &responseTime, &scanDataJSON, &scan.ScannedAt)
-		if err != nil {
-			return nil, err
-		}
-
-		if responseTime.Valid {
-			scan.ResponseTime = responseTime.Float64
-		}
-
-		if len(scanDataJSON) > 0 {
-			var scanData EndpointScanData
-			if err := json.Unmarshal(scanDataJSON, &scanData); err == nil {
-				scan.ScanData = &scanData
-			}
-		}
-
-		scans = append(scans, &scan)
-	}
-
-	return scans, rows.Err()
-}
-
-func (p *PostgresDB) GetEndpointStats(ctx context.Context) (*EndpointStats, error) {
-	query := `
-        SELECT 
-            COUNT(*) as total_endpoints,
-            SUM(CASE WHEN status = 1 THEN 1 ELSE 0 END) as online_endpoints,
-            SUM(CASE WHEN status = 2 THEN 1 ELSE 0 END) as offline_endpoints,
-            (SELECT AVG(response_time) FROM pds_scans WHERE response_time > 0 
-             AND scanned_at > NOW() - INTERVAL '1 hour') as avg_response_time,
-            SUM(user_count) as total_dids
-        FROM endpoints
-    `
-
-	var stats EndpointStats
-	var avgResponseTime sql.NullFloat64
-
-	err := p.db.QueryRowContext(ctx, query).Scan(
-		&stats.TotalEndpoints, &stats.OnlineEndpoints, &stats.OfflineEndpoints,
-		&avgResponseTime, &stats.TotalDIDs,
-	)
-
-	if avgResponseTime.Valid {
-		stats.AvgResponseTime = avgResponseTime.Float64
-	}
-
-	typeQuery := `
-        SELECT endpoint_type, COUNT(*) 
-        FROM endpoints 
-        GROUP BY endpoint_type
-    `
-	rows, err := p.db.QueryContext(ctx, typeQuery)
-	if err == nil {
-		defer rows.Close()
-		stats.ByType = make(map[string]int64)
-		for rows.Next() {
-			var typ string
-			var count int64
-			if err := rows.Scan(&typ, &count); err == nil {
-				stats.ByType[typ] = count
-			}
-		}
-	}
-
-	return &stats, err
-}
-
-// Add method to check if IP needs update
-func (p *PostgresDB) ShouldUpdateIPInfo(ctx context.Context, endpointID int64, currentIP string) (bool, error) {
-	query := `SELECT ip FROM endpoints WHERE id = $1`
-
-	var storedIP sql.NullString
-	err := p.db.QueryRowContext(ctx, query, endpointID).Scan(&storedIP)
-	if err != nil {
-		return false, err
-	}
-
-	// Update if no IP stored or IP changed
-	return !storedIP.Valid || storedIP.String != currentIP, nil
-}
-
-// Update IP info for an endpoint
-func (p *PostgresDB) UpdateEndpointIPInfo(ctx context.Context, endpointID int64, ip string, ipInfo map[string]interface{}) error {
-	ipInfoJSON, err := json.Marshal(ipInfo)
-	if err != nil {
-		return fmt.Errorf("failed to marshal ip_info: %w", err)
-	}
-
-	query := `
-        UPDATE endpoints 
-        SET ip = $1, ip_info = $2, updated_at = $3
-        WHERE id = $4
-    `
-	_, err = p.db.ExecContext(ctx, query, ip, ipInfoJSON, time.Now(), endpointID)
-	return err
 }
 
 // ===== CURSOR OPERATIONS =====

internal/storage/types.go

···
 // Endpoint represents any AT Protocol service endpoint
 type Endpoint struct {
 	ID           int64
-	EndpointType string // "pds", "labeler", etc.
+	EndpointType string
 	Endpoint     string
 	DiscoveredAt time.Time
 	LastChecked  time.Time
 	Status       int
-	UserCount    int64
 	IP           string
-	IPInfo       map[string]interface{}
+	IPResolvedAt time.Time
 	UpdatedAt    time.Time
 }
 
···
 
 // EndpointScanData contains data from an endpoint scan
 type EndpointScanData struct {
-	ServerInfo interface{} `json:"server_info,omitempty"`
-	DIDs       []string    `json:"dids,omitempty"`
-	DIDCount   int         `json:"did_count"`
-	Metadata   interface{} `json:"metadata,omitempty"` // Type-specific metadata
+	ServerInfo interface{}            `json:"server_info,omitempty"`
+	DIDs       []string               `json:"dids,omitempty"`
+	DIDCount   int                    `json:"did_count"`
+	Metadata   map[string]interface{} `json:"metadata,omitempty"`
 }
 
 // EndpointScan represents a historical endpoint scan
···
 	BundleNumbers []int     `json:"bundle_numbers"`
 	CreatedAt     time.Time `json:"created_at"`
 }
+
+// IPInfo represents IP information (stored with IP as primary key)
+type IPInfo struct {
+	IP           string
+	City         string
+	Country      string
+	CountryCode  string
+	ASN          int
+	ASNOrg       string
+	IsDatacenter bool
+	IsVPN        bool
+	Latitude     float32
+	Longitude    float32
+	RawData      map[string]interface{}
+	FetchedAt    time.Time
+	UpdatedAt    time.Time
+}
+
+// PDSListItem is a virtual type created by JOIN for /pds endpoint
+type PDSListItem struct {
+	// From endpoints table
+	ID           int64
+	Endpoint     string
+	DiscoveredAt time.Time
+	LastChecked  time.Time
+	Status       int
+	IP           string
+
+	// From latest endpoint_scans (via JOIN)
+	LatestScan *struct {
+		UserCount    int
+		ResponseTime float64
+		ScannedAt    time.Time
+	}
+
+	// From ip_infos table (via JOIN on endpoints.ip)
+	IPInfo *IPInfo
+}
+
+// PDSDetail is extended version for /pds/{endpoint}
+type PDSDetail struct {
+	PDSListItem
+
+	// Additional data from latest scan
+	LatestScan *struct {
+		UserCount    int
+		ResponseTime float64
+		ServerInfo   interface{} // Full server description
+		ScannedAt    time.Time
+	}
+}

utils/migrate-ipinfo.sh

···
+#!/bin/bash
+# migrate_ipinfo.sh - Migrate IP info from endpoints to ip_infos table
+
+# Configuration (edit these)
+DB_HOST="localhost"
+DB_PORT="5432"
+DB_NAME="atscanner"
+DB_USER="atscanner"
+DB_PASSWORD="Noor1kooz5eeFai9leZagh5ua5eihai4"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo -e "${GREEN}=== IP Info Migration Script ===${NC}"
+echo ""
+
+# Export password for psql
+export PGPASSWORD="$DB_PASSWORD"
+
+# Check if we can connect
+echo -e "${YELLOW}Testing database connection...${NC}"
+if ! psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -c "SELECT 1;" > /dev/null 2>&1; then
+    echo -e "${RED}Error: Cannot connect to database${NC}"
+    exit 1
+fi
+echo -e "${GREEN}✓ Connected to database${NC}"
+echo ""
+
+# Create ip_infos table if it doesn't exist
+echo -e "${YELLOW}Creating ip_infos table...${NC}"
+psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" << 'SQL'
+CREATE TABLE IF NOT EXISTS ip_infos (
+    ip TEXT PRIMARY KEY,
+    city TEXT,
+    country TEXT,
+    country_code TEXT,
+    asn INTEGER,
+    asn_org TEXT,
+    is_datacenter BOOLEAN,
+    is_vpn BOOLEAN,
+    latitude REAL,
+    longitude REAL,
+    raw_data JSONB,
+    fetched_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_ip_infos_country_code ON ip_infos(country_code);
+CREATE INDEX IF NOT EXISTS idx_ip_infos_asn ON ip_infos(asn);
+SQL
+
+if [ $? -eq 0 ]; then
+    echo -e "${GREEN}✓ ip_infos table ready${NC}"
+else
+    echo -e "${RED}✗ Failed to create table${NC}"
+    exit 1
+fi
+echo ""
+
+# Count how many endpoints have IP info
+echo -e "${YELLOW}Checking existing data...${NC}"
+ENDPOINT_COUNT=$(psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -t -c \
+    "SELECT COUNT(*) FROM endpoints WHERE ip IS NOT NULL AND ip != '' AND ip_info IS NOT NULL;")
+echo -e "Endpoints with IP info: ${GREEN}${ENDPOINT_COUNT}${NC}"
+
+EXISTING_IP_COUNT=$(psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -t -c \
+    "SELECT COUNT(*) FROM ip_infos;")
+echo -e "Existing IPs in ip_infos table: ${GREEN}${EXISTING_IP_COUNT}${NC}"
+echo ""
+
+# Migrate data
+echo -e "${YELLOW}Migrating IP info data...${NC}"
+psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" << 'SQL'
+-- Migrate IP info from endpoints to ip_infos
+-- Only insert IPs that don't already exist in ip_infos
+INSERT INTO ip_infos (
+    ip,
+    city,
+    country,
+    country_code,
+    asn,
+    asn_org,
+    is_datacenter,
+    is_vpn,
+    latitude,
+    longitude,
+    raw_data,
+    fetched_at,
+    updated_at
+)
+SELECT DISTINCT ON (e.ip)
+    e.ip,
+    e.ip_info->'location'->>'city' AS city,
+    e.ip_info->'location'->>'country' AS country,
+    e.ip_info->'location'->>'country_code' AS country_code,
+    (e.ip_info->'asn'->>'asn')::INTEGER AS asn,
+    e.ip_info->'asn'->>'org' AS asn_org,
+    -- Check if company type is "hosting" for datacenter detection
+    CASE 
+        WHEN e.ip_info->'company'->>'type' = 'hosting' THEN true
+        ELSE false
+    END AS is_datacenter,
+    -- Check VPN from security field
+    COALESCE((e.ip_info->'security'->>'vpn')::BOOLEAN, false) AS is_vpn,
+    -- Latitude and longitude
+    (e.ip_info->'location'->>'latitude')::REAL AS latitude,
+    (e.ip_info->'location'->>'longitude')::REAL AS longitude,
+    -- Store full raw data
+    e.ip_info AS raw_data,
+    COALESCE(e.updated_at, CURRENT_TIMESTAMP) AS fetched_at,
+    CURRENT_TIMESTAMP AS updated_at
+FROM endpoints e
+WHERE 
+    e.ip IS NOT NULL 
+    AND e.ip != '' 
+    AND e.ip_info IS NOT NULL
+    AND NOT EXISTS (
+        SELECT 1 FROM ip_infos WHERE ip_infos.ip = e.ip
+    )
+ORDER BY e.ip, e.updated_at DESC NULLS LAST;
+SQL
+
+if [ $? -eq 0 ]; then
+    echo -e "${GREEN}✓ Data migration completed${NC}"
+else
+    echo -e "${RED}✗ Migration failed${NC}"
+    exit 1
+fi
+echo ""
+
+# Show results
+echo -e "${YELLOW}Migration summary:${NC}"
+NEW_IP_COUNT=$(psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -t -c \
+    "SELECT COUNT(*) FROM ip_infos;")
+MIGRATED=$((NEW_IP_COUNT - EXISTING_IP_COUNT))
+echo -e "Total IPs now in ip_infos: ${GREEN}${NEW_IP_COUNT}${NC}"
+echo -e "Newly migrated: ${GREEN}${MIGRATED}${NC}"
+echo ""
+
+# Show sample data
+echo -e "${YELLOW}Sample migrated data:${NC}"
+psql -h "$DB_HOST" -ps "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -c \
+    "SELECT ip, city, country, country_code, asn, is_datacenter, is_vpn FROM ip_infos LIMIT 5;"
+echo ""
+
+# Optional: Drop old columns (commented out for safety)
+echo -e "${YELLOW}Cleanup options:${NC}"
+echo -e "To remove old ip_info column from endpoints table, run:"
+echo -e "${RED}  ALTER TABLE endpoints DROP COLUMN IF EXISTS ip_info;${NC}"
+echo -e "To remove old user_count column from endpoints table, run:"
+echo -e "${RED}  ALTER TABLE endpoints DROP COLUMN IF EXISTS user_count;${NC}"
+echo ""
+
+echo -e "${GREEN}=== Migration Complete ===${NC}"
+
+# Unset password
+unset PGPASSWORD