Registro de Entradas

Consultar y modificar entradas registradas. Acceder a metadatos, instantaneas e historial de versiones.

Carga

local registry = require("registry")

Estructura de Entrada

{
    id = "app.lib:assert",     -- string: "namespace:name"
    kind = "function.lua",     -- string: tipo de entrada
    meta = {type = "test"},    -- table: metadatos buscables
    data = {...}               -- any: carga de entrada
}

Obtener Entrada

local entry, err = registry.get("app.lib:assert")

Permiso: registry.get en ID de entrada

Buscar Entradas

local entries, err = registry.find({kind = "function.lua"})
local entries, err = registry.find({kind = "http.endpoint", namespace = "app.api"})

Los campos de filtro coinciden con los metadatos de entrada.

Parsear ID

local id = registry.parse_id("app.lib:assert")
-- id.ns = "app.lib", id.name = "assert"

Instantaneas

Vista punto en el tiempo del registro:

local snap, err = registry.snapshot()           -- estado actual
local snap, err = registry.snapshot_at(5)       -- en versión 5

Metodos de Instantanea

Método	Devuelve	Descripción
`snap:entries()`	`Entry[], error`	Todas las entradas accesibles
`snap:get(id)`	`Entry, error`	Entrada unica por ID
`snap:find(filter)`	`Entry[]`	Filtrar entradas
`snap:namespace(ns)`	`Entry[]`	Entradas en namespace
`snap:versión()`	`Versión`	Versión de instantanea
`snap:changes()`	`Changes`	Crear conjunto de cambios

Versiones

local versión, err = registry.current_version()
local versions, err = registry.versions()

print(versión:id())       -- ID numerico
print(versión:string())   -- cadena de visualizacion
local prev = versión:previous()  -- versión anterior o nil

Historial

local hist, err = registry.history()
local versions, err = hist:versions()
local versión, err = hist:get_version(5)
local snap, err = hist:snapshot_at(versión)

Conjuntos de Cambios

Construir y aplicar modificaciones:

local snap, err = registry.snapshot()
local changes = snap:changes()

changes:create({
    id = "test:new_entry",
    kind = "test.kind",
    meta = {type = "test"},
    data = {config = "value"}
})

changes:update({
    id = "test:existing",
    kind = "test.kind",
    meta = {updated = true},
    data = {new_value = true}
})

changes:delete("test:old_entry")

local new_version, err = changes:apply()

Permiso: registry.apply para changes:apply()

Metodos de Changes

Método	Descripción
`changes:create(entry)`	Agregar operación de creacion
`changes:update(entry)`	Agregar operación de actualizacion
`changes:delete(id)`	Agregar operación de eliminacion (string o `{ns, name}`)
`changes:ops()`	Obtener operaciones pendientes
`changes:apply()`	Aplicar cambios, devuelve nueva Versión

Aplicar Versión

Retroceder o avanzar a una versión especifica:

local prev = current_version:previous()
local ok, err = registry.apply_version(prev)

Permiso: registry.apply_version

Construir Delta

Calcular operaciones para transicionar entre estados:

local from = {{id = "test:a", kind = "test", meta = {}, data = {}}}
local to = {{id = "test:b", kind = "test", meta = {}, data = {}}}

local ops, err = registry.build_delta(from, to)
for _, op in ipairs(ops) do
    print(op.kind, op.entry.id)  -- "entry.create", "entry.update", "entry.delete"
end

Permisos

Permiso	Recurso	Descripción
`registry.get`	ID de entrada	Leer entrada (también filtra resultados de find/entries)
`registry.apply`	-	Aplicar conjunto de cambios
`registry.apply_version`	-	Aplicar/revertir versión

Errores

Condición	Tipo
Entrada no encontrada	`errors.NOT_FOUND`
Versión no encontrada	`errors.NOT_FOUND`
Permiso denegado	`errors.PERMISSION_DENIED`
Parámetro invalido	`errors.INVALID`
Sin cambios para aplicar	`errors.INVALID`
Registro no disponible	`errors.INTERNAL`

Consulte Manejo de Errores para trabajar con errores.