@heyputer/puter.js 2.0.14 → 2.0.16

package/src/modules/FileSystem/operations/readdir.js

@@ -1,6 +1,14 @@
 import * as utils from '../../../lib/utils.js';
 import getAbsolutePathForApp from '../utils/getAbsolutePathForApp.js';
 
+// Track in-flight requests to avoid duplicate backend calls
+// Each entry stores: { promise, timestamp }
+const inflightRequests = new Map();
+
+// Time window (in ms) to group duplicate requests together
+// Requests made within this window will share the same backend call
+const DEDUPLICATION_WINDOW_MS = 2000; // 2 seconds
+
 const readdir = async function (...args) {
     let options;
 
@@ -42,56 +50,108 @@ const readdir = async function (...args) {
             }
         }
 
-        // If auth token is not provided and we are in the web environment, 
-        // try to authenticate with Puter
-        if(!puter.authToken && puter.env === 'web'){
-            try{
-                await puter.ui.authenticateWithPuter();
-            }catch(e){
-                // if authentication fails, throw an error
-                reject('Authentication failed.');
+        // Generate deduplication key based on all request parameters
+        const deduplicationKey = JSON.stringify({
+            path: options.path,
+            uid: options.uid,
+            no_thumbs: options.no_thumbs,
+            no_assocs: options.no_assocs,
+            consistency: options.consistency,
+        });
+
+        // Check if there's already an in-flight request for the same parameters
+        const existingEntry = inflightRequests.get(deduplicationKey);
+        const now = Date.now();
+        
+        if (existingEntry) {
+            const timeSinceRequest = now - existingEntry.timestamp;
+            
+            // Only reuse the request if it's within the deduplication window
+            if (timeSinceRequest < DEDUPLICATION_WINDOW_MS) {
+                // Wait for the existing request and return its result
+                try {
+                    const result = await existingEntry.promise;
+                    resolve(result);
+                } catch (error) {
+                    reject(error);
+                }
+                return;
+            } else {
+                // Request is too old, remove it from the tracker
+                inflightRequests.delete(deduplicationKey);
             }
         }
 
-        // create xhr object
-        const xhr = utils.initXhr('/readdir', this.APIOrigin, undefined, "post", "text/plain;actually=json");
+        // Create a promise for this request and store it to deduplicate concurrent calls
+        const requestPromise = new Promise(async (resolveRequest, rejectRequest) => {
+            // If auth token is not provided and we are in the web environment, 
+            // try to authenticate with Puter
+            if(!puter.authToken && puter.env === 'web'){
+                try{
+                    await puter.ui.authenticateWithPuter();
+                }catch(e){
+                    // if authentication fails, throw an error
+                    rejectRequest('Authentication failed.');
+                    return;
+                }
+            }
 
-        // set up event handlers for load and error events
-        utils.setupXhrEventHandlers(xhr, options.success, options.error, async (result) => {
-            // Calculate the size of the result for cache eligibility check
-            const resultSize = JSON.stringify(result).length;
-            
-            // Cache the result if it's not bigger than MAX_CACHE_SIZE
-            const MAX_CACHE_SIZE = 100 * 1024 * 1024;
+            // create xhr object
+            const xhr = utils.initXhr('/readdir', this.APIOrigin, undefined, "post", "text/plain;actually=json");
 
-            if(resultSize <= MAX_CACHE_SIZE){
-                // UPSERT the cache
-                puter._cache.set(cacheKey, result);
-            }
+            // set up event handlers for load and error events
+            utils.setupXhrEventHandlers(xhr, options.success, options.error, async (result) => {
+                // Calculate the size of the result for cache eligibility check
+                const resultSize = JSON.stringify(result).length;
+                
+                // Cache the result if it's not bigger than MAX_CACHE_SIZE
+                const MAX_CACHE_SIZE = 100 * 1024 * 1024;
+
+                if(resultSize <= MAX_CACHE_SIZE){
+                    // UPSERT the cache
+                    puter._cache.set(cacheKey, result);
+                }
 
-            // set each individual item's cache
-            for(const item of result){
-                puter._cache.set('item:' + item.path, item);
+                // set each individual item's cache
+                for(const item of result){
+                    puter._cache.set('item:' + item.path, item);
+                }
+                
+                resolveRequest(result);
+            }, rejectRequest);
+
+            // Build request payload - support both path and uid parameters
+            const payload = {
+                no_thumbs: options.no_thumbs,
+                no_assocs: options.no_assocs,
+                auth_token: this.authToken
+            };
+
+            // Add either uid or path to the payload
+            if (options.uid) {
+                payload.uid = options.uid;
+            } else if (options.path) {
+                payload.path = getAbsolutePathForApp(options.path);
             }
-            
-            resolve(result);
-        }, reject);
 
-        // Build request payload - support both path and uid parameters
-        const payload = {
-            no_thumbs: options.no_thumbs,
-            no_assocs: options.no_assocs,
-            auth_token: this.authToken
-        };
+            xhr.send(JSON.stringify(payload));
+        });
 
-        // Add either uid or path to the payload
-        if (options.uid) {
-            payload.uid = options.uid;
-        } else if (options.path) {
-            payload.path = getAbsolutePathForApp(options.path);
-        }
+        // Store the promise and timestamp in the in-flight tracker
+        inflightRequests.set(deduplicationKey, {
+            promise: requestPromise,
+            timestamp: now,
+        });
 
-        xhr.send(JSON.stringify(payload));
+        // Wait for the request to complete and clean up
+        try {
+            const result = await requestPromise;
+            inflightRequests.delete(deduplicationKey);
+            resolve(result);
+        } catch (error) {
+            inflightRequests.delete(deduplicationKey);
+            reject(error);
+        }
     })
 }
 

package/src/modules/FileSystem/operations/stat.js

@@ -1,6 +1,14 @@
 import * as utils from '../../../lib/utils.js';
 import getAbsolutePathForApp from '../utils/getAbsolutePathForApp.js';
 
+// Track in-flight requests to avoid duplicate backend calls
+// Each entry stores: { promise, timestamp }
+const inflightRequests = new Map();
+
+// Time window (in ms) to group duplicate requests together
+// Requests made within this window will share the same backend call
+const DEDUPLICATION_WINDOW_MS = 2000; // 2 seconds
+
 const stat = async function (...args) {
     let options;
 
@@ -24,17 +32,6 @@ const stat = async function (...args) {
             options.consistency = 'strong';
         }
 
-        // If auth token is not provided and we are in the web environment, 
-        // try to authenticate with Puter
-        if(!puter.authToken && puter.env === 'web'){
-            try{
-                await puter.ui.authenticateWithPuter();
-            }catch(e){
-                // if authentication fails, throw an error
-                reject('Authentication failed.');
-            }
-        }
-
         // Generate cache key based on path or uid
         let cacheKey;
         if(options.path){
@@ -50,41 +47,106 @@ const stat = async function (...args) {
             }
         }
 
-        // create xhr object
-        const xhr = utils.initXhr('/stat', this.APIOrigin, undefined, "post", "text/plain;actually=json");
+        // Generate deduplication key based on all request parameters
+        const deduplicationKey = JSON.stringify({
+            path: options.path,
+            uid: options.uid,
+            returnSubdomains: options.returnSubdomains,
+            returnPermissions: options.returnPermissions,
+            returnVersions: options.returnVersions,
+            returnSize: options.returnSize,
+            consistency: options.consistency,
+        });
 
-        // set up event handlers for load and error events
-        utils.setupXhrEventHandlers(xhr, options.success, options.error, async (result) => {
-            // Calculate the size of the result for cache eligibility check
-            const resultSize = JSON.stringify(result).length;
+        // Check if there's already an in-flight request for the same parameters
+        const existingEntry = inflightRequests.get(deduplicationKey);
+        const now = Date.now();
+        
+        if (existingEntry) {
+            const timeSinceRequest = now - existingEntry.timestamp;
             
-            // Cache the result if it's not bigger than MAX_CACHE_SIZE
-            const MAX_CACHE_SIZE = 20 * 1024 * 1024;
+            // Only reuse the request if it's within the deduplication window
+            if (timeSinceRequest < DEDUPLICATION_WINDOW_MS) {
+                // Wait for the existing request and return its result
+                try {
+                    const result = await existingEntry.promise;
+                    resolve(result);
+                } catch (error) {
+                    reject(error);
+                }
+                return;
+            } else {
+                // Request is too old, remove it from the tracker
+                inflightRequests.delete(deduplicationKey);
+            }
+        }
 
-            if(resultSize <= MAX_CACHE_SIZE){
-                // UPSERT the cache
-                puter._cache.set(cacheKey, result);
+        // Create a promise for this request and store it to deduplicate concurrent calls
+        const requestPromise = new Promise(async (resolveRequest, rejectRequest) => {
+            // If auth token is not provided and we are in the web environment, 
+            // try to authenticate with Puter
+            if(!puter.authToken && puter.env === 'web'){
+                try{
+                    await puter.ui.authenticateWithPuter();
+                }catch(e){
+                    // if authentication fails, throw an error
+                    rejectRequest('Authentication failed.');
+                    return;
+                }
+            }
+
+            // create xhr object
+            const xhr = utils.initXhr('/stat', this.APIOrigin, undefined, "post", "text/plain;actually=json");
+
+            // set up event handlers for load and error events
+            utils.setupXhrEventHandlers(xhr, options.success, options.error, async (result) => {
+                // Calculate the size of the result for cache eligibility check
+                const resultSize = JSON.stringify(result).length;
+                
+                // Cache the result if it's not bigger than MAX_CACHE_SIZE
+                const MAX_CACHE_SIZE = 20 * 1024 * 1024;
+
+                if(resultSize <= MAX_CACHE_SIZE){
+                    // UPSERT the cache
+                    puter._cache.set(cacheKey, result);
+                }
+                
+                resolveRequest(result);
+            }, rejectRequest);
+
+            let dataToSend = {};
+            if (options.uid !== undefined) {
+                dataToSend.uid = options.uid;
+            } else if (options.path !== undefined) {
+                // If dirPath is not provided or it's not starting with a slash, it means it's a relative path
+                // in that case, we need to prepend the app's root directory to it
+                dataToSend.path = getAbsolutePathForApp(options.path);
             }
             
+            dataToSend.return_subdomains = options.returnSubdomains;
+            dataToSend.return_permissions = options.returnPermissions;
+            dataToSend.return_versions = options.returnVersions;
+            dataToSend.return_size = options.returnSize;
+            dataToSend.auth_token = this.authToken;
+
+            xhr.send(JSON.stringify(dataToSend));
+        });
+
+        // Store the promise and timestamp in the in-flight tracker
+        inflightRequests.set(deduplicationKey, {
+            promise: requestPromise,
+            timestamp: now,
+        });
+
+        // Wait for the request to complete and clean up
+        try {
+            const result = await requestPromise;
+            inflightRequests.delete(deduplicationKey);
             resolve(result);
-        }, reject);
-
-        let dataToSend = {};
-        if (options.uid !== undefined) {
-            dataToSend.uid = options.uid;
-        } else if (options.path !== undefined) {
-            // If dirPath is not provided or it's not starting with a slash, it means it's a relative path
-            // in that case, we need to prepend the app's root directory to it
-            dataToSend.path = getAbsolutePathForApp(options.path);
+        } catch (error) {
+            inflightRequests.delete(deduplicationKey);
+            reject(error);
         }
-        
-        dataToSend.return_subdomains = options.returnSubdomains;
-        dataToSend.return_permissions = options.returnPermissions;
-        dataToSend.return_versions = options.returnVersions;
-        dataToSend.return_size = options.returnSize;
-        dataToSend.auth_token = this.authToken;
-
-        xhr.send(JSON.stringify(dataToSend));
     })
 }
 

package/src/modules/UI.js

@@ -765,6 +765,12 @@ class UI extends EventListener {
         })
     }
 
+    requestUpgrade = function() {
+        return new Promise((resolve) => {
+            this.#postMessageWithCallback('requestUpgrade', resolve, {  });
+        })
+    }
+
     showSaveFilePicker = function(content, suggestedName, type){
         const undefinedOnCancel = new putility.libs.promise.TeePromise();
         const resolveOnlyPromise = new Promise((resolve, reject) => {

package/src/modules/Workers.js

@@ -97,7 +97,7 @@ export class WorkersHandler {
 
         workerName = workerName.toLocaleLowerCase(); // just incase
         // const driverCall = await puter.drivers.call("workers", "worker-service", "destroy", { authorization: puter.authToken, workerName });
-        const driverResult = await utils.make_driver_method(['authorization', 'workerName'], 'workers', "worker-service", 'destroy')(puter.authToken, workerName);;
+        const driverResult = await utils.make_driver_method(['authorization', 'workerName'], 'workers', "worker-service", 'destroy')(puter.authToken, workerName);
 
         if (!driverResult.result) {
             if (!driverResult.result) {
@@ -116,5 +116,55 @@ export class WorkersHandler {
             return true;
         }
     }
+    
+    async getLoggingHandle (workerName) {
+        const loggingEndpoint = await utils.make_driver_method([], 'workers', "worker-service", 'getLoggingUrl')(puter.authToken, workerName);
+        const socket = new WebSocket(`${loggingEndpoint}/${puter.authToken}/${workerName}`);
+        const logStreamObject = new EventTarget();
+        logStreamObject.onLog = (data) => { };
+
+        // Coercibility to ReadableStream
+        Object.defineProperty(logStreamObject, 'start', {
+            enumerable: false,
+            value: async (controller) => {
+                socket.addEventListener("message", (event) => {
+                    controller.enqueue(JSON.parse(event.data));
+                });
+                socket.addEventListener("close", (event) => {
+                    try {
+                        controller.close();
+                    } catch (e) { }
+                });
+            }
+        });
+        Object.defineProperty(logStreamObject, 'cancel', {
+            enumerable: false,
+            value: async () => {
+                socket.close();
+            }
+        });
+
+
+        socket.addEventListener("message", (event) => {
+            const logEvent = new MessageEvent("log", { data: JSON.parse(event.data) });
+
+            logStreamObject.dispatchEvent(logEvent)
+            logStreamObject.onLog(logEvent);
+        });
+        logStreamObject.close = socket.close;
+        return new Promise((res, rej) => {
+            let done = false;
+            socket.onopen = ()=>{
+                done = true;
+                res(logStreamObject);
+            }
+
+            socket.onerror = () => {
+                if (!done) {
+                    rej("Failed to open logging connection");
+                }
+            }
+        })
+    }
 
 }