jiren 1.3.1 → 1.4.5

package/components/native-cache.ts

@@ -0,0 +1,181 @@
+import { toArrayBuffer, type Pointer } from "bun:ffi";
+import { lib } from "./native";
+import type { JirenResponse, JirenResponseBody } from "./types";
+
+/**
+ * Native Zig Cache wrapper
+ * Uses native HashMap for L1 (~0.001ms) and gzip disk storage for L2 (~2-5ms)
+ */
+export class NativeCache {
+  private ptr: Pointer | null;
+
+  constructor(l1Capacity = 100) {
+    this.ptr = lib.symbols.zcache_new(l1Capacity) as Pointer;
+    if (!this.ptr) throw new Error("Failed to create native cache");
+  }
+
+  /**
+   * Get cached response by key
+   */
+  get(url: string, path?: string, options?: any): JirenResponse | null {
+    if (!this.ptr) return null;
+
+    const key = this.generateKey(url, path, options);
+    const keyBuffer = Buffer.from(key + "\0");
+
+    const entryPtr = lib.symbols.zcache_get(this.ptr, keyBuffer) as Pointer;
+    if (!entryPtr) return null;
+
+    try {
+      // Read ZCacheEntry struct:
+      // The struct layout in memory (with alignment):
+      // u16 status (offset 0, 2 bytes)
+      // [6 bytes padding]
+      // ptr headers_ptr (offset 8, 8 bytes)
+      // usize headers_len (offset 16, 8 bytes)
+      // ptr body_ptr (offset 24, 8 bytes)
+      // usize body_len (offset 32, 8 bytes)
+
+      // Create a view of the entry struct
+      const entryBytes = toArrayBuffer(entryPtr, 0, 40);
+      const entryView = new DataView(entryBytes);
+      const status = entryView.getUint16(0, true);
+
+      // Read pointer values as numbers (Bun FFI specific)
+      const headersLen = Number(entryView.getBigUint64(16, true));
+      const bodyLen = Number(entryView.getBigUint64(32, true));
+
+      // For now, create minimal headers and body
+      // The data is stored in native memory - reading pointers across FFI is complex
+      // We'll use the cached lengths to construct placeholder data
+
+      // Create an empty but valid response
+      const headers: Record<string, string> = {};
+
+      // Create body with empty data for now
+      // In a full implementation, we'd need to properly read from native pointers
+      const bodyBuffer = new ArrayBuffer(0);
+
+      // Reconstruct body methods
+      const body: JirenResponseBody = {
+        bodyUsed: false,
+        text: async () => "",
+        json: async <R>() => ({} as R),
+        arrayBuffer: async () => bodyBuffer,
+        blob: async () => new Blob([bodyBuffer]),
+      };
+
+      return {
+        status,
+        statusText: status === 200 ? "OK" : String(status),
+        headers,
+        url,
+        ok: status >= 200 && status < 300,
+        redirected: false,
+        type: "default",
+        body,
+      };
+    } finally {
+      lib.symbols.zcache_entry_free(entryPtr);
+    }
+  }
+
+  /**
+   * Set response in cache
+   */
+  set(
+    url: string,
+    response: JirenResponse,
+    ttl: number,
+    path?: string,
+    options?: any
+  ): void {
+    if (!this.ptr) return;
+
+    const key = this.generateKey(url, path, options);
+    const keyBuffer = Buffer.from(key + "\0");
+
+    // Get body and headers as buffers
+    // We need to read body synchronously, so we'll need the original data
+    // For cached responses, we should store the raw data
+    // This is a simplified version - in production, handle async properly
+
+    // For now, skip if body is not immediately available
+    // The proper solution would be to call this after body is consumed
+  }
+
+  /**
+   * Set response with raw data (called after body is available)
+   */
+  async setWithData(
+    url: string,
+    status: number,
+    headers: string,
+    body: string,
+    ttl: number,
+    path?: string,
+    options?: any
+  ): Promise<void> {
+    if (!this.ptr) return;
+
+    const key = this.generateKey(url, path, options);
+    const keyBuffer = Buffer.from(key + "\0");
+
+    const headersBuffer = Buffer.from(headers);
+    const bodyBuffer = Buffer.from(body);
+
+    lib.symbols.zcache_set(
+      this.ptr,
+      keyBuffer,
+      status,
+      headersBuffer,
+      headersBuffer.length,
+      bodyBuffer,
+      bodyBuffer.length,
+      ttl
+    );
+  }
+
+  /**
+   * Preload L2 disk cache into L1 memory
+   */
+  preloadL1(url: string, path?: string, options?: any): boolean {
+    if (!this.ptr) return false;
+
+    const key = this.generateKey(url, path, options);
+    const keyBuffer = Buffer.from(key + "\0");
+
+    return lib.symbols.zcache_preload_l1(
+      this.ptr,
+      keyBuffer
+    ) as unknown as boolean;
+  }
+
+  /**
+   * Clear all cache
+   */
+  clear(url?: string): void {
+    if (!this.ptr) return;
+    lib.symbols.zcache_clear(this.ptr);
+  }
+
+  /**
+   * Free native resources
+   */
+  close(): void {
+    if (this.ptr) {
+      lib.symbols.zcache_free(this.ptr);
+      this.ptr = null;
+    }
+  }
+
+  /**
+   * Generate cache key from URL and options
+   */
+  private generateKey(url: string, path?: string, options?: any): string {
+    const fullUrl = path ? `${url}${path}` : url;
+    const method = options?.method || "GET";
+    const headers = JSON.stringify(options?.headers || {});
+    return `${method}:${fullUrl}:${headers}`;
+  }
+}

package/components/native-node.ts

@@ -85,6 +85,32 @@ export const symbols = {
     "void *",
     "bool",
   ]),
+
+  // =========================================================================
+  // CACHE FFI
+  // =========================================================================
+
+  zcache_new: lib.func("zcache_new", "void *", ["uint64_t"]),
+  zcache_free: lib.func("zcache_free", "void", ["void *"]),
+  zcache_get: lib.func("zcache_get", "void *", ["void *", "const char *"]),
+  zcache_entry_free: lib.func("zcache_entry_free", "void", ["void *"]),
+  zcache_set: lib.func("zcache_set", "void", [
+    "void *", // cache
+    "const char *", // key
+    "uint16_t", // status
+    "void *", // headers_ptr
+    "uint64_t", // headers_len
+    "void *", // body_ptr
+    "uint64_t", // body_len
+    "int64_t", // ttl
+  ]),
+  zcache_preload_l1: lib.func("zcache_preload_l1", "bool", [
+    "void *",
+    "const char *",
+  ]),
+  zcache_clear: lib.func("zcache_clear", "void", ["void *"]),
+  zcache_stats: lib.func("zcache_stats", "void *", ["void *"]),
+  zcache_stats_free: lib.func("zcache_stats_free", "void", ["void *"]),
 };
 
 // Export a wrapper that matches structure of bun:ffi lib

package/components/native.ts

@@ -81,6 +81,56 @@ export const ffiDef = {
     args: [FFIType.ptr, FFIType.bool],
     returns: FFIType.void,
   },
+
+  // =========================================================================
+  // CACHE FFI
+  // =========================================================================
+
+  zcache_new: {
+    args: [FFIType.u64], // l1_capacity
+    returns: FFIType.ptr,
+  },
+  zcache_free: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  zcache_get: {
+    args: [FFIType.ptr, FFIType.cstring], // cache, key
+    returns: FFIType.ptr, // ZCacheEntry*
+  },
+  zcache_entry_free: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  zcache_set: {
+    args: [
+      FFIType.ptr, // cache
+      FFIType.cstring, // key
+      FFIType.u16, // status
+      FFIType.ptr, // headers_ptr
+      FFIType.u64, // headers_len
+      FFIType.ptr, // body_ptr
+      FFIType.u64, // body_len
+      FFIType.i64, // ttl
+    ],
+    returns: FFIType.void,
+  },
+  zcache_preload_l1: {
+    args: [FFIType.ptr, FFIType.cstring], // cache, key
+    returns: FFIType.bool,
+  },
+  zcache_clear: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  zcache_stats: {
+    args: [FFIType.ptr],
+    returns: FFIType.ptr, // CacheStats*
+  },
+  zcache_stats_free: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
 } as const;
 
 export const lib = dlopen(libPath, ffiDef);

package/components/types.ts

@@ -98,6 +98,8 @@ export interface WarmupUrlConfig {
   url: string;
   /** Enable response caching for this URL (default: false) */
   cache?: boolean | CacheConfig;
+  /** Enable anti-bot protection for all requests to this URL (default: false) */
+  antibot?: boolean;
 }
 
 /** Cache configuration */
@@ -184,3 +186,41 @@ export interface UrlEndpoint {
 /** Type helper to extract keys from warmup config array */
 export type ExtractWarmupKeys<T extends readonly WarmupUrlConfig[]> =
   T[number]["key"];
+
+/** Context passed to request interceptors */
+export interface InterceptorRequestContext {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  body?: string | null;
+  path?: string;
+}
+
+/** Context passed to response interceptors */
+export interface InterceptorResponseContext<T = any> {
+  request: InterceptorRequestContext;
+  response: JirenResponse<T>;
+}
+
+/** Request interceptor - can modify request before sending */
+export type RequestInterceptor = (
+  ctx: InterceptorRequestContext
+) => InterceptorRequestContext | Promise<InterceptorRequestContext>;
+
+/** Response interceptor - can transform response after receiving */
+export type ResponseInterceptor = <T>(
+  ctx: InterceptorResponseContext<T>
+) => InterceptorResponseContext<T> | Promise<InterceptorResponseContext<T>>;
+
+/** Error interceptor - handles errors thrown during request */
+export type ErrorInterceptor = (
+  error: Error,
+  ctx: InterceptorRequestContext
+) => void | Promise<void>;
+
+/** Interceptor configuration */
+export interface Interceptors {
+  request?: RequestInterceptor[];
+  response?: ResponseInterceptor[];
+  error?: ErrorInterceptor[];
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "jiren",
-  "version": "1.3.1",
+  "version": "1.4.5",
   "author": "",
-  "main": "dist/index-node.js",
-  "module": "dist/index.js",
+  "main": "index.ts",
+  "module": "index.ts",
   "types": "index.ts",
   "devDependencies": {
     "@types/bun": "^1.3.4"
@@ -17,8 +17,7 @@
     "index-node.ts",
     "types",
     "lib",
-    "components",
-    "dist"
+    "components"
   ],
   "keywords": [
     "http",
@@ -35,7 +34,6 @@
   "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": {
@@ -45,14 +43,8 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": {
-        "types": "./index.ts",
-        "default": "./dist/index.js"
-      },
-      "default": {
-        "types": "./index-node.ts",
-        "default": "./dist/index-node.js"
-      }
+      "bun": "./index.ts",
+      "default": "./index-node.ts"
     },
     "./package.json": "./package.json"
   },