r3ui-lib 1.2.31 → 1.3.0

package/nuxt-errors/utils/extractRequestId.ts

@@ -0,0 +1,53 @@
+import { REQUEST_ID_HEADERS } from './types';
+
+function readHeader(
+  headers: unknown,
+  name: string
+): string | undefined {
+  if (!headers || typeof headers !== 'object') {
+    return undefined;
+  }
+
+  const rec = headers as {
+    get?: (key: string) => unknown;
+    [key: string]: unknown;
+  };
+
+  if (typeof rec.get === 'function') {
+    const value = rec.get(name) ?? rec.get(name.toLowerCase());
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+  }
+
+  const direct = rec[name] ?? rec[name.toLowerCase()];
+  if (typeof direct === 'string' && direct.trim()) {
+    return direct.trim();
+  }
+  if (Array.isArray(direct) && typeof direct[0] === 'string' && direct[0].trim()) {
+    return direct[0].trim();
+  }
+
+  return undefined;
+}
+
+export function extractRequestId(value: unknown): string | undefined {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+
+  const rec = value as {
+    headers?: unknown;
+    response?: { headers?: unknown };
+  };
+
+  const sources = [rec.headers, rec.response?.headers];
+  for (const headers of sources) {
+    for (const name of REQUEST_ID_HEADERS) {
+      const id = readHeader(headers, name);
+      if (id) {
+        return id;
+      }
+    }
+  }
+
+  return undefined;
+}

package/nuxt-errors/utils/isHttpStatus.ts

@@ -0,0 +1,3 @@
+export function isHttpStatus(value: unknown): value is number {
+  return Number.isInteger(value) && Number(value) >= 400 && Number(value) < 600;
+}

package/nuxt-errors/utils/logAppError.ts

@@ -0,0 +1,68 @@
+import { normalizeAppError } from './normalizeAppError';
+import { serializeCause } from './serializeCause';
+
+export type AppErrorLogEntry = {
+  statusCode: number;
+  kind: string;
+  message: string;
+  requestId?: string;
+  stack?: string;
+  cause?: unknown;
+};
+
+const loggedErrors = new WeakSet<object>();
+
+export function resetLoggedErrorsForTests(): void {
+  // WeakSet нельзя очистить; тесты используют новые объекты.
+}
+
+export function wasLogged(error: object): boolean {
+  return loggedErrors.has(error);
+}
+
+export function markLogged(error: unknown): void {
+  if (error && typeof error === 'object') {
+    loggedErrors.add(error);
+  }
+}
+
+export function toAppErrorLogEntry(
+  error: unknown,
+  options: { isDev: boolean }
+): AppErrorLogEntry {
+  const appError = normalizeAppError(error);
+  if (options.isDev) {
+    return {
+      statusCode: appError.statusCode,
+      kind: appError.kind,
+      message: appError.message ?? appError.messageKey,
+      requestId: appError.requestId,
+      stack: appError.stack,
+      cause: serializeCause(appError.cause),
+    };
+  }
+
+  return {
+    statusCode: appError.statusCode,
+    kind: appError.kind,
+    message: appError.messageKey,
+    requestId: appError.requestId,
+  };
+}
+
+export function logAppError(
+  error: unknown,
+  deps: {
+    isDev: boolean;
+    logger?: Pick<Console, 'error'>;
+  }
+): void {
+  if (error && typeof error === 'object' && loggedErrors.has(error)) {
+    return;
+  }
+
+  markLogged(error);
+  const entry = toAppErrorLogEntry(error, { isDev: deps.isDev });
+  const logger = deps.logger ?? console;
+  logger.error('[app-error]', entry);
+}

package/nuxt-errors/utils/normalizeAppError.ts

@@ -0,0 +1,178 @@
+import { extractHttpStatus } from './extractHttpStatus';
+import { extractFieldErrors, extractPublicMessage } from './extractLaravel';
+import { extractRequestId } from './extractRequestId';
+import {
+  isAbortError,
+  isIntentionalAbort,
+  isNetworkError,
+  isTimeoutError,
+} from './classifyTransport';
+import { MESSAGE_KEYS, type AppError, type AppErrorKind, type NormalizeAppErrorContext } from './types';
+
+function kindFromStatus(status: number): AppErrorKind {
+  if (status === 401) return 'unauthorized';
+  if (status === 403) return 'forbidden';
+  if (status === 404) return 'not_found';
+  if (status === 409) return 'conflict';
+  if (status === 422) return 'validation';
+  if (status === 429) return 'rate_limit';
+  if (status === 408 || status === 504) return 'timeout';
+  if (status === 499) return 'abort';
+  if (status === 503) return 'network';
+  if (status >= 500) return 'server';
+  return 'client';
+}
+
+function readPayload(value: unknown, seen: Set<unknown> = new Set()): unknown {
+  if (!value || typeof value !== 'object' || seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  const rec = value as { data?: unknown; cause?: unknown };
+  if (rec.data !== undefined) {
+    return rec.data;
+  }
+  if ('cause' in rec) {
+    return readPayload(rec.cause, seen);
+  }
+  return value;
+}
+
+function readStack(value: unknown): string | undefined {
+  if (value instanceof Error && value.stack) {
+    return value.stack;
+  }
+  return undefined;
+}
+
+function isAllowedPublicStatus(status: number): boolean {
+  return status === 400 || status === 403 || status === 404 || status === 409 || status === 422 || status === 429;
+}
+
+function isMalformedPayload(value: unknown): boolean {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const rec = value as { kind?: unknown; name?: unknown; message?: unknown };
+  if (rec.kind === 'malformed') {
+    return true;
+  }
+  if (rec.name === 'SyntaxError') {
+    return true;
+  }
+  return typeof rec.message === 'string' && /unexpected token|is not valid json|malformed/i.test(rec.message);
+}
+
+/**
+ * Сырой Response нужно клонировать снаружи, если caller ещё читает body.
+ * Здесь status берётся синхронно; body ожидается уже в `data` (FetchError/ofetch).
+ */
+export function normalizeAppError(
+  value: unknown,
+  context: NormalizeAppErrorContext = {}
+): AppError {
+  const cause = value;
+  const requestId = extractRequestId(value);
+  const payload = readPayload(value);
+  const fieldErrors = extractFieldErrors(payload);
+  const httpStatus = extractHttpStatus(value);
+
+  if (context.intentionalAbort || isIntentionalAbort(value)) {
+    return {
+      kind: 'abort',
+      statusCode: 499,
+      messageKey: MESSAGE_KEYS.abort,
+      requestId,
+      cause,
+      stack: readStack(value),
+    };
+  }
+
+  if (isAbortError(value) && httpStatus === undefined) {
+    return {
+      kind: 'abort',
+      statusCode: 499,
+      messageKey: MESSAGE_KEYS.abort,
+      requestId,
+      cause,
+      stack: readStack(value),
+    };
+  }
+
+  if (isTimeoutError(value) && httpStatus === undefined) {
+    return {
+      kind: 'timeout',
+      statusCode: 504,
+      messageKey: MESSAGE_KEYS.timeout,
+      requestId,
+      cause,
+      stack: readStack(value),
+    };
+  }
+
+  if (isNetworkError(value) && httpStatus === undefined) {
+    return {
+      kind: 'network',
+      statusCode: 503,
+      messageKey: MESSAGE_KEYS.network,
+      requestId,
+      cause,
+      stack: readStack(value),
+    };
+  }
+
+  if (httpStatus !== undefined) {
+    const kind = kindFromStatus(httpStatus);
+    const publicMessage = isAllowedPublicStatus(httpStatus)
+      ? extractPublicMessage(payload)
+      : undefined;
+
+    return {
+      kind,
+      statusCode: httpStatus,
+      messageKey: MESSAGE_KEYS[kind],
+      message: publicMessage,
+      fieldErrors,
+      requestId,
+      cause,
+      stack: readStack(value),
+    };
+  }
+
+  if (isMalformedPayload(value)) {
+    return {
+      kind: 'malformed',
+      statusCode: 502,
+      messageKey: MESSAGE_KEYS.malformed,
+      requestId,
+      cause,
+      stack: readStack(value),
+    };
+  }
+
+  if (typeof value === 'string' && value.trim()) {
+    return {
+      kind: 'runtime',
+      statusCode: 500,
+      messageKey: MESSAGE_KEYS.runtime,
+      requestId,
+      cause,
+      stack: undefined,
+    };
+  }
+
+  return {
+    kind: 'runtime',
+    statusCode: 500,
+    messageKey: MESSAGE_KEYS.runtime,
+    fieldErrors,
+    requestId,
+    cause,
+    stack: readStack(value),
+  };
+}
+
+export function isUnauthorizedError(error: unknown): boolean {
+  return normalizeAppError(error).statusCode === 401;
+}

package/nuxt-errors/utils/presentAppError.ts

@@ -0,0 +1,115 @@
+import { isIntentionalAbort } from './classifyTransport';
+import { normalizeAppError } from './normalizeAppError';
+import type { AppError, AppErrorPresentation } from './types';
+
+export type FatalErrorPayload = {
+  statusCode: number;
+  statusMessage: string;
+  message: string;
+  fatal: boolean;
+  data: {
+    kind: AppError['kind'];
+    messageKey: string;
+    requestId?: string;
+    fieldErrors?: Record<string, string[]>;
+    stack?: string;
+    cause?: unknown;
+  };
+};
+
+export type PresentFatalErrorDeps = {
+  showError: (payload: FatalErrorPayload) => void;
+  isDev: boolean;
+  serializeCause: (cause: unknown) => unknown;
+};
+
+export function toFatalErrorPayload(
+  error: unknown,
+  deps: { isDev: boolean; serializeCause: (cause: unknown) => unknown }
+): FatalErrorPayload {
+  const appError = normalizeAppError(error);
+  return {
+    statusCode: appError.statusCode,
+    statusMessage: appError.message ?? appError.messageKey,
+    message: appError.message ?? appError.messageKey,
+    fatal: true,
+    data: {
+      kind: appError.kind,
+      messageKey: appError.messageKey,
+      requestId: appError.requestId,
+      fieldErrors: appError.fieldErrors,
+      stack: deps.isDev ? appError.stack : undefined,
+      cause: deps.isDev ? deps.serializeCause(appError.cause) : undefined,
+    },
+  };
+}
+
+export function presentFatalError(
+  error: unknown,
+  deps: PresentFatalErrorDeps
+): void {
+  deps.showError(toFatalErrorPayload(error, deps));
+}
+
+export type FormErrorView = {
+  statusCode: number;
+  kind: AppError['kind'];
+  messageKey: string;
+  message: string;
+  fieldErrors: Record<string, string[]>;
+};
+
+export function toFormErrors(error: unknown): FormErrorView {
+  const appError = normalizeAppError(error);
+  return {
+    statusCode: appError.statusCode,
+    kind: appError.kind,
+    messageKey: appError.messageKey,
+    message: appError.message ?? appError.messageKey,
+    fieldErrors: appError.fieldErrors ?? {},
+  };
+}
+
+export function shouldSkipUi(error: unknown, presentation?: AppErrorPresentation): boolean {
+  if (presentation === 'silent') {
+    return true;
+  }
+  return isIntentionalAbort(error);
+}
+
+export type ErrorPageView = {
+  statusCode: number;
+  messageKey: string;
+  publicMessage?: string;
+  showRetry: boolean;
+  showHome: boolean;
+};
+
+export function toErrorPageView(error: unknown): ErrorPageView {
+  const rec = error as {
+    statusCode?: unknown;
+    data?: { messageKey?: unknown };
+    message?: unknown;
+    statusMessage?: unknown;
+  };
+  const normalized = normalizeAppError(error);
+  const statusCode =
+    typeof rec?.statusCode === 'number' ? rec.statusCode : normalized.statusCode;
+  const messageKey =
+    typeof rec?.data?.messageKey === 'string'
+      ? rec.data.messageKey
+      : normalized.messageKey;
+  const showRetry =
+    statusCode >= 500 ||
+    normalized.kind === 'network' ||
+    normalized.kind === 'timeout' ||
+    normalized.kind === 'malformed';
+
+  return {
+    statusCode,
+    messageKey,
+    publicMessage: normalized.message,
+    showRetry,
+    showHome: true,
+  };
+}

package/nuxt-errors/utils/publicHttpMessage.ts

@@ -0,0 +1,23 @@
+import { extractHttpStatus } from './extractHttpStatus';
+
+export function publicHttpMessage(statusCode: number): string {
+  if (statusCode === 400) return 'Bad Request';
+  if (statusCode === 401) return 'Unauthorized';
+  if (statusCode === 403) return 'Forbidden';
+  if (statusCode === 404) return 'Not Found';
+  if (statusCode === 409) return 'Conflict';
+  if (statusCode === 422) return 'Unprocessable Entity';
+  if (statusCode === 429) return 'Too Many Requests';
+  if (statusCode === 502) return 'Bad Gateway';
+  if (statusCode === 503) return 'Service Unavailable';
+  if (statusCode === 504) return 'Gateway Timeout';
+  if (statusCode >= 500) return 'Internal Server Error';
+  return 'Request failed';
+}
+
+export function statusFromUnknown(
+  error: unknown,
+  fallback = 500
+): number {
+  return extractHttpStatus(error) ?? fallback;
+}

package/nuxt-errors/utils/serializeCause.ts

@@ -0,0 +1,25 @@
+import { cloneJson } from './cloneJson';
+
+export function serializeCause(cause: unknown): unknown {
+  if (cause instanceof Error) {
+    const extra = cause as Error & {
+      status?: unknown;
+      statusCode?: unknown;
+      data?: unknown;
+    };
+    return {
+      name: extra.name,
+      message: extra.message,
+      stack: extra.stack,
+      status: extra.status,
+      statusCode: extra.statusCode,
+      data: cloneJson(extra.data),
+    };
+  }
+
+  if (typeof cause === 'object' && cause !== null) {
+    return cloneJson(cause);
+  }
+
+  return cause;
+}

package/nuxt-errors/utils/types.ts

@@ -0,0 +1,55 @@
+export type AppErrorKind =
+  | 'client'
+  | 'unauthorized'
+  | 'forbidden'
+  | 'not_found'
+  | 'conflict'
+  | 'validation'
+  | 'rate_limit'
+  | 'server'
+  | 'network'
+  | 'timeout'
+  | 'abort'
+  | 'malformed'
+  | 'runtime';
+
+export type AppErrorPresentation = 'fatal' | 'local' | 'silent';
+
+export type AppError = {
+  kind: AppErrorKind;
+  statusCode: number;
+  messageKey: string;
+  /** Публичный текст только для ожидаемых 4xx. */
+  message?: string;
+  fieldErrors?: Record<string, string[]>;
+  requestId?: string;
+  cause?: unknown;
+  stack?: string;
+};
+
+export type NormalizeAppErrorContext = {
+  presentation?: AppErrorPresentation;
+  /** Явная отмена запроса — UI можно не показывать. */
+  intentionalAbort?: boolean;
+};
+
+export const REQUEST_ID_HEADERS = [
+  'x-request-id',
+  'x-correlation-id',
+] as const;
+
+export const MESSAGE_KEYS: Record<AppErrorKind, string> = {
+  client: 'pages.errors.bad_request',
+  unauthorized: 'pages.errors.unauthorized',
+  forbidden: 'pages.errors.forbidden',
+  not_found: 'pages.errors.not_found',
+  conflict: 'pages.errors.conflict',
+  validation: 'pages.errors.validation',
+  rate_limit: 'pages.errors.rate_limit',
+  server: 'pages.errors.server',
+  network: 'pages.errors.network',
+  timeout: 'pages.errors.timeout',
+  abort: 'pages.errors.abort',
+  malformed: 'pages.errors.malformed',
+  runtime: 'pages.errors.unexpected',
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "r3ui-lib",
   "private": false,
-  "version": "1.2.31",
+  "version": "1.3.0",
   "description": "Modern Vue 3 UI component library with TypeScript support",
   "keywords": [
     "vue",
@@ -37,12 +37,15 @@
       "import": "./dist/login.es.js",
       "require": "./dist/login.umd.js"
     },
+    "./nuxt-errors": "./nuxt-errors/nuxt.config.ts",
+    "./nuxt-errors/*": "./nuxt-errors/*",
     "./styles": "./dist/r3ui-lib.css",
     "./dist/r3ui-lib.css": "./dist/r3ui-lib.css"
   },
   "files": [
     "dist",
     "assets",
+    "nuxt-errors",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"