async function loadUnits() {
  try {
    const response = await fetch('http://localhost:3000/api/pos/unidadmedida', {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    
    const units = await response.json();
    
    const select = document.getElementById('unitSelect');
    units.forEach(unit => {
      const option = document.createElement('option');
      option.value = unit.um_codigo;
      option.textContent = unit.um_descripcion;
      select.appendChild(option);
    });
  } catch (error) {
    console.error('Error loading units:', error);
  }
}

import requests

def get_units_lookup(token):
    url = "http://localhost:3000/api/pos/unidadmedida"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    units = response.json()
    
    # Create a dictionary for quick lookups
    units_dict = {
        unit['um_codigo']: unit['um_descripcion']
        for unit in units
        if unit['um_estado'] == 'ACT'
    }
    
    return units_dict

# Usage
units = get_units_lookup(token)
print(units['KG'])  # Output: "Kilogramo"
print(units['UN'])  # Output: "Unidad"

import { createContext, useContext, useState, useEffect } from 'react';

const UnitsContext = createContext();

export function UnitsProvider({ children, token }) {
  const [units, setUnits] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    async function fetchUnits() {
      try {
        const response = await fetch('http://localhost:3000/api/pos/unidadmedida', {
          headers: {
            'Authorization': `Bearer ${token}`
          }
        });
        
        const data = await response.json();
        setUnits(data);
      } catch (error) {
        console.error('Error loading units:', error);
      } finally {
        setLoading(false);
      }
    }

    fetchUnits();
  }, [token]);

  const getUnitDescription = (codigo) => {
    const unit = units.find(u => u.um_codigo === codigo);
    return unit ? unit.um_descripcion : codigo;
  };

  return (
    <UnitsContext.Provider value={{ units, loading, getUnitDescription }}>
      {children}
    </UnitsContext.Provider>
  );
}

export function useUnits() {
  return useContext(UnitsContext);
}

// Usage in component
function ProductDisplay({ product }) {
  const { getUnitDescription } = useUnits();
  
  return (
    <div>
      <h3>{product.name}</h3>
      <p>Precio: ${product.price} / {getUnitDescription(product.um_codigo)}</p>
    </div>
  );
}

interface UnidadMedida {
  um_codigo: string;
  um_descripcion: string;
  um_estado: 'ACT' | 'INA';
}

class UnitsService {
  private static units: UnidadMedida[] = [];
  private static lastFetch: number = 0;
  private static CACHE_DURATION = 3600000; // 1 hour

  static async getUnits(token: string): Promise<UnidadMedida[]> {
    const now = Date.now();
    
    // Return cached units if still fresh
    if (this.units.length > 0 && now - this.lastFetch < this.CACHE_DURATION) {
      return this.units;
    }

    const response = await fetch('http://localhost:3000/api/pos/unidadmedida', {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });

    if (!response.ok) {
      throw new Error('Failed to fetch units of measurement');
    }

    this.units = await response.json();
    this.lastFetch = now;
    return this.units;
  }

  static getActiveUnits(): UnidadMedida[] {
    return this.units.filter(u => u.um_estado === 'ACT');
  }

  static findByCode(codigo: string): UnidadMedida | undefined {
    return this.units.find(u => u.um_codigo === codigo);
  }
}

// Usage
const units = await UnitsService.getUnits(token);
const kgUnit = UnitsService.findByCode('KG');
console.log(kgUnit?.um_descripcion); // "Kilogramo"

interface UnidadMedida {
  um_codigo: string;         // Primary key, unique identifier (e.g., "KG", "UN")
  um_descripcion: string;    // Unit name/description (e.g., "Kilogramo", "Unidad")
  um_estado: 'ACT' | 'INA'; // Active or Inactive status
}

const getAll = async (req, res) => {
  const pool = connectFromJWT(req);

  try {
    const result = await getAllQuery(pool);

    if (!result.length) {
      return res.status(404).json({ message: 'No se encontraron unidades de medida' });
    }
    res.status(200).json(result);
  } catch (error) {
    res.status(500).json({ message: error.message });
  } finally {
    await pool.end();
  }
};

const getAllQuery = async (pool) => {
  const query = 'SELECT * FROM unidadmedida ORDER BY um_descripcion';
  const result = await pool.query(query);
  return result.rows;
};