@exyconn/common 2.3.2 → 2.3.3

package/dist/client/http/index.d.ts

@@ -1,85 +1,253 @@
-import { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import * as axios from 'axios';
+import { AxiosResponse } from 'axios';
+export { AxiosError, AxiosResponse } from 'axios';
 
 /**
- * HTTP Client Configuration Options
+ * Response Parser Utility
+ *
+ * Comprehensive response parsing utilities for API responses.
+ * Aligned with server-side response structures.
  */
-interface HttpClientOptions {
-    baseURL: string;
-    timeout?: number;
-    withCredentials?: boolean;
-    getAuthToken?: () => string | null;
-    onUnauthorized?: () => void;
-    onServerError?: (error: AxiosError) => void;
+/**
+ * Standard API response structure from server
+ */
+interface ApiResponse<T = unknown> {
+    message: string;
+    data: T | null;
+    status: string;
+    statusCode: number;
+    paginationData?: PaginationData;
+    columns?: ColumnMetadata[];
 }
 /**
- * Create configured Axios instance
+ * Pagination metadata structure
  */
-declare const createHttpClient: (options: HttpClientOptions) => AxiosInstance;
+interface PaginationData {
+    total?: number;
+    page?: number;
+    limit?: number;
+    totalPages?: number;
+}
 /**
- * Default request config helpers
+ * Column metadata from server
  */
-declare const withFormData: () => AxiosRequestConfig;
-declare const withTimeout: (ms: number) => AxiosRequestConfig;
-declare const withAbortSignal: (signal: AbortSignal) => AxiosRequestConfig;
-
+interface ColumnMetadata {
+    name: string;
+    required: boolean;
+    datatype: string;
+}
 /**
- * Standard API Response Structure
+ * Status codes aligned with backend
  */
-interface ApiResponse<T = unknown> {
-    success: boolean;
+declare const STATUS_CODES: {
+    readonly SUCCESS: 200;
+    readonly CREATED: 201;
+    readonly NO_CONTENT: 204;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly CONFLICT: 409;
+    readonly ERROR: 500;
+};
+/**
+ * Status messages aligned with backend
+ */
+declare const STATUS_MESSAGES: {
+    SUCCESS: string;
+    CREATED: string;
+    NO_CONTENT: string;
+    BAD_REQUEST: string;
+    UNAUTHORIZED: string;
+    FORBIDDEN: string;
+    NOT_FOUND: string;
+    CONFLICT: string;
+    ERROR: string;
+};
+declare const SUCCESS_CODES: number[];
+declare const ERROR_CODES: number[];
+/**
+ * Safely extracts data from API response
+ */
+declare const parseResponseData: <T = unknown>(response: unknown, fallback?: T | null) => T | null;
+/**
+ * Extracts message from response
+ */
+declare const parseResponseMessage: (response: unknown, fallback?: string) => string;
+/**
+ * Extracts status code from response
+ */
+declare const parseResponseStatus: (response: unknown) => number | null;
+/**
+ * Extracts status message from response
+ */
+declare const parseResponseStatusMessage: (response: unknown, fallback?: string) => string;
+/**
+ * Checks if response indicates success
+ */
+declare const isSuccessResponse: (response: unknown) => boolean;
+/**
+ * Checks if response indicates error
+ */
+declare const isErrorResponse: (response: unknown) => boolean;
+/**
+ * Paginated response structure
+ */
+interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages?: number;
+    columns?: ColumnMetadata[];
+}
+/**
+ * Parses paginated response from backend
+ */
+declare const parsePaginatedResponse: <T = unknown>(response: unknown) => PaginatedResponse<T>;
+/**
+ * Extracts specific nested data with path
+ */
+declare const extractNestedData: <T = unknown>(response: unknown, path: string, fallback?: T | null) => T | null;
+/**
+ * Safe JSON parse with fallback
+ */
+declare const safeJsonParse: <T = unknown>(json: string, fallback?: T | null) => T | null;
+/**
+ * Extracts error message from axios error response
+ */
+declare const parseAxiosErrorMessage: (error: unknown) => string;
+/**
+ * Standardized error object
+ */
+interface ParsedError {
     message: string;
-    data?: T;
-    error?: string;
-    statusCode?: number;
+    statusCode: number | null;
+    data: unknown;
+    status?: string;
 }
 /**
- * Paginated Response Structure
+ * Parses error into standardized format
  */
-interface PaginatedResponse<T = unknown> extends ApiResponse<T[]> {
-    pagination: {
-        total: number;
-        page: number;
-        limit: number;
-        totalPages: number;
-        hasNextPage: boolean;
-        hasPrevPage: boolean;
+declare const parseError: (error: unknown) => ParsedError;
+interface SimpleApiResponse {
+    data?: {
+        data?: {
+            data?: unknown;
+            meta?: Record<string, unknown>;
+        };
     };
 }
+declare const simpleParseResponse: (response: SimpleApiResponse) => unknown;
+declare const simpleMetaParseResponse: (response: SimpleApiResponse) => Record<string, unknown> | undefined;
+declare const simpleParseDualDataResponse: (response: SimpleApiResponse) => {
+    data?: unknown;
+    meta?: Record<string, unknown>;
+} | undefined;
+
+declare const API_BASE_URL: string;
+declare const API_PREFIX = "/v1/api";
+declare const axiosInstance: axios.AxiosInstance;
+/**
+ * GET request
+ */
+declare const getRequest: <T = unknown>(url: string, params?: Record<string, unknown>, customHeaders?: Record<string, string>) => Promise<AxiosResponse<T>>;
+/**
+ * POST request
+ */
+declare const postRequest: <T = unknown>(url: string, data?: unknown, customHeaders?: Record<string, string>) => Promise<AxiosResponse<T>>;
+/**
+ * PUT request
+ */
+declare const putRequest: <T = unknown>(url: string, data?: unknown, customHeaders?: Record<string, string>) => Promise<AxiosResponse<T>>;
+/**
+ * PATCH request
+ */
+declare const patchRequest: <T = unknown>(url: string, data?: unknown, customHeaders?: Record<string, string>) => Promise<AxiosResponse<T>>;
+/**
+ * DELETE request
+ */
+declare const deleteRequest: <T = unknown>(url: string, params?: Record<string, unknown>, customHeaders?: Record<string, string>) => Promise<AxiosResponse<T>>;
 /**
- * Parse successful API response
+ * File upload with FormData
  */
-declare const parseResponse: <T>(response: AxiosResponse<ApiResponse<T>>) => T | null;
+declare const uploadFile: <T = unknown>(url: string, file: File, additionalData?: Record<string, unknown>) => Promise<AxiosResponse<T>>;
 /**
- * Parse API response with full metadata
+ * Extract data from response using response-parser
  */
-declare const parseFullResponse: <T>(response: AxiosResponse<ApiResponse<T>>) => ApiResponse<T>;
+declare const extractData: <T = unknown>(response: AxiosResponse) => T | null;
 /**
- * Parse error from API response
+ * Extract message from response
  */
-declare const parseError: (error: AxiosError<ApiResponse>) => string;
+declare const extractMessage: (response: unknown) => string;
 /**
  * Check if response is successful
  */
-declare const isSuccess: <T>(response: AxiosResponse<ApiResponse<T>>) => boolean;
+declare const isSuccess: (response: AxiosResponse) => boolean;
 /**
- * Check if error is a specific status code
+ * Extract paginated data from response
+ */
+declare const extractPaginatedData: <T = unknown>(response: AxiosResponse) => PaginatedResponse<T>;
+
+/**
+ * Slug Utility
+ *
+ * Generates slugs from text for use in URLs and object properties.
  */
-declare const isStatusError: (error: AxiosError, statusCode: number) => boolean;
 /**
- * Check if error is unauthorized (401)
+ * Generates a camelCase slug from a given text for use in object properties
+ * @param text - The text to convert to camelCase slug
+ * @returns The generated camelCase slug
  */
-declare const isUnauthorized: (error: AxiosError) => boolean;
+declare const generateSlug: (text: string) => string;
 /**
- * Check if error is forbidden (403)
+ * Generates a kebab-case slug from a given text for use in URLs
+ * @param text - The text to convert to kebab-case slug
+ * @returns The generated kebab-case slug
  */
-declare const isForbidden: (error: AxiosError) => boolean;
+declare const generateUrlSlug: (text: string) => string;
 /**
- * Check if error is not found (404)
+ * Generates a snake_case slug from a given text
+ * @param text - The text to convert to snake_case slug
+ * @returns The generated snake_case slug
  */
-declare const isNotFound: (error: AxiosError) => boolean;
+declare const generateSnakeSlug: (text: string) => string;
+
 /**
- * Check if error is server error (5xx)
+ * Client Logger Utility
+ *
+ * Centralized logging utility that:
+ * - Only logs in development mode
+ * - Can be extended to send logs to external services (Sentry, LogRocket, etc.)
+ * - Provides consistent logging interface
  */
-declare const isServerError: (error: AxiosError) => boolean;
+interface LogOptions {
+    context?: string;
+    metadata?: Record<string, unknown>;
+}
+declare class Logger {
+    private isDevelopment;
+    /**
+     * Log informational messages
+     */
+    info(message: string, data?: unknown, options?: LogOptions): void;
+    /**
+     * Log warning messages
+     */
+    warn(message: string, data?: unknown, options?: LogOptions): void;
+    /**
+     * Log error messages
+     */
+    error(message: string, error?: unknown, options?: LogOptions): void;
+    /**
+     * Log debug messages (only in development)
+     */
+    debug(message: string, data?: unknown, options?: LogOptions): void;
+    /**
+     * Log API errors with structured information
+     */
+    apiError(endpoint: string, error: unknown, metadata?: Record<string, unknown>): void;
+}
+declare const logger: Logger;
 
-export { type ApiResponse, type HttpClientOptions, type PaginatedResponse, createHttpClient, isForbidden, isNotFound, isServerError, isStatusError, isSuccess, isUnauthorized, parseError, parseFullResponse, parseResponse, withAbortSignal, withFormData, withTimeout };
+export { API_BASE_URL, API_PREFIX, type ApiResponse, type ColumnMetadata, ERROR_CODES, type PaginatedResponse, type PaginationData, type ParsedError, STATUS_CODES, STATUS_MESSAGES, SUCCESS_CODES, axiosInstance as axios, deleteRequest, extractData, extractMessage, extractNestedData, extractPaginatedData, generateSlug, generateSnakeSlug, generateUrlSlug, getRequest, isErrorResponse, isSuccess, isSuccessResponse, logger, parseAxiosErrorMessage, parseError, parsePaginatedResponse, parseResponseData, parseResponseMessage, parseResponseStatus, parseResponseStatusMessage, patchRequest, postRequest, putRequest, safeJsonParse, simpleMetaParseResponse, simpleParseDualDataResponse, simpleParseResponse, uploadFile };