route.ts

Go to the documentation of this file.

import { NextRequest, NextResponse } from 'next/server';
import { promises as fs } from 'fs';
import path from 'path';
import { stores, transformManifestStore, type Store } from '@/lib/stores';
 
interface StoresManifest {
  version: string;
  lastUpdated: string;
  stores: any[];
}
 
const MANIFEST_PATH = path.join(process.cwd(), 'data', 'config', 'stores-manifest.json');
const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 
let manifestCache: { data: StoresManifest | null; timestamp: number } = {
  data: null,
  timestamp: 0,
};
 
/**
 * Read stores from manifest file
 */
async function readManifest(): Promise<StoresManifest> {
  try {
    const fileContent = await fs.readFile(MANIFEST_PATH, 'utf-8');
    return JSON.parse(fileContent);
  } catch (error) {
    console.warn('[Stores API] Failed to read manifest, using fallback:', error);
    // Return fallback data
    return {
      version: '1.0.0',
      lastUpdated: new Date().toISOString(),
      stores: stores,
    };
  }
}
 
/**
 * Write stores to manifest file
 */
async function writeManifest(manifest: StoresManifest): Promise<void> {
  try {
    await fs.writeFile(MANIFEST_PATH, JSON.stringify(manifest, null, 2), 'utf-8');
    console.log('[Stores API] Manifest updated successfully');
  } catch (error) {
    console.error('[Stores API] Failed to write manifest:', error);
    throw error;
  }
}
 
/**
 * GET /api/auth/stores
 * Returns available stores for authentication
 * 
 * Dynamically fetches stores from manifest and transforms them
 * to use friendly IDs (iig, cowra, griffith, murwillumbah) for authentication
 * 
 * Query params:
 * - sync=true: Force sync with Fieldpine locations API
 */
export async function GET(request: NextRequest) {
  try {
    const searchParams = request.nextUrl.searchParams;
    const forceSync = searchParams.get('sync') === 'true';
    
    const now = Date.now();
    const cacheExpired = now - manifestCache.timestamp > CACHE_TTL_MS;
 
    // Use cache if valid and not forcing sync
    if (!forceSync && manifestCache.data && !cacheExpired) {
      // Transform manifest stores to authentication format
      const authStores = manifestCache.data.stores
        .map(transformManifestStore)
        .filter((store): store is Store => store !== null);
      
      console.log(`[Stores API] Returning ${authStores.length} cached authentication stores`);
      return NextResponse.json({
        success: true,
        data: authStores,
        cached: true,
        source: 'manifest',
        lastUpdated: manifestCache.data.lastUpdated,
      });
    }
 
    // Read from manifest file
    const manifest = await readManifest();
    
    // Update cache
    manifestCache = {
      data: manifest,
      timestamp: now,
    };
 
    // Transform manifest stores to authentication format
    const authStores = manifest.stores
      .map(transformManifestStore)
      .filter((store): store is Store => store !== null);
 
    console.log(`[Stores API] Returning ${authStores.length} authentication stores from manifest`);
    
    return NextResponse.json({
      success: true,
      data: authStores,
      cached: false,
      source: 'manifest',
      lastUpdated: manifest.lastUpdated,
    });
  } catch (error: any) {
    console.error('[Stores API] Error:', error);
    
    // Fallback to static stores on error
    return NextResponse.json(
      { 
        success: true,
        data: stores,
        fallback: true,
        error: error.message,
      },
      { status: 200 }
    );
  }
}
 
/**
 * POST /api/auth/stores/sync
 * Sync stores from Fieldpine locations API to manifest
 */
export async function POST(request: NextRequest) {
  try {
    console.log('[Stores API] Syncing stores from Fieldpine...');
    
    // Fetch locations from Fieldpine
    const locationsUrl = `${request.nextUrl.origin}/api/v1/locations`;
    console.log('[Stores API] Fetching from:', locationsUrl);
    
    const response = await fetch(locationsUrl, {
      headers: {
        'Cookie': request.headers.get('Cookie') || '',
      },
    });
    
    if (!response.ok) {
      throw new Error(`Failed to fetch locations: ${response.status}`);
    }
    
    const locations = await response.json();
    console.log('[Stores API] Fetched locations:', locations.length);
    
    // Map Fieldpine locations to Store format
    const stores = locations.map((loc: any) => {
      const id = loc.f100 || loc.id;
      const name = loc.f101 || loc.name || `Store ${id}`;
      const storeType = loc.f164 || loc.storeType || 'store';
      const phone = loc.f150 || loc.phone;
      const email = loc.f151 || loc.email;
      
      // Create store URL based on name or ID
      const urlSlug = name
        .toLowerCase()
        .replace(/cartridge world\s*/i, '')
        .replace(/[^a-z0-9]+/g, '-')
        .replace(/^-+|-+$/g, '') || id;
      
      return {
        id: id?.toString() || `store-${Math.random().toString(36).substr(2, 9)}`,
        name: name,
        url: `https://${urlSlug}.cwanz.online`,
        type: storeType === 'management' ? 'management' : 'store',
        ...(phone && { phone }),
        ...(email && { email }),
        ...(loc.f102 && loc.f103 && {
          coordinates: {
            latitude: parseFloat(loc.f102),
            longitude: parseFloat(loc.f103),
          },
        }),
      };
    });
    
    // Update manifest
    const newManifest: StoresManifest = {
      version: '1.0.0',
      lastUpdated: new Date().toISOString(),
      stores: stores,
    };
    
    await writeManifest(newManifest);
    
    // Clear cache
    manifestCache = { data: null, timestamp: 0 };
    
    console.log('[Stores API] Sync complete:', stores.length, 'stores');
    
    return NextResponse.json({
      success: true,
      message: 'Stores manifest synced successfully',
      storeCount: stores.length,
      lastUpdated: newManifest.lastUpdated,
    });
  } catch (error: any) {
    console.error('[Stores API] Sync error:', error);
    return NextResponse.json(
      { 
        success: false, 
        error: error.message || 'Failed to sync stores',
      },
      { status: 500 }
    );
  }
}