# Funciones nuevas de la biblioteca Edge Estas funciones no existen en Devkron 2.0.1: las agrega la biblioteca Edge. Todas están en `dkle` y llegarán también a Devkron 2.0 con `edge.dkh` (ver [Devkron Edge y Devkron 2.0](/es/devkron/2.0/dkle/devkron2.md)), salvo `httpreq.body_b64`, que solo existe en `dkle`. Los ejemplos se ejecutaron con `dkle` 2.0.1 y muestran su salida real. ## Configuración y entorno | Función | Devuelve | Descripción | |---|---|---| | `config.get(llave)` | cadena | Valor de la sección `app` de `_config/.dkle.json`. Con `/` se entra a registros anidados (`"erp/url"`). Los números, lógicos, registros y listas se devuelven como su texto JSON. `""` si no existe | | `config.dget(llave, pred)` | cadena | Igual, con `pred` si la llave no existe | | `env.get(nombre)` | cadena | Variable de entorno del proceso, **solo** si su nombre está en la lista `env` de la configuración del sitio; si no está autorizada o no existe, `""` | | `env.dget(nombre, pred)` | cadena | Igual, con `pred` si no está autorizada o no existe | Con esta configuración del sitio y la variable `ERP_CLAVE` definida en el servicio: ```json { "app": { "erp": { "url": "https://erp.ejemplo.com/api", "reintentos": 3 }, "zona": "America/Mexico_City" }, "env": ["ERP_CLAVE"] } ``` ```dkl do print(config.get("erp/url")) do print(config.get("erp/reintentos")) do print(config.dget("moneda", "MXN")) do print(env.get("ERP_CLAVE")) do print("[" + env.get("HOME") + "]") do print(env.dget("NO_DEFINIDA", "pred")) ``` ``` https://erp.ejemplo.com/api 3 MXN clave-de-prueba [] pred ``` `HOME` existe en el proceso, pero el sitio no la tiene autorizada: para el programa no existe. Las dos funciones leen el archivo con caché y lo recargan cuando cambia. ## Caché: operaciones atómicas Complementan `cache.set`, `cache.get` y demás de [threads.dkh](/es/devkron/2.0/bibliotecas/estandar/threads.md). Como todo `cache.*` en Edge, trabajan sobre la caché del sitio. `segundos` en 0 (o negativo) quiere decir sin caducidad. | Función | Devuelve | Descripción | |---|---|---| | `cache.incr(llave, delta, segundos)` | número | Suma `delta` al número guardado y devuelve el resultado, de forma atómica. Si la llave no existe, la crea con `delta` y la caducidad indicada; si existe, conserva su caducidad. Error si la llave guarda algo que no es número | | `cache.set_nx(llave, valor, segundos)` | lógico | Guarda `valor` (cadena, registro o lista) **solo si la llave no existe** o ya caducó: `@true` si guardó, `@false` si ya existía. Atómico: entre dos peticiones simultáneas, solo una recibe `@true` | | `cache.keys(prefijo)` | lista | Las llaves vigentes que empiezan con `prefijo`, en orden; `""` las devuelve todas | | `cache.ttl(llave)` | número | Segundos que le quedan; `-1` si no caduca; `0` si no existe | ```dkl do print(cache.incr("visitas", 1, 0)) do print(cache.incr("visitas", 1, 0)) do print(cache.incr("visitas", 10, 0)) do print(cache.set_nx("evento:A1", "1", 3600)) do print(cache.set_nx("evento:A1", "1", 3600)) do cache.set("evento:B2", "1", 60) do print(to.json(cache.keys("evento:"))) do print(cache.ttl("evento:B2")) do print(cache.ttl("visitas")) do print(cache.ttl("no-existe")) ``` ``` 1 2 12 1 0 ["evento:A1","evento:B2"] 60 -1 0 ``` Uso típico de `cache.set_nx`: los proveedores reenvían un webhook si no reciben respuesta a tiempo, así que el mismo evento puede llegar dos veces: ```dkl if not(cache.set_nx("evento:" + field.str(evento, "id"), "1", 86400)) { new r {$$ "estado": "repetido" $$} do httpres.json(r) return 0 } ``` La caché es volátil: si `dkle` se reinicia, se pierde. Para una idempotencia que sobreviva reinicios, el destino debe rechazar el duplicado por su cuenta. ## Bitácora | Función | Descripción | |---|---| | `log.info(mensaje)`, `log.warn(mensaje)`, `log.error(mensaje)` | Una línea JSON con ese nivel | | `log.write(nivel, mensaje)` | Una línea con un nivel propio | | `log.json(registro)` | Una línea de nivel `info` con el registro como JSON en `msg` | ```dkl do log.info("pedido recibido") do log.warn("el cliente no trae correo") do log.write("auditoria", "cambio de precio") new d {$$ "pedido": "1001", "total": 34.00 $$} do log.json(d) ``` ``` {"t":"2026-11-01T16:04:16Z","sitio":"n.localhost","nivel":"info","msg":"pedido recibido"} {"t":"2026-11-01T16:04:16Z","sitio":"n.localhost","nivel":"warn","msg":"el cliente no trae correo"} {"t":"2026-11-01T16:04:16Z","sitio":"n.localhost","nivel":"auditoria","msg":"cambio de precio"} {"t":"2026-11-01T16:04:16Z","sitio":"n.localhost","nivel":"info","msg":{"pedido":"1001","total":34.00}} ``` Todo va a la salida estándar del proceso, en un solo flujo. No hay `log.to` ni `log.file`: guardar, rotar y enviar la bitácora a otro sistema le toca a `journald`, al contenedor o a la herramienta de registro que use. ## Petición y respuesta | Función | Devuelve | Descripción | |---|---|---| | `httpreq.path()` | cadena | La ruta pedida sin la consulta y **sin decodificar** (`/a%20b?q=1` da `/a%20b`). Detrás de `routes.map` es la ruta que pidió el cliente, no la del programa | | `httpreq.body_b64()` | cadena | El cuerpo tal como llegó, en base64 estándar: para cuerpos binarios (imágenes, PDF) que no se pueden manejar como texto. `""` sin cuerpo. **Solo en `dkle`** | | `httpres.binary_b64(b64, tipo, nombre)` | — | Responde el contenido de `b64` (base64 estándar; se ignoran espacios y saltos de línea) con el tipo indicado; con `nombre`, como descarga con ese nombre de archivo | ```dkl // Devuelve una copia del archivo binario recibido b64 = httpreq.body_b64() do log.info("recibí " + str(length(b64)) + " caracteres en base64; ruta " + httpreq.path()) do httpres.binary_b64(b64, "application/octet-stream", "copia.bin") ``` ``` $ curl -s -H "Host: n.localhost" --data-binary @archivo.bin http://127.0.0.1:8080/bin.dkl | od -c 0000000 h o l a \0 377 ``` ## Cliente HTTP | Función | Devuelve | Descripción | |---|---|---| | `http.forward_headers(nombres)` | registro | Los encabezados indicados de la **petición recibida**, con el nombre tal como se pidió, listos para pasarlos a `http.*`. `nombres` es una lista o una cadena separada por comas; los que no vienen en la petición se omiten | | `http.response_headers()` | registro | Los encabezados de la **última respuesta** recibida con `http.*` en esta ejecución (como `http.status()`). Los nombres no distinguen mayúsculas; un encabezado repetido trae sus valores unidos por coma | Con una petición que trae `X-Request-Id: abc-1`, `Authorization: Bearer t0k` y `User-Agent: prueba/1.0`: ```dkl do print(to.json(http.forward_headers("X-Request-Id, Authorization, X-No-Viene"))) ref l = list.create() do list.addstr(l, "User-Agent") do print(to.json(http.forward_headers(l))) ``` ``` {"X-Request-Id":"abc-1","Authorization":"Bearer t0k"} {"User-Agent":"prueba/1.0"} ``` `http.response_headers()` sirve, por ejemplo, para respetar `Retry-After` de un destino saturado: ```dkl ref r = http.post_json(url, encabezados, pedido) if http.status() == 429 { espera = val(field.dstr(http.response_headers(), "Retry-After", "5")) do log.warn("destino saturado; reintento en " + str(espera) + " s") } ``` ## Texto | Función | Devuelve | Descripción | |---|---|---| | `text.starts_with(texto, prefijo)` | lógico | `@true` si `texto` empieza con `prefijo`. Distingue mayúsculas | | `text.ends_with(texto, sufijo)` | lógico | `@true` si `texto` termina con `sufijo`. Distingue mayúsculas | ```dkl do print(text.starts_with("Factura-001", "Factura")) do print(text.ends_with("archivo.JSON", ".json")) ``` ``` 1 0 ``` ## Fechas Reciben una fecha numérica `AAAAMMDD.HHMMSS` como las de [time.dkh](/es/devkron/2.0/bibliotecas/estandar/time.md), interpretada en la **hora local del servidor** (igual que `date.unix`), y la escriben en UTC: | Función | Devuelve | Descripción | |---|---|---| | `date.iso_utc(fecha)` | cadena | ISO 8601 en UTC con `Z`: `2026-11-01T15:30:00Z` | | `date.http(fecha)` | cadena | Formato de los encabezados HTTP (RFC 1123), en GMT: `Sun, 01 Nov 2026 15:30:00 GMT` | En un servidor con zona `America/Mexico_City`: ```dkl do print(date.iso_utc(20261101.093000)) do print(date.http(20261101.093000)) ``` ``` 2026-11-01T15:30:00Z Sun, 01 Nov 2026 15:30:00 GMT ``` ## Hashes y codificación Como `hash.hmac_sha256`, reciben primero el texto y después la llave. La versión normal devuelve hexadecimal en minúsculas; la `_b64`, base64 estándar (la que piden, por ejemplo, las firmas de webhooks de Shopify). | Función | Devuelve | Descripción | |---|---|---| | `hash.hmac_sha256_b64(texto, llave)` | cadena | HMAC-SHA256 en base64 | | `hash.hmac_sha1(texto, llave)`, `hash.hmac_sha1_b64(texto, llave)` | cadena | HMAC-SHA1 en hexadecimal o base64 | | `hash.hmac_sha512(texto, llave)`, `hash.hmac_sha512_b64(texto, llave)` | cadena | HMAC-SHA512 en hexadecimal o base64 | | `hash.hex_to_b64(hex)`, `hash.b64_to_hex(b64)` | cadena | Convierten entre hexadecimal y base64 los mismos bytes | | `uuid.v4()` | cadena | UUID aleatorio versión 4, con guiones (36 caracteres) | ```dkl do print(hash.hmac_sha256("hola", "secreto")) do print(hash.hmac_sha256_b64("hola", "secreto")) do print(hash.hmac_sha1("hola", "secreto")) do print(hash.hex_to_b64("48656c6c6f")) do print(hash.b64_to_hex("SGVsbG8=")) do print(length(uuid.v4())) ``` ``` 066c767a010a01db3c26a63892788142a7add13214edfb9d6fb63a38cb2c1cce Bmx2egEKAds8JqY4kniBQqet0TIU7fudb7Y6OMssHM4= 241471d5d34fe1678fb463919761b5e7b7cdb902 SGVsbG8= 48656c6c6f 36 ``` Para comparar la firma recibida con la calculada use `hash.equals`, que tarda lo mismo sin importar dónde difieren: ```dkl if not(hash.equals(httpreq.header("X-Firma"), hash.hmac_sha256_b64(httpreq.body(), env.get("SECRETO")))) { do httpres.status(401) do httpres.text("firma inválida") return 0 } ``` ## Listas Ordenan o invierten la lista **en su lugar** y la devuelven (la misma lista). | Función | Descripción | |---|---| | `list.sort(lista)` | Ordena: números (por valor), luego cadenas (en orden ordinal: distingue mayúsculas, las mayúsculas van antes), luego objetos (en su orden original), luego nulos. Es estable | | `list.sort_by(lista, campo, desc)` | Ordena una lista de registros por `campo`; `desc` en `@true` invierte el orden de números y cadenas. Los elementos que no son registro o no tienen el campo quedan al final | | `list.reverse(lista)` | Invierte el orden | ```dkl ref l = list.create() do list.addnum(l, 3) do list.addstr(l, "b") do list.addnum(l, 1) do list.addstr(l, "A") do print(to.json(list.sort(l))) do print(to.json(list.reverse(l))) ref ps = list.create() new p1 {$$ "n": "uno", "v": 3 $$} new p2 {$$ "n": "dos", "v": 1 $$} new p3 {$$ "n": "tres", "v": 2 $$} do list.addobj(ps, p1) do list.addobj(ps, p2) do list.addobj(ps, p3) do print(to.json(list.sort_by(ps, "v", @false))) do print(to.json(list.sort_by(ps, "n", @true))) ``` ``` [1,3,"A","b"] ["b","A",3,1] [{"n":"dos","v":1},{"n":"tres","v":2},{"n":"uno","v":3}] [{"n":"uno","v":3},{"n":"tres","v":2},{"n":"dos","v":1}] ``` ## JSON | Función | Devuelve | Descripción | |---|---|---| | `to.json_pretty(objeto)` | cadena | La salida de `to.json` con saltos de línea y sangría de dos espacios. Los valores no cambian (escapes, orden de las llaves, números) | ```dkl new r {$$ "a": 1, "b": [1, 2], "c": {"d": "x"} $$} do print(to.json_pretty(r)) ``` ``` { "a":1, "b":[ 1, 2 ], "c":{ "d":"x" } } ```