Por que TypeScript?

// Primitivos con anotacion explicita
const nombre:  string  = "Arrachera Premium";
const precio:  number  = 189.50;
const activo:  boolean = true;

// Inferencia — TS deduce el tipo automaticamente
const kilos = 2.5;     // inferido: number
const marca = "VLIM";  // inferido: string
let   stock = 42;      // inferido: number

// Arrays
const precios: number[]       = [189, 145, 98];
const tags:    Array<string> = ["res", "cerdo"];

// Tuplas — longitud y tipos fijos
const coord: [number, number]           = [19.43, -99.13];
const fila:  [string, number, boolean] = ["Bistec", 160, true];

// Enum — conjunto de valores nombrados
enum Estado {
  Activo    = "ACTIVO",
  Inactivo  = "INACTIVO",
  Pendiente = "PENDIENTE",
}
const est: Estado = Estado.Activo;

// unknown — alternativa segura a any
let respuesta: unknown;
if (typeof respuesta === "string") {
  console.log(respuesta.toUpperCase()); // ok — verificado
}

// Literal types — solo valores especificos
type Moneda     = "MXN" | "USD" | "EUR";
type MetodoHTTP = "GET" | "POST" | "PUT" | "DELETE";
const m: Moneda = "MXN";  // ok
// const m2: Moneda = "BTC"; // Error: not assignable

// never — funciones que nunca retornan
function error(msg: string): never {
  throw new Error(msg);
}

// Interface — forma de un objeto
interface Producto {
  id:        string;
  nombre:    string;
  precio:    number;
  unidad:    "kg" | "pieza" | "litro";
  activo?:   boolean;        // ? = opcional
  stock:     number;
  readonly creadoEn: string; // no se puede modificar
}

const arrachera: Producto = {
  id: "prod-001", nombre: "Arrachera Premium",
  precio: 189.50, unidad: "kg", stock: 42, creadoEn: "2024-01-15",
};

// Extender interfaces
interface ProductoConProveedor extends Producto {
  proveedorId:  string;
  codigoBarras: string;
  fechaVence?:  Date;
}

// Type alias — mas versatil
type ID          = string | number;
type EstadoVenta  = "pendiente" | "pagada" | "cancelada";

// Interseccion: combina dos tipos
type Auditado = {
  creadoPor:     string;
  creadoEn:      Date;
  actualizadoEn: Date;
};
type VentaAuditada = Venta & Auditado;

// Index signatures — claves dinamicas
interface PreciosPorSucursal {
  [sucursalId: string]: number;
}
const precios: PreciosPorSucursal = {
  "suc-01": 189, "suc-02": 195,
};

// Diferencia clave: interface permite declaration merging
interface Config { host: string }
interface Config { port: number }
// Config ahora tiene { host, port } fusionados
// type no puede fusionarse — genera Duplicate identifier

// Funcion basica con tipos
function conIva(precio: number, iva: number = 0.16): number {
  return precio * (1 + iva);
}

// Arrow function tipada
const formatMXN = (n: number): string =>
  new Intl.NumberFormat("es-MX", { style: "currency", currency: "MXN" }).format(n);

// Parametros opcionales y rest
function crearEtiqueta(nombre: string, peso?: number, ...extras: string[]): string {
  let label = nombre;
  if (peso !== undefined) label += ` ${peso}kg`;
  if (extras.length) label += ` [${extras.join(", ")}]`;
  return label;
}

// Function overloads — misma funcion, firmas distintas
function buscarProducto(id: string):    Producto;
function buscarProducto(codigo: number): Producto;
function buscarProducto(query: string | number): Producto {
  if (typeof query === "string") return db.findById(query);
  return db.findByCodigo(query);
}

// Tipo de funcion como interfaz
type CalculadoraPrecio = (precio: number, cantidad: number) => number;

const calcularSubtotal: CalculadoraPrecio = (precio, cantidad) => precio * cantidad;
const calcularDescuento: CalculadoraPrecio = (precio, pct) => precio * (pct / 100);

// Higher-order functions tipadas
function aplicarDescuento(
  fn: CalculadoraPrecio,
  precio: number,
  arg: number
): number {
  return precio - fn(precio, arg);
}

// Callback con tipos
function procesarVentas(
  ventas:   Venta[],
  onExito:  (venta: Venta) => void,
  onError?: (err: Error, venta: Venta) => void
): void {
  ventas.forEach(v => {
    try   { onExito(v); }
    catch (e) { onError?.(e as Error, v); }
  });
}

// Generic basico — <T> es el parametro de tipo
function primero<T>(arr: T[]): T | undefined {
  return arr[0];
}
primero([1, 2, 3]);           // T = number
primero(["a", "b"]);          // T = string

// Respuesta paginada generica — reutilizable para cualquier entidad
interface PaginaRespuesta<T> {
  data:    T[];
  total:   number;
  pagina:  number;
  limite:  number;
  siguiente?: string;
}

// Se usa con cualquier entidad
const resp: PaginaRespuesta<Producto> = {
  data: [arrachera], total: 120, pagina: 1, limite: 20,
};

// Constraints — limitar que tipos acepta el generic
function obtenerNombre<T extends { nombre: string }>(entidad: T): string {
  return entidad.nombre;
}
obtenerNombre(arrachera);     // ok — Producto tiene nombre
obtenerNombre({ nombre: "Juan", rol: "admin" }); // ok

// Generic con multiples parametros
function mapear<T, R>(arr: T[], fn: (item: T) => R): R[] {
  return arr.map(fn);
}
const totales = mapear(ventas, v => v.total);  // T=Venta, R=number

// Clase generica — repositorio base del ERP
class Repositorio<T extends { id: string }> {
  private items: Map<string, T> = new Map();

  guardar(item: T): void           { this.items.set(item.id, item); }
  obtener(id: string): T | undefined { return this.items.get(id); }
  listar(): T[]                      { return [...this.items.values()]; }
  eliminar(id: string): boolean      { return this.items.delete(id); }
}

const productos = new Repositorio<Producto>();
const usuarios  = new Repositorio<Usuario>();

// Union type — puede ser cualquiera de los tipos
type EntradaBusqueda = string | number | string[];

function buscar(query: EntradaBusqueda) {
  if (typeof query === "string") {
    return db.buscarPorNombre(query);   // narrowed: string
  }
  if (typeof query === "number") {
    return db.buscarPorId(query);       // narrowed: number
  }
  return db.buscarMultiples(query);    // narrowed: string[]
}

// Discriminated unions — patron muy comun en ERP
type EventoVenta =
  | { tipo: "creada";    venta: Venta;   sucursalId: string }
  | { tipo: "cancelada"; ventaId: string; razon: string  }
  | { tipo: "pagada";    ventaId: string; monto: number  }
  | { tipo: "devuelta";  ventaId: string; items: string[] };

function manejarEvento(ev: EventoVenta): void {
  switch (ev.tipo) {
    case "creada":
      registrarVenta(ev.venta);            // ev.venta disponible
      break;
    case "cancelada":
      cancelarVenta(ev.ventaId, ev.razon); // ev.razon disponible
      break;
    case "pagada":
      procesarPago(ev.ventaId, ev.monto);  // ev.monto disponible
      break;
    default:
      const _exhaustive: never = ev; // Error si falta un caso
  }
}

// Type guards personalizados — is keyword
function esProductoCarne(p: Producto): p is ProductoCarne {
  return ["res", "cerdo", "aves"].includes((p as ProductoCarne).categoria);
}

function procesarProducto(p: Producto) {
  if (esProductoCarne(p)) {
    console.log(p.categoria, p.corte); // narrowed: ProductoCarne
  }
}

// Nullish handling — muy comun con datos de BD
function getNombreCliente(venta: Venta): string {
  return venta.cliente?.nombre ?? "Cliente mostrador";
}

// Assertion functions — asegurar tipos en runtime
function assertDefined<T>(val: T, msg: string): asserts val is NonNullable<T> {
  if (val === null || val === undefined) throw new Error(msg);
}

interface Producto {
  id: string; nombre: string; precio: number; stock: number; activo: boolean;
}

// Partial<T> — todos los campos opcionales (para PATCH/update)
type ActualizarProducto = Partial<Producto>;
const update: ActualizarProducto = { precio: 195 }; // ok, resto opcional

// Required<T> — todos los campos obligatorios
type ProductoCompleto = Required<Producto>;

// Readonly<T> — todo inmutable (respuestas de API)
type ProductoAPI = Readonly<Producto>;
// productoAPI.precio = 200; // Error: cannot assign to readonly

// Pick<T, Keys> — seleccionar solo algunos campos
type ProductoResumen = Pick<Producto, "id" | "nombre" | "precio">;
type CrearProducto   = Pick<Producto, "nombre" | "precio" | "stock">;

// Omit<T, Keys> — excluir campos
type ProductoSinId = Omit<Producto, "id">;
type ProductoPublico = Omit<Producto, "stock" | "activo">;

// Record<Keys, Type> — mapa tipado
type StockPorSucursal = Record<string, number>;
type PermisoPorRol    = Record<"admin"|"cajero"|"bodeguero", string[]>;

// Exclude / Extract — filtrar uniones
type EstadoActivo = Exclude<EstadoVenta, "cancelada" | "devuelta">;
// = "pendiente" | "pagada"

// ReturnType / Parameters — extraer tipos de funciones
type ResultadoCalculo  = ReturnType<typeof calcularLinea>;
type ParamsCalculadora = Parameters<typeof calcularLinea>;

// NonNullable — elimina null y undefined de un tipo
type ClienteDefinido = NonNullable<Venta["cliente"]>;

// Awaited<T> (TS 4.5+) — tipo que devuelve una Promise
type ProductoDB = Awaited<ReturnType<typeof obtenerProducto>>;

// Clase con modificadores de acceso
class EntidadBase {
  readonly id: string;
  protected creadoEn: Date;
  private _version: number = 1;

  constructor(id?: string) {
    this.id = id ?? crypto.randomUUID();
    this.creadoEn = new Date();
  }

  get version(): number { return this._version; }

  toJSON(): Record<string, unknown> {
    return { id: this.id, creadoEn: this.creadoEn };
  }
}

// Clase hija que implementa una interface
interface IProducto {
  calcularPrecioFinal(cantidad: number): number;
  aplicarDescuento(pct: number): this;
}

class Producto extends EntidadBase implements IProducto {
  private _precio: number;
  private _descuento: number = 0;

  constructor(
    public readonly nombre: string,   // shorthand: crea y asigna
    precio: number,
    public readonly unidad: string = "kg",
  ) {
    super();
    this._precio = precio;
  }

  get precio(): number { return this._precio; }
  set precio(v: number) {
    if (v < 0) throw new Error("Precio no puede ser negativo");
    this._precio = v;
  }

  calcularPrecioFinal(cantidad: number): number {
    const base = this._precio * cantidad * (1 - this._descuento);
    return base * 1.16;  // IVA incluido
  }

  aplicarDescuento(pct: number): this {
    this._descuento = pct / 100;
    return this;  // fluent API
  }

  static desdeBD(row: Record<string, unknown>): Producto {
    const p = new Producto(row.nombre as string, row.precio as number);
    return p;
  }
}

// Uso: fluent API
const p = new Producto("Arrachera", 189)
  .aplicarDescuento(10);

console.log(p.calcularPrecioFinal(2)); // 189*2*0.9*1.16

// Parametros y retorno tipados
function calcularTotal(precio: number, cantidad: number): number {
  return precio * cantidad;
}

// Parametros opcionales y con valor por defecto
function formatPrecio(
  valor: number,
  moneda: string = "MXN",    // default
  decimales?: number          // opcional
): string {
  return new Intl.NumberFormat("es-MX", {
    style: "currency", currency: moneda,
    minimumFractionDigits: decimales ?? 2,
  }).format(valor);
}

// Arrow functions tipadas
const conIVA = (precio: number): number => precio * 1.16;

// Funcion que retorna void (no retorna valor util)
const logVenta = (ventaId: string): void => {
  console.log(`Venta registrada: ${ventaId}`);
};

// Tipado de funciones como valor (Function type)
type Transformador = (valor: number) => number;
const aplicarDescuento: Transformador = (v) => v * 0.9;

// Sobrecarga de funciones (overloads)
function buscarProducto(id: number): Producto;
function buscarProducto(codigo: string): Producto;
function buscarProducto(param: number | string): Producto {
  if (typeof param === "number") {
    return buscarPorId(param);
  }
  return buscarPorCodigo(param);
}

// Rest parameters tipados
function sumarPrecios(...precios: number[]): number {
  return precios.reduce((a, b) => a + b, 0);
}

// Callbacks tipados
function procesarItems(
  items: Producto[],
  callback: (item: Producto, index: number) => void
): void {
  items.forEach(callback);
}

// Generic basico — T es un "tipo parametro"
function primerElemento<T>(array: T[]): T | undefined {
  return array[0];
}
const p1 = primerElemento([1, 2, 3]);       // inferido: number | undefined
const p2 = primerElemento(["a", "b"]);      // inferido: string | undefined

// Respuesta API generica — patron muy usado en el ERP
interface ApiResponse<T> {
  data:    T;
  total?:  number;
  pagina?: number;
  ok:      boolean;
  error?:  string;
}

type ProductosResponse = ApiResponse<Producto[]>;
type VentaResponse    = ApiResponse<Venta>;

// Restricciones con extends
interface ConId { id: string }

function buscarPorId<T extends ConId>(items: T[], id: string): T | undefined {
  return items.find(item => item.id === id);
}
// Funciona con cualquier objeto que tenga .id
buscarPorId(productos, "prod-001");
buscarPorId(ventas,    "vta-042");

// Multiples parametros de tipo
function mapeo<K extends string, V>(keys: K[], val: V): Record<K, V> {
  return Object.fromEntries(keys.map(k => [k, val])) as Record<K, V>;
}

// Clase generica — repositorio generico del ERP
class Repositorio<T extends ConId> {
  private items: Map<string, T> = new Map();

  guardar(item: T): void {
    this.items.set(item.id, item);
  }
  buscar(id: string): T | undefined {
    return this.items.get(id);
  }
  todos(): T[] {
    return [...this.items.values()];
  }
}

const repoProductos = new Repositorio<Producto>();
const repoVentas    = new Repositorio<Venta>();

// ── Union types ───────────────────────────────────────
type StringOrNumber = string | number;
type NullableString = string | null;

// ── typeof narrowing ──────────────────────────────────
function formatId(id: string | number): string {
  if (typeof id === "number") {
    return id.toString().padStart(6, "0");  // TS sabe: id es number aqui
  }
  return id.toUpperCase();                   // TS sabe: id es string aqui
}

// ── Discriminated unions — patron clave del ERP ───────
interface PagoEfectivo {
  tipo:   "efectivo";
  monto:  number;
}
interface PagoTarjeta {
  tipo:        "tarjeta";
  monto:       number;
  ultimos4:    string;
  autorizacion:string;
}
interface PagoTransferencia {
  tipo:    "transferencia";
  monto:   number;
  clabe:   string;
  banco:   string;
}
type Pago = PagoEfectivo | PagoTarjeta | PagoTransferencia;

function procesarPago(pago: Pago): string {
  switch (pago.tipo) {
    case "efectivo":
      return `Efectivo: $${pago.monto}`;
    case "tarjeta":
      return `Tarjeta ***${pago.ultimos4} auth:${pago.autorizacion}`;
    case "transferencia":
      return `SPEI ${pago.banco} CLABE:${pago.clabe}`;
    default:
      const _exhaustive: never = pago; // error si falta un caso
      return _exhaustive;
  }
}

// ── Type guards personalizados ────────────────────────
function esPagoTarjeta(pago: Pago): pago is PagoTarjeta {
  return pago.tipo === "tarjeta";
}

// ── Nullish narrowing ─────────────────────────────────
function obtenerNombre(p: Producto | null): string {
  if (!p) return "Sin producto";
  return p.nombre;                    // TS sabe: p no es null aqui
}

// ── Optional chaining + nullish coalescing ────────────
const ciudad = cliente?.direccion?.ciudad ?? "Sin ciudad";

interface Producto {
  id:       string;
  nombre:   string;
  precio:   number;
  stock:    number;
  activo:   boolean;
  creadoEn: Date;
}

// Partial — todas las propiedades opcionales (PATCH/update)
type ActualizarProducto = Partial<Producto>;
// { id?: string; nombre?: string; precio?: number; ... }

// Required — todas obligatorias (inversion de Partial)
type ProductoCompleto = Required<Producto>;

// Readonly — ninguna propiedad modificable
type ProductoFijo = Readonly<Producto>;

// Pick — seleccionar solo algunas propiedades
type ProductoLista = Pick<Producto, "id" | "nombre" | "precio">;
// { id: string; nombre: string; precio: number }

// Omit — excluir algunas propiedades (DTO de creacion)
type CrearProducto = Omit<Producto, "id" | "creadoEn">;
// { nombre: string; precio: number; stock: number; activo: boolean }

// Record — objeto con claves y valores tipados
type StockPorSucursal = Record<string, number>;
type CacheProductos   = Record<string, Producto>;

const stock: StockPorSucursal = {
  "suc-01": 42, "suc-02": 18, "suc-03": 5
};

// Exclude / Extract — filtrar unions
type EstadoVenta  = "pendiente" | "pagada" | "cancelada" | "devuelta";
type EstadoFinal  = Extract<EstadoVenta, "pagada" | "cancelada">;   // "pagada" | "cancelada"
type EstadoActivo = Exclude<EstadoVenta, "cancelada" | "devuelta">;  // "pendiente" | "pagada"

// NonNullable — elimina null y undefined
type ClienteSeguro = NonNullable<Cliente | null | undefined>;  // Cliente

// ReturnType — extrae el tipo de retorno de una funcion
function crearVenta() { return { id: "", total: 0, items: [] }; }
type Venta = ReturnType<typeof crearVenta>;

// Parameters — extrae parametros de una funcion
type ParamsCalcular = Parameters<typeof calcularTotal>;
// [precio: number, cantidad: number]

// Awaited — extrae el tipo resuelto de una Promise (TS 4.5+)
type ResultadoDB = Awaited<ReturnType<typeof buscarProductoAsync>>;

abstract class EntidadBase {
  readonly id: string;
  readonly creadoEn: Date;
  actualizadoEn: Date;

  constructor(id?: string) {
    this.id          = id ?? crypto.randomUUID();
    this.creadoEn    = new Date();
    this.actualizadoEn = new Date();
  }

  abstract validar(): boolean;   // subclases deben implementar

  toJSON(): Record<string, unknown> {
    return { id: this.id, creadoEn: this.creadoEn };
  }
}

class Producto extends EntidadBase {
  // Campo privado — verdaderamente inaccesible fuera (ES2022)
  #stockInterno: number;

  constructor(
    public readonly nombre: string,     // shorthand: crea y asigna en constructor
    public          precio: number,
    private         codigoBarra: string,
    stockInicial: number = 0
  ) {
    super();
    this.#stockInterno = stockInicial;
  }

  // Getter/setter tipados
  get stock(): number { return this.#stockInterno; }

  set stock(cantidad: number) {
    if (cantidad < 0) throw new Error("Stock no puede ser negativo");
    this.#stockInterno = cantidad;
    this.actualizadoEn = new Date();
  }

  precioConIVA(): number { return this.precio * 1.16; }

  static desdeBD(row: Record<string, unknown>): Producto {
    const p = new Producto(
      row.nombre as string,
      row.precio as number,
      row.codigo_barra as string,
      row.stock as number
    );
    return p;
  }

  validar(): boolean {
    return this.nombre.length > 0 && this.precio > 0;
  }
}

// Interfaces para clases — contrato publico
interface IServicio<T> {
  buscarPorId(id: string): Promise<T | null>;
  listar(filtros?: Partial<T>): Promise<T[]>;
  crear(datos: Omit<T, "id">): Promise<T>;
  actualizar(id: string, datos: Partial<T>): Promise<T>;
  eliminar(id: string): Promise<void>;
}

class ProductosService implements IServicio<Producto> {
  // TS verifica que implementa TODOS los metodos de la interfaz
  async buscarPorId(id: string): Promise<Producto | null> { return null; }
  async listar(): Promise<Producto[]> { return []; }
  async crear(datos: Omit<Producto, "id">): Promise<Producto> { return datos as Producto; }
  async actualizar(id: string, datos: Partial<Producto>): Promise<Producto> { return datos as Producto; }
  async eliminar(id: string): Promise<void> { }
}

{
  "compilerOptions": {
    // Target y formato de salida
    "target":       "ES2022",
    "module":       "NodeNext",    // ESM nativo de Node 20
    "moduleResolution": "NodeNext",
    "outDir":       "./dist",
    "rootDir":      "./src",

    // Strict mode — SIEMPRE activar en proyectos nuevos
    "strict":                       true,  // activa los 8 de abajo
    "noImplicitAny":                true,  // parametros sin tipo -> error
    "strictNullChecks":             true,  // null/undefined separados
    "strictFunctionTypes":          true,
    "strictPropertyInitialization": true,  // propiedades inicializadas
    "noUncheckedIndexedAccess":     true,  // array[i] puede ser undefined

    // Calidad extra
    "noUnusedLocals":       true,
    "noUnusedParameters":   true,
    "noImplicitReturns":    true,
    "exactOptionalPropertyTypes": true,

    // Utilidades
    "sourceMap":      true,
    "declaration":    true,    // genera .d.ts
    "esModuleInterop":true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,  // import config from './config.json'

    // Para path aliases (@/services/...)
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]
    }
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

{
  "scripts": {
    "build":     "tsc",
    "dev":       "tsx watch src/index.ts",     // tsx: ts-node alternativa mas rapida
    "typecheck": "tsc --noEmit",              // solo verificar, no compilar
    "start":     "node dist/index.js"
  },
  "devDependencies": {
    "typescript": "^5.4.0",
    "tsx":        "^4.0.0",       // ejecuta TS directamente en Node
    "@types/node":"^20.0.0"      // tipos de Node.js
  }
}

// Promise tipada — T es el tipo resuelto
async function buscarProducto(id: string): Promise<Producto | null> {
  const row = await db.query('SELECT * FROM productos WHERE id=$1', [id]);
  return row ? Producto.desdeBD(row) : null;
}

async function listarProductos(filtros?: {
  activo?: boolean;
  limite?: number;
  offset?: number;
}): Promise<{ data: Producto[]; total: number }> {
  const { activo = true, limite = 20, offset = 0 } = filtros ?? {};
  const [data, total] = await Promise.all([
    db.queryRows<Producto>('SELECT * FROM productos WHERE activo=$1 LIMIT $2 OFFSET $3', [activo, limite, offset]),
    db.queryOne<{ count: number }>('SELECT COUNT(*) FROM productos WHERE activo=$1', [activo]),
  ]);
  return { data, total: total?.count ?? 0 };
}

// Result type — alternativa a try/catch en toda la cadena
type Ok<T>  = { ok: true;  data: T };
type Err<E> = { ok: false; error: E };
type Result<T, E = string> = Ok<T> | Err<E>;

async function registrarVenta(dto: CrearVenta): Promise<Result<Venta>> {
  try {
    const venta = await ventasService.crear(dto);
    return { ok: true, data: venta };
  } catch (e) {
    return { ok: false, error: e instanceof Error ? e.message : "Error desconocido" };
  }
}

// Uso con narrowing automatico
const resultado = await registrarVenta(dto);
if (resultado.ok) {
  console.log(resultado.data.id);    // TS sabe: data es Venta
} else {
  console.error(resultado.error);    // TS sabe: error es string
}

// Tipar respuestas de APIs externas con zod (validacion en runtime)
// import { z } from 'zod';
// const ProductoSchema = z.object({ id: z.string(), precio: z.number() });
// type ProductoAPI = z.infer<typeof ProductoSchema>;

// ── Mapped types — transformar cada propiedad ─────────
type Nullable<T> = { [K in keyof T]: T[K] | null };
type Getters<T>  = { [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K] };

// Template Literal Types — generar nombres de eventos
type Entidad  = "venta" | "producto" | "cliente";
type Accion   = "creado" | "actualizado" | "eliminado";
type Evento   = `${Entidad}.${Accion}`;
// "venta.creado" | "venta.actualizado" | ... | "cliente.eliminado"

function onEvento(evento: Evento, handler: () => void): void { /* ... */ }
onEvento("venta.creado", handler);      // ok
// onEvento("sucursal.creado", handler); // Error — no es Evento valido

// Conditional types — tipo que depende de una condicion
type IsArray<T> = T extends any[] ? true : false;
type Unwrap<T>  = T extends Promise<infer U> ? U : T;
// Unwrap<Promise<Producto>> → Producto
// Unwrap<string>           → string

// keyof y typeof — reflexion de tipos
const CONFIG = { host: "localhost", port: 5432, ssl: false } as const;
type ConfigKey   = keyof typeof CONFIG;  // "host" | "port" | "ssl"
type ConfigValue = (typeof CONFIG)[ConfigKey]; // string | number | boolean

// Satisfies — verifica tipo sin perder informacion
const roles = {
  admin:   ["ventas.crear", "productos.editar", "reportes.ver"],
  cajero:  ["ventas.crear"],
  gerente: ["reportes.ver", "ventas.crear"],
} satisfies Record<string, string[]>;

roles.admin  // TS sabe que es string[], no solo string[]
roles.cajero // acceso seguro por clave literal

// Decoradores (experimental, Moleculer los usa con reflect-metadata)
// @Service({ name: "productos" })
// class ProductosService { ... }

// ── types/dominio.ts — fuente unica de verdad ─────────

export type ID      = string;
export type Dinero  = number;  // siempre en pesos MXN
export type Kilos   = number;

export interface Auditado {
  creadoEn:      Date;
  actualizadoEn: Date;
  creadoPor:     ID;
}

export interface Producto extends Auditado {
  id:          ID;
  nombre:      string;
  codigo:      string;
  precio:      Dinero;
  unidad:      "kg" | "pieza" | "litro";
  categoria:   "res" | "cerdo" | "pollo" | "embutido" | "otro";
  perecedero:  boolean;
  activo:      boolean;
}

export interface LineaVenta {
  productoId: ID;
  nombre:     string;
  cantidad:   number;
  precio:     Dinero;
  descuento:  number;   // 0-1
  subtotal:   Dinero;
  iva:        Dinero;
  total:      Dinero;
}

export type MetodoPago  = "efectivo" | "tarjeta" | "transferencia" | "credito";
export type EstadoVenta = "abierta"  | "pagada"  | "cancelada"     | "devuelta";

export interface Venta extends Auditado {
  id:          ID;
  sucursalId:  ID;
  clienteId?:  ID;
  items:       LineaVenta[];
  subtotal:    Dinero;
  descuentos:  Dinero;
  iva:         Dinero;
  total:       Dinero;
  metodoPago:  MetodoPago;
  estado:      EstadoVenta;
  folio:       string;
  cfdiUUID?:   string;
}

// ── DTOs de entrada ───────────────────────────────────
export type CrearVentaDTO = Pick<Venta,
  "sucursalId" | "clienteId" | "metodoPago"
> & {
  items: Array<{
    productoId: ID;
    cantidad:   number;
    descuento?: number;
  }>;
};

// ── Servicio tipado con Result ─────────────────────────
type Result<T> = { ok: true; data: T } | { ok: false; error: string; code: number };

export interface IVentasService {
  registrar(dto: CrearVentaDTO): Promise<Result<Venta>>;
  cancelar(id: ID, motivo: string): Promise<Result<Venta>>;
  listar(filtros: {
    sucursalId?: ID;
    fechaDesde?: Date;
    fechaHasta?: Date;
    estado?:     EstadoVenta;
    pagina?:     number;
    limite?:     number;
  }): Promise<{ data: Venta[]; total: number }>;
}

// ── Eventos tipados para Moleculer ────────────────────
export type EventoVenta =
  | { tipo: "venta.registrada"; venta: Venta }
  | { tipo: "venta.cancelada";  ventaId: ID; motivo: string }
  | { tipo: "venta.cfdi.emitido"; ventaId: ID; uuid: string };