@opensas/xml-rest-adapter 0.1.0

package/dist/parse-request.js

@@ -0,0 +1,80 @@
+// Arma un XmlSentencia completo a partir de una request HTTP + el objeto/id ya resuelto del
+// `[...path]` — la contraparte de http/request-body.ts en convenios_web, más la orquestación que
+// ahí vivía repartida entre los 4 handlers (GET/POST/PUT/DELETE) de cada `+server.ts`: validar
+// params, chequear permisos, parsear el body, y armar la sentencia según el método. No ejecuta
+// nada contra la base — deja el XmlSentencia listo para pasarle a execXmlSentencia/
+// execXmlConsulta.
+import { appError } from './errors.js';
+import { toXmlAlta, toXmlBaja, toXmlConsulta, toXmlConsultaId, toXmlModificacion, } from './request-to-xml.js';
+import { err, ok } from './result.js';
+import { checkPermiso, validParams } from './valid.js';
+const MULTIPART_CONTENT_TYPE = 'multipart/form-data';
+// Los browsers agregan un File vacío (size 0, name '') cuando un <input type="file"> queda sin
+// seleccionar — se descarta para no numerarlo como @fileN.
+function esArchivoFantasma(file) {
+    return file.size === 0 && file.name === '';
+}
+async function parseMultipart(request) {
+    const formData = await request.formData();
+    const record = {};
+    const archivos = [];
+    for (const [key, value] of formData.entries()) {
+        if (value instanceof File) {
+            if (!esArchivoFantasma(value))
+                archivos.push(Buffer.from(await value.arrayBuffer()));
+        }
+        else {
+            record[key] = value;
+        }
+    }
+    return { record, archivos };
+}
+async function parseRequestBody(request) {
+    const contentType = request.headers.get('content-type') || '';
+    if (contentType.includes(MULTIPART_CONTENT_TYPE))
+        return parseMultipart(request);
+    const record = (await request.json());
+    return { record, archivos: [] };
+}
+const METODOS_SOPORTADOS = new Set(['GET', 'POST', 'PUT', 'DELETE']);
+export async function parseRequest(app, request, path, usuario) {
+    if (!METODOS_SOPORTADOS.has(request.method)) {
+        return err(appError(`Método ${request.method} no soportado`, 'BAD_REQUEST'));
+    }
+    const metodo = request.method;
+    const paramsResult = validParams(app, path, metodo === 'PUT' || metodo === 'DELETE' ? 'withId' : 'noId');
+    if (!paramsResult.ok)
+        return paramsResult;
+    const { objeto, id, fieldId, archivoParams } = paramsResult.data;
+    // checkPermiso se llama siempre, sin importar authorization: la Capa 1 (acciones permitidas
+    // por objeto) es estática y tiene que regir incluso en apps sin permisos dinámicos — es
+    // checkPermiso quien decide puertas adentro si además corresponde la Capa 2 (ver valid.ts).
+    const permisoResult = checkPermiso(app, objeto, metodo, usuario.permisos);
+    if (!permisoResult.ok)
+        return permisoResult;
+    const operador = usuario.domainUser;
+    const url = new URL(request.url);
+    if (metodo === 'GET') {
+        const sentencia = id
+            ? toXmlConsultaId(url.searchParams, app, objeto, id, operador, fieldId)
+            : toXmlConsulta(url.searchParams, app, objeto, operador);
+        return ok({ objeto, id, sentencia, archivos: [], archivoParams });
+    }
+    if (metodo === 'DELETE') {
+        const sentencia = toXmlBaja(app, objeto, operador);
+        sentencia.Parametro[fieldId] = id;
+        return ok({ objeto, id, sentencia, archivos: [], archivoParams });
+    }
+    // POST / PUT — llevan body
+    const { record, archivos } = await parseRequestBody(request);
+    record.OperadorId = String(usuario.usuarioId);
+    if (metodo === 'POST') {
+        const sentencia = toXmlAlta(app, objeto, operador, record);
+        return ok({ objeto, id, sentencia, archivos, archivoParams });
+    }
+    // PUT: el id de la URL siempre gana sobre lo que venga en el body, aunque el body traiga
+    // otro valor (o ninguno) para ese campo.
+    const sentencia = toXmlModificacion(app, objeto, operador, record);
+    sentencia.Parametro[fieldId] = id;
+    return ok({ objeto, id, sentencia, archivos, archivoParams });
+}

package/dist/request-to-xml.d.ts

@@ -0,0 +1,8 @@
+import { type Aplicacion } from './types.js';
+import { type XmlSentencia } from './xml.js';
+export declare function toXmlConsulta(urlSearchParams: URLSearchParams, app: Aplicacion, objeto: string, operador: string): XmlSentencia;
+export declare function toXmlConsultaId(urlSearchParams: URLSearchParams, app: Aplicacion, objeto: string, id: number, username: string, fieldId?: string): XmlSentencia;
+export declare function toXmlAlta(app: Aplicacion, objeto: string, username: string, data: Record<string, string>): XmlSentencia;
+export declare function toXmlModificacion(app: Aplicacion, objeto: string, username: string, data: Record<string, string>): XmlSentencia;
+export declare function toXmlBaja(app: Aplicacion, objeto: string, username: string, data?: Record<string, string>): XmlSentencia;
+export declare function toXmlParametros(condicion: Record<string, unknown>, Parametro: string): string;

package/dist/request-to-xml.js

@@ -0,0 +1,219 @@
+// Arma un `XmlSentencia` a partir de una request HTTP y serializa su `Parametro` al XML que
+// esperan los SPs xmlXXX. `toXmlConsulta`/`toXmlConsultaId` parsean filtros de
+// `URLSearchParams` — el operador va embebido en el propio valor (`=`, `!=`, `*valor*`,
+// `min..max`, `v1;v2`, etc., ver condition.ts); `toXmlAlta`/`toXmlModificacion`/`toXmlBaja` arman
+// la sentencia a partir del body ya parseado. `toXmlParametros` serializa el resultado final
+// (`Parametro`/`Condiciones`) al string XML que espera el SP — lo consume db.ts.
+import { condition, getXmlConditionValue, } from './condition.js';
+import {} from './types.js';
+import { xmlAlta, xmlBaja, xmlConsulta, xmlModificacion } from './xml.js';
+const QUERY_KEYS = {
+    metodo: 'metodo',
+    servicio: 'servicio',
+    longitudPagina: '_limit',
+    pagina: '_page',
+    campos: '_fields',
+    orden: '_order',
+};
+export function toXmlConsulta(urlSearchParams, app, objeto, operador) {
+    const metodoDefault = 'Consulta';
+    const metodo = urlSearchParams.get(QUERY_KEYS.metodo) || metodoDefault;
+    const servicio = urlSearchParams.get(QUERY_KEYS.servicio) || undefined;
+    const longitudPagina = urlSearchParams.get(QUERY_KEYS.longitudPagina);
+    const pagina = urlSearchParams.get(QUERY_KEYS.pagina);
+    const campos = urlSearchParams.get(QUERY_KEYS.campos);
+    const orden = urlSearchParams.get(QUERY_KEYS.orden);
+    return xmlConsulta({
+        Operador: operador,
+        Metodo: metodo,
+        AplicacionCodigo: app.name,
+        ServicioCodigo: servicio,
+        Parametro: {
+            Tabla: objeto,
+            // El '0' adelante evita paginación negativa: parseInt corta en el primer caracter no
+            // numérico, así que '0' + '-5' da 0 en vez de -5 — Number('0-5') da NaN, por eso tiene
+            // que ser parseInt y no la conversión que sugiere unicorn/prefer-number-coercion.
+            // eslint-disable-next-line unicorn/prefer-number-coercion
+            PaginaLong: longitudPagina ? Number.parseInt('0' + longitudPagina, 10) : undefined,
+            // eslint-disable-next-line unicorn/prefer-number-coercion
+            Pagina: pagina ? Number.parseInt('0' + pagina, 10) : undefined,
+            SqlPaginate: app.pagination === 'sql' ? 1 : 0,
+            Campos: campos || '*',
+            Orden: orden ? getXmlOrden(orden) : undefined,
+            Condiciones: keysToCondition(urlSearchParams),
+        },
+    });
+}
+export function toXmlConsultaId(urlSearchParams, app, objeto, id, username, fieldId) {
+    fieldId ||= objeto + 'Id';
+    return xmlConsulta({
+        Operador: username,
+        Metodo: urlSearchParams.get(QUERY_KEYS.metodo) || 'Consulta',
+        AplicacionCodigo: app.name,
+        ServicioCodigo: urlSearchParams.get(QUERY_KEYS.servicio) || undefined,
+        Parametro: {
+            Tabla: objeto,
+            PaginaLong: 20,
+            Pagina: 1,
+            Campos: '*',
+            Orden: fieldId,
+            Condiciones: condition.eq(fieldId, id),
+        },
+    });
+}
+export function toXmlAlta(app, objeto, username, data) {
+    return xmlAlta({
+        Operador: username,
+        AplicacionCodigo: app.name,
+        ServicioCodigo: app.name,
+        Parametro: { Tabla: objeto, ...data },
+    });
+}
+export function toXmlModificacion(app, objeto, username, data) {
+    return xmlModificacion({
+        Operador: username,
+        AplicacionCodigo: app.name,
+        ServicioCodigo: app.name,
+        Parametro: { Tabla: objeto, ...data },
+    });
+}
+export function toXmlBaja(app, objeto, username, data = {}) {
+    return xmlBaja({
+        Operador: username,
+        AplicacionCodigo: app.name,
+        ServicioCodigo: app.name,
+        Parametro: { Tabla: objeto, ...data },
+    });
+}
+const getXmlOrden = (orden) => orden
+    .split(',')
+    .map((field) => field.trim())
+    .map((field) => {
+    if (field.startsWith('-'))
+        return field.slice(1) + ' DESC';
+    if (field.startsWith('+'))
+        return field.slice(1);
+    return field;
+})
+    .join(',');
+const keysToCondition = (params) => {
+    const cond = [];
+    for (const [key, value] of params) {
+        if (!key.startsWith('_')) {
+            cond.push(getCondition(key, value));
+        }
+    }
+    if (cond.length === 0)
+        return {};
+    if (cond.length === 1)
+        return cond[0];
+    return { AND: cond };
+};
+const getCondition = (key, value) => {
+    if (value.startsWith('*') && value.endsWith('*')) {
+        // value === '*' (un solo caracter): substring(1, 0) hace swap de argumentos y
+        // devuelve '*'; slice(1, 0) devolvería '' — Math.min/Math.max replican el swap
+        // de substring para no cambiar el comportamiento en ese caso límite.
+        return condition.contains(key, value.slice(Math.min(1, value.length - 1), Math.max(1, value.length - 1)));
+    }
+    if (value.startsWith('*'))
+        return condition.endsWith(key, value.slice(1));
+    if (value.endsWith('*'))
+        return condition.beginWith(key, value.slice(0, Math.max(0, value.length - 1)));
+    if (value.includes('..')) {
+        const [left, right] = value.split('..');
+        return condition.between(key, left, right);
+    }
+    if (value.startsWith('!=') || value.startsWith('<>'))
+        return condition.neq(key, value.slice(2));
+    if (value.startsWith('<='))
+        return condition.lte(key, value.slice(2));
+    if (value.startsWith('<'))
+        return condition.lt(key, value.slice(1));
+    if (value.startsWith('>='))
+        return condition.gte(key, value.slice(2));
+    if (value.startsWith('>'))
+        return condition.gt(key, value.slice(1));
+    if (value.includes(';')) {
+        const pos = value.startsWith('=;') ? 2 : value.startsWith('=') || value.startsWith(';') ? 1 : 0;
+        return condition.in(key, value.slice(Math.max(0, pos)));
+    }
+    if (value.startsWith('='))
+        return condition.eq(key, value.slice(1));
+    return condition.beginWith(key, value);
+};
+export function toXmlParametros(condicion, Parametro) {
+    let xml = `<${Parametro}>\n`;
+    let level = 0;
+    const processField = (fieldName, operator, value) => {
+        const tag = substringAfterLast(fieldName, '.');
+        const nodeContent = fieldName.startsWith('Condiciones.')
+            ? getXmlConditionValue(operator, value)
+            : operator === '='
+                ? formatValueForXml(value)
+                : `${operator}${formatValueForXml(value)}`;
+        xml += `${spaces((level + 1) * 2)}<${escapeXmlTag(tag)}>${escapeXmlContent(nodeContent)}</${escapeXmlTag(tag)}>\n`;
+    };
+    const traverseObject = (obj, path = '') => {
+        for (const key in obj) {
+            let currentPath = path ? `${path}.${key}` : key;
+            const value = obj[key];
+            if (substringAfterLast(currentPath, '.') === 'AND') {
+                const arr = value;
+                for (const [index, element] of arr.entries()) {
+                    currentPath = `${path}.${key}_${index}`;
+                    traverseObject(element, currentPath);
+                }
+            }
+            else if (value &&
+                typeof value === 'object' &&
+                !Array.isArray(value) &&
+                'operator' in value) {
+                // Condición con operador explícito
+                const typed = value;
+                processField(currentPath, typed.operator, typed.value);
+            }
+            else if (value && typeof value === 'object' && !Array.isArray(value)) {
+                // Objeto anidado
+                level++;
+                xml += `${spaces(level * 2)}<${substringAfterLast(currentPath, '.')}>\n`;
+                traverseObject(value, currentPath);
+                xml += `${spaces(level * 2)}</${substringAfterLast(currentPath, '.')}>\n`;
+                level--;
+            }
+            else {
+                // Condición simple (igualdad implícita)
+                processField(currentPath, '=', value);
+            }
+        }
+    };
+    if (Array.isArray(condicion)) {
+        for (const item of condicion)
+            traverseObject(item);
+    }
+    else {
+        traverseObject(condicion);
+    }
+    xml += `</${Parametro}>`;
+    return xml;
+}
+function formatValueForXml(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (Array.isArray(value))
+        return value.join(',');
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    return String(value);
+}
+function escapeXmlContent(content) {
+    return content.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+function escapeXmlTag(tag) {
+    return tag.replaceAll(/[^a-zA-Z0-9_.-]/g, '_');
+}
+const substringAfterLast = (text, char) => {
+    const lastIndex = text.lastIndexOf(char);
+    return lastIndex === -1 ? text : text.slice(lastIndex + 1);
+};
+const spaces = (n) => ' '.repeat(n);

package/dist/result.d.ts

@@ -0,0 +1,14 @@
+type Ok<Data> = {
+    ok: true;
+    data: Data;
+    error: null;
+};
+type Err<Error> = {
+    ok: false;
+    data: null;
+    error: Error;
+};
+export type Result<Data, Error> = Ok<Data> | Err<Error>;
+export declare function ok<Data>(data: Data): Ok<Data>;
+export declare function err<Error>(error: Error): Err<Error>;
+export {};

package/dist/result.js

@@ -0,0 +1,6 @@
+export function ok(data) {
+    return { ok: true, data, error: null };
+}
+export function err(error) {
+    return { ok: false, data: null, error };
+}

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+import type { DbInfo } from './db.js';
+export type Accion = 'consulta' | 'alta' | 'baja' | 'modificacion';
+export type Permisos = Record<string, Accion[]>;
+export type Usuario = {
+    usuarioId: number;
+    codigo: string;
+    apellido: string;
+    nombres: string;
+    apellidoNombres: string;
+    activo: boolean;
+    grupos: string[];
+    permisos: Permisos;
+    domainUser: string;
+};
+export type Authentication = {
+    type: 'none';
+} | {
+    type: 'iis-node';
+};
+export type Authorization = {
+    type: 'none';
+} | {
+    type: 'metaSSC';
+    dbInfo: DbInfo | string;
+    serviceUser?: string;
+};
+export type Aplicacion = {
+    name: string;
+    aplicacionCodigo?: string;
+    servicioCodigo?: string;
+    authentication: Authentication;
+    authorization: Authorization;
+    dbInfo: DbInfo | string;
+    pagination: 'sql' | 'com+';
+    endpoints: Endpoint[];
+};
+type AccionOrAll = Accion | '*';
+export type Endpoint = {
+    name: string;
+    recurso: string;
+    fieldId: string;
+    acciones?: AccionOrAll[];
+    archivoParams?: string[];
+};
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/valid.d.ts

@@ -0,0 +1,15 @@
+import { type AppError } from './errors.js';
+import { type Result } from './result.js';
+import type { Accion, Aplicacion, Permisos } from './types.js';
+export declare function validParams(app: Aplicacion, path: string, withId?: 'withId' | 'noId'): Result<{
+    objeto: string;
+    id: number;
+    fieldId: string;
+    archivoParams: string[];
+}, AppError>;
+export type Metodo = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export declare function checkPermiso(app: Aplicacion, objeto: string, metodo: Metodo, permisos: Permisos): Result<{
+    accion: Accion;
+    recurso?: string;
+    permisos?: Accion[];
+}, AppError>;

package/dist/valid.js

@@ -0,0 +1,92 @@
+// Parseo del `[...path]` de la request (objeto + id opcional) y chequeo de permisos por acción.
+// A diferencia de convenios_web, acá no hay `aplicacion` que resolver: el adapter siempre opera
+// sobre la única `Aplicacion` con la que se lo creó (ver docs/proximos-pasos.md), así que `app`
+// llega ya resuelta — lo único variable en cada request es el objeto/id (el `[...path]`) y el
+// método HTTP.
+import { appError } from './errors.js';
+import { err, ok } from './result.js';
+// Único caller de getEndpoint en toda la librería — vive acá en vez de en types.ts porque ahí
+// solo van formas de datos, no funciones.
+//
+// El segmento de URL puede venir en snake_case (`tipo_dato`) o ya en PascalCase (`TipoDato`,
+// que es como se configura `Endpoint.name`) — se soportan ambos normalizando el segmento antes de
+// comparar. Portado de `convenios_web` (`snakeToPascal` en `$lib/utils/string.ts`): si ya está en
+// PascalCase queda igual (`TipoDato` → `TipoDato`), snake_case se junta y capitaliza cada parte
+// (`tipo_dato` → `TipoDato`), y un segmento todo en mayúsculas no queda gritando (`PROVINCIA` →
+// `Provincia`).
+function toPascalCase(str) {
+    return str
+        .split('_')
+        .map((part) => {
+        const tail = part === part.toUpperCase() ? part.slice(1).toLowerCase() : part.slice(1);
+        return part.charAt(0).toUpperCase() + tail;
+    })
+        .join('');
+}
+const getEndpoint = (app, objeto) => app.endpoints.find((ep) => ep.name === toPascalCase(objeto));
+export function validParams(app, path, withId = 'noId') {
+    const [objetoRaw, idRaw] = path.split('/');
+    if (!objetoRaw)
+        return err(appError('Objeto no especificado', 'BAD_REQUEST'));
+    // getEndpoint matchea case-insensitive (y snake_case) y devuelve el nombre canónico
+    // configurado — no hace falta normalizar el segmento de URL a mano, alcanza con el endpoint
+    // que realmente matcheó.
+    const endpointConfig = getEndpoint(app, objetoRaw);
+    if (!endpointConfig)
+        return err(appError(`Objeto ${objetoRaw} inválido`, 'BAD_REQUEST'));
+    // Dos chequeos independientes, no uno solo: si vino un segundo segmento en el path, tiene que
+    // ser un entero válido sin importar el método — un GET con id basura (`/Provincia/abc`) no
+    // puede degradar en silencio a "listar todo" solo porque `withId` (que exige el id) es 'noId'
+    // para GET. Bug real, encontrado recién probando contra un vite dev real (Playwright,
+    // errors.http.test.ts): `id` colapsaba "no vino idRaw" y "vino pero es inválido" al mismo 0,
+    // y noId nunca miraba ese 0 para GET. En convenios_web esto no podía pasar: GET-con-id y
+    // GET-sin-id eran rutas de SvelteKit distintas ([objeto]/+server.ts vs [objeto]/[id]/
+    // +server.ts) — acá, con un solo [...path], hay que recrear esa distinción a mano.
+    const idProvisto = idRaw !== undefined && idRaw !== '';
+    const id = idProvisto && isInteger(idRaw) ? Number(idRaw) : 0;
+    if (idProvisto && id === 0)
+        return err(appError(`Id ${id} inválido`, 'BAD_REQUEST'));
+    if (withId === 'withId' && !idProvisto)
+        return err(appError(`Id ${id} inválido`, 'BAD_REQUEST'));
+    return ok({
+        objeto: endpointConfig.name,
+        id,
+        fieldId: endpointConfig.fieldId,
+        archivoParams: endpointConfig.archivoParams || [],
+    });
+}
+const isInteger = (str) => /^-?\d+$/.test(str.trim());
+const metodos = {
+    GET: 'consulta',
+    POST: 'alta',
+    PUT: 'modificacion',
+    DELETE: 'baja',
+};
+export function checkPermiso(app, objeto, metodo, permisos) {
+    const accion = metodos[metodo];
+    const endpointConfig = getEndpoint(app, objeto);
+    if (!endpointConfig)
+        return err(appError('Objeto inválido', 'BAD_REQUEST'));
+    // Capa 1: acciones permitidas por endpoint — estática, siempre activa.
+    if (endpointConfig.acciones &&
+        !endpointConfig.acciones.includes('*') &&
+        !endpointConfig.acciones.includes(accion)) {
+        return err(appError('Acceso denegado', 'FORBIDDEN'));
+    }
+    if (app.authorization.type === 'none')
+        return ok({ accion });
+    // Capa 2: permisos dinámicos contra Meta — búsqueda relajada de recurso (mayúsculas, sin
+    // espacios/guiones/"TABLAS "), no controlamos cómo se llaman los recursos ahí.
+    const recurso = endpointConfig.recurso;
+    const permisoKey = Object.keys(permisos).find((r) => rawRecurso(r) === rawRecurso(recurso));
+    if (!permisoKey || !permisos[permisoKey].includes(accion)) {
+        return err(appError('Acceso denegado', 'FORBIDDEN'));
+    }
+    return ok({ accion, recurso: permisoKey, permisos: permisos[permisoKey] });
+}
+function rawRecurso(recurso) {
+    return recurso
+        .toUpperCase()
+        .replace(/^TABLAS /, '')
+        .replaceAll(/[^A-Z0-9]/g, '');
+}

package/dist/xml.d.ts

@@ -0,0 +1,25 @@
+import type { Condition } from './condition.js';
+export type XmlTipo = 'Consulta' | 'Alta' | 'Baja' | 'Modificacion';
+export type XmlParametro = {
+    Tabla: string;
+    PaginaLong?: number;
+    Pagina?: number;
+    SqlPaginate?: number;
+    Campos?: string;
+    Orden?: string;
+    Condiciones?: Condition;
+    [key: string]: unknown;
+};
+export type XmlSentencia = {
+    Operador: string;
+    Clase: string;
+    Metodo: string;
+    Tipo: XmlTipo;
+    AplicacionCodigo: string;
+    ServicioCodigo: string;
+    Parametro: XmlParametro;
+};
+export declare function xmlConsulta(options: Partial<XmlSentencia>): XmlSentencia;
+export declare const xmlAlta: (options: Partial<XmlSentencia>) => XmlSentencia;
+export declare const xmlModificacion: (options: Partial<XmlSentencia>) => XmlSentencia;
+export declare const xmlBaja: (options: Partial<XmlSentencia>) => XmlSentencia;

package/dist/xml.js

@@ -0,0 +1,36 @@
+// Tipos y builders para armar el `XmlSentencia` que consumen execXmlSentencia/execXmlConsulta
+// (ver db.ts) al invocar los SPs `xmlXXX_Alta|Baja|Modificacion|Consulta`. Cada builder devuelve
+// una sentencia con los defaults de su tipo — `xmlConsulta` además completa los defaults de
+// paginación de `Parametro`; los otros tres solo fijan `Metodo`/`Tipo` y clonan `Parametro` tal
+// como venga (nunca comparten referencia con el `options.Parametro` de entrada).
+function xmlInit(tipo, options) {
+    return {
+        Operador: options.Operador || 'ANONYMOUS',
+        Clase: 'Tabla',
+        Metodo: options.Metodo || tipo,
+        Tipo: tipo,
+        AplicacionCodigo: options.AplicacionCodigo || '',
+        ServicioCodigo: options.ServicioCodigo || '',
+        Parametro: { Tabla: '', ...options.Parametro },
+    };
+}
+export function xmlConsulta(options) {
+    return xmlInit('Consulta', {
+        ...options,
+        Parametro: {
+            Tabla: options.Parametro?.Tabla || '',
+            // `??`, no `||`: 0 es un valor válido y distinto de "no especificado" (ver
+            // request-to-xml.ts, que clampea paginación negativa a 0 — con `||` ese 0 quedaría
+            // pisado por el default y el clamp no serviría de nada).
+            PaginaLong: options.Parametro?.PaginaLong ?? 20,
+            Pagina: options.Parametro?.Pagina ?? 1,
+            SqlPaginate: options.Parametro?.SqlPaginate || 0,
+            Campos: options.Parametro?.Campos || '*',
+            Orden: options.Parametro?.Orden,
+            Condiciones: options.Parametro?.Condiciones,
+        },
+    });
+}
+export const xmlAlta = (options) => xmlInit('Alta', options);
+export const xmlModificacion = (options) => xmlInit('Modificacion', options);
+export const xmlBaja = (options) => xmlInit('Baja', options);

package/package.json

@@ -0,0 +1,99 @@
+{
+	"name": "@opensas/xml-rest-adapter",
+	"version": "0.1.0",
+	"publishConfig": {
+		"access": "public"
+	},
+	"volta": {
+		"node": "24.19.0",
+		"pnpm": "11.21.0",
+		"npm": "12.0.2"
+	},
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run prepack",
+		"preview": "vite preview",
+		"prepare": "svelte-kit sync || echo ''",
+		"prepack": "svelte-kit sync && svelte-package && publint",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"check:all": "npm run format && eslint . --fix --cache && npm run check",
+		"format": "prettier --write --cache .",
+		"lint": "eslint . --cache",
+		"verify": "npm run format & eslint . --fix --cache & npm run check",
+		"up:safe": "pnpm --config.minimumReleaseAge=1440 up -i",
+		"test:unit": "vitest run --project=unit-tests",
+		"test:vite": "vitest run",
+		"test:api": "playwright test --project=api-tests --pass-with-no-tests",
+		"test:e2e": "playwright test --project=e2e-tests --pass-with-no-tests",
+		"test:play": "playwright test --pass-with-no-tests",
+		"test": "npm run test:vite && npm run test:play",
+		"test:ci": "tsx scripts/test-ci.ts",
+		"fixture:init": "tsx scripts/fixture-init.ts",
+		"fixture:purge": "docker compose -f docker/fixture/docker-compose.yaml down -v",
+		"fixture:start": "docker compose -f docker/fixture/docker-compose.yaml up -d",
+		"fixture:stop": "docker compose -f docker/fixture/docker-compose.yaml stop",
+		"fixture:status": "docker ps --filter name=fixture-db --format 'table {{.Names}}\\t{{.Status}}'",
+		"gitlab-runner:start": "sudo gitlab-runner start",
+		"gitlab-runner:stop": "sudo gitlab-runner stop",
+		"gitlab-runner:status": "sudo gitlab-runner status",
+		"gitlab-runner:logs": "sudo journalctl -u gitlab-runner -f"
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"sideEffects": [
+		"**/*.css"
+	],
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"peerDependencies": {
+		"@sveltejs/kit": "^2.0.0",
+		"svelte": "^5.0.0"
+	},
+	"devDependencies": {
+		"@eslint/js": "^10.0.1",
+		"@playwright/test": "^1.62.1",
+		"@sveltejs/adapter-auto": "^7.0.1",
+		"@sveltejs/kit": "^2.63.0",
+		"@sveltejs/package": "^2.5.8",
+		"@sveltejs/vite-plugin-svelte": "^7.1.2",
+		"@types/mssql": "^12.3.0",
+		"@types/node": "^24",
+		"dotenv": "^17.4.2",
+		"eslint": "^10.4.1",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-check-file": "^3.3.2",
+		"eslint-plugin-simple-import-sort": "^13.0.0",
+		"eslint-plugin-svelte": "^3.19.0",
+		"eslint-plugin-unicorn": "^71.1.0",
+		"globals": "^17.6.0",
+		"jiti": "^2.7.0",
+		"prettier": "^3.8.3",
+		"prettier-plugin-svelte": "^4.1.0",
+		"publint": "^0.3.21",
+		"svelte": "^5.56.1",
+		"svelte-check": "^4.6.0",
+		"tsx": "^4.23.12",
+		"typescript": "^6.0.3",
+		"typescript-eslint": "^8.60.1",
+		"vite": "^8.0.16",
+		"vitest": "^4.1.8"
+	},
+	"keywords": [
+		"svelte"
+	],
+	"dependencies": {
+		"mssql": "^12.7.0"
+	}
+}