Data Sources

dataSources: [
  {
    id: 'source-1',
    name: 'Source One',
    adapter: 'static',
    adapterConfig: { path: '/data/source1.json' },
    enabled: true,
  },
  {
    id: 'source-2', 
    name: 'Source Two',
    adapter: 'supabase',
    adapterConfig: {},
    enabled: true,
  },
]

{
  "incidents": [
    {
      "id": "incident-001",
      "status": "published",
      "createdAt": "2024-01-15T00:00:00Z",
      "updatedAt": "2024-01-15T00:00:00Z",
      "temporal": {
        "date": "2024-01-15",
        "dateCertainty": "exact"
      },
      "location": {
        "name": "Phoenix, Arizona",
        "country": "United States",
        "latitude": 33.4484,
        "longitude": -112.074,
        "siteType": "urban",
        "locationSensitivity": "standard"
      },
      "summary": "Description of the incident."
    }
  ]
}

{
  id: 'my-data',
  name: 'My Incidents',
  adapter: 'static',
  adapterConfig: {
    path: '/data/my-incidents.json',
  },
  enabled: true,
}

CREATE TABLE incidents (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  status TEXT NOT NULL DEFAULT 'draft',
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW(),
  
  -- Temporal
  temporal JSONB NOT NULL,
  
  -- Location
  location JSONB NOT NULL,
  
  -- Optional sections
  summary TEXT,
  classification JSONB,
  witnesses JSONB,
  sensor_evidence JSONB,
  object_characteristics JSONB,
  movement JSONB,
  investigation JSONB,
  response_impact JSONB,
  source_data JSONB,
  environment JSONB,
  media JSONB,
  related_incidents JSONB
);

-- Enable RLS
ALTER TABLE incidents ENABLE ROW LEVEL SECURITY;

-- Public read access for published incidents
CREATE POLICY "Public read access"
  ON incidents FOR SELECT
  USING (status = 'published');

NEXT_PUBLIC_SUPABASE_URL=https://xxx.supabase.co
NEXT_PUBLIC_SUPABASE_ANON_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

{
  id: 'database',
  name: 'Production Database',
  adapter: 'supabase',
  adapterConfig: {
    // Uses env vars by default, or override here
    // url: 'https://your-project.supabase.co',
    // anonKey: 'your-anon-key',
  },
  enabled: true,
}

-- Only show published incidents publicly
CREATE POLICY "Public can view published"
  ON incidents FOR SELECT
  USING (status = 'published');

-- Authenticated users can view all
CREATE POLICY "Authenticated view all"
  ON incidents FOR SELECT
  TO authenticated
  USING (true);

{
  id: 'external-api',
  name: 'External Data',
  adapter: 'api',
  adapterConfig: {
    endpoint: 'https://api.example.com/incidents',
    
    // Optional: API key authentication
    apiKey: process.env.API_KEY,
    
    // Optional: custom headers
    headers: {
      'X-Custom-Header': 'value',
    },
  },
  enabled: true,
}

{
  "incidents": [
    {
      "id": "...",
      "temporal": { "date": "2024-01-15", "dateCertainty": "exact" },
      "location": { /* ... */ },
      // ... other fields
    }
  ],
  "meta": {
    "total": 150,
    "page": 1,
    "pageSize": 100
  }
}

dataSources: [
  {
    id: 'official',
    name: 'Official Reports',
    color: '#3b82f6', // Blue
    adapter: 'supabase',
    adapterConfig: {},
    enabled: true,
  },
  {
    id: 'community',
    name: 'Community Reports',
    color: '#10b981', // Green
    adapter: 'api',
    adapterConfig: { endpoint: 'https://community-api.example.com' },
    enabled: true,
  },
  {
    id: 'historical',
    name: 'Historical Archive',
    color: '#8b5cf6', // Purple
    adapter: 'static',
    adapterConfig: { path: '/data/historical.json' },
    enabled: false, // Off by default
  },
]

import type { DataAdapter, Incident, DataSourceConfig } from './types';

export class MyAdapter implements DataAdapter {
  readonly id: string;
  readonly name: string;
  
  constructor(config: DataSourceConfig) {
    this.id = config.id;
    this.name = config.name;
  }
  
  async getIncidents(): Promise<Incident[]> {
    // Fetch and transform your data
    const response = await fetch('...');
    const data = await response.json();
    return this.transformData(data);
  }
  
  async getIncidentById(id: string): Promise<Incident | null> {
    const incidents = await this.getIncidents();
    return incidents.find(i => i.id === id) || null;
  }
  
  async getFilterOptions() {
    const incidents = await this.getIncidents();
    return {
      countries: [...new Set(incidents.map(i => i.location?.country))],
      siteTypes: [...new Set(incidents.map(i => i.location?.siteType))],
      // ... other options
    };
  }
  
  private transformData(raw: any[]): Incident[] {
    return raw.map(item => ({
      id: item.id,
      status: 'published',
      temporal: { date: item.date, dateCertainty: 'exact' },
      location: {
        name: item.location,
        country: item.country,
        latitude: item.lat,
        longitude: item.lng,
        siteType: 'unknown',
        locationSensitivity: 'standard',
      },
      // ... map other fields
    }));
  }
}

import { MyAdapter } from './my-adapter';

export function createAdapter(config: DataSourceConfig): DataAdapter {
  switch (config.adapter) {
    case 'my-adapter':
      return new MyAdapter(config);
    // ... other cases
  }
}

const { refresh } = useData();
await refresh();

async getIncidents(): Promise<Incident[]> {
  try {
    const response = await fetch(this.endpoint);
    if (!response.ok) throw new Error('Fetch failed');
    return await response.json();
  } catch (error) {
    console.error('Failed to fetch incidents:', error);
    return []; // Return empty array on error
  }
}