valtech-components 2.0.838 → 2.0.840

package/esm2022/lib/services/errors/interpret-error.mjs

@@ -0,0 +1,130 @@
+/**
+ * Error interpretation helper for the Valtech factory.
+ *
+ * Todos los frontends del factory consumen la misma API (backend Go) y la misma
+ * librería. La lógica de interpretar errores debe vivir una sola vez, acá.
+ *
+ * El backend Go (`apperrors`) SIEMPRE devuelve errores como JSON:
+ *   { "code": string, "message": string, "operationId": string }
+ * donde `message` ya viene en español y es user-friendly.
+ *
+ * En Angular un error HTTP llega como `HttpErrorResponse` (body en `.error`).
+ * Un fallo de red es un `HttpErrorResponse` con `status === 0`.
+ *
+ * Además `AuthService.handleAuthError` aplana el `HttpErrorResponse` a un
+ * `AuthError { code, message }` (code/message al nivel superior). Por eso este
+ * helper acepta AMBAS formas — el crudo y el aplanado.
+ */
+/** Mensaje genérico para fallos de red (sin conexión / backend inalcanzable). */
+const NETWORK_MESSAGE = 'Sin conexión. Verifica tu conexión a internet e inténtalo de nuevo.';
+/** Mensaje genérico para errores no identificables. */
+const UNKNOWN_MESSAGE = 'Ocurrió un error inesperado. Inténtalo de nuevo.';
+/** Sentinel para fallos de red. */
+const NETWORK_CODE = 'NETWORK';
+/** Sentinel para errores no identificables. */
+const UNKNOWN_CODE = 'UNKNOWN';
+/** Type guard laxo: ¿el valor parece un `HttpErrorResponse`? */
+function isHttpErrorResponse(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        // No importamos HttpErrorResponse para mantener la fn libre de Angular;
+        // detectamos por shape: tiene `status` numérico y `name` reconocible o `error`.
+        ('status' in err || err.name === 'HttpErrorResponse'));
+}
+/** Devuelve un string si el valor lo es y no está vacío; si no, `undefined`. */
+function asNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/**
+ * Normaliza CUALQUIER error a un `InterpretedError`.
+ *
+ * Función pura — sin dependencias de Angular DI, testeable y usable desde
+ * cualquier lado (componentes, servicios, interceptores, scripts).
+ *
+ * Nunca lanza: siempre devuelve un `InterpretedError` válido.
+ *
+ * Casos cubiertos:
+ * - `HttpErrorResponse` con `status === 0` (o sin respuesta) → fallo de red.
+ * - `HttpErrorResponse` con body `{ code, message, operationId }` del backend.
+ * - `AuthError` aplanado `{ code, message }` (code/message top-level).
+ * - `Error` plano de JS → `code: 'UNKNOWN'`, `message: err.message`.
+ * - Cualquier otra cosa (string, null, undefined, objeto raro) → genérico.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await firstValueFrom(this.http.get(url));
+ * } catch (err) {
+ *   const e = interpretError(err);
+ *   if (e.isNetwork) {
+ *     this.toast.show({ message: e.message, color: 'dark' });
+ *   } else {
+ *     this.errorCode.set(e.code);
+ *   }
+ * }
+ * ```
+ */
+export function interpretError(err) {
+    // 1. HttpErrorResponse — el caso más común al hablar con el backend.
+    if (isHttpErrorResponse(err)) {
+        const status = typeof err.status === 'number' ? err.status : undefined;
+        // 1a. Fallo de red: status 0 o sin body de respuesta del servidor.
+        if (status === 0) {
+            return {
+                code: NETWORK_CODE,
+                message: NETWORK_MESSAGE,
+                status: 0,
+                isNetwork: true,
+            };
+        }
+        // 1b. Body del backend `{ code, message, operationId }`.
+        const body = err.error;
+        if (typeof body === 'object' && body !== null) {
+            const b = body;
+            return {
+                code: asNonEmptyString(b.code) ?? UNKNOWN_CODE,
+                message: asNonEmptyString(b.message) ?? UNKNOWN_MESSAGE,
+                operationId: asNonEmptyString(b.operationId),
+                status,
+                isNetwork: false,
+            };
+        }
+        // 1c. HttpErrorResponse sin body estructurado (ej. body string / null).
+        return {
+            code: UNKNOWN_CODE,
+            message: asNonEmptyString(err.message) ?? UNKNOWN_MESSAGE,
+            status,
+            isNetwork: false,
+        };
+    }
+    // 2. AuthError aplanado u objeto con `code`/`message` top-level.
+    if (typeof err === 'object' && err !== null) {
+        const o = err;
+        const code = asNonEmptyString(o.code);
+        const message = asNonEmptyString(o.message);
+        if (code || message) {
+            return {
+                code: code ?? UNKNOWN_CODE,
+                message: message ?? UNKNOWN_MESSAGE,
+                operationId: asNonEmptyString(o.operationId),
+                isNetwork: false,
+            };
+        }
+        // 2b. Error plano de JS (instancia de Error sin code) — `message` ya
+        //     cubierto arriba; este branch atrapa Error con message vacío.
+        if (err instanceof Error) {
+            return {
+                code: UNKNOWN_CODE,
+                message: asNonEmptyString(err.message) ?? UNKNOWN_MESSAGE,
+                isNetwork: false,
+            };
+        }
+    }
+    // 3. Cualquier otra cosa: string, null, undefined, objeto raro.
+    return {
+        code: UNKNOWN_CODE,
+        message: UNKNOWN_MESSAGE,
+        isNetwork: false,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interpret-error.js","sourceRoot":"","sources":["../../../../../../src/lib/services/errors/interpret-error.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Error interpretation helper for the Valtech factory.\n *\n * Todos los frontends del factory consumen la misma API (backend Go) y la misma\n * librería. La lógica de interpretar errores debe vivir una sola vez, acá.\n *\n * El backend Go (`apperrors`) SIEMPRE devuelve errores como JSON:\n *   { \"code\": string, \"message\": string, \"operationId\": string }\n * donde `message` ya viene en español y es user-friendly.\n *\n * En Angular un error HTTP llega como `HttpErrorResponse` (body en `.error`).\n * Un fallo de red es un `HttpErrorResponse` con `status === 0`.\n *\n * Además `AuthService.handleAuthError` aplana el `HttpErrorResponse` a un\n * `AuthError { code, message }` (code/message al nivel superior). Por eso este\n * helper acepta AMBAS formas — el crudo y el aplanado.\n */\n\n/**\n * Resultado normalizado de cualquier error. Garantiza una forma estable y\n * predecible para que las webapps no tengan que hacer narrowing manual.\n */\nexport interface InterpretedError {\n  /** Código del backend, o el sentinel `'NETWORK'` / `'UNKNOWN'`. */\n  code: string;\n  /** Mensaje del backend (español, user-friendly) o un genérico en español. */\n  message: string;\n  /** `operationId` del backend, si vino. Útil para soporte / tracing. */\n  operationId?: string;\n  /** HTTP status, si aplica (`0` para fallos de red). */\n  status?: number;\n  /** `true` si fue un fallo de red (status 0 / sin respuesta). */\n  isNetwork: boolean;\n}\n\n/** Mensaje genérico para fallos de red (sin conexión / backend inalcanzable). */\nconst NETWORK_MESSAGE = 'Sin conexión. Verifica tu conexión a internet e inténtalo de nuevo.';\n\n/** Mensaje genérico para errores no identificables. */\nconst UNKNOWN_MESSAGE = 'Ocurrió un error inesperado. Inténtalo de nuevo.';\n\n/** Sentinel para fallos de red. */\nconst NETWORK_CODE = 'NETWORK';\n\n/** Sentinel para errores no identificables. */\nconst UNKNOWN_CODE = 'UNKNOWN';\n\n/** Type guard laxo: ¿el valor parece un `HttpErrorResponse`? */\nfunction isHttpErrorResponse(err: unknown): err is {\n  status?: number;\n  error?: unknown;\n  message?: string;\n  name?: string;\n} {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    // No importamos HttpErrorResponse para mantener la fn libre de Angular;\n    // detectamos por shape: tiene `status` numérico y `name` reconocible o `error`.\n    ('status' in err || (err as { name?: string }).name === 'HttpErrorResponse')\n  );\n}\n\n/** Devuelve un string si el valor lo es y no está vacío; si no, `undefined`. */\nfunction asNonEmptyString(value: unknown): string | undefined {\n  return typeof value === 'string' && value.length > 0 ? value : undefined;\n}\n\n/**\n * Normaliza CUALQUIER error a un `InterpretedError`.\n *\n * Función pura — sin dependencias de Angular DI, testeable y usable desde\n * cualquier lado (componentes, servicios, interceptores, scripts).\n *\n * Nunca lanza: siempre devuelve un `InterpretedError` válido.\n *\n * Casos cubiertos:\n * - `HttpErrorResponse` con `status === 0` (o sin respuesta) → fallo de red.\n * - `HttpErrorResponse` con body `{ code, message, operationId }` del backend.\n * - `AuthError` aplanado `{ code, message }` (code/message top-level).\n * - `Error` plano de JS → `code: 'UNKNOWN'`, `message: err.message`.\n * - Cualquier otra cosa (string, null, undefined, objeto raro) → genérico.\n *\n * @example\n * ```ts\n * try {\n *   await firstValueFrom(this.http.get(url));\n * } catch (err) {\n *   const e = interpretError(err);\n *   if (e.isNetwork) {\n *     this.toast.show({ message: e.message, color: 'dark' });\n *   } else {\n *     this.errorCode.set(e.code);\n *   }\n * }\n * ```\n */\nexport function interpretError(err: unknown): InterpretedError {\n  // 1. HttpErrorResponse — el caso más común al hablar con el backend.\n  if (isHttpErrorResponse(err)) {\n    const status = typeof err.status === 'number' ? err.status : undefined;\n\n    // 1a. Fallo de red: status 0 o sin body de respuesta del servidor.\n    if (status === 0) {\n      return {\n        code: NETWORK_CODE,\n        message: NETWORK_MESSAGE,\n        status: 0,\n        isNetwork: true,\n      };\n    }\n\n    // 1b. Body del backend `{ code, message, operationId }`.\n    const body = err.error;\n    if (typeof body === 'object' && body !== null) {\n      const b = body as {\n        code?: unknown;\n        message?: unknown;\n        operationId?: unknown;\n      };\n      return {\n        code: asNonEmptyString(b.code) ?? UNKNOWN_CODE,\n        message: asNonEmptyString(b.message) ?? UNKNOWN_MESSAGE,\n        operationId: asNonEmptyString(b.operationId),\n        status,\n        isNetwork: false,\n      };\n    }\n\n    // 1c. HttpErrorResponse sin body estructurado (ej. body string / null).\n    return {\n      code: UNKNOWN_CODE,\n      message: asNonEmptyString(err.message) ?? UNKNOWN_MESSAGE,\n      status,\n      isNetwork: false,\n    };\n  }\n\n  // 2. AuthError aplanado u objeto con `code`/`message` top-level.\n  if (typeof err === 'object' && err !== null) {\n    const o = err as {\n      code?: unknown;\n      message?: unknown;\n      operationId?: unknown;\n    };\n    const code = asNonEmptyString(o.code);\n    const message = asNonEmptyString(o.message);\n\n    if (code || message) {\n      return {\n        code: code ?? UNKNOWN_CODE,\n        message: message ?? UNKNOWN_MESSAGE,\n        operationId: asNonEmptyString(o.operationId),\n        isNetwork: false,\n      };\n    }\n\n    // 2b. Error plano de JS (instancia de Error sin code) — `message` ya\n    //     cubierto arriba; este branch atrapa Error con message vacío.\n    if (err instanceof Error) {\n      return {\n        code: UNKNOWN_CODE,\n        message: asNonEmptyString(err.message) ?? UNKNOWN_MESSAGE,\n        isNetwork: false,\n      };\n    }\n  }\n\n  // 3. Cualquier otra cosa: string, null, undefined, objeto raro.\n  return {\n    code: UNKNOWN_CODE,\n    message: UNKNOWN_MESSAGE,\n    isNetwork: false,\n  };\n}\n"]}

package/esm2022/lib/services/firebase/index.mjs

@@ -45,7 +45,7 @@ export { buildPath, extractPathParams, getCollectionPath, getDocumentId, isColle
 // Storage
 export { StorageService } from './storage.service';
 // Messaging (FCM)
-export { MessagingService } from './messaging.service';
+export { MessagingService, } from './messaging.service';
 // Notifications (Firestore)
 export { NotificationsService } from './notifications.service';
 // Analytics (GA4)
@@ -53,4 +53,4 @@ export { AnalyticsService } from './analytics.service';
 export { AnalyticsRouterTracker } from './analytics-router-tracker';
 export { AnalyticsErrorHandler } from './analytics-error-handler';
 export * from './analytics-types';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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