scrapely 1.2.9 → 1.2.10

package/dist/charging.d.ts

@@ -122,6 +122,8 @@ export declare class ChargingManager {
     private getEventPricing;
     private normalizeChargingEventName;
     private calculateMaxChargesByPrice;
+    /** @internal Remaining allowance per event (pushDataAndCharge's uncertain path). */
+    _chargeableWithinLimit(): Record<string, number>;
     private getChargeableWithinLimit;
     private quarantineStalePending;
     /**
@@ -137,7 +139,14 @@ export declare class ChargingManager {
      * (POST /v2/actor-runs/:runId/charge/void), then unwind the local
      * reservation. Returns true when the platform voided it.
      */
-    _voidCharge(eventName: string, operationId: string, reservedCount: number): Promise<boolean>;
+    /**
+     * @internal Cancel a charge whose outcome was never confirmed, for items that
+     * were then not stored: drop the pending intent (so the exit flush never
+     * posts it) and void it in case the original request did apply. A 404 here
+     * means it never applied.
+     */
+    _cancelUncertainCharge(eventName: string, operationId: string, reservedCount: number): Promise<boolean>;
+    _voidCharge(eventName: string, operationId: string, reservedCount: number, notFoundMeansVoided?: boolean): Promise<boolean>;
     /**
      * @internal Retry unconfirmed voids (caller holds the operation lock).
      * Returns false while any earlier void is still unconfirmed.

package/dist/charging.js

@@ -345,6 +345,10 @@ class ChargingManager {
         const roundedResult = Math.floor(Number(unroundedResult.toFixed(4)));
         return Math.max(0, roundedResult);
     }
+    /** @internal Remaining allowance per event (pushDataAndCharge's uncertain path). */
+    _chargeableWithinLimit() {
+        return this.chargingState === undefined ? {} : this.getChargeableWithinLimit();
+    }
     getChargeableWithinLimit() {
         if (Object.keys(this.pricingInfo).length === 0) {
             return {};
@@ -414,7 +418,17 @@ class ChargingManager {
      * (POST /v2/actor-runs/:runId/charge/void), then unwind the local
      * reservation. Returns true when the platform voided it.
      */
-    async _voidCharge(eventName, operationId, reservedCount) {
+    /**
+     * @internal Cancel a charge whose outcome was never confirmed, for items that
+     * were then not stored: drop the pending intent (so the exit flush never
+     * posts it) and void it in case the original request did apply. A 404 here
+     * means it never applied.
+     */
+    async _cancelUncertainCharge(eventName, operationId, reservedCount) {
+        this.pendingCharges.delete(operationId);
+        return this._voidCharge(eventName, operationId, reservedCount, true);
+    }
+    async _voidCharge(eventName, operationId, reservedCount, notFoundMeansVoided = false) {
         if (!this.isAtHome || !this.actorRunId)
             return false;
         const runClient = this.apifyClient.run(this.actorRunId);
@@ -431,6 +445,13 @@ class ChargingManager {
             }
             catch (err) {
                 const status = httpStatusOf(err);
+                // Only the void route's own answer proves it never applied; a server
+                // without the route (older deployment) also answers 404.
+                if (status === 404 && notFoundMeansVoided && apiErrorTypeOf(err) === 'charge-not-found') {
+                    // The unconfirmed charge never reached the ledger: nothing billed.
+                    this.applyAcceptedCount(eventName, reservedCount, 0);
+                    return true;
+                }
                 // 404: nothing to void; 409: already settled; 4xx auth: permanent.
                 // The charge stands; keep the local reservation that matches it.
                 if (status !== undefined && status >= 400 && status < 500)
@@ -440,7 +461,7 @@ class ChargingManager {
             }
         }
         // Outcome unknown: keep the reservation and retry before the next push / at exit.
-        this.pendingVoids.push({ eventName, operationId, reservedCount });
+        this.pendingVoids.push({ eventName, operationId, reservedCount, notFoundMeansVoided });
         console.error(`[Scrapely] Void of charge ${operationId} ('${eventName}') not confirmed yet; will retry`);
         return false;
     }
@@ -452,7 +473,7 @@ class ChargingManager {
         const pending = this.pendingVoids;
         this.pendingVoids = [];
         for (const v of pending) {
-            await this._voidCharge(v.eventName, v.operationId, v.reservedCount);
+            await this._voidCharge(v.eventName, v.operationId, v.reservedCount, v.notFoundMeansVoided);
         }
         return this.pendingVoids.length === 0;
     }
@@ -784,10 +805,30 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
             try {
                 for (const [name, chargeCount] of ordered) {
                     chargingManager._takeLastAcceptedOperationId?.();
-                    const r = await chargingManager._chargeExclusive({
-                        eventName: name,
-                        count: chargeCount,
-                    });
+                    let r;
+                    try {
+                        r = await chargingManager._chargeExclusive({
+                            eventName: name,
+                            count: chargeCount,
+                        });
+                    }
+                    catch (chargeErr) {
+                        if (!(chargeErr instanceof ChargeUncertainError))
+                            throw chargeErr;
+                        // The platform did not confirm the charge (5xx / timeouts after
+                        // retries). Never drop the items for that: the intent stays
+                        // pending with its idempotency key and is re-posted by the exit
+                        // flush, so the items are stored now and billed once.
+                        console.warn(`[Scrapely] Charge for '${name}' not confirmed yet (${chargeErr.operationId}); storing the items and retrying the charge later`);
+                        r = {
+                            eventChargeLimitReached: false,
+                            chargedCount: chargeErr.count,
+                            chargeableWithinLimit: chargingManager._chargeableWithinLimit?.() ?? {},
+                        };
+                        results.push(r);
+                        reservedInOp.push({ name, reserved: chargeErr.count, operationId: chargeErr.operationId, uncertain: true });
+                        continue;
+                    }
                     results.push(r);
                     reservedInOp.push({ name, reserved: r.chargedCount, operationId: chargingManager._takeLastAcceptedOperationId?.() });
                 }
@@ -814,7 +855,12 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
                 const [name] = ordered[i];
                 const reserved = results[i].chargedCount;
                 if (reserved > acceptedForItems) {
-                    chargingManager.applyAcceptedCount(name, reserved, acceptedForItems);
+                    // Nothing stored and a platform charge was made: leave its local
+                    // count to the void below, which releases it only once the
+                    // platform confirms (never on a server without the void route).
+                    const platformOp = acceptedForItems <= 0 && reservedInOp[i]?.operationId;
+                    if (!platformOp)
+                        chargingManager.applyAcceptedCount(name, reserved, acceptedForItems);
                     results[i] = {
                         ...results[i],
                         chargedCount: acceptedForItems,
@@ -824,6 +870,20 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
             }
             chargeResult = results.reduce(mergeChargeResults);
             if (acceptedForItems <= 0) {
+                // Nothing will be stored (another event of this push was capped to
+                // zero): undo every platform charge this operation made, so no
+                // result is billed for items that are never saved.
+                for (let i = 0; i < reservedInOp.length; i++) {
+                    const { name, operationId, uncertain, reserved } = reservedInOp[i];
+                    if (reserved <= 0 || !operationId)
+                        continue;
+                    // Original count: the local reservation is released only when
+                    // the platform confirms the void (or that it never applied).
+                    if (uncertain)
+                        await chargingManager._cancelUncertainCharge?.(name, operationId, reserved);
+                    else
+                        await chargingManager._voidCharge(name, operationId, reserved);
+                }
                 return {
                     eventChargeLimitReached: true,
                     chargedCount: chargeResult.chargedCount,
@@ -848,11 +908,15 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
                 if (!pushCertainlyFailed(pushErr))
                     throw pushErr;
                 for (let i = 0; i < reservedInOp.length; i++) {
-                    const { name, operationId } = reservedInOp[i];
+                    const { name, operationId, uncertain } = reservedInOp[i];
                     const reserved = results[i].chargedCount;
                     if (reserved <= 0)
                         continue;
-                    if (operationId) {
+                    if (operationId && uncertain) {
+                        // Never re-post a charge for items that were not stored.
+                        await chargingManager._cancelUncertainCharge?.(name, operationId, reserved);
+                    }
+                    else if (operationId) {
                         await chargingManager._voidCharge(name, operationId, reserved);
                     }
                     else if (isSyntheticEvent(name)) {
@@ -895,3 +959,9 @@ function pushCertainlyFailed(err) {
     }
     return false;
 }
+/** API error type (e.g. 'charge-not-found') of a client error, if the server sent one. */
+function apiErrorTypeOf(err) {
+    const e = err;
+    const t = e?.type ?? e?.data?.error?.type ?? e?.response?.data?.error?.type;
+    return typeof t === 'string' ? t : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "scrapely",
-    "version": "1.2.9",
+    "version": "1.2.10",
     "description": "Scrapely SDK for building JavaScript and TypeScript Actors",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",