arcli 2.0.0 → 2.2.0

package/dist/cli/error-output.js

@@ -1,13 +1,7 @@
-import { ConfigService } from '../modules/config/config.service.js';
-function readJsonDefault() {
-    const service = new ConfigService();
-    try {
-        return service.getConfig().output.jsonPorDefecto;
-    }
-    finally {
-        service.close();
-    }
-}
+import { CommanderError } from 'commander';
+import { AppError } from '../lib/errors/app-error.js';
+import { formatCliError, writeTerminalError, writeTerminalJsonError } from '../ui/index.js';
+import { readJsonDefault } from './global-options.js';
 /**
  * Los errores salen en JSON con `--json` o, sin el flag, si la config tiene `json=true`, igual que los
  * resultados. La config se lee recien al fallar; si tambien falla (config invalida), sale en texto.
@@ -23,4 +17,88 @@ export function shouldPrintErrorAsJson(argv, readDefault = readJsonDefault) {
         return false;
     }
 }
-//# sourceMappingURL=error-output.js.map
+/** Lo que commander señaliza por `exitOverride` sin que sea un error de uso: ayuda y version, ya impresas. */
+const COMMANDER_NON_ERROR_CODES = new Set(['commander.help', 'commander.helpDisplayed', 'commander.version']);
+/** Ayuda o version: commander ya las imprimio y solo queda salir con su exit code. */
+export function isCommanderExit(error) {
+    return error instanceof CommanderError && COMMANDER_NON_ERROR_CODES.has(error.code);
+}
+/** Un error de uso de commander: opcion desconocida, valor faltante, argumento de mas, etc. */
+export function isCommanderUsageError(error) {
+    return error instanceof CommanderError && !COMMANDER_NON_ERROR_CODES.has(error.code);
+}
+/** Los mensajes de error de uso de commander (15.x), que vienen en ingles. */
+const COMMANDER_MESSAGES = [
+    [/unknown option '([^']+)'/, "opción desconocida '$1'"],
+    [/unknown command '([^']+)'/, "comando desconocido '$1'"],
+    [/missing required argument '([^']+)'/, "falta el argumento obligatorio '$1'"],
+    [/option '([^']+)' argument missing/, "falta el valor de la opción '$1'"],
+    [/required option '([^']+)' not specified/, "falta la opción obligatoria '$1'"],
+    [/option '([^']+)' argument '([^']*)' is invalid\./, "el valor '$2' de la opción '$1' no es válido."],
+    [
+        /too many arguments(?: for '([^']+)')?\. Expected (\d+) arguments? but got (\d+): (.*)\./,
+        'sobran argumentos: espera $2 y recibió $3 ($4).',
+    ],
+    [/ cannot be used with /, ' no se puede usar junto con '],
+    [/\(Did you mean one of ([^?]+)\?\)/, '(¿quisiste decir alguno de $1?)'],
+    [/\(Did you mean ([^?]+)\?\)/, '(¿quisiste decir $1?)'],
+];
+export function translateCommanderMessage(message) {
+    return COMMANDER_MESSAGES.reduce((result, [pattern, replacement]) => result.replace(pattern, replacement), message);
+}
+/** El error de uso de commander como `INPUT_VALIDATION_ERROR`, en el mismo formato que el resto. */
+export function toUsageError(error) {
+    // Commander arma el mensaje con "error: " adelante y, a veces, una segunda linea "(Did you mean --monto?)".
+    const message = translateCommanderMessage(error.message)
+        .replace(/^error:\s*/i, '')
+        .replace(/\s*\n\s*/g, ' ')
+        .trim();
+    return new AppError(message, {
+        code: 'INPUT_VALIDATION_ERROR',
+        suggestion: 'Usá "arcli ayuda" o "arcli <comando> --ayuda" para ver comandos y opciones.',
+    });
+}
+/**
+ * Commander tira los errores de uso en vez de cortar el proceso, para que `index.ts` los maneje como el resto. En
+ * texto commander los escribe como siempre (con la pista de la ayuda); en JSON se callan y sale el JSON de error.
+ * Va antes de registrar los comandos: los subcomandos copian esta config al crearse.
+ */
+export function configureUsageErrors(program, errorsAsJson) {
+    let failing = false;
+    program.exitOverride().configureOutput({
+        outputError: (message, write) => {
+            failing = true;
+            if (!errorsAsJson()) {
+                write(translateCommanderMessage(message));
+            }
+        },
+        writeErr: (text) => {
+            // Despues de un error, commander escribe la pista de la ayuda: en JSON no va.
+            if (!(failing && errorsAsJson())) {
+                process.stderr.write(text);
+            }
+        },
+    });
+}
+/**
+ * Imprime un error que corto la ejecucion y devuelve el exit code. Ayuda y version no son errores; los errores de
+ * uso en texto ya los escribio commander.
+ */
+export function reportCliError(error, errorsAsJson) {
+    if (isCommanderExit(error)) {
+        return error.exitCode;
+    }
+    if (isCommanderUsageError(error)) {
+        if (errorsAsJson) {
+            writeTerminalJsonError(formatCliError(toUsageError(error), true));
+        }
+        return error.exitCode;
+    }
+    if (errorsAsJson) {
+        writeTerminalJsonError(formatCliError(error, true));
+    }
+    else {
+        writeTerminalError(formatCliError(error, false));
+    }
+    return 1;
+}

package/dist/cli/global-options.js

@@ -0,0 +1,55 @@
+import { ConfigService } from '../modules/config/config.service.js';
+/**
+ * Las opciones globales las parsea el programa (commander no usa opciones posicionales), asi que estan en
+ * cualquier comando. Cada comando declara solo las que usa: asi salen en su ayuda y, si se pasa otra, el aviso de
+ * `ignored-global-options` avisa que no aplica.
+ */
+export function registerEnvironmentOptions(command) {
+    return command
+        .option('--testing', 'usar entorno de testing en esta ejecución')
+        .option('--produccion', 'usar entorno de producción en esta ejecución');
+}
+export function registerJsonOption(command) {
+    return command.option('--json', 'imprimir salida JSON');
+}
+/** Solo facturacion muestra la respuesta bruta de ARCA. */
+export function registerRawOption(command) {
+    return command.option('--bruto', 'mostrar la respuesta bruta de ARCA cuando exista');
+}
+/** Las cuatro: el programa (para que cualquier comando las acepte) y los comandos de facturacion. */
+export function registerGlobalOptions(command) {
+    return registerRawOption(registerJsonOption(registerEnvironmentOptions(command)));
+}
+/** Entorno y salida: comandos que consultan ARCA pero no tienen respuesta bruta que mostrar. */
+export function registerQueryOptions(command) {
+    return registerJsonOption(registerEnvironmentOptions(command));
+}
+export function getGlobalOptions(command) {
+    return command.optsWithGlobals();
+}
+/** `json` de la config. Si la config no se puede leer, texto: el error de la config ya sale por su lado. */
+export function readJsonDefault() {
+    try {
+        const service = new ConfigService();
+        try {
+            return service.getConfig().output.jsonPorDefecto;
+        }
+        finally {
+            service.close();
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * La unica forma de decidir si un comando imprime JSON: `--json` o, sin el flag, `json=true` de la config. Sin
+ * config a mano (comandos que no la necesitan), se lee al llamar.
+ */
+export function resolveOutputJson(command, config) {
+    const flag = getGlobalOptions(command).json;
+    if (typeof flag === 'boolean') {
+        return flag;
+    }
+    return config ? config.output.jsonPorDefecto : readJsonDefault();
+}

package/dist/cli/help-argv.js

@@ -18,4 +18,3 @@ export function normalizeHelpArgv(argv, interactive) {
     }
     return argv;
 }
-//# sourceMappingURL=help-argv.js.map