jiren 1.0.14 → 1.1.0

package/components/client-bun.ts

@@ -0,0 +1,188 @@
+import { CString, type Pointer } from "bun:ffi";
+import { lib } from "./native";
+import type {
+  RequestOptions,
+  GetRequestOptions,
+  PostRequestOptions,
+  HttpResponse,
+} from "../types";
+
+export class JirenClient {
+  private ptr: Pointer | null;
+
+  constructor() {
+    this.ptr = lib.symbols.zclient_new();
+    if (!this.ptr) throw new Error("Failed to create native client instance");
+  }
+
+  /**
+   * Free the native client resources.
+   * Must be called when the client is no longer needed.
+   */
+  public close(): void {
+    if (this.ptr) {
+      lib.symbols.zclient_free(this.ptr);
+      this.ptr = null;
+    }
+  }
+
+  /**
+   * Perform a HTTP request.
+   * @param url - The URL to request
+   * @param options - Request options (method, headers, body)
+   * @returns Response object
+   */
+  public request(url: string, options: RequestOptions = {}): HttpResponse {
+    if (!this.ptr) throw new Error("Client is closed");
+
+    const method = options.method || "GET";
+    const methodBuffer = Buffer.from(method + "\0");
+    const urlBuffer = Buffer.from(url + "\0");
+
+    let headersBuffer: Buffer | null = null;
+    if (options.headers) {
+      const headerStr = Object.entries(options.headers)
+        .map(([k, v]) => `${k.toLowerCase()}: ${v}`)
+        .join("\r\n");
+      if (headerStr.length > 0) {
+        headersBuffer = Buffer.from(headerStr + "\0");
+      }
+    }
+
+    let bodyBuffer: Buffer | null = null;
+    if (options.body) {
+      const bodyStr =
+        typeof options.body === "string"
+          ? options.body
+          : JSON.stringify(options.body);
+      bodyBuffer = Buffer.from(bodyStr + "\0");
+    }
+
+    const respPtr = lib.symbols.zclient_request(
+      this.ptr,
+      methodBuffer,
+      urlBuffer,
+      headersBuffer,
+      bodyBuffer
+    );
+
+    const response = this.parseResponse(respPtr);
+
+    // Handle Redirects
+    if (
+      options.maxRedirects &&
+      options.maxRedirects > 0 &&
+      response.status >= 300 &&
+      response.status < 400 &&
+      response.headers &&
+      response.headers["location"]
+    ) {
+      const location = response.headers["location"];
+      const newUrl = new URL(location, url).toString(); // Resolve relative URLs
+      const newOptions = { ...options, maxRedirects: options.maxRedirects - 1 };
+
+      return this.request(newUrl, newOptions);
+    }
+
+    return response;
+  }
+
+  public get(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "GET" });
+  }
+
+  public post(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "POST", body });
+  }
+
+  public put(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "PUT", body });
+  }
+
+  public delete(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "DELETE" });
+  }
+
+  public patch(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "PATCH", body });
+  }
+
+  public head(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "HEAD" });
+  }
+
+  /**
+   * Prefetch URLs to warm up connections (resolve DNS & Handshake).
+   * @param urls - List of URLs to prefetch
+   */
+  public prefetch(urls: string[]) {
+    if (!this.ptr) throw new Error("Client is closed");
+
+    for (const url of urls) {
+      const urlBuffer = Buffer.from(url + "\0");
+      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
+    }
+  }
+
+  private parseResponse(respPtr: Pointer | null) {
+    if (!respPtr)
+      throw new Error("Native request failed (returned null pointer)");
+
+    try {
+      const status = lib.symbols.zclient_response_status(respPtr);
+      const bodyLen = Number(lib.symbols.zclient_response_body_len(respPtr));
+      const bodyPtr = lib.symbols.zclient_response_body(respPtr);
+      const headersLen = Number(
+        lib.symbols.zclient_response_headers_len(respPtr)
+      );
+      const headersPtr = lib.symbols.zclient_response_headers(respPtr);
+
+      let bodyString = "";
+      if (bodyLen > 0 && bodyPtr) {
+        // CString uses the full length if not null-terminated or we can just read the ptr
+        // Since we know the length, we can be more precise, but CString assumes null-terminated
+        // for now we trust it is null terminated from Zig
+        bodyString = new CString(bodyPtr).toString();
+      }
+
+      const headers: Record<string, string> = {};
+      if (headersLen > 0 && headersPtr) {
+        const headersStr = new CString(headersPtr).toString();
+        const lines = headersStr.split("\r\n");
+        for (const line of lines) {
+          if (!line) continue;
+          const colonIdx = line.indexOf(":");
+          if (colonIdx !== -1) {
+            const key = line.substring(0, colonIdx).trim().toLowerCase();
+            const val = line.substring(colonIdx + 1).trim();
+            headers[key] = val;
+          }
+        }
+      }
+
+      return {
+        status,
+        body: bodyString,
+        headers,
+        json: <T = any>() => {
+          if (!bodyString) return null as T;
+          return JSON.parse(bodyString) as T;
+        },
+      };
+    } finally {
+      lib.symbols.zclient_response_free(respPtr);
+    }
+  }
+}

package/components/client-node.ts

@@ -0,0 +1,105 @@
+import type {
+  RequestOptions,
+  GetRequestOptions,
+  PostRequestOptions,
+  HttpResponse,
+} from "../types/index.js";
+
+/**
+ * Node.js fallback client using native fetch
+ */
+export class NodeJirenClient {
+  constructor() {
+    // No initialization needed for Node.js fetch
+  }
+
+  public close(): void {
+    // No cleanup needed
+  }
+
+  public async request(
+    url: string,
+    options: RequestOptions = {}
+  ): Promise<HttpResponse> {
+    const method = options.method || "GET";
+    const headers = options.headers || {};
+
+    const fetchOptions: RequestInit = {
+      method,
+      headers,
+      redirect:
+        options.maxRedirects && options.maxRedirects > 0 ? "follow" : "manual",
+    };
+
+    if (options.body) {
+      fetchOptions.body =
+        typeof options.body === "string"
+          ? options.body
+          : JSON.stringify(options.body);
+    }
+
+    try {
+      const response = await fetch(url, fetchOptions);
+      const body = await response.text();
+
+      // Convert Headers to plain object
+      const responseHeaders: Record<string, string> = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key.toLowerCase()] = value;
+      });
+
+      return {
+        status: response.status,
+        body,
+        headers: responseHeaders,
+        json: <T = any>() => {
+          if (!body) return null as T;
+          return JSON.parse(body) as T;
+        },
+      };
+    } catch (error) {
+      throw new Error(`HTTP request failed: ${error}`);
+    }
+  }
+
+  public async get(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "GET" });
+  }
+
+  public async post(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "POST", body });
+  }
+
+  public async put(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "PUT", body });
+  }
+
+  public async delete(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "DELETE" });
+  }
+
+  public async patch(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "PATCH", body });
+  }
+
+  public async head(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "HEAD" });
+  }
+
+  public prefetch(urls: string[]) {
+    // No-op in Node.js
+    // Could implement DNS prefetch here if needed
+  }
+}

package/components/index.ts

@@ -0,0 +1,13 @@
+import { isBun } from "./runtime.js";
+
+// Conditionally export the right client
+export const JirenClient = isBun
+  ? (await import("./client-bun.js")).JirenClient
+  : (await import("./client-node.js")).NodeJirenClient;
+
+export type {
+  HttpResponse,
+  RequestOptions,
+  GetRequestOptions,
+  PostRequestOptions,
+} from "../types/index.js";

package/components/native.ts

@@ -0,0 +1,64 @@
+import { dlopen, FFIType, suffix } from "bun:ffi";
+import { join } from "path";
+
+// Resolve library path relative to this module
+const libPath = join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
+
+export const ffiDef = {
+  zclient_new: {
+    args: [],
+    returns: FFIType.ptr,
+  },
+  zclient_free: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  zclient_get: {
+    args: [FFIType.ptr, FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+  zclient_post: {
+    args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+  zclient_prefetch: {
+    args: [FFIType.ptr, FFIType.cstring],
+    returns: FFIType.void,
+  },
+  zclient_response_status: {
+    args: [FFIType.ptr],
+    returns: FFIType.u16,
+  },
+  zclient_response_body: {
+    args: [FFIType.ptr],
+    returns: FFIType.ptr,
+  },
+  zclient_response_body_len: {
+    args: [FFIType.ptr],
+    returns: FFIType.u64,
+  },
+  zclient_response_headers: {
+    args: [FFIType.ptr],
+    returns: FFIType.ptr,
+  },
+  zclient_response_headers_len: {
+    args: [FFIType.ptr],
+    returns: FFIType.u64,
+  },
+  zclient_response_free: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  zclient_request: {
+    args: [
+      FFIType.ptr, // client
+      FFIType.cstring, // method
+      FFIType.cstring, // url
+      FFIType.cstring, // headers (nullable)
+      FFIType.cstring, // body (nullable)
+    ],
+    returns: FFIType.ptr,
+  },
+} as const;
+
+export const lib = dlopen(libPath, ffiDef);

package/components/runtime.ts

@@ -0,0 +1,11 @@
+// Runtime detection
+export const isBun = typeof Bun !== "undefined";
+export const isNode = !isBun && typeof process !== "undefined";
+
+// Re-export types
+export type {
+  HttpResponse,
+  RequestOptions,
+  GetRequestOptions,
+  PostRequestOptions,
+} from "../types/index.js";

package/components/types.ts

@@ -0,0 +1,61 @@
+/**
+ * pow - Ultra-fast HTTP/HTTPS client powered by native Zigr than any other HTTP/HTTPS client
+ */
+
+/** Options for batch HTTP requests */
+export interface BatchOptions {
+  /** Number of requests to send (default: 1000) */
+  count?: number;
+  /** Number of concurrent threads (default: 100) */
+  threads?: number;
+}
+
+/** Result of a batch request operation */
+export interface BatchResult {
+  /** Number of successful requests */
+  success: number;
+  /** Total requests attempted */
+  total: number;
+  /** Duration in seconds */
+  duration: number;
+  /** Requests per second */
+  requestsPerSecond: number;
+}
+
+/** Options for single HTTP requests */
+export interface RequestOptions {
+  /** HTTP method (default: GET) */
+  method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD";
+  /** Request headers */
+  headers?: Record<string, string>;
+  /** Request body (for POST, PUT, PATCH) */
+  body?: string | object;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+}
+
+/** HTTP Response */
+export interface HttpResponse {
+  /** HTTP status code */
+  status: number;
+  /** Response body as string */
+  body: string;
+  /** Response headers */
+  headers?: Record<string, string>;
+}
+
+/** Configuration for JirenHttpClient */
+export interface JirenHttpConfig {
+  /** Default number of threads for batch operations */
+  defaultThreads?: number;
+  /** Base URL prefix for all requests */
+  baseUrl?: string;
+}
+
+/** Parsed URL components */
+export interface ParsedUrl {
+  protocol: "http" | "https";
+  host: string;
+  port: number;
+  path: string;
+}

package/dist/index.js

@@ -1,70 +1,88 @@
 // @bun
-// components/client.ts
-import { CString } from "bun:ffi";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // components/native.ts
 import { dlopen, FFIType, suffix } from "bun:ffi";
 import { join } from "path";
-var libPath = join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
-var ffiDef = {
-  zclient_new: {
-    args: [],
-    returns: FFIType.ptr
-  },
-  zclient_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void
-  },
-  zclient_get: {
-    args: [FFIType.ptr, FFIType.cstring],
-    returns: FFIType.ptr
-  },
-  zclient_post: {
-    args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
-    returns: FFIType.ptr
-  },
-  zclient_prefetch: {
-    args: [FFIType.ptr, FFIType.cstring],
-    returns: FFIType.void
-  },
-  zclient_response_status: {
-    args: [FFIType.ptr],
-    returns: FFIType.u16
-  },
-  zclient_response_body: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr
-  },
-  zclient_response_body_len: {
-    args: [FFIType.ptr],
-    returns: FFIType.u64
-  },
-  zclient_response_headers: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr
-  },
-  zclient_response_headers_len: {
-    args: [FFIType.ptr],
-    returns: FFIType.u64
-  },
-  zclient_response_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void
-  },
-  zclient_request: {
-    args: [
-      FFIType.ptr,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring
-    ],
-    returns: FFIType.ptr
-  }
-};
-var lib = dlopen(libPath, ffiDef);
+var libPath, ffiDef, lib;
+var init_native = __esm(() => {
+  libPath = join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
+  ffiDef = {
+    zclient_new: {
+      args: [],
+      returns: FFIType.ptr
+    },
+    zclient_free: {
+      args: [FFIType.ptr],
+      returns: FFIType.void
+    },
+    zclient_get: {
+      args: [FFIType.ptr, FFIType.cstring],
+      returns: FFIType.ptr
+    },
+    zclient_post: {
+      args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
+      returns: FFIType.ptr
+    },
+    zclient_prefetch: {
+      args: [FFIType.ptr, FFIType.cstring],
+      returns: FFIType.void
+    },
+    zclient_response_status: {
+      args: [FFIType.ptr],
+      returns: FFIType.u16
+    },
+    zclient_response_body: {
+      args: [FFIType.ptr],
+      returns: FFIType.ptr
+    },
+    zclient_response_body_len: {
+      args: [FFIType.ptr],
+      returns: FFIType.u64
+    },
+    zclient_response_headers: {
+      args: [FFIType.ptr],
+      returns: FFIType.ptr
+    },
+    zclient_response_headers_len: {
+      args: [FFIType.ptr],
+      returns: FFIType.u64
+    },
+    zclient_response_free: {
+      args: [FFIType.ptr],
+      returns: FFIType.void
+    },
+    zclient_request: {
+      args: [
+        FFIType.ptr,
+        FFIType.cstring,
+        FFIType.cstring,
+        FFIType.cstring,
+        FFIType.cstring
+      ],
+      returns: FFIType.ptr
+    }
+  };
+  lib = dlopen(libPath, ffiDef);
+});
+
+// components/client-bun.ts
+var exports_client_bun = {};
+__export(exports_client_bun, {
+  JirenClient: () => JirenClient
+});
+import { CString } from "bun:ffi";
 
-// components/client.ts
 class JirenClient {
   ptr;
   constructor() {
@@ -177,6 +195,77 @@ class JirenClient {
     }
   }
 }
+var init_client_bun = __esm(() => {
+  init_native();
+});
+
+// components/client-node.ts
+var exports_client_node = {};
+__export(exports_client_node, {
+  NodeJirenClient: () => NodeJirenClient
+});
+
+class NodeJirenClient {
+  constructor() {}
+  close() {}
+  async request(url, options = {}) {
+    const method = options.method || "GET";
+    const headers = options.headers || {};
+    const fetchOptions = {
+      method,
+      headers,
+      redirect: options.maxRedirects && options.maxRedirects > 0 ? "follow" : "manual"
+    };
+    if (options.body) {
+      fetchOptions.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
+    }
+    try {
+      const response = await fetch(url, fetchOptions);
+      const body = await response.text();
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key.toLowerCase()] = value;
+      });
+      return {
+        status: response.status,
+        body,
+        headers: responseHeaders,
+        json: () => {
+          if (!body)
+            return null;
+          return JSON.parse(body);
+        }
+      };
+    } catch (error) {
+      throw new Error(`HTTP request failed: ${error}`);
+    }
+  }
+  async get(url, options = {}) {
+    return this.request(url, { ...options, method: "GET" });
+  }
+  async post(url, body, options = {}) {
+    return this.request(url, { ...options, method: "POST", body });
+  }
+  async put(url, body, options = {}) {
+    return this.request(url, { ...options, method: "PUT", body });
+  }
+  async delete(url, options = {}) {
+    return this.request(url, { ...options, method: "DELETE" });
+  }
+  async patch(url, body, options = {}) {
+    return this.request(url, { ...options, method: "PATCH", body });
+  }
+  async head(url, options = {}) {
+    return this.request(url, { ...options, method: "HEAD" });
+  }
+  prefetch(urls) {}
+}
+
+// components/runtime.ts
+var isBun = typeof Bun !== "undefined";
+
+// components/index.ts
+var JirenClient2 = isBun ? (await Promise.resolve().then(() => (init_client_bun(), exports_client_bun))).JirenClient : (await Promise.resolve().then(() => exports_client_node)).NodeJirenClient;
 export {
-  JirenClient
+  JirenClient2 as JirenClient
 };

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "jiren",
-  "version": "1.0.14",
+  "version": "1.1.0",
   "author": "",
   "main": "dist/index.js",
   "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "types/index.ts",
   "devDependencies": {
     "@types/bun": "^1.3.4",
+    "@types/node": "^20",
     "bun-types": "^1.3.4"
   },
   "peerDependencies": {
     "typescript": "^5"
   },
-  "description": "Jiren is a high-performance HTTP/HTTPS client, Faster than any other HTTP/HTTPS client.",
+  "description": "Jiren is a high-performance HTTP/HTTPS client. Ultra-fast with Bun FFI, falls back to fetch in Node.js.",
   "files": [
     "dist",
-    "lib"
+    "lib",
+    "components",
+    "types"
   ],
   "keywords": [
     "http",
@@ -27,17 +30,18 @@
     "benchmark",
     "performance",
     "bun",
+    "node",
     "parser"
   ],
   "license": "MIT",
   "scripts": {
     "build:zig": "cd .. && zig build --release=fast",
-    "build": "bun build ./index.ts --outdir dist --target bun && bun run types",
-    "types": "bun x tsc --declaration --emitDeclarationOnly --outDir dist",
+    "build": "bun build ./index.ts --outdir dist --target bun",
     "prepare": "bun run build",
     "test": "bun run examples/basic.ts"
   },
   "engines": {
+    "node": ">=18.0.0",
     "bun": ">=1.1.0"
   },
   "type": "module"

package/types/index.ts

@@ -0,0 +1,73 @@
+/**
+ * jiren - Ultra-fast HTTP/HTTPS Client Types
+ * 56% faster than llhttp
+ */
+
+/** Options for batch HTTP requests */
+export interface BatchOptions {
+  /** Number of requests to send (default: 1000) */
+  count?: number;
+  /** Number of concurrent threads (default: 100) */
+  threads?: number;
+}
+
+/** Result of a batch request operation */
+export interface BatchResult {
+  /** Number of successful requests */
+  success: number;
+  /** Total requests attempted */
+  total: number;
+  /** Duration in seconds */
+  duration: number;
+  /** Requests per second */
+  requestsPerSecond: number;
+}
+
+/** Options for single HTTP requests */
+/** Options for single HTTP requests */
+export interface RequestOptions {
+  /** HTTP method (default: GET) */
+  method?: string;
+  /** Request headers */
+  headers?: Record<string, string>;
+  /** Request body (for POST, PUT, PATCH) */
+  body?: string | object;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /** Maximum number of redirects to follow (default: 0) */
+  maxRedirects?: number;
+}
+
+/** Options for requests without a body (GET, DELETE, HEAD) */
+export type GetRequestOptions = Omit<RequestOptions, "method" | "body">;
+
+/** Options for requests with a body (POST, PUT, PATCH) where body is a separate argument */
+export type PostRequestOptions = Omit<RequestOptions, "method" | "body">;
+
+/** HTTP Response */
+export interface HttpResponse {
+  /** HTTP status code */
+  status: number;
+  /** Response body as string */
+  body: string;
+  /** Response headers */
+  headers?: Record<string, string>;
+  /** Helper to parse JSON body */
+  json: <T = any>() => T;
+}
+
+/** Configuration for JirenHttpClient */
+export interface JirenHttpConfig {
+  /** Default number of threads for batch operations */
+  defaultThreads?: number;
+  /** Base URL prefix for all requests */
+  baseUrl?: string;
+}
+
+/** Parsed URL components */
+export interface ParsedUrl {
+  protocol: "http" | "https";
+  host: string;
+  port: number;
+  path: string;
+}