@crawlee/core 4.0.0-beta.105 → 4.0.0-beta.106

package/storages/storage_instance_manager.d.ts

@@ -19,8 +19,7 @@ type Hashable = string;
  * assigns a reserved default alias.
  */
 export declare class StorageInstanceManager {
-    private readonly cache;
-    private readonly openerLocks;
+    #private;
     /**
      * Open (or retrieve from cache) a storage instance.
      *

package/storages/storage_instance_manager.js

@@ -120,8 +120,8 @@ class StorageCache {
  * assigns a reserved default alias.
  */
 export class StorageInstanceManager {
-    cache = new StorageCache();
-    openerLocks = new Map();
+    #cache = new StorageCache();
+    #openerLocks = new Map();
     /**
      * Open (or retrieve from cache) a storage instance.
      *
@@ -142,46 +142,46 @@ export class StorageInstanceManager {
         }
         // Fast-path cache check (no lock).
         if (alias !== undefined) {
-            const cached = this.cache.get(cls, { alias, backendCacheKey });
+            const cached = this.#cache.get(cls, { alias, backendCacheKey });
             if (cached)
                 return cached;
         }
         else if (id) {
-            const cached = this.cache.get(cls, { id, backendCacheKey });
+            const cached = this.#cache.get(cls, { id, backendCacheKey });
             if (cached)
                 return cached;
         }
         else if (name) {
-            const cached = this.cache.get(cls, { name, backendCacheKey });
+            const cached = this.#cache.get(cls, { name, backendCacheKey });
             if (cached)
                 return cached;
         }
         const identifierKey = id ?? name ?? alias ?? DEFAULT_STORAGE_ALIAS;
         const lockKey = `${cls.name}:${identifierKey}:${backendCacheKey}`;
-        if (!this.openerLocks.has(lockKey)) {
-            this.openerLocks.set(lockKey, new AsyncQueue());
+        if (!this.#openerLocks.has(lockKey)) {
+            this.#openerLocks.set(lockKey, new AsyncQueue());
         }
-        const queue = this.openerLocks.get(lockKey);
+        const queue = this.#openerLocks.get(lockKey);
         await queue.wait();
         try {
             // Double-check cache under lock (another caller may have filled it while we waited).
             if (alias !== undefined) {
-                const cached = this.cache.get(cls, { alias, backendCacheKey });
+                const cached = this.#cache.get(cls, { alias, backendCacheKey });
                 if (cached)
                     return cached;
             }
             else if (id) {
-                const cached = this.cache.get(cls, { id, backendCacheKey });
+                const cached = this.#cache.get(cls, { id, backendCacheKey });
                 if (cached)
                     return cached;
             }
             else if (name) {
-                const cached = this.cache.get(cls, { name, backendCacheKey });
+                const cached = this.#cache.get(cls, { name, backendCacheKey });
                 if (cached)
                     return cached;
             }
             // Prevent the same string from being used as both a name and an alias.
-            this.cache.checkNameAliasConflict(cls, { name, alias, backendCacheKey });
+            this.#cache.checkNameAliasConflict(cls, { name, alias, backendCacheKey });
             // Cache miss — create the sub-backend and storage instance.
             const subBackend = await backendOpener();
             const storageInfo = await subBackend.getMetadata();
@@ -189,7 +189,7 @@ export class StorageInstanceManager {
             // we just fetched (so `id`/`name` etc. are available synchronously) along with the backend.
             const instance = new cls({ metadata: storageInfo, backend: subBackend });
             // Atomic cache writes (no awaits between these).
-            this.cache.set(cls, instance, backendCacheKey, alias);
+            this.#cache.set(cls, instance, backendCacheKey, alias);
             return instance;
         }
         finally {
@@ -197,7 +197,7 @@ export class StorageInstanceManager {
             // Clean up idle locks so the map doesn't grow unboundedly
             // (mirrors crawlee-python's WeakValueDictionary behaviour).
             if (queue.remaining === 0) {
-                this.openerLocks.delete(lockKey);
+                this.#openerLocks.delete(lockKey);
             }
         }
     }
@@ -205,7 +205,7 @@ export class StorageInstanceManager {
      * Remove a storage instance from the cache (called from `storage.drop()`).
      */
     removeFromCache(instance) {
-        this.cache.removeFromCache(instance);
+        this.#cache.removeFromCache(instance);
     }
     /**
      * Clear the entire cache. Also calls `clearCache()` on any cached KeyValueStore
@@ -213,12 +213,12 @@ export class StorageInstanceManager {
      * Called during service locator reset.
      */
     clearCache() {
-        for (const instance of this.cache.allValues()) {
+        for (const instance of this.#cache.allValues()) {
             if ('clearCache' in instance && typeof instance.clearCache === 'function') {
                 instance.clearCache();
             }
         }
-        this.cache.clear();
+        this.#cache.clear();
     }
 }
 /**

package/storages/storage_stats.d.ts

@@ -39,7 +39,7 @@ export interface RequestQueueStats {
  * the buckets that make sense for it.
  */
 export declare class StorageStatsTracker<T extends Record<keyof T, number>> {
-    private readonly counters;
+    #private;
     constructor(initial: T);
     /** Increment a counter bucket by `by` (default `1`). */
     add(key: keyof T, by?: number): void;

package/storages/storage_stats.js

@@ -14,16 +14,16 @@
  * the buckets that make sense for it.
  */
 export class StorageStatsTracker {
-    counters;
+    #counters;
     constructor(initial) {
-        this.counters = { ...initial };
+        this.#counters = { ...initial };
     }
     /** Increment a counter bucket by `by` (default `1`). */
     add(key, by = 1) {
-        this.counters[key] += by;
+        this.#counters[key] += by;
     }
     /** Return a snapshot of the current counters. The returned object is a copy and safe to keep. */
     get current() {
-        return { ...this.counters };
+        return { ...this.#counters };
     }
 }

package/storages/transaction.d.ts

@@ -142,13 +142,11 @@ export interface StorageTransactionOptions {
  * handler unless `transactionalStorage: false` is set.
  */
 export declare class StorageTransaction implements StorageTransactionView {
+    #private;
     /** The ordered, append-only journal — the source of truth for commit, introspection and reads. */
     readonly journal: JournalEntry[];
     /** Per-storage-type write policy. */
     readonly policy: StorageWritePolicy;
-    private readonly commitTimeoutMillis;
-    private _state;
-    private disposed;
     /** @internal */
     constructor(options?: StorageTransactionOptions);
     get state(): StorageTransactionState;

package/storages/transaction.js

@@ -21,23 +21,23 @@ export class StorageTransaction {
     journal = [];
     /** Per-storage-type write policy. */
     policy;
-    commitTimeoutMillis;
-    _state = 'open';
-    disposed = false;
+    #commitTimeoutMillis;
+    #state = 'open';
+    #disposed = false;
     /** @internal */
     constructor(options = {}) {
         this.policy = { ...DEFAULT_STORAGE_WRITE_POLICY, ...options.policy };
-        this.commitTimeoutMillis = options.commitTimeoutMillis ?? DEFAULT_COMMIT_TIMEOUT_MILLIS;
+        this.#commitTimeoutMillis = options.commitTimeoutMillis ?? DEFAULT_COMMIT_TIMEOUT_MILLIS;
     }
     get state() {
-        return this._state;
+        return this.#state;
     }
     /**
      * `true` only while `state === 'open'`. This is the single predicate every storage operation
      * consults — operations performed after the transaction is closed pass through to the real backend.
      */
     get isActive() {
-        return this._state === 'open';
+        return this.#state === 'open';
     }
     /** Runs `callback` with this transaction installed in the async context. */
     async run(callback) {
@@ -49,7 +49,7 @@ export class StorageTransaction {
      */
     recordJournalEntry(entry) {
         if (!this.isActive) {
-            throw new Error(`Cannot record a journal entry on a transaction in the '${this._state}' state`);
+            throw new Error(`Cannot record a journal entry on a transaction in the '${this.#state}' state`);
         }
         this.journal.push(entry);
     }
@@ -62,20 +62,20 @@ export class StorageTransaction {
      * partway may have applied some of the writes already.
      */
     async commit() {
-        if (this._state !== 'open') {
+        if (this.#state !== 'open') {
             return;
         }
-        this._state = 'committing';
+        this.#state = 'committing';
         try {
             // The replay re-drives the frontend write path, which checks for cancellation (`tryCancel`)
             // on every operation - and `@apify/timeout` shares one `AbortController` across nested
             // frames, so a request-handler timeout that already fired would abort the commit of a
             // handler that succeeded. Hence a fresh timeout context, which also provides the time bound.
-            await timeoutStorage.exit(async () => addTimeoutToPromise(async () => this.flush(), this.commitTimeoutMillis, `Committing the storage transaction timed out after ${this.commitTimeoutMillis / 1000} seconds.`));
-            this._state = 'committed';
+            await timeoutStorage.exit(async () => addTimeoutToPromise(async () => this.flush(), this.#commitTimeoutMillis, `Committing the storage transaction timed out after ${this.#commitTimeoutMillis / 1000} seconds.`));
+            this.#state = 'committed';
         }
         catch (error) {
-            this._state = 'failed';
+            this.#state = 'failed';
             throw error;
         }
     }
@@ -106,10 +106,10 @@ export class StorageTransaction {
      * and never throws.
      */
     rollback() {
-        if (this._state !== 'open') {
+        if (this.#state !== 'open') {
             return;
         }
-        this._state = 'rolledBack';
+        this.#state = 'rolledBack';
     }
     /**
      * Releases the journal and the write-time snapshots it holds. Must be called for *every* terminal
@@ -117,10 +117,10 @@ export class StorageTransaction {
      * {@link StorageTransactionView} of this transaction is only valid until this is called.
      */
     dispose() {
-        if (this.disposed) {
+        if (this.#disposed) {
             return;
         }
-        if (this._state === 'open') {
+        if (this.#state === 'open') {
             // Disposing an open transaction is an internal invariant violation - roll back first.
             try {
                 serviceLocator
@@ -132,7 +132,7 @@ export class StorageTransaction {
             }
             this.rollback();
         }
-        this.disposed = true;
+        this.#disposed = true;
         this.journal.length = 0;
     }
     get datasetItems() {

package/system-info/runtime.js

@@ -50,31 +50,31 @@ export async function isContainerized() {
 export function isLambda() {
     return !!process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE;
 }
-let _cgroupsVersion;
+let cgroupsVersion;
 /**
  * gets the cgroup version by checking for a file at /sys/fs/cgroup/memory
  * @returns "V1" or "V2" for the version of cgroup or null if cgroup is not found.
  */
 export async function getCgroupsVersion(forceReset) {
     // Parameter forceReset is just internal for unit tests.
-    if (_cgroupsVersion !== undefined && !forceReset) {
-        return _cgroupsVersion;
+    if (cgroupsVersion !== undefined && !forceReset) {
+        return cgroupsVersion;
     }
     try {
         // If this directory does not exists, cgroups are not available
         await fs.access('/sys/fs/cgroup/');
     }
     catch (e) {
-        _cgroupsVersion = null;
+        cgroupsVersion = null;
         return null;
     }
-    _cgroupsVersion = 'V1';
+    cgroupsVersion = 'V1';
     try {
         // If this directory does not exists, assume the container is using cgroups V2
         await fs.access('/sys/fs/cgroup/memory/');
     }
     catch (e) {
-        _cgroupsVersion = 'V2';
+        cgroupsVersion = 'V2';
     }
-    return _cgroupsVersion;
+    return cgroupsVersion;
 }