@ressjs/vite-router 0.5.2 → 0.6.0-experimental.0

package/dist/config/load.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.normalizeBasePath = normalizeBasePath;
+const config_1 = require("@ressjs/config");
+const validate_1 = require("./validate");
+/**
+ * Lee la configuración del proyecto y la deja lista para consultar.
+ *
+ * **Una sola superficie**: la carpeta `config/`, con un archivo por modo.
+ *
+ * ```
+ * config/default.js       ← lo común, opcional
+ * config/development.js
+ * config/production.js
+ * config/test.js
+ * config/local.js         ← esta máquina; no se sube
+ * ```
+ *
+ * Cada archivo exporta por defecto un objeto con **todo**: `basePath`,
+ * `redirects`, `publicEnv`, `dev.hmr`, `security`, y también los valores propios
+ * del proyecto —la URL de una API, una clave—. Se fusionan `default` → el modo
+ * activo → `local`, y la última capa que declara una clave gana.
+ *
+ * Antes esto estaban partido en dos archivos distintos, `ress.config` para el
+ * comportamiento y `config/` para los valores. Eran dos lugares donde buscar la
+ * misma respuesta —"¿de dónde sale este valor?"— y dos formas de declararla.
+ */
+async function loadConfig(root = process.cwd(), mode = process.env.NODE_ENV === 'production' ? 'production' : 'development') {
+    // La misma resolución que lee el código de la aplicación con
+    // `import { config } from '@ressjs/config'`: un solo objeto, resuelto una vez.
+    const declared = (await (0, config_1.resolveConfig)(root, mode));
+    (0, validate_1.validateConfig)(declared);
+    return resolve(declared);
+}
+/**
+ * Completa lo que el proyecto no declaró.
+ *
+ * Se hace una vez al arrancar y no por consulta: así el resto del framework lee
+ * `config.dev.hmr` sin `?.` ni `??` en cada uso, y los valores por defecto están
+ * escritos en un solo lugar.
+ */
+async function resolve(declared) {
+    return {
+        // Sin barra final: se agrega al componer, y tenerla en el valor guardado
+        // obliga a recordar si ya está en cada concatenación.
+        basePath: normalizeBasePath(declared.basePath ?? ''),
+        trailingSlash: declared.trailingSlash ?? 'ignore',
+        // Las tres son funciones para que el proyecto pueda leer un archivo o
+        // consultar algo al arrancar. Se invocan una vez, acá.
+        redirects: (await declared.redirects?.()) ?? [],
+        rewrites: (await declared.rewrites?.()) ?? [],
+        headers: (await declared.headers?.()) ?? [],
+        publicEnv: declared.publicEnv ?? [],
+        extensions: declared.extensions ?? {},
+        platform: declared.platform ?? {},
+        security: declared.security ?? {},
+        assets: declared.assets ?? {},
+        dev: {
+            prettyErrors: declared.dev?.prettyErrors ?? true,
+            hmr: declared.dev?.hmr ?? true,
+        },
+        server: declared.server ?? {},
+    };
+}
+/** `'/app/'` y `'app'` describen lo mismo: se guardan como `'/app'`. */
+function normalizeBasePath(basePath) {
+    const trimmed = basePath.trim();
+    if (!trimmed || trimmed === '/')
+        return '';
+    const withLeading = trimmed.startsWith('/') ? trimmed : '/' + trimmed;
+    return withLeading.replace(/\/+$/, '');
+}

package/dist/config/middleware.d.ts

@@ -0,0 +1,18 @@
+import { type CompiledRules } from './rules';
+import type { ResolvedConfig } from './types';
+/**
+ * Lo que la configuración aporta al pipeline de petición.
+ *
+ * El orden es fijo y está en el plan:
+ *
+ * 1. barra final — para que todo lo que sigue vea una sola forma de cada URL
+ * 2. prefijo de ruta — para que el manifest trabaje siempre sin prefijo
+ * 3. redirecciones — si alguna coincide, se responde y se termina
+ * 4. reescrituras — cambian la ruta a resolver, no la que el navegador muestra
+ * 5. cabeceras — al escribir la respuesta, sin pisar las del framework
+ */
+export interface ConfigMiddlewareOptions {
+    /** Reglas ya compiladas. Se compilan una vez al arrancar, no por petición. */
+    compiled?: CompiledRules;
+}
+export declare function createConfigMiddleware(config: ResolvedConfig, options?: ConfigMiddlewareOptions): (req: any, res: any, next: (err?: unknown) => void) => void;

package/dist/config/middleware.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigMiddleware = createConfigMiddleware;
+const base_path_1 = require("./base-path");
+const rules_1 = require("./rules");
+function createConfigMiddleware(config, options = {}) {
+    const rules = options.compiled ?? (0, rules_1.compileRules)(config);
+    const { basePath, trailingSlash } = config;
+    return function configMiddleware(req, res, next) {
+        const url = req.url ?? '/';
+        const cut = url.search(/[?#]/);
+        const pathname = cut === -1 ? url : url.slice(0, cut);
+        const suffix = cut === -1 ? '' : url.slice(cut);
+        const canonical = (0, base_path_1.canonicalTrailingSlash)(pathname, trailingSlash);
+        if (canonical !== undefined) {
+            // 308: el navegador y los intermediarios tienen que conservar el método.
+            // Un 301 convierte un POST en GET al repetir.
+            return redirect(res, 308, canonical + suffix);
+        }
+        const inner = (0, base_path_1.stripBasePath)(pathname, basePath);
+        if (inner === undefined) {
+            // Fuera del prefijo no hay aplicación: se marca para que ni los artefactos
+            // ni las páginas la atiendan. Sin la marca, declarar un prefijo dejaba el
+            // sitio servido por dos direcciones distintas a la vez, que es justo lo
+            // que un prefijo existe para evitar.
+            req.ressOutsideBasePath = true;
+            return next();
+        }
+        // La URL original queda a mano: los mensajes de error y los enlaces
+        // canónicos hablan de lo que el navegador pidió, no de lo que quedó
+        // después de quitar el prefijo.
+        req.ressOriginalUrl ??= url;
+        req.ressBasePath = basePath;
+        req.url = inner + suffix;
+        const redirection = (0, rules_1.matchRule)(rules.redirects, inner);
+        if (redirection) {
+            const target = (0, rules_1.applyParams)(redirection.compiled.rule.destination, redirection.params);
+            return redirect(res, redirection.compiled.rule.permanent ? 308 : 307, absolute(target) ? target : (0, base_path_1.withBasePath)(target, basePath) + suffix);
+        }
+        const rewrite = (0, rules_1.matchRule)(rules.rewrites, inner);
+        if (rewrite) {
+            // Sólo cambia lo que el servidor resuelve: `req.url` es interno, y la
+            // barra de direcciones del navegador no se entera.
+            req.url = (0, rules_1.applyParams)(rewrite.compiled.rule.destination, rewrite.params) + suffix;
+        }
+        applyHeaderRules(rules, inner, res);
+        next();
+    };
+}
+function absolute(target) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(target) || target.startsWith('//');
+}
+function redirect(res, status, location) {
+    res.statusCode = status;
+    res.setHeader('Location', location);
+    res.end();
+}
+/**
+ * Las cabeceras declaradas se escriben al enviar, no ahora.
+ *
+ * Ponerlas ya las dejaría expuestas a que el framework las pisara después; y
+ * ponerlas después de las suyas es justamente la regla: complementan lo que el
+ * framework decidió, no lo corrigen. Por eso sólo se escribe lo que nadie fijó.
+ */
+function applyHeaderRules(rules, pathname, res) {
+    const match = (0, rules_1.matchRule)(rules.headers, pathname);
+    if (!match)
+        return;
+    const write = res.writeHead?.bind(res);
+    if (!write)
+        return;
+    res.writeHead = (...args) => {
+        for (const { key, value } of match.compiled.rule.headers) {
+            if (res.getHeader?.(key) === undefined)
+                res.setHeader(key, value);
+        }
+        return write(...args);
+    };
+}

package/dist/config/rules.d.ts

@@ -0,0 +1,48 @@
+import type { RouteSegment } from '../routes/types';
+import type { HeaderRule, RedirectRule, ResolvedConfig, RewriteRule } from './types';
+/**
+ * Redirecciones, reescrituras y cabeceras declaradas por el proyecto.
+ *
+ * Las tres comparten patrón, y el patrón es **el mismo analizador de rutas** que
+ * usa el manifest: `matchSegments()` recorre segmento a segmento y exige consumir
+ * la URL entera. Una segunda implementación de coincidencia acá significaría que
+ * `/docs/:seccion` puede querer decir dos cosas distintas según quién la lea.
+ *
+ * Notación de un patrón:
+ *
+ * | Escrito | Coincide con |
+ * |---|---|
+ * | `/precios` | exactamente `/precios` |
+ * | `/blog/:slug` | un segmento, disponible como `:slug` en el destino |
+ * | `/docs/:...resto` | uno o más segmentos |
+ * | `/docs/:...resto?` | cero o más segmentos |
+ */
+export interface CompiledRule<T> {
+    rule: T;
+    source: string;
+    segments: RouteSegment[];
+    paramNames: string[];
+}
+export interface CompiledRules {
+    redirects: CompiledRule<RedirectRule>[];
+    rewrites: CompiledRule<RewriteRule>[];
+    headers: CompiledRule<HeaderRule>[];
+}
+export declare function parseRulePattern(source: string, label: string): {
+    segments: RouteSegment[];
+    paramNames: string[];
+};
+/**
+ * Compila las tres listas y comprueba lo que sólo se puede comprobar con los
+ * patrones ya analizados: parámetros que el destino usa sin que el origen los
+ * declare, cabeceras reservadas, y ciclos de redirección.
+ */
+export declare function compileRules(config: ResolvedConfig): CompiledRules;
+export interface RuleMatch<T> {
+    compiled: CompiledRule<T>;
+    params: Record<string, string | string[]>;
+}
+/** La primera regla que atiende esta ruta, en el orden en que se declararon. */
+export declare function matchRule<T>(rules: readonly CompiledRule<T>[], pathname: string): RuleMatch<T> | undefined;
+/** Traslada los parámetros que capturó el origen al destino. */
+export declare function applyParams(destination: string, params: Record<string, string | string[]>): string;

package/dist/config/rules.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRulePattern = parseRulePattern;
+exports.compileRules = compileRules;
+exports.matchRule = matchRule;
+exports.applyParams = applyParams;
+const match_1 = require("../routes/match");
+/** Cabeceras que administra el framework: declararlas desde el proyecto las rompe. */
+const RESERVED_HEADERS = new Set(['vary', 'content-type', 'content-length', 'transfer-encoding']);
+function parseRulePattern(source, label) {
+    if (!source.startsWith('/')) {
+        throw new Error(`[ress] ${label}: el patrón "${source}" tiene que empezar con "/". ` +
+            'Es una ruta de esta aplicación, no una URL relativa.');
+    }
+    const segments = [];
+    const paramNames = [];
+    // El patrón se parte a mano y no con `splitPath()`: esa función descarta la
+    // consulta a partir del `?`, que acá es la marca de catch-all opcional.
+    for (const raw of source.split('/').filter(Boolean)) {
+        const previous = segments[segments.length - 1];
+        if (previous && (previous.kind === 'catchAll' || previous.kind === 'optionalCatchAll')) {
+            throw new Error(`[ress] ${label}: "${source}" pone un segmento después de un catch-all, ` +
+                'que ya consume el resto de la URL.');
+        }
+        if (!raw.startsWith(':')) {
+            segments.push({ kind: 'static', value: raw });
+            continue;
+        }
+        const optional = raw.endsWith('?');
+        const body = optional ? raw.slice(1, -1) : raw.slice(1);
+        const catchAll = body.startsWith('...');
+        const name = catchAll ? body.slice(3) : body;
+        if (!name) {
+            throw new Error(`[ress] ${label}: "${source}" declara un parámetro sin nombre.`);
+        }
+        if (optional && !catchAll) {
+            throw new Error(`[ress] ${label}: "${source}" marca ":${name}" como opcional. ` +
+                'Sólo un catch-all puede serlo: ":...' + name + '?".');
+        }
+        if (paramNames.includes(name)) {
+            throw new Error(`[ress] ${label}: "${source}" usa el parámetro ":${name}" dos veces.`);
+        }
+        paramNames.push(name);
+        segments.push({
+            kind: catchAll ? (optional ? 'optionalCatchAll' : 'catchAll') : 'dynamic',
+            value: name,
+        });
+    }
+    return { segments, paramNames };
+}
+/**
+ * Compila las tres listas y comprueba lo que sólo se puede comprobar con los
+ * patrones ya analizados: parámetros que el destino usa sin que el origen los
+ * declare, cabeceras reservadas, y ciclos de redirección.
+ */
+function compileRules(config) {
+    const compiled = {
+        redirects: compileList(config.redirects, 'redirects'),
+        rewrites: compileList(config.rewrites, 'rewrites'),
+        headers: compileList(config.headers, 'headers'),
+    };
+    const problems = [];
+    for (const [index, entry] of compiled.redirects.entries()) {
+        checkDestination(entry, entry.rule.destination, `redirects[${index}]`, problems);
+    }
+    for (const [index, entry] of compiled.rewrites.entries()) {
+        checkDestination(entry, entry.rule.destination, `rewrites[${index}]`, problems);
+    }
+    for (const [index, entry] of compiled.headers.entries()) {
+        for (const header of entry.rule.headers) {
+            if (RESERVED_HEADERS.has(header.key.toLowerCase())) {
+                problems.push(`headers[${index}]: "${header.key}" la administra el framework y no se puede declarar acá.`);
+            }
+        }
+    }
+    const cycle = findRedirectCycle(compiled.redirects);
+    if (cycle) {
+        problems.push(`redirects: las reglas ${cycle.join(' → ')} forman un ciclo. ` +
+            'Un ciclo deja al navegador saltando hasta que se rinde.');
+    }
+    if (problems.length) {
+        throw new Error('[ress] La configuración tiene reglas inválidas:\n' +
+            problems.map((p) => `  · ${p}`).join('\n'));
+    }
+    return compiled;
+}
+function compileList(rules, label) {
+    return rules.map((rule, index) => {
+        const { segments, paramNames } = parseRulePattern(rule.source, `${label}[${index}]`);
+        return { rule, source: rule.source, segments, paramNames };
+    });
+}
+/** Todo `:param` del destino tiene que estar declarado en el origen. */
+function checkDestination(entry, destination, label, problems) {
+    for (const used of destination.matchAll(/:(\.{3})?([A-Za-z0-9_]+)/g)) {
+        const name = used[2];
+        if (!entry.paramNames.includes(name)) {
+            problems.push(`${label}.destination: usa ":${name}", que "${entry.source}" no declara. ` +
+                `Declarados: ${entry.paramNames.map((p) => ':' + p).join(', ') || 'ninguno'}.`);
+        }
+    }
+}
+/**
+ * Un ciclo de redirecciones.
+ *
+ * Se sigue la cadena desde cada regla: se toma su destino, se busca qué regla lo
+ * atendería, y así. Volver a pisar una regla ya visitada en la misma cadena es un
+ * ciclo. Sólo se puede seguir un destino sin parámetros sin inventar valores, así
+ * que la comprobación es de los ciclos que se pueden demostrar.
+ */
+function findRedirectCycle(redirects) {
+    for (const start of redirects) {
+        const seen = [start.source];
+        let current = start;
+        for (let step = 0; step < redirects.length; step++) {
+            const destination = current.rule.destination;
+            if (destination.includes(':'))
+                break;
+            const next = matchRule(redirects, destination);
+            if (!next)
+                break;
+            if (seen.includes(next.compiled.source)) {
+                return [...seen, next.compiled.source];
+            }
+            seen.push(next.compiled.source);
+            current = next.compiled;
+        }
+    }
+    return undefined;
+}
+/** La primera regla que atiende esta ruta, en el orden en que se declararon. */
+function matchRule(rules, pathname) {
+    const parts = (0, match_1.splitPath)(pathname);
+    for (const compiled of rules) {
+        const params = (0, match_1.matchSegments)(compiled.segments, parts);
+        if (params)
+            return { compiled, params };
+    }
+    return undefined;
+}
+/** Traslada los parámetros que capturó el origen al destino. */
+function applyParams(destination, params) {
+    return destination.replace(/:(\.{3})?([A-Za-z0-9_]+)/g, (whole, _spread, name) => {
+        const value = params[name];
+        if (value === undefined)
+            return whole;
+        return Array.isArray(value) ? value.join('/') : value;
+    });
+}

package/dist/config/types.d.ts

@@ -0,0 +1,164 @@
+import type { ExtensionPolicy } from '../fs/module-extensions';
+import type { SecurityOptions } from '../security';
+/**
+ * La configuración del proyecto: un objeto por archivo de `config/`.
+ *
+ * ```js
+ * // config/production.js
+ * export default {
+ *   basePath: '/app',
+ *   redirects: () => [{ source: '/viejo', destination: '/nuevo', permanent: true }],
+ *   dev: { hmr: false },
+ *
+ *   // Y las claves propias del proyecto, que conviven con las del framework.
+ *   API_URL: 'https://api.example.com',
+ * }
+ * ```
+ *
+ * Las claves que el framework reconoce están declaradas abajo; cualquier otra es
+ * del proyecto y se lee con `import { config } from '@ressjs/config'`. No hay un
+ * segundo archivo para eso: un solo lugar donde buscar de dónde sale un valor.
+ *
+ * Cada spec que necesita configuración aporta su propia interfaz y la enchufa
+ * como una clave. Esta spec aporta el continente, la carga, la fusión y la
+ * validación; no el contenido de cada sección.
+ */
+export type TrailingSlashMode = 'always' | 'never' | 'ignore';
+export interface RessConfig {
+    /** Prefijo bajo el que se sirve la aplicación. Sin barra final. */
+    basePath?: string;
+    /** Qué hacer con la barra final de una URL. */
+    trailingSlash?: TrailingSlashMode;
+    redirects?: () => RedirectRule[] | Promise<RedirectRule[]>;
+    rewrites?: () => RewriteRule[] | Promise<RewriteRule[]>;
+    headers?: () => HeaderRule[] | Promise<HeaderRule[]>;
+    /**
+     * Variables de entorno que llegan al navegador.
+     *
+     * Lista explícita y no un prefijo: un prefijo publica lo que alguien agregue
+     * después sin que nadie lo decida.
+     */
+    publicEnv?: string[];
+    /** Extensiones reconocidas como código de usuario. F-017. */
+    extensions?: Partial<ExtensionPolicy>;
+    /** Tokens de plataforma propios del proyecto. Alimenta sólo los tipos generados; F-024. */
+    platform?: PlatformConfig;
+    /**
+     * Cabeceras, política de contenido y límites.
+     *
+     * Se carga, se fusiona y se valida como el resto de la configuración, pero
+     * todavía no llega al pipeline de petición: `request-handler.ts` sigue
+     * leyendo `RouterOptions.security`/`securityOptions`, que es un objeto
+     * aparte. Declarar esta clave en `config/*.js` no tiene efecto todavía.
+     * F-019.
+     */
+    security?: SecurityOptions;
+    /** Prefijo de CDN para archivos estáticos. Consumido por F-006. */
+    assets?: AssetsConfig;
+    /** Experiencia de desarrollo. Consumido por F-034 y F-015/F-016. */
+    dev?: DevConfig;
+    /**
+     * Vía de escape nivel 1 (F-033): extender la aplicación de servidor sin
+     * salir de los comandos de la CLI.
+     */
+    server?: RessServerConfig;
+    /**
+     * Capas por modo, sólo en la forma de archivo único (`config.js` en vez de la
+     * carpeta). La forma de carpeta las expresa con un archivo por modo, que es la
+     * que conviene cuando la configuración crece.
+     */
+    development?: ModeOverrides;
+    production?: ModeOverrides;
+    local?: ModeOverrides;
+    /**
+     * Los valores propios del proyecto: una URL de API, una clave, un feature
+     * flag. Conviven con las claves del framework en el mismo objeto y se leen con
+     * `import { config } from '@ressjs/config'`.
+     */
+    [key: string]: unknown;
+}
+/** Una capa de modo no puede contener otras capas. */
+export type ModeOverrides = Omit<RessConfig, 'development' | 'production' | 'local'>;
+export interface AssetsConfig {
+    /** Prefijo absoluto desde el que se sirven los artefactos. */
+    cdnPrefix?: string;
+}
+export interface DevConfig {
+    /** Página de error con contexto en desarrollo. F-034. */
+    prettyErrors?: boolean;
+    /** Recarga en caliente. F-015 y F-016. */
+    hmr?: boolean;
+}
+/**
+ * Vía de escape nivel 1: extender la aplicación de servidor desde la
+ * configuración, sin dejar de usar `ress dev` / `ress build` / `ress start`.
+ *
+ * Las funciones reciben el `Express` que construye `createRessApp` (F-033).
+ * `beforeRouter` corre antes de montar el enrutador del framework y gana ante
+ * sus rutas; `afterRouter` corre después y no puede pisarlas.
+ */
+export interface RessServerConfig {
+    /** Se ejecuta antes de montar el enrutador del framework. Gana ante rutas del framework. */
+    beforeRouter?: (app: import('express').Express) => void | Promise<void>;
+    /** Se ejecuta después. No puede pisar rutas del framework. */
+    afterRouter?: (app: import('express').Express) => void | Promise<void>;
+}
+/**
+ * Tokens de plataforma propios del proyecto, para el autocompletado.
+ *
+ * `detect`, `axisPrecedence` y `edge` no están acá: el motor de detección los
+ * lee de `defaultPlatformRegistry`, no de esta configuración. Declararlos aquí
+ * sin que nada los consuma es la clase de clave que promete algo que no hace.
+ */
+export interface PlatformConfig {
+    values?: Array<{
+        token: string;
+        axis: string;
+        label?: string;
+    }>;
+    /** Plataformas para las que se prepara el proyecto generado. F-033. */
+    targets?: string[];
+    /**
+     * Intención declarativa de usar clientes completos forkeables. Las plantillas
+     * y sus runtimes pertenecen a F-028 (React Native) y F-029 (Electron).
+     */
+    forkedClients?: string[];
+}
+export interface RedirectRule {
+    source: string;
+    destination: string;
+    /** Permanente emite 308; temporal, 307. */
+    permanent?: boolean;
+}
+export interface RewriteRule {
+    source: string;
+    destination: string;
+}
+export interface HeaderRule {
+    source: string;
+    headers: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+/**
+ * La configuración ya resuelta.
+ *
+ * Todas las claves que el framework consulta existen, así que nadie tiene que
+ * escribir `config.dev?.hmr ?? true` en cada uso. Las capas de modo desaparecen:
+ * ya se fusionaron.
+ */
+export interface ResolvedConfig {
+    basePath: string;
+    trailingSlash: TrailingSlashMode;
+    redirects: RedirectRule[];
+    rewrites: RewriteRule[];
+    headers: HeaderRule[];
+    publicEnv: string[];
+    extensions: Partial<ExtensionPolicy>;
+    platform: PlatformConfig;
+    security: SecurityOptions;
+    assets: Required<AssetsConfig> | AssetsConfig;
+    dev: Required<DevConfig>;
+    server: RessServerConfig;
+}

package/dist/config/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/validate.d.ts

@@ -0,0 +1,19 @@
+import type { HeaderRule, RedirectRule, RessConfig, RewriteRule } from './types';
+/**
+ * Comprueba la configuración al arrancar.
+ *
+ * Un valor mal escrito acá se manifiesta como una petición que responde raro
+ * mucho después y en otro lugar. Fallar al arrancar, nombrando la clave, es la
+ * diferencia entre corregir un error en un minuto y buscarlo durante una tarde.
+ *
+ * Se acumulan todos los problemas antes de fallar: arreglar de a uno, reiniciar,
+ * y encontrar el siguiente es una forma lenta de perder la tarde.
+ */
+export declare function validateConfig(config: RessConfig): void;
+/**
+ * Comprueba las reglas que devolvieron `redirects`, `rewrites` y `headers`.
+ *
+ * Se hace después de invocarlas, no en `validateConfig`, porque hasta ese momento
+ * son funciones sin ejecutar.
+ */
+export declare function validateRules(redirects: RedirectRule[], rewrites: RewriteRule[], headers: HeaderRule[]): void;

package/dist/config/validate.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+exports.validateRules = validateRules;
+/**
+ * Comprueba la configuración al arrancar.
+ *
+ * Un valor mal escrito acá se manifiesta como una petición que responde raro
+ * mucho después y en otro lugar. Fallar al arrancar, nombrando la clave, es la
+ * diferencia entre corregir un error en un minuto y buscarlo durante una tarde.
+ *
+ * Se acumulan todos los problemas antes de fallar: arreglar de a uno, reiniciar,
+ * y encontrar el siguiente es una forma lenta de perder la tarde.
+ */
+function validateConfig(config) {
+    const problems = [];
+    checkBasePath(config, problems);
+    checkTrailingSlash(config, problems);
+    checkPublicEnv(config, problems);
+    checkCallable(config, problems);
+    checkAssets(config, problems);
+    if (problems.length === 0)
+        return;
+    throw new Error(`[ress] La configuración tiene ${problems.length === 1 ? 'un problema' : `${problems.length} problemas`}:\n` +
+        problems.map((p) => `  · ${p}`).join('\n'));
+}
+function checkBasePath({ basePath }, problems) {
+    if (basePath === undefined)
+        return;
+    if (typeof basePath !== 'string') {
+        return void problems.push('`basePath` tiene que ser una cadena.');
+    }
+    if (/[?#]/.test(basePath)) {
+        problems.push('`basePath` es un prefijo de ruta: no puede llevar `?` ni `#`.');
+    }
+    if (/^https?:\/\//i.test(basePath)) {
+        problems.push('`basePath` es un prefijo de ruta, no una URL completa. Para servir desde ' +
+            'otro dominio está `assets.cdnPrefix`.');
+    }
+}
+function checkTrailingSlash({ trailingSlash }, problems) {
+    const valid = ['always', 'never', 'ignore'];
+    if (trailingSlash !== undefined && !valid.includes(trailingSlash)) {
+        problems.push(`\`trailingSlash\` sólo acepta ${valid.join(', ')}; se recibió "${trailingSlash}".`);
+    }
+}
+function checkPublicEnv({ publicEnv }, problems) {
+    if (publicEnv === undefined)
+        return;
+    if (!Array.isArray(publicEnv)) {
+        return void problems.push('`publicEnv` tiene que ser una lista de nombres de variable.');
+    }
+    for (const name of publicEnv) {
+        if (typeof name !== 'string' || !name.trim()) {
+            problems.push('`publicEnv` sólo admite nombres de variable no vacíos.');
+            break;
+        }
+    }
+}
+/** Las tres son funciones para que el proyecto pueda calcularlas al arrancar. */
+function checkCallable(config, problems) {
+    for (const key of ['redirects', 'rewrites', 'headers']) {
+        const value = config[key];
+        if (value !== undefined && typeof value !== 'function') {
+            problems.push(`\`${key}\` tiene que ser una función que devuelve la lista, no la lista. ` +
+                'Así el proyecto puede calcularla al arrancar.');
+        }
+    }
+}
+function checkAssets({ assets }, problems) {
+    const prefix = assets?.cdnPrefix;
+    if (prefix === undefined)
+        return;
+    if (typeof prefix !== 'string' || !/^(https?:)?\/\//.test(prefix)) {
+        problems.push('`assets.cdnPrefix` tiene que ser una URL absoluta o empezar con `//`: ' +
+            'los artefactos se sirven desde otro origen.');
+    }
+}
+/**
+ * Comprueba las reglas que devolvieron `redirects`, `rewrites` y `headers`.
+ *
+ * Se hace después de invocarlas, no en `validateConfig`, porque hasta ese momento
+ * son funciones sin ejecutar.
+ */
+function validateRules(redirects, rewrites, headers) {
+    const problems = [];
+    for (const [index, rule] of redirects.entries()) {
+        if (!rule?.source || !rule?.destination) {
+            problems.push(`La redirección #${index + 1} necesita \`source\` y \`destination\`.`);
+        }
+    }
+    for (const [index, rule] of rewrites.entries()) {
+        if (!rule?.source || !rule?.destination) {
+            problems.push(`La reescritura #${index + 1} necesita \`source\` y \`destination\`.`);
+        }
+    }
+    for (const [index, rule] of headers.entries()) {
+        if (!rule?.source || !Array.isArray(rule?.headers)) {
+            problems.push(`La regla de cabeceras #${index + 1} necesita \`source\` y \`headers\`.`);
+        }
+    }
+    if (problems.length) {
+        throw new Error(`[ress] La configuración tiene reglas inválidas:\n` + problems.map((p) => `  · ${p}`).join('\n'));
+    }
+}