Master Data Catalogs

interface Proveedor {
  id: string
  nombre: string        // Supplier name
  activo: boolean       // Active/inactive status
  created_at: string
}

interface Producto {
  id: string
  nombre: string           // Product name
  descripcion: string | null  // Optional description
  activo: boolean
  created_at: string
}

interface Presentacion {
  id: string
  nombre: string       // Presentation format
  activo: boolean
  created_at: string
}

interface Destino {
  id: string
  nombre: string       // Location name
  activo: boolean
  created_at: string
}

interface Estatus {
  id: string
  nombre: string       // Status name
  color_hex: string    // Hex color code for visual display
  activo: boolean
  created_at: string
}

interface Unidad {
  id: string
  nombre: string           // Full unit name
  abreviatura: string      // Abbreviated form
  activo: boolean
  created_at: string
}

import { createCatalogEntry } from '@/lib/actions/catalogos'

// Create a new supplier
const result = await createCatalogEntry('proveedores', {
  nombre: 'Nuevo Proveedor SA de CV'
})

if (result.error) {
  console.error('Error:', result.error)
} else {
  console.log('Created:', result.data)
}

// Create a product with description
const result = await createCatalogEntry('productos', {
  nombre: 'Acido Clorhídrico',
  descripcion: 'Solución al 37%, grado industrial'
})

// Create a unit of measure
const result = await createCatalogEntry('unidades', {
  nombre: 'Metros cúbicos',
  abreviatura: 'm³'
})

// Create a status with color
const result = await createCatalogEntry('estatus', {
  nombre: 'En Espera',
  color_hex: '#FCD34D'
})

import { updateCatalogEntry } from '@/lib/actions/catalogos'

// Update supplier name
const result = await updateCatalogEntry(
  'proveedores',
  supplierId,
  {
    nombre: 'Proveedor Actualizado SA'
  }
)

// Update product description
const result = await updateCatalogEntry(
  'productos',
  productId,
  {
    descripcion: 'Nueva descripción técnica'
  }
)

// Update status color
const result = await updateCatalogEntry(
  'estatus',
  statusId,
  {
    color_hex: '#34D399'
  }
)

import { toggleCatalogStatus } from '@/lib/actions/catalogos'

// Deactivate a supplier
const result = await toggleCatalogStatus(
  'proveedores',
  supplierId,
  false  // Set to inactive
)

// Reactivate a product
const result = await toggleCatalogStatus(
  'productos',
  productId,
  true  // Set to active
)

import { deleteCatalogEntry } from '@/lib/actions/catalogos'

const result = await deleteCatalogEntry('proveedores', supplierId)

if (result.error) {
  // Handle foreign key constraint errors
  console.error(result.error)
  // Likely: "No se puede eliminar porque está siendo utilizado..."
}

-- All authenticated users can read catalogs
CREATE POLICY "proveedores: all authenticated can select" ON proveedores
  FOR SELECT TO authenticated USING (TRUE);

-- Only admin can create/update/delete
CREATE POLICY "proveedores: admin full access" ON proveedores
  FOR ALL TO authenticated 
  USING (get_my_role() = 'admin')
  WITH CHECK (get_my_role() = 'admin');

import { useCatalogos } from '@/lib/hooks/useCatalogos'

function RequisicionForm() {
  const { catalogos, loading } = useCatalogos()
  
  return (
    <Select
      value={form.watch('proveedor_id')}
      onValueChange={(val) => form.setValue('proveedor_id', val)}
    >
      <SelectTrigger>
        <SelectValue placeholder="Seleccionar proveedor" />
      </SelectTrigger>
      <SelectContent>
        {catalogos.proveedores
          .filter(p => p.activo || p.id === currentValue)
          .map(p => (
            <SelectItem key={p.id} value={p.id}>
              {p.nombre}
            </SelectItem>
          ))}
      </SelectContent>
    </Select>
  )
}

<Button
  type="button"
  variant="outline"
  size="icon"
  className="h-8 w-8 shrink-0 border-dashed"
  onClick={() => setQuickAdd({ 
    open: true, 
    title: 'Proveedor', 
    table: 'proveedores', 
    field: 'proveedor_id' 
  })}
>
  <Plus className="h-3 w-3" />
</Button>

import { getCatalogos } from '@/lib/actions/requisiciones'

const catalogos = await getCatalogos()

// Returns:
interface Catalogos {
  proveedores: Proveedor[]
  productos: Producto[]
  presentaciones: Presentacion[]
  destinos: Destino[]
  estatus: Estatus[]
  unidades: Unidad[]
}

const [proveedores, productos, presentaciones, destinos, estatus, unidades] =
  await Promise.all([
    supabase.from('proveedores').select('*').order('nombre'),
    supabase.from('productos').select('*').order('nombre'),
    supabase.from('presentaciones').select('*').order('nombre'),
    supabase.from('destinos').select('*').order('nombre'),
    supabase.from('estatus').select('*').order('nombre'),
    supabase.from('unidades').select('*').order('nombre'),
  ])

import { revalidatePath } from 'next/cache'

// After create/update/delete
revalidatePath('/dashboard/catalogos')
revalidatePath('/dashboard/requisiciones')
revalidatePath('/dashboard/requisiciones/nueva')

CREATE TABLE proveedores (
  id          UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  nombre      TEXT NOT NULL,
  activo      BOOLEAN NOT NULL DEFAULT TRUE,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
);