axiomate 1.0.0

package/README.md

@@ -0,0 +1,148 @@
+# axiomate
+
+> Zero-boilerplate API client — define once, use everywhere.
+
+Stop writing `axios.get(...)` with headers in every component. Define your entire backend API in one file, then call it anywhere with a single line.
+
+---
+
+## Install
+
+```bash
+npm install axiomate axios
+```
+
+---
+
+## Quick Start
+
+### 1. Setup (sirf ek baar — `index.js` ya `App.js` mein)
+
+```js
+import { setTokenGetter, addErrorInterceptor } from "axiomate";
+
+// Token kahan se lena hai batao
+setTokenGetter(() => localStorage.getItem("token"));
+
+// Global error handling
+addErrorInterceptor((error) => {
+  if (error.status === 401) {
+    window.location.href = "/login";
+  }
+});
+```
+
+### 2. API define karo (ek file — `api.config.js`)
+
+```js
+import { createApi } from "axiomate";
+
+export const api = createApi({
+  baseUrl: "http://localhost:8080",
+  endpoints: {
+    login:       { path: "/auth/login",    method: "POST" },
+    getUser:     { path: "/user/profile",  method: "GET"  },
+    updateUser:  { path: "/user/update",   method: "PUT"  },
+    getProducts: { path: "/products",      method: "GET"  },
+  },
+});
+```
+
+### 3. Anywhere use karo
+
+```js
+import { api } from "./api.config";
+
+// Simple call
+const res = await api.login({ username: "ali", password: "1234" });
+
+// GET with query params
+const products = await api.getProducts({ page: 1, limit: 10 });
+// → GET /products?page=1&limit=10
+```
+
+### 4. React Hook
+
+```jsx
+import { useApi } from "axiomate";
+import { api } from "./api.config";
+
+function ProfilePage() {
+  const { data, loading, error } = useApi(api.getUser);
+
+  if (loading) return <p>Loading...</p>;
+  if (error)   return <p>{error.message}</p>;
+  return <h1>Hello, {data.name}</h1>;
+}
+```
+
+---
+
+## API Reference
+
+### `createApi(config)`
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `baseUrl` | string | ✅ | — | Backend ka base URL |
+| `endpoints` | object | ✅ | — | Endpoints ka map |
+| `headers` | object | ❌ | `{}` | Extra default headers |
+| `timeout` | number | ❌ | `10000` | Timeout in ms |
+| `autoToken` | boolean | ❌ | `true` | Auto Bearer token attach |
+
+### `setTokenGetter(fn)`
+Token kahan se lena hai define karo.
+```js
+setTokenGetter(() => store.getState().auth.token);
+```
+
+### `addRequestInterceptor(fn)`
+Har request se pehle kuch karo.
+```js
+addRequestInterceptor((config) => {
+  config.headers["X-App-Version"] = "2.0";
+  return config;
+});
+```
+
+### `addResponseInterceptor(fn)`
+Har response aane ke baad kuch karo.
+```js
+addResponseInterceptor((response) => {
+  console.log("Response:", response.config.url);
+  return response;
+});
+```
+
+### `addErrorInterceptor(fn)`
+Koi request fail ho toh handle karo.
+```js
+addErrorInterceptor((error) => {
+  if (error.status === 403) alert("Access denied!");
+});
+```
+
+### `useApi(apiFn, options?)`
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `params` | object | `{}` | Default params |
+| `immediate` | boolean | `true` | Mount pe call karo |
+| `initialData` | any | `null` | Initial data value |
+
+**Returns:** `{ data, loading, error, execute, reset }`
+
+```jsx
+// Auto call
+const { data, loading, error } = useApi(api.getUser);
+
+// Manual call
+const { execute, loading } = useApi(api.login, { immediate: false });
+await execute({ username, password });
+```
+
+---
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "axiomate",
+  "version": "1.0.0",
+  "description": "Zero-boilerplate API client — define once, use everywhere.",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "keywords": ["api", "axios", "react", "http-client", "rest"],
+  "author": "Your Name",
+  "license": "MIT",
+  "peerDependencies": {
+    "axios": "^1.0.0",
+    "react": ">=16.8.0"
+  },
+  "devDependencies": {
+    "axios": "^1.6.0",
+    "react": "^18.0.0"
+  },
+  "files": ["src"],
+  "scripts": {
+    "test": "node tests/test.js"
+  }
+}

package/src/_store.js

@@ -0,0 +1,16 @@
+/**
+ * _store.js
+ * Internal shared state — library ke andar use hota hai
+ * Developer directly use na kare
+ */
+
+const _store = {
+  instance: null,
+  interceptors: {
+    request: [],
+    response: [],
+    error: [],
+  },
+};
+
+module.exports = { _store };

package/src/createApi.js

@@ -0,0 +1,164 @@
+const axios = require("axios");
+const { _store } = require("./_store");
+
+/**
+ * Token getter — developer set karta hai apna logic
+ */
+let _getToken = () => localStorage.getItem("token");
+
+/**
+ * setTokenGetter — developer apna token logic provide kare
+ * @param {Function} fn - function jo token return kare
+ *
+ * @example
+ * setTokenGetter(() => store.getState().auth.token);
+ */
+const setTokenGetter = (fn) => {
+  _getToken = fn;
+};
+
+/**
+ * createApi — library ka core function
+ *
+ * @param {Object} config
+ * @param {string} config.baseUrl       - Backend ka base URL
+ * @param {Object} config.endpoints     - Sare endpoints ka map
+ * @param {Object} [config.headers]     - Extra default headers
+ * @param {number} [config.timeout]     - Request timeout ms (default: 10000)
+ * @param {boolean} [config.autoToken]  - Auto Bearer token lagao (default: true)
+ *
+ * @returns {Object} - Har endpoint ke liye ek callable function
+ *
+ * @example
+ * const api = createApi({
+ *   baseUrl: "http://localhost:8080",
+ *   endpoints: {
+ *     login:   { path: "/auth/login",   method: "POST" },
+ *     getUser: { path: "/user/profile", method: "GET"  },
+ *   }
+ * });
+ *
+ * await api.login({ username: "ali", password: "1234" });
+ */
+const createApi = (config) => {
+  const {
+    baseUrl,
+    endpoints = {},
+    headers = {},
+    timeout = 10000,
+    autoToken = true,
+  } = config;
+
+  if (!baseUrl) throw new Error("[axiomate] baseUrl is required in createApi config.");
+  if (!endpoints || Object.keys(endpoints).length === 0) {
+    console.warn("[axiomate] No endpoints defined.");
+  }
+
+  // Axios instance banao
+  _store.instance = axios.create({
+    baseURL: baseUrl,
+    timeout,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers,
+    },
+  });
+
+  // ─── Request Interceptor ───────────────────────────────────────────────────
+  _store.instance.interceptors.request.use(
+    (axiosConfig) => {
+      // Auto token attach
+      if (autoToken) {
+        const token = _getToken();
+        if (token) {
+          axiosConfig.headers["Authorization"] = `Bearer ${token}`;
+        }
+      }
+
+      // Developer ke custom request interceptors chalao
+      let finalConfig = axiosConfig;
+      for (const fn of _store.interceptors.request) {
+        finalConfig = fn(finalConfig) || finalConfig;
+      }
+
+      return finalConfig;
+    },
+    (error) => Promise.reject(error)
+  );
+
+  // ─── Response Interceptor ─────────────────────────────────────────────────
+  _store.instance.interceptors.response.use(
+    (response) => {
+      let finalResponse = response;
+      for (const fn of _store.interceptors.response) {
+        finalResponse = fn(finalResponse) || finalResponse;
+      }
+      return finalResponse;
+    },
+    (error) => {
+      // Developer ke custom error interceptors chalao
+      for (const fn of _store.interceptors.error) {
+        fn(error);
+      }
+
+      // Meaningful error message banao
+      const status = error?.response?.status;
+      const message =
+        error?.response?.data?.message ||
+        error?.response?.data?.error ||
+        error?.message ||
+        "Something went wrong";
+
+      const enhancedError = new Error(message);
+      enhancedError.status = status;
+      enhancedError.data = error?.response?.data;
+      enhancedError.original = error;
+
+      return Promise.reject(enhancedError);
+    }
+  );
+
+  // ─── Endpoints ko functions mein convert karo ─────────────────────────────
+  const api = {};
+
+  for (const [name, endpoint] of Object.entries(endpoints)) {
+    const { path, method = "GET" } = endpoint;
+
+    if (!path) {
+      console.warn(`[axiomate] Endpoint "${name}" has no path defined. Skipping.`);
+      continue;
+    }
+
+    /**
+     * Generated endpoint function
+     *
+     * @param {Object} [data]          - POST/PUT ke liye request body
+     * @param {Object} [params]        - GET ke liye query params
+     * @param {Object} [extraConfig]   - Axios extra config override
+     */
+    api[name] = (data = {}, params = {}, extraConfig = {}) => {
+      const upperMethod = method.toUpperCase();
+
+      const requestConfig = {
+        method: upperMethod,
+        url: path,
+        ...extraConfig,
+      };
+
+      if (upperMethod === "GET" || upperMethod === "DELETE") {
+        requestConfig.params = { ...params, ...data };
+      } else {
+        requestConfig.data = data;
+        if (Object.keys(params).length > 0) {
+          requestConfig.params = params;
+        }
+      }
+
+      return _store.instance(requestConfig).then((res) => res.data);
+    };
+  }
+
+  return api;
+};
+
+module.exports = { createApi, setTokenGetter };

package/src/index.js

@@ -0,0 +1,22 @@
+/**
+ * axiomate
+ * ─────────────────────────────────────────────
+ * Zero-boilerplate API client.
+ * Define once, use everywhere.
+ *
+ * @author  Your Name
+ * @version 1.0.0
+ */
+
+const { createApi, setTokenGetter } = require("./createApi");
+const { addRequestInterceptor, addResponseInterceptor, addErrorInterceptor } = require("./interceptors");
+const { useApi } = require("./useApi");
+
+module.exports = {
+  createApi,
+  setTokenGetter,
+  addRequestInterceptor,
+  addResponseInterceptor,
+  addErrorInterceptor,
+  useApi,
+};

package/src/interceptors.js

@@ -0,0 +1,62 @@
+/**
+ * interceptors.js
+ * Developer apne custom interceptors register kare
+ */
+
+const { _store } = require("./_store");
+
+/**
+ * addRequestInterceptor
+ * Har request jaane se pehle ye function chalega
+ *
+ * @param {Function} fn - (axiosConfig) => axiosConfig
+ *
+ * @example
+ * addRequestInterceptor((config) => {
+ *   config.headers["X-App-Version"] = "1.0.0";
+ *   return config;
+ * });
+ */
+const addRequestInterceptor = (fn) => {
+  _store.interceptors.request.push(fn);
+};
+
+/**
+ * addResponseInterceptor
+ * Har successful response aane ke baad ye function chalega
+ *
+ * @param {Function} fn - (response) => response
+ *
+ * @example
+ * addResponseInterceptor((response) => {
+ *   console.log("Response received:", response.config.url);
+ *   return response;
+ * });
+ */
+const addResponseInterceptor = (fn) => {
+  _store.interceptors.response.push(fn);
+};
+
+/**
+ * addErrorInterceptor
+ * Koi bhi request fail ho toh ye function chalega
+ *
+ * @param {Function} fn - (error) => void
+ *
+ * @example
+ * addErrorInterceptor((error) => {
+ *   if (error.status === 401) {
+ *     // logout user
+ *     window.location.href = "/login";
+ *   }
+ * });
+ */
+const addErrorInterceptor = (fn) => {
+  _store.interceptors.error.push(fn);
+};
+
+module.exports = {
+  addRequestInterceptor,
+  addResponseInterceptor,
+  addErrorInterceptor,
+};

package/src/useApi.js

@@ -0,0 +1,76 @@
+const { useState, useEffect, useCallback, useRef } = require("react");
+
+/**
+ * useApi — React hook for API calls
+ * Loading, error, data sab automatic!
+ *
+ * @param {Function} apiFn        - api.getUser jaise function
+ * @param {Object}   [options]
+ * @param {any}      [options.params]      - Function ko pass karne wale params
+ * @param {boolean}  [options.immediate]   - Mount hote hi call karo (default: true)
+ * @param {any}      [options.initialData] - Data ka initial value
+ *
+ * @returns {{ data, loading, error, execute, reset }}
+ *
+ * @example
+ * // Auto call on mount:
+ * const { data, loading, error } = useApi(api.getUser);
+ *
+ * // Manual call (form submit etc):
+ * const { data, loading, execute } = useApi(api.login, { immediate: false });
+ * const handleSubmit = () => execute({ username, password });
+ *
+ * // With params:
+ * const { data } = useApi(api.getUserById, { params: { id: 5 } });
+ */
+const useApi = (apiFn, options = {}) => {
+  const {
+    params = {},
+    immediate = true,
+    initialData = null,
+  } = options;
+
+  const [data, setData] = useState(initialData);
+  const [loading, setLoading] = useState(immediate);
+  const [error, setError] = useState(null);
+
+  // Latest params ref — stale closure se bachne ke liye
+  const paramsRef = useRef(params);
+  paramsRef.current = params;
+
+  const execute = useCallback(
+    async (overrideParams = {}) => {
+      setLoading(true);
+      setError(null);
+
+      try {
+        const mergedParams = { ...paramsRef.current, ...overrideParams };
+        const result = await apiFn(mergedParams);
+        setData(result);
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiFn]
+  );
+
+  const reset = useCallback(() => {
+    setData(initialData);
+    setError(null);
+    setLoading(false);
+  }, [initialData]);
+
+  useEffect(() => {
+    if (immediate) {
+      execute();
+    }
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
+
+  return { data, loading, error, execute, reset };
+};
+
+module.exports = { useApi };