scrapely 1.2.20 → 1.2.21

package/dist/charging.d.ts

@@ -77,6 +77,15 @@ export declare class ChargingManager {
     private chargeLimitHit;
     /** Default-dataset rows refused after the limit (one warning, then a count). */
     private refusedDefaultDatasetItems;
+    /**
+     * Prepaid-row balance: priced events charged through charge() minus rows
+     * pushed to the default dataset without a per-row charge. An Actor that
+     * charges first and then pushes plainly (charge('product'); pushData(row))
+     * has a positive balance after the charge, so the row it already paid for is
+     * still saved when that charge used up the spending limit. Push-then-charge
+     * Actors never go positive, so they get nothing extra for free.
+     */
+    private prepaidRowBalance;
     /** @internal Called by Actor shutdown before the final flush. */
     close(): void;
     /**
@@ -98,6 +107,18 @@ export declare class ChargingManager {
     /** @internal Whether every row of a push with these events is charged a positive price. */
     _isPaidPerItem(eventName: string | undefined, isDefaultDataset: boolean): boolean;
     /** @internal */
+    _notePrepaidCharge(eventName: string, chargedCount: number): void;
+    /** @internal */
+    _isPayPerEvent(): boolean;
+    /** @internal Current prepaid-row balance (tests). */
+    _prepaidRowBalance(): number;
+    /**
+     * @internal Account for rows pushed without a per-row charge. Returns how
+     * many may be stored: all while the limit is not reached, afterwards only
+     * the rows earlier charges already paid for (the positive balance).
+     */
+    _takeUnpaidRows(itemCount: number): number;
+    /** @internal */
     _refuseDefaultDatasetPush(itemCount: number): boolean;
     /** @internal Whether shutdown has closed this manager to new charges. */
     isClosed(): boolean;

package/dist/charging.js

@@ -154,6 +154,15 @@ class ChargingManager {
     chargeLimitHit = false;
     /** Default-dataset rows refused after the limit (one warning, then a count). */
     refusedDefaultDatasetItems = 0;
+    /**
+     * Prepaid-row balance: priced events charged through charge() minus rows
+     * pushed to the default dataset without a per-row charge. An Actor that
+     * charges first and then pushes plainly (charge('product'); pushData(row))
+     * has a positive balance after the charge, so the row it already paid for is
+     * still saved when that charge used up the spending limit. Push-then-charge
+     * Actors never go positive, so they get nothing extra for free.
+     */
+    prepaidRowBalance = 0;
     /** @internal Called by Actor shutdown before the final flush. */
     close() {
         this._closed = true;
@@ -216,9 +225,49 @@ class ChargingManager {
         return names.some((name) => (this.calculateEventPrice(name) ?? 0) > 0);
     }
     /** @internal */
+    _notePrepaidCharge(eventName, chargedCount) {
+        if (chargedCount > 0 && !isSyntheticEvent(eventName) && (this.pricingInfo[eventName]?.price ?? 0) > 0) {
+            this.prepaidRowBalance += chargedCount;
+        }
+    }
+    /** @internal */
+    _isPayPerEvent() {
+        return this.chargingState !== undefined && this.isPayPerEvent;
+    }
+    /** @internal Current prepaid-row balance (tests). */
+    _prepaidRowBalance() {
+        return this.prepaidRowBalance;
+    }
+    /**
+     * @internal Account for rows pushed without a per-row charge. Returns how
+     * many may be stored: all while the limit is not reached, afterwards only
+     * the rows earlier charges already paid for (the positive balance).
+     */
+    _takeUnpaidRows(itemCount) {
+        if (itemCount <= 0)
+            return 0;
+        if (!this.isChargeLimitReached()) {
+            this.prepaidRowBalance -= itemCount;
+            return itemCount;
+        }
+        const allowed = Math.max(0, Math.min(itemCount, this.prepaidRowBalance));
+        this.prepaidRowBalance -= allowed;
+        return allowed;
+    }
+    /** @internal */
     _refuseDefaultDatasetPush(itemCount) {
-        if (itemCount <= 0 || !this.isChargeLimitReached())
+        if (itemCount <= 0 || !this.isPayPerEvent)
+            return false;
+        if (!this.isChargeLimitReached()) {
+            this._takeUnpaidRows(itemCount);
             return false;
+        }
+        // All-or-nothing here (storage clients cannot store a slice): store the
+        // batch only when earlier charges paid for every row of it.
+        if (this.prepaidRowBalance >= itemCount) {
+            this.prepaidRowBalance -= itemCount;
+            return false;
+        }
         this._noteRefusedDefaultDatasetItems(itemCount);
         return true;
     }
@@ -771,7 +820,11 @@ class ChargingManager {
         }
     }
     async charge({ eventName, count = 1 }) {
-        return this._withOperationLock(() => this._chargeExclusive({ eventName, count }));
+        return this._withOperationLock(async () => {
+            const result = await this._chargeExclusive({ eventName, count });
+            this._notePrepaidCharge(eventName, result.chargedCount);
+            return result;
+        });
     }
     /** @internal Caller must hold the operation lock. */
     async _chargeExclusive({ eventName, count = 1 }) {
@@ -983,16 +1036,27 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
         // default-dataset push that does not pay per row (no event, or only free
         // events) stores nothing. Paid pushes go on below, where the budget cap
         // stores only the rows that are actually charged.
+        // Rows the Actor already paid for with an earlier charge() (charge first,
+        // then a plain push) are still stored: see ChargingManager._takeUnpaidRows.
+        // The result still reports the limit, so the Actor stops after them.
+        let unpaidPastLimit = false;
         if (isDefaultDataset &&
             requested > 0 &&
-            chargingManager.isChargeLimitReached?.() &&
+            chargingManager._isPayPerEvent() &&
             !chargingManager._isPaidPerItem(eventName, isDefaultDataset)) {
-            chargingManager._noteRefusedDefaultDatasetItems(requested);
-            return {
-                eventChargeLimitReached: true,
-                chargedCount: 0,
-                chargeableWithinLimit: chargingManager._chargeableWithinLimit?.() ?? {},
-            };
+            unpaidPastLimit = chargingManager.isChargeLimitReached?.() ?? false;
+            const allowed = chargingManager._takeUnpaidRows(requested);
+            if (allowed < requested) {
+                chargingManager._noteRefusedDefaultDatasetItems(requested - allowed);
+                if (allowed === 0) {
+                    return {
+                        eventChargeLimitReached: true,
+                        chargedCount: 0,
+                        chargeableWithinLimit: chargingManager._chargeableWithinLimit?.() ?? {},
+                    };
+                }
+                items = (Array.isArray(items) ? items.slice(0, allowed) : items);
+            }
         }
         const { limitedItems, eventsToCharge } = chargingManager.calculatePushDataLimits({
             items,
@@ -1161,12 +1225,12 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
                 }
                 throw pushErr;
             }
-            return chargeResult;
+            return unpaidPastLimit ? { ...chargeResult, eventChargeLimitReached: true } : chargeResult;
         }
         // No billable events — still persist the budget-limited items.
         await chargeGatedPush.run(true, () => pushFn(Array.isArray(items) ? limitedItems : limitedItems[0]));
         return {
-            eventChargeLimitReached: false,
+            eventChargeLimitReached: unpaidPastLimit,
             chargedCount: 0,
             chargeableWithinLimit: {},
         };

package/package.json

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