jiren 1.2.6 → 1.2.8

package/dist/index.js

@@ -0,0 +1,664 @@
+// @bun
+var __require = import.meta.require;
+
+// components/client.ts
+import { toArrayBuffer } from "bun:ffi";
+
+// 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_request: {
+    args: [
+      FFIType.ptr,
+      FFIType.cstring,
+      FFIType.cstring,
+      FFIType.cstring,
+      FFIType.cstring,
+      FFIType.u8,
+      FFIType.bool
+    ],
+    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_parse_header_offsets: {
+    args: [FFIType.ptr],
+    returns: FFIType.ptr
+  },
+  zclient_header_offsets_free: {
+    args: [FFIType.ptr],
+    returns: FFIType.void
+  },
+  z_find_header_value: {
+    args: [FFIType.ptr, FFIType.u64, FFIType.cstring],
+    returns: FFIType.ptr
+  },
+  zclient_header_value_free: {
+    args: [FFIType.ptr],
+    returns: FFIType.void
+  },
+  zclient_response_free: {
+    args: [FFIType.ptr],
+    returns: FFIType.void
+  },
+  zclient_set_benchmark_mode: {
+    args: [FFIType.ptr, FFIType.bool],
+    returns: FFIType.void
+  }
+};
+var lib = dlopen(libPath, ffiDef);
+
+// components/cache.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { gzipSync, gunzipSync } from "zlib";
+import { createHash } from "crypto";
+import { join as join2 } from "path";
+
+class ResponseCache {
+  cacheDir;
+  maxSize;
+  constructor(maxSize = 100, cacheDir = ".cache/jiren") {
+    this.maxSize = maxSize;
+    this.cacheDir = cacheDir;
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+  generateKey(url, path, options) {
+    const fullUrl = path ? `${url}${path}` : url;
+    const method = options?.method || "GET";
+    const headers = JSON.stringify(options?.headers || {});
+    const key = `${method}:${fullUrl}:${headers}`;
+    return createHash("md5").update(key).digest("hex");
+  }
+  getCacheFilePath(key) {
+    return join2(this.cacheDir, `${key}.json.gz`);
+  }
+  get(url, path, options) {
+    const key = this.generateKey(url, path, options);
+    const filePath = this.getCacheFilePath(key);
+    if (!existsSync(filePath))
+      return null;
+    try {
+      const compressed = readFileSync(filePath);
+      const decompressed = gunzipSync(compressed);
+      const data = decompressed.toString("utf-8");
+      const entry = JSON.parse(data);
+      const now = Date.now();
+      if (now - entry.timestamp > entry.ttl) {
+        try {
+          __require("fs").unlinkSync(filePath);
+        } catch {}
+        return null;
+      }
+      return entry.response;
+    } catch (error) {
+      try {
+        __require("fs").unlinkSync(filePath);
+      } catch {}
+      return null;
+    }
+  }
+  set(url, response, ttl, path, options) {
+    const key = this.generateKey(url, path, options);
+    const filePath = this.getCacheFilePath(key);
+    const entry = {
+      response,
+      timestamp: Date.now(),
+      ttl
+    };
+    try {
+      const json = JSON.stringify(entry);
+      const compressed = gzipSync(json);
+      writeFileSync(filePath, compressed);
+    } catch (error) {
+      console.warn("Failed to write cache:", error);
+    }
+  }
+  clear(url) {
+    if (url) {
+      this.clearAll();
+    } else {
+      this.clearAll();
+    }
+  }
+  clearAll() {
+    try {
+      const fs = __require("fs");
+      const files = fs.readdirSync(this.cacheDir);
+      for (const file of files) {
+        if (file.endsWith(".json.gz")) {
+          fs.unlinkSync(join2(this.cacheDir, file));
+        }
+      }
+    } catch (error) {}
+  }
+  stats() {
+    try {
+      const fs = __require("fs");
+      const files = fs.readdirSync(this.cacheDir);
+      const cacheFiles = files.filter((f) => f.endsWith(".json.gz"));
+      let totalSize = 0;
+      for (const file of cacheFiles) {
+        const stats = fs.statSync(join2(this.cacheDir, file));
+        totalSize += stats.size;
+      }
+      return {
+        size: cacheFiles.length,
+        maxSize: this.maxSize,
+        cacheDir: this.cacheDir,
+        totalSizeKB: (totalSize / 1024).toFixed(2)
+      };
+    } catch {
+      return {
+        size: 0,
+        maxSize: this.maxSize,
+        cacheDir: this.cacheDir,
+        totalSizeKB: "0"
+      };
+    }
+  }
+}
+
+// components/client.ts
+var STATUS_TEXT = {
+  200: "OK",
+  201: "Created",
+  204: "No Content",
+  301: "Moved Permanently",
+  302: "Found",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable"
+};
+class JirenClient {
+  ptr;
+  urlMap = new Map;
+  cacheConfig = new Map;
+  cache;
+  inflightRequests = new Map;
+  globalRetry;
+  url;
+  constructor(options) {
+    this.ptr = lib.symbols.zclient_new();
+    if (!this.ptr)
+      throw new Error("Failed to create native client instance");
+    this.cache = new ResponseCache(100);
+    if (options?.benchmark) {
+      lib.symbols.zclient_set_benchmark_mode(this.ptr, true);
+    }
+    if (options?.warmup) {
+      const urls = [];
+      const warmup = options.warmup;
+      if (Array.isArray(warmup)) {
+        for (const item of warmup) {
+          if (typeof item === "string") {
+            urls.push(item);
+          } else {
+            const config = item;
+            urls.push(config.url);
+            this.urlMap.set(config.key, config.url);
+            if (config.cache) {
+              const cacheConfig = typeof config.cache === "boolean" ? { enabled: true, ttl: 60000 } : { enabled: true, ttl: config.cache.ttl || 60000 };
+              this.cacheConfig.set(config.key, cacheConfig);
+            }
+          }
+        }
+      } else {
+        for (const [key, urlConfig] of Object.entries(warmup)) {
+          if (typeof urlConfig === "string") {
+            urls.push(urlConfig);
+            this.urlMap.set(key, urlConfig);
+          } else {
+            urls.push(urlConfig.url);
+            this.urlMap.set(key, urlConfig.url);
+            if (urlConfig.cache) {
+              const cacheConfig = typeof urlConfig.cache === "boolean" ? { enabled: true, ttl: 60000 } : { enabled: true, ttl: urlConfig.cache.ttl || 60000 };
+              this.cacheConfig.set(key, cacheConfig);
+            }
+          }
+        }
+      }
+      if (urls.length > 0) {
+        this.warmup(urls);
+      }
+    }
+    this.url = this.createUrlAccessor();
+    if (options?.retry) {
+      this.globalRetry = typeof options.retry === "number" ? { count: options.retry, delay: 100, backoff: 2 } : options.retry;
+    }
+  }
+  async waitFor(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  createUrlAccessor() {
+    const self = this;
+    return new Proxy({}, {
+      get(_target, prop) {
+        const baseUrl = self.urlMap.get(prop);
+        if (!baseUrl) {
+          throw new Error(`URL key "${prop}" not found. Available keys: ${Array.from(self.urlMap.keys()).join(", ")}`);
+        }
+        const buildUrl = (path) => path ? `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}` : baseUrl;
+        return {
+          get: async (options) => {
+            const cacheConfig = self.cacheConfig.get(prop);
+            if (cacheConfig?.enabled) {
+              const cached = self.cache.get(baseUrl, options?.path, options);
+              if (cached) {
+                return cached;
+              }
+            }
+            const dedupKey = `GET:${buildUrl(options?.path)}:${JSON.stringify(options?.headers || {})}`;
+            if (self.inflightRequests.has(dedupKey)) {
+              return self.inflightRequests.get(dedupKey);
+            }
+            const requestPromise = (async () => {
+              try {
+                const response = await self.request("GET", buildUrl(options?.path), null, {
+                  headers: options?.headers,
+                  maxRedirects: options?.maxRedirects,
+                  responseType: options?.responseType,
+                  antibot: options?.antibot
+                });
+                if (cacheConfig?.enabled && typeof response === "object" && "status" in response) {
+                  self.cache.set(baseUrl, response, cacheConfig.ttl, options?.path, options);
+                }
+                return response;
+              } finally {
+                self.inflightRequests.delete(dedupKey);
+              }
+            })();
+            self.inflightRequests.set(dedupKey, requestPromise);
+            return requestPromise;
+          },
+          post: async (options) => {
+            const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
+            return self.request("POST", buildUrl(options?.path), serializedBody, {
+              headers,
+              maxRedirects: options?.maxRedirects,
+              responseType: options?.responseType
+            });
+          },
+          put: async (options) => {
+            const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
+            return self.request("PUT", buildUrl(options?.path), serializedBody, {
+              headers,
+              maxRedirects: options?.maxRedirects,
+              responseType: options?.responseType
+            });
+          },
+          patch: async (options) => {
+            const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
+            return self.request("PATCH", buildUrl(options?.path), serializedBody, {
+              headers,
+              maxRedirects: options?.maxRedirects,
+              responseType: options?.responseType
+            });
+          },
+          delete: async (options) => {
+            const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
+            return self.request("DELETE", buildUrl(options?.path), serializedBody, {
+              headers,
+              maxRedirects: options?.maxRedirects,
+              responseType: options?.responseType
+            });
+          },
+          head: async (options) => {
+            return self.request("HEAD", buildUrl(options?.path), null, {
+              headers: options?.headers,
+              maxRedirects: options?.maxRedirects,
+              antibot: options?.antibot
+            });
+          },
+          options: async (options) => {
+            return self.request("OPTIONS", buildUrl(options?.path), null, {
+              headers: options?.headers,
+              maxRedirects: options?.maxRedirects,
+              antibot: options?.antibot
+            });
+          },
+          prefetch: async (options) => {
+            self.cache.clear(baseUrl);
+            const cacheConfig = self.cacheConfig.get(prop);
+            if (cacheConfig?.enabled) {
+              await self.request("GET", buildUrl(options?.path), null, {
+                headers: options?.headers,
+                maxRedirects: options?.maxRedirects,
+                antibot: options?.antibot
+              });
+            }
+          }
+        };
+      }
+    });
+  }
+  close() {
+    if (this.ptr) {
+      lib.symbols.zclient_free(this.ptr);
+      this.ptr = null;
+    }
+  }
+  async warmup(urls) {
+    if (!this.ptr)
+      throw new Error("Client is closed");
+    await Promise.all(urls.map((url) => new Promise((resolve) => {
+      const urlBuffer = Buffer.from(url + "\x00");
+      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
+      resolve();
+    })));
+  }
+  prefetch(urls) {
+    this.warmup(urls);
+  }
+  async request(method, url, body, options) {
+    if (!this.ptr)
+      throw new Error("Client is closed");
+    let headers = {};
+    let maxRedirects = 5;
+    let responseType;
+    let antibot = false;
+    if (options) {
+      if ("maxRedirects" in options || "headers" in options || "responseType" in options || "method" in options || "timeout" in options || "antibot" in options) {
+        const opts = options;
+        if (opts.headers)
+          headers = opts.headers;
+        if (opts.maxRedirects !== undefined)
+          maxRedirects = opts.maxRedirects;
+        if (opts.responseType)
+          responseType = opts.responseType;
+        if (opts.antibot !== undefined)
+          antibot = opts.antibot;
+      } else {
+        headers = options;
+      }
+    }
+    const methodBuffer = Buffer.from(method + "\x00");
+    const urlBuffer = Buffer.from(url + "\x00");
+    let bodyBuffer = null;
+    if (body) {
+      bodyBuffer = Buffer.from(body + "\x00");
+    }
+    let headersBuffer = null;
+    const defaultHeaders = {
+      "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+      "accept-encoding": "gzip",
+      "accept-language": "en-US,en;q=0.9",
+      "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+      "sec-ch-ua-mobile": "?0",
+      "sec-ch-ua-platform": '"macOS"',
+      "sec-fetch-dest": "document",
+      "sec-fetch-mode": "navigate",
+      "sec-fetch-site": "none",
+      "sec-fetch-user": "?1",
+      "upgrade-insecure-requests": "1"
+    };
+    const finalHeaders = { ...defaultHeaders, ...headers };
+    const orderedHeaders = {};
+    const keys = [
+      "sec-ch-ua",
+      "sec-ch-ua-mobile",
+      "sec-ch-ua-platform",
+      "upgrade-insecure-requests",
+      "user-agent",
+      "accept",
+      "sec-fetch-site",
+      "sec-fetch-mode",
+      "sec-fetch-user",
+      "sec-fetch-dest",
+      "accept-encoding",
+      "accept-language"
+    ];
+    for (const key of keys) {
+      if (finalHeaders[key]) {
+        orderedHeaders[key] = finalHeaders[key];
+        delete finalHeaders[key];
+      }
+    }
+    for (const [key, value] of Object.entries(finalHeaders)) {
+      orderedHeaders[key] = value;
+    }
+    const headerStr = Object.entries(orderedHeaders).map(([k, v]) => `${k.toLowerCase()}: ${v}`).join(`\r
+`);
+    if (headerStr.length > 0) {
+      headersBuffer = Buffer.from(headerStr + "\x00");
+    }
+    let retryConfig = this.globalRetry;
+    if (options && typeof options === "object" && "retry" in options) {
+      const userRetry = options.retry;
+      if (typeof userRetry === "number") {
+        retryConfig = { count: userRetry, delay: 100, backoff: 2 };
+      } else if (typeof userRetry === "object") {
+        retryConfig = userRetry;
+      }
+    }
+    let attempts = 0;
+    const maxAttempts = (retryConfig?.count || 0) + 1;
+    let currentDelay = retryConfig?.delay || 100;
+    const backoff = retryConfig?.backoff || 2;
+    let lastError;
+    while (attempts < maxAttempts) {
+      attempts++;
+      try {
+        const respPtr = lib.symbols.zclient_request(this.ptr, methodBuffer, urlBuffer, headersBuffer, bodyBuffer, maxRedirects, antibot);
+        if (!respPtr) {
+          throw new Error("Native request failed (returned null pointer)");
+        }
+        const response = this.parseResponse(respPtr, url);
+        if (responseType) {
+          if (responseType === "json")
+            return response.body.json();
+          if (responseType === "text")
+            return response.body.text();
+          if (responseType === "arraybuffer")
+            return response.body.arrayBuffer();
+          if (responseType === "blob")
+            return response.body.blob();
+        }
+        return response;
+      } catch (err) {
+        lastError = err;
+        if (attempts < maxAttempts) {
+          await this.waitFor(currentDelay);
+          currentDelay *= backoff;
+        }
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  parseResponse(respPtr, url) {
+    if (!respPtr)
+      throw new Error("Native request failed (returned null pointer)");
+    try {
+      const status = lib.symbols.zclient_response_status(respPtr);
+      const len = 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));
+      let headersObj = {};
+      if (headersLen > 0) {
+        const rawHeadersPtr = lib.symbols.zclient_response_headers(respPtr);
+        if (rawHeadersPtr) {
+          const rawSrc = toArrayBuffer(rawHeadersPtr, 0, headersLen);
+          const raw = new Uint8Array(rawSrc.slice(0));
+          headersObj = new NativeHeaders(raw);
+        }
+      }
+      const headersProxy = new Proxy(headersObj instanceof NativeHeaders ? headersObj : {}, {
+        get(target, prop) {
+          if (target instanceof NativeHeaders && typeof prop === "string") {
+            if (prop === "toJSON")
+              return () => target.toJSON();
+            const val = target.get(prop);
+            if (val !== null)
+              return val;
+          }
+          return Reflect.get(target, prop);
+        }
+      });
+      let buffer = new ArrayBuffer(0);
+      if (len > 0 && bodyPtr) {
+        buffer = toArrayBuffer(bodyPtr, 0, len).slice(0);
+      }
+      let bodyUsed = false;
+      const consumeBody = () => {
+        if (bodyUsed) {}
+        bodyUsed = true;
+      };
+      const bodyObj = {
+        bodyUsed: false,
+        arrayBuffer: async () => {
+          consumeBody();
+          if (Buffer.isBuffer(buffer)) {
+            const buf = buffer;
+            return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+          }
+          return buffer;
+        },
+        blob: async () => {
+          consumeBody();
+          return new Blob([buffer]);
+        },
+        text: async () => {
+          consumeBody();
+          return new TextDecoder().decode(buffer);
+        },
+        json: async () => {
+          consumeBody();
+          const text = new TextDecoder().decode(buffer);
+          return JSON.parse(text);
+        }
+      };
+      Object.defineProperty(bodyObj, "bodyUsed", {
+        get: () => bodyUsed
+      });
+      return {
+        url,
+        status,
+        statusText: STATUS_TEXT[status] || "",
+        headers: headersProxy,
+        ok: status >= 200 && status < 300,
+        redirected: false,
+        type: "basic",
+        body: bodyObj
+      };
+    } finally {
+      lib.symbols.zclient_response_free(respPtr);
+    }
+  }
+  prepareBody(body, userHeaders) {
+    let serializedBody = null;
+    const headers = { ...userHeaders };
+    if (body !== null && body !== undefined) {
+      if (typeof body === "object") {
+        serializedBody = JSON.stringify(body);
+        const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
+        if (!hasContentType) {
+          headers["Content-Type"] = "application/json";
+        }
+      } else {
+        serializedBody = String(body);
+      }
+    }
+    return { headers, serializedBody };
+  }
+}
+
+class NativeHeaders {
+  raw;
+  len;
+  decoder = new TextDecoder;
+  cache = new Map;
+  constructor(raw) {
+    this.raw = raw;
+    this.len = raw.byteLength;
+  }
+  get(name) {
+    const target = name.toLowerCase();
+    if (this.cache.has(target))
+      return this.cache.get(target);
+    const keyBuf = Buffer.from(target + "\x00");
+    const resPtr = lib.symbols.z_find_header_value(this.raw, this.len, keyBuf);
+    if (!resPtr)
+      return null;
+    try {
+      const view = new DataView(toArrayBuffer(resPtr, 0, 16));
+      const valPtr = view.getBigUint64(0, true);
+      const valLen = Number(view.getBigUint64(8, true));
+      if (valLen === 0) {
+        this.cache.set(target, "");
+        return "";
+      }
+      const valBytes = toArrayBuffer(Number(valPtr), 0, valLen);
+      const val = this.decoder.decode(valBytes);
+      this.cache.set(target, val);
+      return val;
+    } finally {
+      lib.symbols.zclient_header_value_free(resPtr);
+    }
+  }
+  toJSON() {
+    const obj = {};
+    const text = this.decoder.decode(this.raw);
+    const lines = text.split(`\r
+`);
+    for (const line of lines) {
+      if (!line)
+        continue;
+      const colon = line.indexOf(":");
+      if (colon === -1)
+        continue;
+      const key = line.substring(0, colon).trim().toLowerCase();
+      const val = line.substring(colon + 1).trim();
+      obj[key] = val;
+    }
+    return obj;
+  }
+}
+export {
+  JirenClient
+};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "jiren",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "author": "",
-  "main": "index.ts",
-  "module": "index.ts",
+  "main": "dist/index-node.js",
+  "module": "dist/index.js",
   "types": "index.ts",
   "devDependencies": {
     "@types/bun": "^1.3.4"
@@ -17,7 +17,8 @@
     "index-node.ts",
     "types",
     "lib",
-    "components"
+    "components",
+    "dist"
   ],
   "keywords": [
     "http",
@@ -34,6 +35,7 @@
   "license": "MIT",
   "scripts": {
     "build:zig": "cd .. && zig build --release=fast",
+    "build": "bun build ./index.ts --outfile ./dist/index.js --target bun && bun build ./index-node.ts --outfile ./dist/index-node.js --target node --external koffi",
     "test": "bun run examples/basic.ts"
   },
   "engines": {
@@ -43,8 +45,8 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./index.ts",
-      "default": "./index-node.ts"
+      "bun": "./dist/index.js",
+      "default": "./dist/index-node.js"
     },
     "./package.json": "./package.json"
   },