scrapely 1.2.12 → 1.2.13

package/dist/actor.js

@@ -18,6 +18,7 @@ var ACTOR_PERMISSION_LEVEL;
 })(ACTOR_PERMISSION_LEVEL || (exports.ACTOR_PERMISSION_LEVEL = ACTOR_PERMISSION_LEVEL = {}));
 const core_1 = require("@crawlee/core");
 const configuration_js_1 = require("./configuration.js");
+const proxy_input_aliases_js_1 = require("./proxy-input-aliases.js");
 const patch_storage_js_1 = require("./storage/patch-storage.js");
 const api_storage_client_js_1 = require("./storage/api-storage-client.js");
 const events_client_js_1 = require("./events/events-client.js");
@@ -417,7 +418,7 @@ class Actor {
                     // Same treatment as the regular input: decrypt secret fields
                     // and let the synchronous Actor.input getter return it.
                     if (typeof metamorphInput === 'object' && !Array.isArray(metamorphInput)) {
-                        const decrypted = (0, secrets_js_1.decryptSecretInputs)(metamorphInput);
+                        const decrypted = (0, proxy_input_aliases_js_1.withProxyKeyAliases)((0, secrets_js_1.decryptSecretInputs)(metamorphInput));
                         cachedInput = decrypted;
                         return decrypted;
                     }
@@ -448,7 +449,8 @@ class Actor {
         // Decrypt secret inputs after loading (must happen here, not in init(),
         // because the input needs to be available first)
         if (input && typeof input === 'object' && !Array.isArray(input)) {
-            const decrypted = (0, secrets_js_1.decryptSecretInputs)(input);
+            // Proxy objects carry both namings (scrapelyProxy* and apifyProxy*).
+            const decrypted = (0, proxy_input_aliases_js_1.withProxyKeyAliases)((0, secrets_js_1.decryptSecretInputs)(input));
             // Large inputs are only in the INPUT record (no ACTOR_INPUT env):
             // let the synchronous Actor.input getter return what was loaded here.
             cachedInput = decrypted;
@@ -494,7 +496,7 @@ class Actor {
         }
         // Decrypt secret inputs after loading
         if (cachedInput && typeof cachedInput === 'object' && !Array.isArray(cachedInput)) {
-            cachedInput = (0, secrets_js_1.decryptSecretInputs)(cachedInput);
+            cachedInput = (0, proxy_input_aliases_js_1.withProxyKeyAliases)((0, secrets_js_1.decryptSecretInputs)(cachedInput));
         }
         return cachedInput ?? undefined;
     }

package/dist/proxy-input-aliases.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Proxy input objects with both namings. An input-schema proxy field may be
+ * written with the Scrapely names (`useScrapelyProxy`, `scrapelyProxyGroups`,
+ * `scrapelyProxyCountry`, `scrapelyProxySubdivision`) or the Apify names
+ * (`useApifyProxy`, `apifyProxy*`). Actor.getInput() and Actor.input return
+ * every set option under both names, so actor code that reads either naming
+ * sees the user's choice.
+ *
+ * Precedence matches createProxyConfiguration(): a boolean `useScrapelyProxy`
+ * wins over `useApifyProxy`, and a set `scrapelyProxy*` value wins over its
+ * `apifyProxy*` counterpart. Nothing is removed: keys with unset or
+ * non-boolean values stay as sent.
+ */
+/** `input` with every top-level proxy object under both namings; `input` itself when nothing changes. Never mutates. */
+export declare function withProxyKeyAliases<T>(input: T): T;

package/dist/proxy-input-aliases.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Proxy input objects with both namings. An input-schema proxy field may be
+ * written with the Scrapely names (`useScrapelyProxy`, `scrapelyProxyGroups`,
+ * `scrapelyProxyCountry`, `scrapelyProxySubdivision`) or the Apify names
+ * (`useApifyProxy`, `apifyProxy*`). Actor.getInput() and Actor.input return
+ * every set option under both names, so actor code that reads either naming
+ * sees the user's choice.
+ *
+ * Precedence matches createProxyConfiguration(): a boolean `useScrapelyProxy`
+ * wins over `useApifyProxy`, and a set `scrapelyProxy*` value wins over its
+ * `apifyProxy*` counterpart. Nothing is removed: keys with unset or
+ * non-boolean values stay as sent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withProxyKeyAliases = withProxyKeyAliases;
+const OPTION_NAMES = ['Groups', 'Country', 'Subdivision'];
+const SWITCH_KEYS = ['useScrapelyProxy', 'useApifyProxy'];
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function isSet(value) {
+    return value !== undefined && value !== null;
+}
+function isProxyObject(value) {
+    return SWITCH_KEYS.some((k) => Object.hasOwn(value, k))
+        || OPTION_NAMES.some((n) => Object.hasOwn(value, `scrapelyProxy${n}`) || Object.hasOwn(value, `apifyProxy${n}`));
+}
+function aliasProxyObject(value) {
+    const result = { ...value };
+    const use = SWITCH_KEYS.map((k) => value[k]).find((v) => typeof v === 'boolean');
+    if (use !== undefined) {
+        for (const k of SWITCH_KEYS)
+            result[k] = use;
+    }
+    for (const name of OPTION_NAMES) {
+        const scrapely = `scrapelyProxy${name}`;
+        const apify = `apifyProxy${name}`;
+        const option = isSet(value[scrapely]) ? value[scrapely] : value[apify];
+        if (isSet(option)) {
+            result[scrapely] = option;
+            result[apify] = option;
+        }
+    }
+    return result;
+}
+function sameObject(a, b) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((k) => Object.hasOwn(b, k) && a[k] === b[k]);
+}
+/** `input` with every top-level proxy object under both namings; `input` itself when nothing changes. Never mutates. */
+function withProxyKeyAliases(input) {
+    if (!isPlainObject(input))
+        return input;
+    let result;
+    for (const [key, value] of Object.entries(input)) {
+        if (!isPlainObject(value) || !isProxyObject(value))
+            continue;
+        const aliased = aliasProxyObject(value);
+        if (sameObject(aliased, value))
+            continue;
+        result ??= { ...input };
+        result[key] = aliased;
+    }
+    return (result ?? input);
+}

package/dist/storage/api-storage-client.js

@@ -313,7 +313,10 @@ class BaseApiClient {
                 const response = await fetch(url, {
                     method,
                     headers,
-                    body: body !== undefined ? (typeof body === 'string' ? body : JSON.stringify(body)) : undefined,
+                    // Binary bodies (KV records) go out as the raw bytes, never JSON/base64.
+                    body: body === undefined ? undefined
+                        : typeof body === 'string' || body instanceof Uint8Array ? body
+                            : JSON.stringify(body),
                     signal: controller.signal,
                 });
                 // Update rate limiter state from response headers
@@ -429,14 +432,15 @@ class BaseApiClient {
                 return { data: undefined, contentType: '' };
             }
             const responseContentType = response.headers.get('content-type') || 'application/json';
-            if (responseContentType.includes('text/plain')) {
-                return { data: await response.text(), contentType: 'text/plain' };
+            const mime = responseContentType.split(';')[0].trim().toLowerCase() || 'application/json';
+            if (mime === 'application/json' || mime.endsWith('+json')) {
+                return { data: await response.json(), contentType: mime };
             }
-            if (responseContentType.includes('application/octet-stream')) {
-                return { data: Buffer.from(await response.arrayBuffer()), contentType: 'application/octet-stream' };
+            if (mime.startsWith('text/')) {
+                return { data: await response.text(), contentType: mime };
             }
-            const json = await response.json();
-            return { data: json, contentType: responseContentType.split(';')[0].trim() || 'application/json' };
+            // Any other content type (video/mp4, image/png, application/zip, ...) is binary.
+            return { data: Buffer.from(await response.arrayBuffer()), contentType: mime };
         });
     }
 }
@@ -632,12 +636,16 @@ class ApiKeyValueStoreClient extends BaseApiClient {
             for await (const chunk of value) {
                 chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
             }
-            const buffered = Buffer.concat(chunks);
-            body = buffered.toString('base64');
+            body = Buffer.concat(chunks);
+            ct = 'application/octet-stream';
+        }
+        else if (value instanceof Uint8Array) {
+            // Raw bytes, as Apify stores them; the API returns them unchanged on GET.
+            body = value;
             ct = 'application/octet-stream';
         }
-        else if (Buffer.isBuffer(value)) {
-            body = value.toString('base64');
+        else if (value instanceof ArrayBuffer) {
+            body = Buffer.from(value);
             ct = 'application/octet-stream';
         }
         else if (typeof value === 'string') {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "scrapely",
-    "version": "1.2.12",
+    "version": "1.2.13",
     "description": "Scrapely SDK for building JavaScript and TypeScript Actors",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -38,7 +38,9 @@
         "test:run-control": "npx tsx --test tests/run-control.test.ts",
         "test:rq-list": "npx tsx --test tests/rq-list-requests.test.ts",
         "test:terminal-status": "npx tsx --test tests/terminal-status-message.test.ts",
-        "test:cdp-retry": "npx tsx --test tests/cdp-retry.test.ts"
+        "test:cdp-retry": "npx tsx --test tests/cdp-retry.test.ts",
+        "test:proxy-input-aliases": "npx tsx --test tests/proxy-input-aliases.test.ts",
+        "test:charge-retries": "npx tsx --test tests/charge-retries.test.ts"
     },
     "author": "SandeepDev1",
     "license": "ISC",