varfetch 0.1.0 → 0.2.0

package/README.md

@@ -31,6 +31,7 @@ const result = await fireRequest({ connector, request, variables: { date: '2026-
 
 - **Interpolation:** `{{name}}` in path, query values, header values, auth values and body. Missing variables become an empty string.
 - **JSON path:** `$`, `$.a.b`, `$.items[0].name`, `$['key']`. Own properties only.
+- **Binary:** `responseType: "binary"` (or `"image"`) returns the raw bytes as `body` (a Buffer) and the `contentType`, with the same guard, redirect and size limits; `mappings` are not applied.
 - **Mapping:** each mapping writes a string (or JSON text for objects and arrays) to a variable; `skipIfNull` (default true) leaves unresolved paths out.
 - **SSRF guard:** every URL, redirects included, is resolved and checked. Loopback, private, link-local, CGNAT, reserved and multicast addresses are blocked unless you allow them: `network: { allow: ['10.1.0.0/16', 'anno.internal:3000'], deny: ['*.blocked.example'] }`. `deny` wins over `allow`. The check happens before the connection and does not defend against DNS rebinding.
 - **Limits:** 10 s timeout and 5 MiB response by default (`timeoutMs`, `maxBytes`), at most 5 redirects, credentials and other connector headers are not forwarded to another origin.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "varfetch",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Fire configured HTTP requests with {{variable}} interpolation, an SSRF guard and JSON path mapping of the response onto named variables.",
   "type": "module",
   "main": "src/index.js",

package/src/fire.js

@@ -60,10 +60,14 @@ export async function fireRequest({ connector, request, variables = {}, network
       url = next;
     }
 
-    const text = await readLimited(response, maxBytes);
+    const bytes = await readLimited(response, maxBytes);
     if (!response.ok) return { ok: false, status: response.status, values: {}, error: `HTTP ${response.status}` };
 
     const contentType = response.headers.get('content-type') || '';
+    if (request.responseType === 'binary' || request.responseType === 'image') {
+      return { ok: true, status: response.status, values: {}, body: bytes, contentType };
+    }
+    const text = bytes.toString('utf8');
     const wantsJson = request.responseType === 'json' || ((request.responseType ?? 'auto') === 'auto' && /json/i.test(contentType));
     let parsed = text;
     if (wantsJson) {
@@ -83,7 +87,7 @@ export async function fireRequest({ connector, request, variables = {}, network
 async function readLimited(response, maxBytes) {
   const declared = Number(response.headers.get('content-length'));
   if (declared > maxBytes) throw new Error(`Response larger than ${maxBytes} bytes`);
-  if (!response.body) return '';
+  if (!response.body) return Buffer.alloc(0);
   const reader = response.body.getReader();
   const chunks = [];
   let size = 0;
@@ -97,5 +101,5 @@ async function readLimited(response, maxBytes) {
     }
     chunks.push(value);
   }
-  return Buffer.concat(chunks).toString('utf8');
+  return Buffer.concat(chunks);
 }

package/src/index.d.ts

@@ -31,7 +31,8 @@ export interface RequestDef {
   query?: Pair[];
   bodyType?: 'none' | 'json' | 'text';
   body?: string;
-  responseType?: 'auto' | 'json' | 'text';
+  /** `binary` and `image` return the raw bytes as `body` (a Buffer) and skip `mappings`. */
+  responseType?: 'auto' | 'json' | 'text' | 'binary' | 'image';
   mappings?: Mapping[];
   timeoutMs?: number;
 }
@@ -43,8 +44,10 @@ export interface FireResult {
   status?: number;
   /** Variable name to value; non-string values are JSON text. */
   values: Record<string, string | null>;
-  /** Parsed JSON, or the text for a non-JSON response. */
+  /** Parsed JSON, the text for a non-JSON response, or a Buffer for a `binary`/`image` request. */
   body?: unknown;
+  /** Response content-type, set for a `binary`/`image` request. */
+  contentType?: string;
   error?: string;
 }