@next-feature/client 0.1.1 → 0.1.2-10

package/hooks/use-api-error.d.ts

@@ -0,0 +1,10 @@
+import { ApiError } from '../lib/error';
+interface UseApiErrorResult {
+    error: ApiError | null;
+    setError: (error: ApiError | null) => void;
+    clearError: () => void;
+    handleError: (error: unknown) => void;
+    errorMessage: string | null;
+}
+export declare function useApiError(): UseApiErrorResult;
+export {};

package/{src/index.ts → index.d.ts}

@@ -21,10 +21,10 @@
  *    - Customize src/hooks/use-api-error.tsx
  *    - Customize src/components/api-error-boundary.tsx
  */
-
-// Core API utilities
-export { ApiClient, type ApiClientConfig } from './lib/client';
-export { ApiError, ApiErrorBuilder, type ProblemDetail } from './lib/error';
-export * from './lib/types';
+export { ApiClient } from './lib/client';
+export { ApiError } from './lib/error';
+export * from './lib/types/client';
+export * from './lib/types/index';
+export * from './lib/utils/axios';
 export * from './lib/utils/error';
-export * from './lib/utils/helper';
+export * from './lib/utils/zod';

package/index.js

@@ -0,0 +1,195 @@
+import { z as i, a, h as r } from "./error-CN4QrYXy.js";
+import { A as m, g as E, b as k, c as w, i as A } from "./error-CN4QrYXy.js";
+i.object({
+  NODE_ENV: i.enum(["development", "production"]),
+  CLIENT_API_URL: i.string().url()
+});
+process.env.NODE_ENV;
+const h = process.env.CLIENT_API_URL, c = "@next-feature/client", u = "0.1.2-6", p = {
+  name: c,
+  version: u
+}, { name: o, version: d } = p;
+class R {
+  constructor(e) {
+    this.isRefreshing = !1, this.pendingRequests = [], this.config = {
+      baseURL: h,
+      timeout: 3e4,
+      enableRefreshToken: !1,
+      maxRetries: 1,
+      retryDelay: 1e3,
+      skipRefreshPaths: [],
+      onUnauthorized: async () => {
+        console.log(`[${o}] Unauthorized`);
+      },
+      onRefreshTokenExpired: async () => {
+        console.log("Refresh token expired");
+      },
+      onAuthenticated: async (t) => {
+        console.log(
+          `[${o}]`,
+          t.method?.toUpperCase(),
+          t.url,
+          t.data ?? ""
+        );
+      },
+      onRefreshToken: async () => "",
+      ...e
+    }, this.instance = a.create({
+      baseURL: this.config.baseURL,
+      timeout: this.config.timeout,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": `${o}:${d}`
+      }
+    }), this.setupInterceptors();
+  }
+  /**
+   * Setup request and response interceptors
+   */
+  setupInterceptors() {
+    this.instance.interceptors.request.use(
+      this.handleRequestFulfilled.bind(this),
+      this.handleRequestRejected.bind(this)
+    ), this.instance.interceptors.response.use(
+      this.handleResponseFulfilled.bind(this),
+      this.handleResponseRejected.bind(this)
+    );
+  }
+  /**
+   * Attach JWT token to request headers
+   */
+  async handleRequestFulfilled(e) {
+    try {
+      return this.config.onAuthenticated && await this.config.onAuthenticated(e), e;
+    } catch (t) {
+      return console.error("onAuthenticated error on request:", t), e;
+    }
+  }
+  /**
+   * Handle request errors
+   */
+  handleRequestRejected(e) {
+    return console.error("Request configuration error:", e), Promise.reject(e);
+  }
+  /**
+   * Pass through successful responses
+   */
+  handleResponseFulfilled(e) {
+    return e;
+  }
+  /**
+   * Check if a path should skip the refresh token logic
+   */
+  shouldSkipRefresh(e) {
+    return !e || !this.config.skipRefreshPaths?.length ? !1 : this.config.skipRefreshPaths.some((t) => t.test(e));
+  }
+  /**
+   * Handle response errors with retry logic and token refresh
+   */
+  async handleResponseRejected(e) {
+    const t = e.config;
+    return t ? e.response?.status === 401 && this.config.enableRefreshToken && !this.shouldSkipRefresh(t.url) ? this.handleUnauthorizedError(e, t) : this.shouldRetry(e, t) ? this.retryRequest(t) : Promise.reject(r(e)) : Promise.reject(r(e));
+  }
+  /**
+   * Handle 401 errors with token refresh
+   */
+  async handleUnauthorizedError(e, t) {
+    if (t._retry)
+      return this.config.onRefreshTokenExpired && await this.config.onRefreshTokenExpired(), Promise.reject(r(e));
+    if (t._retry = !0, this.isRefreshing)
+      return new Promise((s, n) => {
+        this.pendingRequests.push({ resolve: s, reject: n });
+      }).then((s) => (t.headers.Authorization = `Bearer ${s}`, this.instance(t))).catch((s) => Promise.reject(r(s)));
+    this.isRefreshing = !0;
+    try {
+      const s = await this.refreshToken(t);
+      return t.headers.Authorization = `Bearer ${s}`, this.processPendingRequests(null, s), this.instance(t);
+    } catch (s) {
+      return this.processPendingRequests(s, null), this.config.onUnauthorized && await this.config.onUnauthorized(), Promise.reject(r(e));
+    } finally {
+      this.isRefreshing = !1;
+    }
+  }
+  /**
+   * Refresh the JWT token using the refresh token
+   */
+  async refreshToken(e) {
+    try {
+      const t = await this.config.onRefreshToken();
+      return await this.post("/api/auth/refresh", {
+        refreshToken: t,
+        headers: e.headers
+      });
+    } catch (t) {
+      throw console.error("Token refresh failed:", t), t;
+    }
+  }
+  /**
+   * Process all pending requests after token refresh
+   */
+  processPendingRequests(e, t) {
+    this.pendingRequests.forEach((s) => {
+      e ? s.reject(e) : t && s.resolve(t);
+    }), this.pendingRequests = [];
+  }
+  /**
+   * Determine if request should be retried
+   */
+  shouldRetry(e, t) {
+    if ((t._retryCount || 0) >= this.config.maxRetries)
+      return !1;
+    if (!e.response)
+      return !0;
+    const n = e.response.status;
+    return n >= 500 && n !== 501 || n === 429;
+  }
+  /**
+   * Retry failed request with exponential backoff
+   */
+  async retryRequest(e) {
+    e._retryCount = (e._retryCount || 0) + 1;
+    const t = this.config.retryDelay * Math.pow(2, e._retryCount - 1);
+    return await this.sleep(t), console.log(
+      `Retrying request (attempt ${e._retryCount}):`,
+      e.url
+    ), this.instance(e);
+  }
+  /**
+   * Sleep helper for retry delays
+   */
+  sleep(e) {
+    return new Promise((t) => setTimeout(t, e));
+  }
+  /**
+   * HTTP Methods with proper typing
+   */
+  async get(e, t) {
+    return (await this.instance.get(e, t)).data;
+  }
+  async post(e, t, s) {
+    return (await this.instance.post(e, t, s)).data;
+  }
+  async put(e, t, s) {
+    return (await this.instance.put(e, t, s)).data;
+  }
+  async patch(e, t, s) {
+    return (await this.instance.patch(e, t, s)).data;
+  }
+  async delete(e, t) {
+    return (await this.instance.delete(e, t)).data;
+  }
+  /**
+   * Get the underlying Axios instance for advanced usage
+   */
+  getAxiosInstance() {
+    return this.instance;
+  }
+}
+export {
+  R as ApiClient,
+  m as ApiError,
+  E as getErrorMessage,
+  k as handleAxiosError,
+  w as handleZodError,
+  A as isHttpStatus
+};

package/lib/actions/with-api.d.ts

@@ -0,0 +1,7 @@
+import { ApiResponse } from '../types';
+interface WithApiOptions<T> {
+    fallbackData?: T;
+    successMessage?: string;
+}
+export declare function withApi<F extends (...args: any[]) => Promise<any>>(fn: F, options?: WithApiOptions<Awaited<ReturnType<F>>>): (...args: Parameters<F>) => Promise<ApiResponse<Awaited<ReturnType<F>>>>;
+export {};

package/lib/client.d.ts

@@ -0,0 +1,72 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { ApiClientConfig } from './types/client';
+/**
+ * Axios wrapper with JWT/Refresh token handling
+ */
+export declare class ApiClient {
+    private readonly instance;
+    private isRefreshing;
+    private pendingRequests;
+    private config;
+    constructor(config: ApiClientConfig);
+    /**
+     * Setup request and response interceptors
+     */
+    private setupInterceptors;
+    /**
+     * Attach JWT token to request headers
+     */
+    private handleRequestFulfilled;
+    /**
+     * Handle request errors
+     */
+    private handleRequestRejected;
+    /**
+     * Pass through successful responses
+     */
+    private handleResponseFulfilled;
+    /**
+     * Check if a path should skip the refresh token logic
+     */
+    private shouldSkipRefresh;
+    /**
+     * Handle response errors with retry logic and token refresh
+     */
+    private handleResponseRejected;
+    /**
+     * Handle 401 errors with token refresh
+     */
+    private handleUnauthorizedError;
+    /**
+     * Refresh the JWT token using the refresh token
+     */
+    private refreshToken;
+    /**
+     * Process all pending requests after token refresh
+     */
+    private processPendingRequests;
+    /**
+     * Determine if request should be retried
+     */
+    private shouldRetry;
+    /**
+     * Retry failed request with exponential backoff
+     */
+    private retryRequest;
+    /**
+     * Sleep helper for retry delays
+     */
+    private sleep;
+    /**
+     * HTTP Methods with proper typing
+     */
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    /**
+     * Get the underlying Axios instance for advanced usage
+     */
+    getAxiosInstance(): AxiosInstance;
+}

package/lib/config/env.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+declare const envSchema: z.ZodObject<{
+    NODE_ENV: z.ZodEnum<["development", "production"]>;
+    CLIENT_API_URL: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    NODE_ENV?: "development" | "production";
+    CLIENT_API_URL?: string;
+}, {
+    NODE_ENV?: "development" | "production";
+    CLIENT_API_URL?: string;
+}>;
+declare global {
+    namespace NodeJS {
+        interface ProcessEnv extends z.infer<typeof envSchema> {
+        }
+    }
+}
+export declare const NODE_ENV: "development" | "production" | "test";
+export declare const BACKEND_API_URL: string;
+export {};

package/lib/error.d.ts

@@ -0,0 +1,35 @@
+import { HttpStatusCode } from 'axios';
+import { ProblemDetail } from './types';
+/**
+ * Custom error class for API errors
+ */
+export declare class ApiError extends Error {
+    problemDetail: ProblemDetail;
+    originalError?: Error;
+    constructor(problemDetail: ProblemDetail, originalError?: Error);
+    get status(): HttpStatusCode;
+    get body(): ProblemDetail;
+    get isClientError(): boolean;
+    get isServerError(): boolean;
+    get isUnauthorized(): boolean;
+    get isForbidden(): boolean;
+    get isNotFound(): boolean;
+    static builder(): ApiErrorBuilder;
+    static of(error: Error | unknown): ApiError;
+}
+export declare class ApiErrorBuilder {
+    private _originalError;
+    private _problemDetail;
+    constructor(_originalError: Error | null);
+    /**
+     * Set standard ProblemDetail
+     */
+    problemDetail(problemDetail: ProblemDetail): ApiErrorBuilder;
+    originalError(error: Error): ApiErrorBuilder;
+    message(msg: string): ApiErrorBuilder;
+    status(status: HttpStatusCode): ApiErrorBuilder;
+    errors(errors: Record<string, string>): ApiErrorBuilder;
+    title(title: string): ApiErrorBuilder;
+    instance(instance: string): ApiErrorBuilder;
+    build(): ApiError;
+}

package/lib/types/client.d.ts

@@ -0,0 +1,24 @@
+import { InternalAxiosRequestConfig } from 'axios';
+/**
+ * Configuration options for the API client
+ *
+ * [api-client-config]
+ * next-feature@0.1.1-beta.5
+ * January 11th 2026, 9:00:22 pm
+ */
+export interface ApiClientConfig {
+    baseURL: string;
+    timeout?: number;
+    enableRefreshToken?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+    /**
+     * Paths that should skip the refresh token logic on 401.
+     * Useful for login/register endpoints that expect 401 as a valid response.
+     */
+    skipRefreshPaths?: RegExp[];
+    onAuthenticated?: (config: InternalAxiosRequestConfig) => void | Promise<void>;
+    onUnauthorized?: () => void | Promise<void>;
+    onRefreshTokenExpired?: () => void | Promise<void>;
+    onRefreshToken?: () => string | Promise<string>;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,27 @@
+import { HttpStatusCode } from 'axios';
+/**
+ * [api-response]
+ * next-feature@0.0.11-beta
+ * November 4th 2025, 6:37:27 pm
+ */
+export interface ApiResponse<Response> {
+    success?: boolean;
+    message?: string;
+    error?: ProblemDetail;
+    data: Response;
+}
+/**
+ * Spring Boot ProblemDetail structure
+ *
+ * [problem-detail]
+ * next-feature@0.1.1-beta.5
+ * January 11th 2026, 8:55:50 pm
+ */
+export interface ProblemDetail {
+    type: string;
+    title: string;
+    status: HttpStatusCode;
+    detail: string;
+    instance?: string;
+    errors?: Record<string, string>;
+}

package/lib/utils/axios.d.ts

@@ -0,0 +1,7 @@
+import { AxiosError } from 'axios';
+/**
+ * [handle-axios-error]
+ * next-feature@0.1.1-beta.5
+ * January 11th 2026, 9:37:55 pm
+ */
+export declare function handleAxiosError(e: AxiosError): import('../error').ApiError;

package/lib/utils/error.d.ts

@@ -0,0 +1,19 @@
+import { ApiError } from '../error';
+/**
+ * Extract user-friendly error message from ApiError
+ *
+ * [get-error-message]
+ * next-feature@0.0.11-beta
+ * November 4th 2025, 11:47:45 am
+ *
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Check if error is a specific HTTP status
+ */
+export declare function isHttpStatus(error: unknown, status: number): boolean;
+/**
+ * Handle common API errors
+ */
+declare function handleApiError(error: unknown): ApiError;
+export default handleApiError;

package/lib/utils/zod.d.ts

@@ -0,0 +1,10 @@
+import { ZodError } from 'zod';
+import { ApiError } from '../error';
+/**
+ * Create ApiError from Zod validation error
+ *
+ * [handle-zod-error]
+ * next-feature@0.1.1-beta.5
+ * January 11th 2026, 9:40:46 pm
+ */
+export declare function handleZodError(zodError: ZodError): ApiError;

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "@next-feature/client",
-  "version": "0.1.1",
+  "version": "0.1.2-10",
+  "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": "./index.mjs",
-      "require": "./index.js"
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
     },
     "./server": {
-      "types": "./dist/server.d.ts",
-      "import": "./dist/server.js",
-      "default": "./dist/server.js"
-    }
+      "types": "./server.d.ts",
+      "import": "./server.js",
+      "default": "./server.js"
+    },
+    "./package.json": "./package.json"
   }
 }

package/server.d.ts

@@ -0,0 +1 @@
+export * from './lib/actions/with-api';

package/server.js

@@ -0,0 +1,29 @@
+import { A as o } from "./error-CN4QrYXy.js";
+function u(r, c) {
+  const e = {
+    fallbackData: {},
+    successMessage: "success",
+    ...c
+  };
+  return async (...t) => {
+    try {
+      const s = await r(...t);
+      return {
+        success: !0,
+        message: e.successMessage,
+        data: s
+      };
+    } catch (s) {
+      const a = o.of(s);
+      return {
+        data: e.fallbackData,
+        error: a.body,
+        message: a.message,
+        success: !1
+      };
+    }
+  };
+}
+export {
+  u as withApi
+};

package/.babelrc

@@ -1,12 +0,0 @@
-{
-  "presets": [
-    [
-      "@nx/react/babel",
-      {
-        "runtime": "automatic",
-        "useBuiltIns": "usage"
-      }
-    ]
-  ],
-  "plugins": []
-}

package/eslint.config.mjs

@@ -1,12 +0,0 @@
-import nx from '@nx/eslint-plugin';
-import baseConfig from '../../eslint.config.mjs';
-
-export default [
-  ...baseConfig,
-  ...nx.configs['flat/react'],
-  {
-    files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
-    // Override or add rules here
-    rules: {},
-  },
-];

package/jest.config.cts

@@ -1,10 +0,0 @@
-module.exports = {
-  displayName: 'client',
-  preset: '../../jest.preset.js',
-  transform: {
-    '^(?!.*\\.(js|jsx|ts|tsx|css|json)$)': '@nx/react/plugins/jest',
-    '^.+\\.[tj]sx?$': ['babel-jest', { presets: ['@nx/react/babel'] }],
-  },
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
-  coverageDirectory: '../../coverage/clients/client',
-};

package/project.json

@@ -1,32 +0,0 @@
-{
-  "name": "client",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "clients/client/src",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@nx/vite:build",
-      "outputs": ["{options.outputPath}"],
-      "defaultConfiguration": "production",
-      "options": {
-        "outputPath": "dist/clients/client"
-      },
-      "configurations": {
-        "development": {
-          "mode": "development"
-        },
-        "production": {
-          "mode": "production"
-        }
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "clients/client/jest.config.cts"
-      }
-    }
-  }
-}

package/src/components/api-error-boundary.tsx

@@ -1,58 +0,0 @@
-'use client';
-
-import React, { Component, ErrorInfo, ReactNode } from 'react';
-import { ApiError } from '../lib/error';
-import { getErrorMessage } from '../lib/utils/error';
-
-interface Props {
-  children: ReactNode;
-  fallback?: (error: ApiError) => ReactNode;
-  onError?: (error: Error, errorInfo: ErrorInfo) => void;
-}
-
-interface State {
-  hasError: boolean;
-  error: Error | null;
-}
-
-export class ApiErrorBoundary extends Component<Props, State> {
-  constructor(props: Props) {
-    super(props);
-    this.state = { hasError: false, error: null };
-  }
-
-  static getDerivedStateFromError(error: Error): State {
-    return { hasError: true, error };
-  }
-
-  componentDidCatch(error: Error, errorInfo: ErrorInfo) {
-    console.error('ApiErrorBoundary caught error:', error, errorInfo);
-
-    if (this.props.onError) {
-      this.props.onError(error, errorInfo);
-    }
-  }
-
-  render() {
-    if (this.state.hasError && this.state.error) {
-      if (this.state.error instanceof ApiError && this.props.fallback) {
-        return this.props.fallback(this.state.error);
-      }
-
-      // Default error UI
-      return (
-        <div className="error-container">
-          <h2>Something went wrong</h2>
-          <p>{getErrorMessage(this.state.error)}</p>
-          <button
-            onClick={() => this.setState({ hasError: false, error: null })}
-          >
-            Try again
-          </button>
-        </div>
-      );
-    }
-
-    return this.props.children;
-  }
-}