@winxs/wind 0.1.1 → 0.1.2

package/dist/cjs/index.cjs

@@ -0,0 +1,254 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  wind: () => wind,
+  windClient: () => windClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Utility/HttpError.ts
+var HttpError = class extends Error {
+  constructor(message, type, status, response) {
+    super(message);
+    this.type = type;
+    this.status = status;
+    this.response = response;
+  }
+};
+function classifyError(err) {
+  if (err instanceof HttpError) return err;
+  if (err.name === "AbortError") return new HttpError("Request Timed Out", "TIMEOUT");
+  if (err.status) {
+    if (err.status === 429) return new HttpError("Rate limited", "RATE_LIMIT", 429);
+    if (err.status >= 500) return new HttpError("Server error", "SERVER", err.status);
+    if (err.status >= 400) return new HttpError("Client error", "CLIENT", err.status);
+  }
+  return new HttpError(err.message || "Unknown error", "UNKNOWN");
+}
+
+// src/Utility/coreRequest.ts
+async function coreRequest(url, options) {
+  const controller = new AbortController();
+  if (options.timeoutMS) {
+    setTimeout(() => controller.abort(), options.timeoutMS);
+  }
+  let finalUrl = url;
+  if (options.params) {
+    const searchParams = new URLSearchParams(
+      Object.entries(options.params).map(([key, value]) => [
+        key,
+        String(value)
+      ])
+    );
+    finalUrl += `?${searchParams.toString()}`;
+  }
+  const res = await fetch(finalUrl, {
+    method: options.method ?? "GET",
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    },
+    body: options.body ? JSON.stringify(options.body) : void 0,
+    signal: controller.signal
+  });
+  let text;
+  try {
+    text = await res.text();
+  } catch {
+    throw new HttpError("Failed to read response", "NETWORK", res.status);
+  }
+  let data = null;
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new HttpError("Invalid JSON Response", "SCHEMA", res.status, text);
+    }
+  }
+  if (!res.ok) {
+    throw new HttpError("HTTP Error", "CLIENT", res.status, data);
+  }
+  return data;
+}
+
+// src/Utility/Retry.ts
+async function withRetry(fn, options) {
+  const {
+    attempts,
+    backOffMs = 300,
+    //5 mins
+    retryOn = ["NETWORK", "TIMEOUT", "RATE_LIMIT", "SERVER"]
+  } = options;
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      let classified = classifyError(err);
+      lastError = classified;
+      if (!retryOn.includes(classified.type)) throw classified;
+      await new Promise((r) => setTimeout(r, backOffMs * (i + 1)));
+    }
+  }
+  throw lastError;
+}
+
+// src/Utility/CircuitBreaker.ts
+var CircuitBreaker = class {
+  constructor(threshold = 5, timeoutMs = 1e4) {
+    this.threshold = threshold;
+    this.timeoutMs = timeoutMs;
+    this.failures = 0;
+    this.lastFailure = 0;
+  }
+  canRequest() {
+    if (this.failures < this.threshold) return true;
+    return Date.now() - this.lastFailure > this.timeoutMs;
+  }
+  success() {
+    this.failures = 0;
+  }
+  failure() {
+    this.failures++;
+    this.lastFailure = Date.now();
+  }
+};
+
+// src/Helper/Pagination.ts
+async function* paginate(fetcher, path, body, config = {}) {
+  let FIXED_PARAMS = "";
+  if (config.FIXED_PARAMS) {
+    Object.entries(config.FIXED_PARAMS).forEach(
+      ([key, value]) => FIXED_PARAMS += `&${key}=${value}`
+    );
+  }
+  const pages = pagination(config.TOTAL_SIZE, config.CHUNK_SIZE);
+  const CHUNK_PAGINATION_KEY = config.PARAMS_KEY?.CHUNK_PAGINATION_KEY;
+  const CHUNK_SIZE_KEY = config.PARAMS_KEY?.CHUNK_SIZE_KEY;
+  if (Array.isArray(pages)) {
+    for (const page of pages) {
+      const paramsPath = `${CHUNK_PAGINATION_KEY}=${page.CHUNK_START}&${CHUNK_SIZE_KEY}=${page.CHUNK_SIZE}` + FIXED_PARAMS;
+      let args = {
+        ...config.options,
+        body
+      };
+      const data = await fetcher(`${path}?${paramsPath}`, args);
+      if (config.stopOnEmpty !== false && (!data || Array.isArray(data) && data.length === 0)) {
+        break;
+      }
+      yield data;
+    }
+  }
+}
+function pagination(TOTAL_SIZE = 2e3, CHUNK_SIZE = 2e3, start = 1) {
+  try {
+    const totalChunks = Math.ceil(TOTAL_SIZE / CHUNK_SIZE);
+    CHUNK_SIZE = TOTAL_SIZE < CHUNK_SIZE ? TOTAL_SIZE : CHUNK_SIZE;
+    const requests = Array.from({ length: totalChunks }, (_, index) => {
+      const CHUNK_START = start + index * CHUNK_SIZE;
+      return { CHUNK_START, CHUNK_SIZE };
+    });
+    return requests;
+  } catch (error) {
+    throw error;
+  }
+}
+
+// src/Helper/Batch.ts
+async function batch(tasks, options = {}) {
+  const concurrency = options.concurrency ?? tasks.length;
+  const failFast = options.failFast ?? false;
+  const results = [];
+  const errors = [];
+  let index = 0;
+  async function worker() {
+    while (index < tasks.length) {
+      const i = index++;
+      try {
+        results[i] = await tasks[i]();
+      } catch (err) {
+        errors[i] = err;
+        if (failFast) throw err;
+      }
+    }
+  }
+  await Promise.all(
+    Array.from({ length: concurrency }, worker)
+  );
+  return { results, errors };
+}
+
+// src/index.ts
+var windClient = class {
+  constructor(baseURL = "") {
+    this.baseURL = baseURL;
+    this.breaker = new CircuitBreaker();
+  }
+  async request(path, options = {}) {
+    if (!this.breaker.canRequest()) {
+      throw new Error("Circuit breaker is open");
+    }
+    const exec = async () => {
+      return await coreRequest(this.baseURL + path, options);
+    };
+    try {
+      const result = options.retry ? await withRetry(exec, options.retry) : await exec();
+      this.breaker.success();
+      return result;
+    } catch (err) {
+      if (this.shouldTripBreaker(err)) {
+        this.breaker.failure();
+      }
+      throw err;
+    }
+  }
+  get(path, options) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  post(path, body, options) {
+    return this.request(path, { ...options, method: "POST", body });
+  }
+  paginate(path, body, config) {
+    return paginate(this.post.bind(this), path, body, config);
+  }
+  batch(tasks, options) {
+    return batch(tasks, options);
+  }
+  shouldTripBreaker(err) {
+    const status = err?.status;
+    if (!status) return true;
+    if (status >= 500) return true;
+    if (status === 429) return true;
+    return false;
+  }
+};
+function wind(config = {}) {
+  return new windClient(config.baseURL ?? "");
+}
+var defaultWind = new windClient();
+var index_default = defaultWind;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  wind,
+  windClient
+});

package/dist/{index.d.ts → esm/index.d.ts}

@@ -8,7 +8,7 @@ declare class HttpError extends Error {
 }
 
 interface RetryOptions {
-    attemps: number;
+    attempts: number;
     backOffMs?: number;
     retryOn?: ErrorType[];
 }
@@ -18,14 +18,20 @@ interface RequestOptions {
     headers?: Record<string, string>;
     body?: any;
     timeoutMS?: number;
+    params?: any;
     retry?: RetryOptions;
 }
 
 interface PaginationConfig {
-    pageParam?: string;
-    startPage?: number;
+    FIXED_PARAMS?: Record<string, string | number>;
+    TOTAL_SIZE?: number;
+    CHUNK_SIZE?: number;
     stopOnEmpty?: boolean;
     options?: RequestOptions;
+    PARAMS_KEY?: {
+        CHUNK_PAGINATION_KEY?: string;
+        CHUNK_SIZE_KEY?: string;
+    };
 }
 
 interface BatchOptions {
@@ -40,7 +46,7 @@ declare class windClient {
     request<T>(path: string, options?: RequestOptions): Promise<T>;
     get<T>(path: string, options?: RequestOptions): Promise<T>;
     post<T>(path: string, body: any, options?: RequestOptions): Promise<T>;
-    paginate<T>(path: string, config?: PaginationConfig): AsyncGenerator<T, any, any>;
+    paginate<T>(path: string, body: any, config?: PaginationConfig): AsyncGenerator<T, any, any>;
     batch<T>(tasks: (() => Promise<T>)[], options?: BatchOptions): Promise<{
         results: T[];
         errors: HttpError[];

package/dist/{index.js → esm/index.js}

@@ -24,21 +24,38 @@ async function coreRequest(url, options) {
   if (options.timeoutMS) {
     setTimeout(() => controller.abort(), options.timeoutMS);
   }
-  const res = await fetch(url, {
-    method: options.method || "GET",
+  let finalUrl = url;
+  if (options.params) {
+    const searchParams = new URLSearchParams(
+      Object.entries(options.params).map(([key, value]) => [
+        key,
+        String(value)
+      ])
+    );
+    finalUrl += `?${searchParams.toString()}`;
+  }
+  const res = await fetch(finalUrl, {
+    method: options.method ?? "GET",
     headers: {
+      "Content-Type": "application/json",
       ...options.headers
     },
     body: options.body ? JSON.stringify(options.body) : void 0,
     signal: controller.signal
   });
-  let data = null;
-  let text = null;
+  let text;
   try {
     text = await res.text();
-    data = text ? JSON.parse(text) : null;
   } catch {
-    throw new HttpError("Invalid JSON Response", "SCHEMA", res.status, text);
+    throw new HttpError("Failed to read response", "NETWORK", res.status);
+  }
+  let data = null;
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new HttpError("Invalid JSON Response", "SCHEMA", res.status, text);
+    }
   }
   if (!res.ok) {
     throw new HttpError("HTTP Error", "CLIENT", res.status, data);
@@ -49,13 +66,13 @@ async function coreRequest(url, options) {
 // src/Utility/Retry.ts
 async function withRetry(fn, options) {
   const {
-    attemps,
+    attempts,
     backOffMs = 300,
     //5 mins
     retryOn = ["NETWORK", "TIMEOUT", "RATE_LIMIT", "SERVER"]
   } = options;
   let lastError;
-  for (let i = 0; i < attemps; i++) {
+  for (let i = 0; i < attempts; i++) {
     try {
       return await fn();
     } catch (err) {
@@ -90,19 +107,42 @@ var CircuitBreaker = class {
 };
 
 // src/Helper/Pagination.ts
-async function* paginate(fetcher, path, config = {}) {
-  const pageParam = config.pageParam ?? "page";
-  let page = config.startPage ?? 1;
-  while (true) {
-    const data = await fetcher(
-      `${path}?${pageParam}=${page}`,
-      config.options
+async function* paginate(fetcher, path, body, config = {}) {
+  let FIXED_PARAMS = "";
+  if (config.FIXED_PARAMS) {
+    Object.entries(config.FIXED_PARAMS).forEach(
+      ([key, value]) => FIXED_PARAMS += `&${key}=${value}`
     );
-    if (config.stopOnEmpty !== false && (!data || Array.isArray(data) && data.length === 0)) {
-      break;
+  }
+  const pages = pagination(config.TOTAL_SIZE, config.CHUNK_SIZE);
+  const CHUNK_PAGINATION_KEY = config.PARAMS_KEY?.CHUNK_PAGINATION_KEY;
+  const CHUNK_SIZE_KEY = config.PARAMS_KEY?.CHUNK_SIZE_KEY;
+  if (Array.isArray(pages)) {
+    for (const page of pages) {
+      const paramsPath = `${CHUNK_PAGINATION_KEY}=${page.CHUNK_START}&${CHUNK_SIZE_KEY}=${page.CHUNK_SIZE}` + FIXED_PARAMS;
+      let args = {
+        ...config.options,
+        body
+      };
+      const data = await fetcher(`${path}?${paramsPath}`, args);
+      if (config.stopOnEmpty !== false && (!data || Array.isArray(data) && data.length === 0)) {
+        break;
+      }
+      yield data;
     }
-    yield data;
-    page++;
+  }
+}
+function pagination(TOTAL_SIZE = 2e3, CHUNK_SIZE = 2e3, start = 1) {
+  try {
+    const totalChunks = Math.ceil(TOTAL_SIZE / CHUNK_SIZE);
+    CHUNK_SIZE = TOTAL_SIZE < CHUNK_SIZE ? TOTAL_SIZE : CHUNK_SIZE;
+    const requests = Array.from({ length: totalChunks }, (_, index) => {
+      const CHUNK_START = start + index * CHUNK_SIZE;
+      return { CHUNK_START, CHUNK_SIZE };
+    });
+    return requests;
+  } catch (error) {
+    throw error;
   }
 }
 
@@ -141,7 +181,7 @@ var windClient = class {
       throw new Error("Circuit breaker is open");
     }
     const exec = async () => {
-      return coreRequest(this.baseURL + path, options);
+      return await coreRequest(this.baseURL + path, options);
     };
     try {
       const result = options.retry ? await withRetry(exec, options.retry) : await exec();
@@ -160,8 +200,8 @@ var windClient = class {
   post(path, body, options) {
     return this.request(path, { ...options, method: "POST", body });
   }
-  paginate(path, config) {
-    return paginate(this.get.bind(this), path, config);
+  paginate(path, body, config) {
+    return paginate(this.post.bind(this), path, body, config);
   }
   batch(tasks, options) {
     return batch(tasks, options);

package/package.json

@@ -1,44 +1,40 @@
-{
-  "name": "@winxs/wind",
-  "version": "0.1.1",
-  "description": "Modern HTTP orchestration client for pagination, retries, batching, and failure-safe APIs",
-  "license": "MIT",
-  "author": "Winxs",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts",
-    "dev": "tsup src/index.ts --watch",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "http",
-    "fetch",
-    "axios",
-    "client",
-    "pagination",
-    "retry",
-    "batch",
-    "workers"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/winxs/wind"
-  },
-  "devDependencies": {
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "@winxs/wind",
+  "version": "0.1.2",
+  "description": "Modern HTTP orchestration client for pagination, retries, batching, and failure-safe APIs",
+  "license": "MIT",
+  "author": "Winxs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    "import": "./dist/esm/index.js",
+    "require": "./dist/cjs/index.cjs"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "keywords": [
+    "http",
+    "fetch",
+    "axios",
+    "client",
+    "pagination",
+    "retry",
+    "batch",
+    "workers"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adirathod1822/wind"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}