reqforge 0.2.0 → 0.4.0

package/.claude/settings.local.json

@@ -7,7 +7,11 @@
       "Bash(git add *)",
       "Bash(git commit *)",
       "Bash(git push *)",
-      "Bash(npm publish *)"
+      "Bash(npm publish *)",
+      "Bash(npm view *)",
+      "Bash(git checkout *)",
+      "Bash(curl *)",
+      "Bash(git pull *)"
     ]
   }
 }

package/README.md

@@ -11,21 +11,33 @@ npm install reqforge
 ## Quick Start
 
 ```javascript
-const { config } = require('reqforge');
+const { config, utils, request } = require('reqforge');
 
 // Get the base URL for API requests
 const baseURL = config.getBaseURL();
 console.log(baseURL); // https://api.example.com/v1
 
-// Merge custom configuration
-const customConfig = config.mergeConfig({
-  timeout: 10000,
-  headers: {
-    'Authorization': 'Bearer your-token'
-  }
-});
+// Make a GET request
+request.get('/users')
+  .then(res => res.json())
+  .then(data => console.log(data));
+
+// Make a POST request
+request.post('/users', { name: 'John', email: 'john@example.com' })
+  .then(res => res.json())
+  .then(data => console.log(data));
 ```
 
+## Request Methods
+
+The `request` module provides:
+
+- `sendRequest(endpoint, data, options)` - Generic request method
+- `get(endpoint, options)` - GET request
+- `post(endpoint, data, options)` - POST request
+- `put(endpoint, data, options)` - PUT request
+- `del(endpoint, options)` - DELETE request
+
 ## Configuration
 
 The `config` module provides:
@@ -35,6 +47,17 @@ The `config` module provides:
 - `defaultConfig` - Default configuration object
 - `mergeConfig(customConfig)` - Merge custom configuration with defaults
 
+## Utilities
+
+The `utils` module provides:
+
+- `buildURL(baseURL, params)` - Build URL with query parameters
+- `serializeQuery(obj)` - Serialize object to query string
+- `parseQuery(queryString)` - Parse query string to object
+- `deepMerge(target, source)` - Deep merge objects
+- `isPlainObject(value)` - Check if value is a plain object
+- `delay(ms)` - Delay execution
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reqforge",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A lightweight, flexible HTTP client library with request interception, automatic retry, and logging capabilities, designed for modern web applications.",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -4,7 +4,11 @@
  */
 
 const config = require('./config');
+const utils = require('./utils');
+const request = require('./request');
 
 module.exports = {
-  config
+  config,
+  utils,
+  request
 };

package/src/request.js

@@ -0,0 +1,79 @@
+/**
+ * Core request module for ReqForge
+ * @module request
+ */
+
+const { getBaseURL } = require('./config');
+
+/**
+ * Send HTTP request
+ * @param {string} endpoint - API endpoint
+ * @param {Object} data - Request body data
+ * @param {Object} options - Request options
+ * @returns {Promise<Response>} Fetch response promise
+ */
+function sendRequest(endpoint, data, options = {}) {
+  const url = getBaseURL() + endpoint;
+
+  const fetchOptions = {
+    method: options.method || 'GET',
+    headers: options.headers || {}
+  };
+
+  if (data) {
+    fetchOptions.body = JSON.stringify(data);
+    fetchOptions.headers['Content-Type'] = 'application/json';
+  }
+
+  return fetch(url, fetchOptions);
+}
+
+/**
+ * GET request helper
+ * @param {string} endpoint - API endpoint
+ * @param {Object} options - Request options
+ * @returns {Promise<Response>} Fetch response promise
+ */
+function get(endpoint, options = {}) {
+  return sendRequest(endpoint, null, { ...options, method: 'GET' });
+}
+
+/**
+ * POST request helper
+ * @param {string} endpoint - API endpoint
+ * @param {Object} data - Request body data
+ * @param {Object} options - Request options
+ * @returns {Promise<Response>} Fetch response promise
+ */
+function post(endpoint, data, options = {}) {
+  return sendRequest(endpoint, data, { ...options, method: 'POST' });
+}
+
+/**
+ * PUT request helper
+ * @param {string} endpoint - API endpoint
+ * @param {Object} data - Request body data
+ * @param {Object} options - Request options
+ * @returns {Promise<Response>} Fetch response promise
+ */
+function put(endpoint, data, options = {}) {
+  return sendRequest(endpoint, data, { ...options, method: 'PUT' });
+}
+
+/**
+ * DELETE request helper
+ * @param {string} endpoint - API endpoint
+ * @param {Object} options - Request options
+ * @returns {Promise<Response>} Fetch response promise
+ */
+function del(endpoint, options = {}) {
+  return sendRequest(endpoint, null, { ...options, method: 'DELETE' });
+}
+
+module.exports = {
+  sendRequest,
+  get,
+  post,
+  put,
+  del
+};

package/src/utils.js

@@ -0,0 +1,91 @@
+/**
+ * Utility functions for ReqForge
+ * @module utils
+ */
+
+/**
+ * Build URL with query parameters
+ * @param {string} baseURL - The base URL
+ * @param {Object} params - Query parameters
+ * @returns {string} URL with query string
+ */
+function buildURL(baseURL, params = {}) {
+  const url = new URL(baseURL);
+  Object.keys(params).forEach(key => {
+    if (params[key] !== undefined && params[key] !== null) {
+      url.searchParams.append(key, params[key]);
+    }
+  });
+  return url.toString();
+}
+
+/**
+ * Serialize object to query string
+ * @param {Object} obj - Object to serialize
+ * @returns {string} Query string
+ */
+function serializeQuery(obj) {
+  return Object.keys(obj)
+    .filter(key => obj[key] !== undefined && obj[key] !== null)
+    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(obj[key])}`)
+    .join('&');
+}
+
+/**
+ * Parse query string to object
+ * @param {string} queryString - Query string to parse
+ * @returns {Object} Parsed query object
+ */
+function parseQuery(queryString) {
+  const params = {};
+  const searchParams = new URLSearchParams(queryString);
+  searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  return params;
+}
+
+/**
+ * Deep merge objects
+ * @param {Object} target - Target object
+ * @param {Object} source - Source object
+ * @returns {Object} Merged object
+ */
+function deepMerge(target, source) {
+  const result = { ...target };
+  Object.keys(source).forEach(key => {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  });
+  return result;
+}
+
+/**
+ * Check if value is a plain object
+ * @param {*} value - Value to check
+ * @returns {boolean} True if plain object
+ */
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === '[object Object]';
+}
+
+/**
+ * Delay execution
+ * @param {number} ms - Milliseconds to delay
+ * @returns {Promise} Promise that resolves after delay
+ */
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  buildURL,
+  serializeQuery,
+  parseQuery,
+  deepMerge,
+  isPlainObject,
+  delay
+};