@opensas/xml-rest-adapter 0.1.0

package/README.md

@@ -0,0 +1,4 @@
+# xml-rest-adapter
+
+Proyecto _de uso interno_ que expone mediante una API REST las bases de datos que utilizan el
+formato propio de `xmlEntidad_Accion` para encapsular la lógica de negocio.

package/dist/auth.d.ts

@@ -0,0 +1,8 @@
+import { type AppError } from './errors.js';
+import { type Result } from './result.js';
+import type { Aplicacion, Permisos, Usuario } from './types.js';
+export declare const ANONYMOUS_USER: Usuario;
+export declare function getDomainUser(request: Request, as?: string | null): string;
+export declare function parseGrupos(raw: string): string[];
+export declare function parsePermisos(raw: string): Permisos;
+export declare function resolveUser(app: Aplicacion, identity: string | Request): Promise<Result<Usuario, AppError>>;

package/dist/auth.js

@@ -0,0 +1,125 @@
+import { execXmlSentencia } from './db.js';
+import { appError } from './errors.js';
+import { err, ok } from './result.js';
+import { xmlAlta } from './xml.js';
+export const ANONYMOUS_USER = {
+    usuarioId: 0,
+    codigo: 'ANONIMO',
+    apellido: 'Anónimo',
+    nombres: '',
+    apellidoNombres: 'Anónimo',
+    activo: true,
+    grupos: [],
+    permisos: {},
+    domainUser: '',
+};
+// Identidad cruda tal como la inyecta IIS-node (Windows Integrated Auth) — ver
+// `authentication: { type: 'iis-node' }`. `as` (ej. `?as=DOMINIO\usuario`) permite pisarla desde
+// afuera del header, típicamente en dev/tests.
+export function getDomainUser(request, as) {
+    return (request.headers.get('x-iisnode-auth_user') ||
+        request.headers.get('iisnode-remote_user') ||
+        as ||
+        '');
+}
+export function parseGrupos(raw) {
+    return raw
+        ? raw
+            .split(';')
+            .map((grupo) => grupo.trim())
+            .filter(Boolean)
+        : [];
+}
+// Ej: "Recurso(ALTA;CONSULTA),OtroRecurso(CONSULTA)" -> [recurso, acciones] por cada match
+const RECURSO_ACCIONES_PATTERN = /([^(,]+)\(([^)]+)\)/g;
+export function parsePermisos(raw) {
+    const permisos = {};
+    for (const match of raw.matchAll(RECURSO_ACCIONES_PATTERN)) {
+        const recurso = match[1].trim();
+        const acciones = match[2].split(';').map((accion) => accion.toLowerCase());
+        permisos[recurso] = acciones;
+    }
+    return permisos;
+}
+// No exportada: es el mecanismo de bajo nivel que orquesta `resolveUser` (más abajo) para
+// authorization: 'metaSSC' — no hay caller fuera de este archivo, ni falta: todo lo que necesita
+// "identidad + permisos" pasa por `resolveUser`, que además sabe cuándo NO hace falta pegarle a
+// ninguna base (authentication/authorization en 'none').
+async function readUsuario(dbInfo, aplicacionCodigo, usuario) {
+    const sentencia = xmlAlta({
+        Operador: usuario,
+        Parametro: {
+            Tabla: 'UsuarioAutenticacion',
+            AplicacionCodigo: aplicacionCodigo, // esta SI se usa, la lee xmlUsuarioAutenticacion_Validacion
+            UsuarioCodigo: usuario,
+        },
+    });
+    const resultRow = await execXmlSentencia(dbInfo, 'UsuarioAutenticacion', sentencia);
+    if (!resultRow.ok) {
+        // Un RAISERROR de negocio (usuario/aplicación inválidos) es un 401 real. Un error de
+        // sistema (base caída, etc.) no lo es — se propaga tal cual en vez de disfrazarlo de
+        // "no autorizado", que induciría a buscar el problema en las credenciales.
+        if (resultRow.error.code === 'VALIDATION_ERROR') {
+            return err(appError({ title: resultRow.error.title, code: 'UNAUTHORIZED' }));
+        }
+        return resultRow;
+    }
+    const [row] = resultRow.data;
+    if (!row) {
+        return err(appError({
+            title: 'No se pudo autenticar al usuario',
+            detail: 'xmlUsuarioAutenticacion_Alta no retornó ningún registro',
+            code: 'UNAUTHORIZED',
+        }));
+    }
+    return ok({
+        usuarioId: row.UsuarioId,
+        codigo: row.UsuarioCodigo,
+        apellido: row.UsuarioApellido,
+        nombres: row.UsuarioNombres,
+        apellidoNombres: row.UsuarioApellidoNombres,
+        activo: row.UsuarioActivo === 1,
+        grupos: parseGrupos(row.UsuarioGrupos),
+        permisos: parsePermisos(row.UsuarioPermisos),
+        domainUser: usuario,
+    });
+}
+// Orquesta authentication + authorization (ver types.ts) para resolver el Usuario de un request,
+// la contraparte de `authUser` en convenios_web/src/hooks.server.ts — sin la resolución de
+// "aplicación" (siempre es la única `Aplicacion` del adapter), sin cache (ver auth/cache.ts en
+// convenios_web, queda para después como mejora) y sin el registro central para el authProvider
+// de otra app (authorization.dbInfo ya es la connection string directa, ver types.ts).
+//
+// Segundo parámetro: string | Request, mismo patrón que DbInfo | string en db.ts (aceptar la
+// forma "ya resuelta" o la más rica). Con `authentication` ya en la config, el consumidor no
+// tiene por qué saber CÓMO se extrae la identidad ('iis-node' es siempre el mismo mecanismo fijo,
+// ver getDomainUser) — le alcanza con pasar el `Request` tal cual. La forma string sigue
+// existiendo para tests (pasar 'TEST\ADMIN' directo, sin fabricar un Request) y para quien ya
+// resolvió el domainUser por su cuenta.
+//
+// A propósito, esto NO lee ningún `?as=` de la URL: soportar impersonation vía querystring no es
+// un feature de la librería (sería un footgun de seguridad tenerlo de fábrica) — es una
+// conveniencia de dev/tests que arma el caller (ver src/routes/fixture/[...path]/+server.ts),
+// pasando el string ya resuelto en vez del Request cuando corresponde.
+export async function resolveUser(app, identity) {
+    const domainUser = typeof identity === 'string' ? identity : getDomainUser(identity);
+    const aplicacionCodigo = app.aplicacionCodigo || app.name;
+    if (app.authentication.type === 'none') {
+        // app pública/anónima: no hay identidad real de un caller que resolver.
+        if (app.authorization.type === 'none')
+            return ok(ANONYMOUS_USER);
+        // Igual se puede acotar por Meta con una cuenta de servicio de solo lectura (ver
+        // types.ts:Authorization) — sin ella, no hay con quién autenticar, sigue anónimo.
+        const { dbInfo, serviceUser } = app.authorization;
+        if (!serviceUser)
+            return ok(ANONYMOUS_USER);
+        return readUsuario(dbInfo, aplicacionCodigo, serviceUser);
+    }
+    // authentication.type === 'iis-node': domainUser ya viene resuelto (getDomainUser), como el
+    // login de Windows real de quien hizo el request.
+    if (!domainUser)
+        return err(appError('Usuario desconocido', 'UNAUTHORIZED'));
+    if (app.authorization.type === 'none')
+        return ok({ ...ANONYMOUS_USER, domainUser });
+    return readUsuario(app.authorization.dbInfo, aplicacionCodigo, domainUser);
+}

package/dist/condition.d.ts

@@ -0,0 +1,25 @@
+export type Operator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'CONTAINS' | 'BEGINS_WITH' | 'ENDS_WITH' | 'IN' | 'BETWEEN';
+export type ValueCondition = string | number | boolean | string[] | number[] | boolean[] | null;
+export type SimpleCondition = {
+    [field: string]: ValueCondition | {
+        operator: Operator;
+        value: ValueCondition;
+    };
+};
+export type Condition = SimpleCondition | {
+    AND: Condition[];
+};
+export declare const condition: {
+    eq: (field: string, value: ValueCondition) => Condition;
+    neq: (field: string, value: ValueCondition) => Condition;
+    lt: (field: string, value: ValueCondition) => Condition;
+    gt: (field: string, value: ValueCondition) => Condition;
+    lte: (field: string, value: ValueCondition) => Condition;
+    gte: (field: string, value: ValueCondition) => Condition;
+    contains: (field: string, value: ValueCondition) => Condition;
+    beginWith: (field: string, value: ValueCondition) => Condition;
+    endsWith: (field: string, value: ValueCondition) => Condition;
+    in: (field: string, values: ValueCondition) => Condition;
+    between: (field: string, min: ValueCondition, max: ValueCondition) => Condition;
+};
+export declare const getXmlConditionValue: (operator: Operator, value: ValueCondition) => string;

package/dist/condition.js

@@ -0,0 +1,60 @@
+// Constructores de condiciones para armar `Parametro.Condiciones` en las sentencias XML que
+// consume xml.ts. Se arman con el objeto `condition` (`condition.eq('Campo', valor)`,
+// `condition.between('Fecha', min, max)`, etc.) y se combinan con `{ AND: [cond1, cond2] }`.
+// `getXmlConditionValue` traduce una condición ya resuelta (operador + valor) al string que
+// espera el SP (`=valor`, `*valor*`, `min..max`, etc.).
+function cond(field, operator, value) {
+    return { [field]: { operator, value } };
+}
+const eq = (field, value) => cond(field, '=', value);
+const neq = (field, value) => cond(field, '!=', value);
+const lt = (field, value) => cond(field, '<', value);
+const gt = (field, value) => cond(field, '>', value);
+const lte = (field, value) => cond(field, '<=', value);
+const gte = (field, value) => cond(field, '>=', value);
+const contains = (field, value) => cond(field, 'CONTAINS', value);
+const beginWith = (field, value) => cond(field, 'BEGINS_WITH', value);
+const endsWith = (field, value) => cond(field, 'ENDS_WITH', value);
+const inOp = (field, values) => cond(field, 'IN', values);
+const between = (field, min, max) => cond(field, 'BETWEEN', [min, max]);
+export const condition = {
+    eq,
+    neq,
+    lt,
+    gt,
+    lte,
+    gte,
+    contains,
+    beginWith,
+    endsWith,
+    in: inOp,
+    between,
+};
+export const getXmlConditionValue = (operator, value) => {
+    // Solo null/undefined son "sin valor" — 0 y false son valores válidos y distintos de
+    // "no especificado" (`!value` los trataría igual que null, perdiéndolos).
+    if (value === null || value === undefined)
+        value = '';
+    switch (operator) {
+        case '=':
+        case '<':
+        case '>':
+        case '<=':
+        case '>=':
+            return operator + value.toString();
+        case '!=':
+            return '<>' + value.toString();
+        case 'CONTAINS':
+            return '*' + value.toString() + '*';
+        case 'BEGINS_WITH':
+            return value.toString() + '*';
+        case 'ENDS_WITH':
+            return '*' + value.toString();
+        case 'IN':
+            return value.toString();
+        case 'BETWEEN':
+            if (!Array.isArray(value) || value.length !== 2)
+                throw new Error('BETWEEN espera exactamente 2 valores (min, max)');
+            return `${value[0]}..${value[1]}`;
+    }
+};

package/dist/create-adapter.d.ts

@@ -0,0 +1,8 @@
+import type { RequestEvent } from '@sveltejs/kit';
+import type { AppError } from './errors.js';
+import type { Result } from './result.js';
+import type { Aplicacion, Usuario } from './types.js';
+export declare function createXmlRestAdapter(app: Aplicacion): {
+    resolveUser: (identity: string | Request) => Promise<Result<Usuario, AppError>>;
+    handle: (event: RequestEvent, usuario: Usuario) => Promise<Response>;
+};

package/dist/create-adapter.js

@@ -0,0 +1,95 @@
+import { json } from '@sveltejs/kit';
+import { resolveUser } from './auth.js';
+import { execXmlConsulta, execXmlSentencia } from './db.js';
+import { appError, jsonError } from './errors.js';
+import { parseRequest } from './parse-request.js';
+function validarAplicacion(app) {
+    if (!app.name)
+        throw new Error('createXmlRestAdapter: "name" es obligatorio');
+    if (!app.dbInfo)
+        throw new Error('createXmlRestAdapter: "dbInfo" es obligatorio');
+    if (app.pagination !== 'sql' && app.pagination !== 'com+') {
+        throw new Error(`createXmlRestAdapter: "pagination" inválido (${JSON.stringify(app.pagination)}) — debe ser "sql" o "com+"`);
+    }
+    if (!app.authentication) {
+        throw new Error('createXmlRestAdapter: "authentication" es obligatorio');
+    }
+    // Tipado como string, no como Authentication['type']: una vez descartados 'none'/'iis-node' acá
+    // abajo, TS angosta el tipo a `never` — accederlo de nuevo para el mensaje de error rompería
+    // la comparación (ver el mismo patrón para authorization más abajo).
+    const authenticationType = app.authentication.type;
+    if (authenticationType !== 'none' && authenticationType !== 'iis-node') {
+        throw new Error(`createXmlRestAdapter: "authentication.type" inválido (${JSON.stringify(authenticationType)}) — debe ser "none" o "iis-node"`);
+    }
+    if (!app.authorization) {
+        throw new Error('createXmlRestAdapter: "authorization" es obligatorio');
+    }
+    const authorizationType = app.authorization.type;
+    if (authorizationType !== 'none' && authorizationType !== 'metaSSC') {
+        throw new Error(`createXmlRestAdapter: "authorization.type" inválido (${JSON.stringify(authorizationType)}) — debe ser "none" o "metaSSC"`);
+    }
+    if (app.authorization.type === 'metaSSC' && !app.authorization.dbInfo) {
+        throw new Error('createXmlRestAdapter: "authorization.dbInfo" es obligatorio cuando "authorization.type" es "metaSSC"');
+    }
+    if (!Array.isArray(app.endpoints)) {
+        throw new TypeError('createXmlRestAdapter: "endpoints" debe ser un array');
+    }
+    for (const endpoint of app.endpoints) {
+        if (!endpoint.name)
+            throw new Error('createXmlRestAdapter: cada endpoint necesita "name"');
+        if (!endpoint.recurso) {
+            throw new Error(`createXmlRestAdapter: el endpoint "${endpoint.name}" necesita "recurso"`);
+        }
+        if (!endpoint.fieldId) {
+            throw new Error(`createXmlRestAdapter: el endpoint "${endpoint.name}" necesita "fieldId"`);
+        }
+    }
+}
+export function createXmlRestAdapter(app) {
+    validarAplicacion(app);
+    // Resuelve identidad (authentication) + permisos (authorization) — ver auth.ts. Acepta el
+    // Request tal cual (extrae domainUser según app.authentication) o un string ya resuelto (para
+    // tests, o un consumidor que ya lo extrajo por su cuenta). Devuelve Result, no throw ni
+    // Usuario a secas: mismo vocabulario (Result/AppError/jsonError) que el resto de la librería,
+    // incluido lo que ya usa `handle` puertas adentro.
+    function resolveUserFn(identity) {
+        return resolveUser(app, identity);
+    }
+    async function handle(event, usuario) {
+        try {
+            // Genérico a propósito: cada consumidor define su propia carpeta `[...path]`, así que
+            // el nombre real del param lo tipa `$types` del lado del consumidor, no acá.
+            const path = event.params.path ?? '';
+            const parsed = await parseRequest(app, event.request, path, usuario);
+            if (!parsed.ok)
+                return jsonError(parsed.error);
+            const { objeto, id, sentencia, archivos, archivoParams } = parsed.data;
+            if (sentencia.Tipo === 'Consulta') {
+                const result = await execXmlConsulta(app.dbInfo, objeto, sentencia);
+                if (!result.ok)
+                    return jsonError(result.error);
+                // Consulta por id sin resultados = 404. (En convenios_web este chequeo existía
+                // pero comparaba contra el objeto {rows,count} entero, que nunca es falsy — no
+                // llegaba a dispararse nunca; acá sí compara lo que corresponde.)
+                if (id && result.data.rows.length === 0) {
+                    return jsonError(appError(`${objeto} ${id} no encontrado`, 'NOT_FOUND'));
+                }
+                return json(result.data);
+            }
+            const result = await execXmlSentencia(app.dbInfo, objeto, sentencia, archivoParams, archivos);
+            if (!result.ok)
+                return jsonError(result.error);
+            if (sentencia.Tipo === 'Baja')
+                return json(result.data);
+            return json({ rows: result.data, count: 1 });
+        }
+        catch (err_) {
+            return jsonError(appError({
+                title: 'Error interno del servidor',
+                code: 'INTERNAL_ERROR',
+                detail: String(err_),
+            }));
+        }
+    }
+    return { resolveUser: resolveUserFn, handle };
+}

package/dist/db.d.ts

@@ -0,0 +1,34 @@
+import type { XmlSentencia } from './xml.js';
+export type DbInfo = {
+    user: string;
+    password: string;
+    server: string;
+    database: string;
+    options: {
+        encrypt: boolean;
+        trustServerCertificate: boolean;
+    };
+};
+export declare function closeAllPools(): Promise<void>;
+export declare function execXmlSentencia<T>(dbInfo: DbInfo | string, objeto: string, sentencia: XmlSentencia, archivoParams?: string[], archivos?: Buffer[]): Promise<{
+    ok: false;
+    data: null;
+    error: import("./errors.js").AppError;
+} | {
+    ok: true;
+    data: T[];
+    error: null;
+}>;
+export declare function execXmlConsulta<T = Record<string, string>>(dbInfo: DbInfo | string, objeto: string, sentencia: XmlSentencia): Promise<{
+    ok: false;
+    data: null;
+    error: import("./errors.js").AppError;
+} | {
+    ok: true;
+    data: {
+        rows: T[];
+        count: number;
+    };
+    error: null;
+}>;
+export declare function postProcessRows<T>(rows: T[]): T[];

package/dist/db.js

@@ -0,0 +1,134 @@
+// Ejecuta los SPs xmlXXX_Alta|Baja|Modificacion|Consulta contra SQL Server, serializando la
+// XmlSentencia al XML que esperan (ver request-to-xml.ts) y devolviendo el resultado como
+// Result (ver result.ts) en vez de tirar excepciones.
+import sql from 'mssql';
+import { appError } from './errors.js';
+import { toXmlParametros } from './request-to-xml.js';
+import { err, ok } from './result.js';
+const pools = new Map();
+// Cierra los pools abiertos — se registra en SIGTERM/SIGINT más abajo, y se expone también para
+// quien necesite cerrarlos a mano (tests de integración, scripts). A diferencia de convenios_web
+// (una app dueña de todo el proceso), acá NO se llama process.exit(): esto es una librería, puede
+// convivir con otro código en el mismo proceso que también quiera reaccionar a la señal, y forzar
+// la salida del proceso completo no es una decisión que le corresponda tomar a un cliente de la
+// librería.
+export async function closeAllPools() {
+    for (const pool of pools.values())
+        await pool.close();
+    pools.clear();
+}
+/* eslint-disable unicorn/no-top-level-side-effects */
+process.on('SIGTERM', closeAllPools);
+process.on('SIGINT', closeAllPools);
+async function getPool(dbInfo) {
+    const key = typeof dbInfo === 'string' ? dbInfo : JSON.stringify(dbInfo);
+    let pool = pools.get(key);
+    if (!pool || !pool.connected) {
+        pool = await new sql.ConnectionPool(dbInfo).connect();
+        pools.set(key, pool);
+    }
+    return pool;
+}
+const SQL_USER_ERROR_NUMBER = 50_000;
+async function execStoredProcedure(spName, params = [], dbInfo) {
+    try {
+        const pool = await getPool(dbInfo);
+        const request = pool.request();
+        for (const p of params)
+            request.input(p.name, p.value);
+        const result = await request.execute(spName);
+        return ok(result.recordset);
+    }
+    catch (err_) {
+        const sqlErr = err_;
+        if (sqlErr.number === SQL_USER_ERROR_NUMBER) {
+            // RAISERROR del SP — error de negocio, seguro mostrar al usuario
+            return err(appError({ title: sqlErr.message ?? String(err_), code: 'VALIDATION_ERROR' }));
+        }
+        // Error de sistema — loguear server-side, no exponer detalle al cliente
+        console.error('[db] execStoredProcedure error:', String(err_));
+        return err(appError({
+            title: 'Error interno del servidor',
+            code: 'INTERNAL_ERROR',
+            detail: String(err_),
+        }));
+    }
+}
+async function execXml(dbInfo, objeto, operacion, xmlParameters, archivoParams = [], archivos = []) {
+    if (archivos.length > archivoParams.length) {
+        return err(appError({
+            title: `El objeto ${objeto} admite hasta ${archivoParams.length} archivo(s).`,
+            code: 'BAD_REQUEST',
+        }));
+    }
+    const xmlIn = '<?xml version="1.0" encoding="iso-8859-1"?>\r\n' + xmlParameters;
+    const fileParams = archivos.map((buffer, index) => ({
+        name: archivoParams[index],
+        type: sql.VarBinary(sql.MAX),
+        value: buffer,
+    }));
+    return await execStoredProcedure(`xml${objeto}_${operacion}`, [{ name: 'xml', type: sql.VarChar, value: xmlIn }, ...fileParams], dbInfo);
+}
+// dbInfo/archivoParams van directo, no una Aplicacion completa — el adapter siempre opera sobre
+// la única app que tiene configurada (ver docs/proximos-pasos.md), así que quien llama ya tiene
+// esos dos datos a mano (app.dbInfo, getEndpoint(app, objeto)?.archivoParams) sin que db.ts necesite
+// conocer la forma de Aplicacion para nada más que eso.
+export async function execXmlSentencia(dbInfo, objeto, sentencia, archivoParams = [], archivos = []) {
+    // El resto del envelope (Operador, Clase, AplicacionCodigo, ServicioCodigo) se descarta acá
+    // — ver el comentario sobre XmlSentencia en xml.ts.
+    const xmlParameters = toXmlParametros(sentencia.Parametro, 'Parametro');
+    const result = await execXml(dbInfo, objeto, sentencia.Tipo, xmlParameters, archivoParams, archivos);
+    if (!result.ok)
+        return result;
+    // Bug de convenios_web portado y corregido acá: el original solo hexificaba `Stamp` en
+    // execXmlConsulta — un Alta/Modificacion devolvía la columna como Buffer crudo (serializa
+    // como `{type:"Buffer",data:[...]}` en JSON), inconsistente con lo que devuelve el GET
+    // inmediatamente después para la misma fila.
+    return ok(postProcessRows(result.data));
+}
+export async function execXmlConsulta(dbInfo, objeto, sentencia) {
+    const countParametro = {
+        ...sentencia.Parametro,
+        Campos: 'Count(*) as count',
+        Orden: 'count',
+        SqlPaginate: 0,
+    };
+    const xmlParameters = toXmlParametros(sentencia.Parametro, 'Parametro');
+    const xmlCountParameters = toXmlParametros(countParametro, 'Parametro');
+    const [resultRows, resultCountData] = await Promise.all([
+        execXml(dbInfo, objeto, 'Consulta', xmlParameters),
+        execXml(dbInfo, objeto, 'Consulta', xmlCountParameters),
+    ]);
+    if (!resultRows.ok)
+        return resultRows;
+    if (!resultCountData.ok)
+        return resultCountData;
+    const [rows, countData] = [resultRows.data, resultCountData.data];
+    // El SP de paginación COM+ (a diferencia de la SQL) devuelve Pagina + PaginaLong + 1 filas
+    // desde el principio — hay que recortar el offset y la fila de "hay más" acá.
+    if (rows &&
+        sentencia.Parametro.SqlPaginate === 0 &&
+        sentencia.Parametro.PaginaLong &&
+        sentencia.Parametro.Pagina) {
+        rows.splice(0, sentencia.Parametro.PaginaLong * (sentencia.Parametro.Pagina - 1));
+        if (rows.length > sentencia.Parametro.PaginaLong)
+            rows.pop();
+    }
+    const count = countData?.length > 0 ? countData[0].count : 0;
+    return ok({ rows: postProcessRows(rows), count });
+}
+// El tipo SQL Server `rowversion`/`timestamp` (columna `Stamp`, usada para optimistic
+// concurrency) llega como Buffer — se hexifica para que viaje bien en JSON.
+export function postProcessRows(rows) {
+    // Un SP sin SELECT final (ej. xmlXXX_Baja: solo DELETE) deja `result.recordset` en
+    // `undefined` — execStoredProcedure lo tipa igual como Array<T> (ver más arriba), pero acá
+    // no hay filas que recorrer, no un error.
+    if (!Array.isArray(rows))
+        return rows;
+    for (const row of rows) {
+        if (typeof row === 'object' && !!row && 'Stamp' in row) {
+            row.Stamp = '0x' + row.Stamp.toString('hex');
+        }
+    }
+    return rows;
+}

package/dist/endpoints.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from './types.js';
+export type PartialEndpoint = Pick<Endpoint, 'name'> & Partial<Omit<Endpoint, 'name'>>;
+export declare function endpoints(items: Array<string | PartialEndpoint>): Endpoint[];

package/dist/endpoints.js

@@ -0,0 +1,17 @@
+export function endpoints(items) {
+    return items.map((item) => {
+        if (typeof item === 'string') {
+            return { name: item, recurso: item, fieldId: `${item}Id`, archivoParams: [] };
+        }
+        const recurso = item.recurso || item.name;
+        return {
+            name: item.name,
+            recurso,
+            // fieldId por default sale de `recurso` (no de `name`): si el endpoint ya cambió el
+            // nombre de recurso, el id por convención acompaña al recurso, no al nombre expuesto.
+            fieldId: item.fieldId || `${recurso}Id`,
+            acciones: item.acciones,
+            archivoParams: item.archivoParams || [],
+        };
+    });
+}

package/dist/errors.d.ts

@@ -0,0 +1,18 @@
+import { type HTTP_STATUS } from './http-status.js';
+export declare const APP_ERROR_CODES: readonly ["VALIDATION_ERROR", "BAD_REQUEST", "UNAUTHORIZED", "FORBIDDEN", "NOT_FOUND", "INTERNAL_ERROR"];
+export type AppErrorCode = (typeof APP_ERROR_CODES)[number];
+export type AppError = {
+    code: AppErrorCode;
+    title: string;
+    detail?: string;
+    status: HTTP_STATUS;
+};
+type AppErrorOptions = {
+    code?: AppErrorCode;
+    title?: string;
+    detail?: string;
+    status?: HTTP_STATUS;
+};
+export declare function appError(options?: AppErrorOptions | string, code?: AppErrorCode): AppError;
+export declare function jsonError(...params: Parameters<typeof appError>): Response;
+export {};

package/dist/errors.js

@@ -0,0 +1,42 @@
+// Error de negocio estructurado y homogéneo para toda la librería. Se arma con `appError(...)`
+// (título + código + detalle opcional) y se devuelve al cliente con `jsonError(...)`, que lo
+// envuelve en un `Response` JSON con el status HTTP que corresponde al código.
+import { json } from '@sveltejs/kit';
+import { BAD_REQUEST, FORBIDDEN, INTERNAL_ERROR, NOT_FOUND, UNAUTHORIZED, UNPROCESSABLE_ENTITY, } from './http-status.js';
+export const APP_ERROR_CODES = [
+    'VALIDATION_ERROR',
+    'BAD_REQUEST',
+    'UNAUTHORIZED',
+    'FORBIDDEN',
+    'NOT_FOUND',
+    'INTERNAL_ERROR',
+];
+function defaultStatus(code) {
+    switch (code) {
+        case 'VALIDATION_ERROR':
+            return UNPROCESSABLE_ENTITY;
+        case 'BAD_REQUEST':
+            return BAD_REQUEST;
+        case 'UNAUTHORIZED':
+            return UNAUTHORIZED;
+        case 'FORBIDDEN':
+            return FORBIDDEN;
+        case 'NOT_FOUND':
+            return NOT_FOUND;
+        case 'INTERNAL_ERROR':
+            return INTERNAL_ERROR;
+    }
+}
+export function appError(options = {}, code) {
+    if (typeof options === 'string')
+        options = { title: options };
+    if (code)
+        options = { ...options, code };
+    const { title = 'Error desconocido', detail, status } = options;
+    const finalCode = options.code || 'INTERNAL_ERROR';
+    return { code: finalCode, title, detail, status: status ?? defaultStatus(finalCode) };
+}
+export function jsonError(...params) {
+    const e = appError(...params);
+    return json(e, { status: e.status });
+}

package/dist/http-status.d.ts

@@ -0,0 +1,8 @@
+export declare const OK = 200;
+export declare const BAD_REQUEST = 400;
+export declare const UNAUTHORIZED = 401;
+export declare const FORBIDDEN = 403;
+export declare const NOT_FOUND = 404;
+export declare const UNPROCESSABLE_ENTITY = 422;
+export declare const INTERNAL_ERROR = 500;
+export type HTTP_STATUS = typeof OK | typeof BAD_REQUEST | typeof UNAUTHORIZED | typeof FORBIDDEN | typeof NOT_FOUND | typeof UNPROCESSABLE_ENTITY | typeof INTERNAL_ERROR;

package/dist/http-status.js

@@ -0,0 +1,7 @@
+export const OK = 200;
+export const BAD_REQUEST = 400;
+export const UNAUTHORIZED = 401;
+export const FORBIDDEN = 403;
+export const NOT_FOUND = 404;
+export const UNPROCESSABLE_ENTITY = 422;
+export const INTERNAL_ERROR = 500;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { createXmlRestAdapter } from './create-adapter.js';
+export { endpoints, type PartialEndpoint } from './endpoints.js';
+export { getDomainUser } from './auth.js';
+export { appError, jsonError, type AppError, type AppErrorCode } from './errors.js';
+export { closeAllPools } from './db.js';
+export type { Result } from './result.js';
+export type { Accion, Aplicacion, Authentication, Authorization, Endpoint, Permisos, Usuario, } from './types.js';
+export type { DbInfo } from './db.js';

package/dist/index.js

@@ -0,0 +1,25 @@
+// Forma pública de la librería — lo único que un consumidor necesita importar. Ver
+// docs/proximos-pasos.md ("API pública") para el porqué de cada decisión de diseño.
+//
+// Uso típico:
+//
+//   const adapter = createXmlRestAdapter({ name: 'MiApp', ..., endpoints: endpoints([...]) });
+//
+//   export const fallback: RequestHandler = async (event) => {
+//     const result = await adapter.resolveUser(event.request);
+//     if (!result.ok) return jsonError(result.error);
+//     return adapter.handle(event, result.data);
+//   };
+export { createXmlRestAdapter } from './create-adapter.js';
+export { endpoints } from './endpoints.js';
+// Identidad: getDomainUser es el único helper que un consumidor necesita para armar su propia
+// ruta de prueba/dev con impersonation vía `?as=` (ver src/routes/fixture/[...path]/+server.ts)
+// — a propósito NO es un feature de resolveUser (sería impersonation de fábrica).
+export { getDomainUser } from './auth.js';
+// Errores: mismo vocabulario que usa la librería puertas adentro, para que un consumidor pueda
+// devolver un error propio (antes de llegar a `handle`, por ejemplo) con la misma forma.
+export { appError, jsonError } from './errors.js';
+// Apagado prolijo de los pools de SQL Server — útil para tests de integración del consumidor o
+// scripts que necesiten cerrar la conexión explícitamente (la librería ya lo hace sola en
+// SIGTERM/SIGINT, ver db.ts).
+export { closeAllPools } from './db.js';

package/dist/parse-request.d.ts

@@ -0,0 +1,12 @@
+import { type AppError } from './errors.js';
+import { type Result } from './result.js';
+import type { Aplicacion, Usuario } from './types.js';
+import type { XmlSentencia } from './xml.js';
+export type ParsedRequest = {
+    objeto: string;
+    id: number;
+    sentencia: XmlSentencia;
+    archivos: Buffer[];
+    archivoParams: string[];
+};
+export declare function parseRequest(app: Aplicacion, request: Request, path: string, usuario: Usuario): Promise<Result<ParsedRequest, AppError>>;