@twin.org/core 0.0.1-next.52 → 0.0.1-next.54

package/dist/cjs/index.cjs

@@ -4006,20 +4006,88 @@ class AsyncCache {
      * @param key The key for the entry in the cache.
      * @param ttlMs The TTL of the entry in the cache.
      * @param requestMethod The method to call if not cached.
+     * @param cacheFailures Cache failure results, defaults to false.
      * @returns The response.
      */
-    static exec(key, ttlMs, requestMethod) {
+    static exec(key, ttlMs, requestMethod, cacheFailures) {
         const cacheEnabled = Is.integer(ttlMs) && ttlMs >= 0;
         if (cacheEnabled) {
             AsyncCache.cleanupExpired();
             const cache = AsyncCache.getSharedCache();
-            if (!cache[key]) {
-                cache[key] = {
-                    response: requestMethod(),
-                    expires: ttlMs === 0 ? 0 : Date.now() + ttlMs
-                };
+            // Do we have a cache entry for the key
+            if (cache[key]) {
+                if (!Is.empty(cache[key].result)) {
+                    // If the cache has already resulted in a value, resolve it
+                    return Promise.resolve(cache[key].result);
+                }
+                else if (!Is.empty(cache[key].error)) {
+                    // If the cache has already resulted in an error, reject it
+                    return Promise.reject(cache[key].error);
+                }
+                // Otherwise create a promise to return and store the resolver
+                // and rejector in the cache entry, so that we can call then
+                // when the request is done
+                let storedResolve;
+                let storedReject;
+                const wait = new Promise((resolve, reject) => {
+                    storedResolve = resolve;
+                    storedReject = reject;
+                });
+                if (!Is.empty(storedResolve) && !Is.empty(storedReject)) {
+                    cache[key].promiseQueue.push({
+                        requestMethod,
+                        resolve: storedResolve,
+                        reject: storedReject
+                    });
+                }
+                return wait;
             }
-            return cache[key].response;
+            // If we don't have a cache entry, create a new one
+            cache[key] = {
+                promiseQueue: [],
+                expires: ttlMs === 0 ? 0 : Date.now() + ttlMs
+            };
+            // Return a promise that wraps the original request method
+            // so that we can store any results or errors in the cache
+            return new Promise((resolve, reject) => {
+                // Call the request method and store the result
+                requestMethod()
+                    // eslint-disable-next-line promise/prefer-await-to-then
+                    .then(res => {
+                    // If the request was successful, store the result
+                    cache[key].result = res;
+                    // and resolve both this promise and all the waiters
+                    resolve(res);
+                    for (const wait of cache[key].promiseQueue) {
+                        wait.resolve(res);
+                    }
+                    return res;
+                })
+                    // eslint-disable-next-line promise/prefer-await-to-then
+                    .catch((err) => {
+                    // Reject the promise
+                    reject(err);
+                    // Handle the waiters based on the cacheFailures flag
+                    if (cacheFailures ?? false) {
+                        // If we are caching failures, store the error and reject the waiters
+                        cache[key].error = err;
+                        for (const wait of cache[key].promiseQueue) {
+                            wait.reject(err);
+                        }
+                        // Clear the waiters so we don't call them again
+                        cache[key].promiseQueue = [];
+                    }
+                    else {
+                        // If not caching failures for any queued requests we
+                        // have no value to either resolve or reject, so we
+                        // just resolve with the original request method
+                        for (const wait of cache[key].promiseQueue) {
+                            wait.resolve(wait.requestMethod());
+                        }
+                        delete cache[key];
+                    }
+                });
+            });
         }
     }
     /**
@@ -4029,7 +4097,14 @@ class AsyncCache {
      */
     static async get(key) {
         const cache = AsyncCache.getSharedCache();
-        return cache[key]?.response;
+        if (!Is.empty(cache[key].result)) {
+            // If the cache has already resulted in a value, resolve it
+            return cache[key].result;
+        }
+        else if (!Is.empty(cache[key].error)) {
+            // If the cache has already resulted in an error, reject it
+            throw cache[key].error;
+        }
     }
     /**
      * Set an entry into the cache.
@@ -4041,7 +4116,8 @@ class AsyncCache {
     static async set(key, value, ttlMs) {
         const cache = AsyncCache.getSharedCache();
         cache[key] = {
-            response: Promise.resolve(value),
+            result: value,
+            promiseQueue: [],
             expires: Date.now() + (ttlMs ?? 1000)
         };
     }

package/dist/esm/index.mjs

@@ -4004,20 +4004,88 @@ class AsyncCache {
      * @param key The key for the entry in the cache.
      * @param ttlMs The TTL of the entry in the cache.
      * @param requestMethod The method to call if not cached.
+     * @param cacheFailures Cache failure results, defaults to false.
      * @returns The response.
      */
-    static exec(key, ttlMs, requestMethod) {
+    static exec(key, ttlMs, requestMethod, cacheFailures) {
         const cacheEnabled = Is.integer(ttlMs) && ttlMs >= 0;
         if (cacheEnabled) {
             AsyncCache.cleanupExpired();
             const cache = AsyncCache.getSharedCache();
-            if (!cache[key]) {
-                cache[key] = {
-                    response: requestMethod(),
-                    expires: ttlMs === 0 ? 0 : Date.now() + ttlMs
-                };
+            // Do we have a cache entry for the key
+            if (cache[key]) {
+                if (!Is.empty(cache[key].result)) {
+                    // If the cache has already resulted in a value, resolve it
+                    return Promise.resolve(cache[key].result);
+                }
+                else if (!Is.empty(cache[key].error)) {
+                    // If the cache has already resulted in an error, reject it
+                    return Promise.reject(cache[key].error);
+                }
+                // Otherwise create a promise to return and store the resolver
+                // and rejector in the cache entry, so that we can call then
+                // when the request is done
+                let storedResolve;
+                let storedReject;
+                const wait = new Promise((resolve, reject) => {
+                    storedResolve = resolve;
+                    storedReject = reject;
+                });
+                if (!Is.empty(storedResolve) && !Is.empty(storedReject)) {
+                    cache[key].promiseQueue.push({
+                        requestMethod,
+                        resolve: storedResolve,
+                        reject: storedReject
+                    });
+                }
+                return wait;
             }
-            return cache[key].response;
+            // If we don't have a cache entry, create a new one
+            cache[key] = {
+                promiseQueue: [],
+                expires: ttlMs === 0 ? 0 : Date.now() + ttlMs
+            };
+            // Return a promise that wraps the original request method
+            // so that we can store any results or errors in the cache
+            return new Promise((resolve, reject) => {
+                // Call the request method and store the result
+                requestMethod()
+                    // eslint-disable-next-line promise/prefer-await-to-then
+                    .then(res => {
+                    // If the request was successful, store the result
+                    cache[key].result = res;
+                    // and resolve both this promise and all the waiters
+                    resolve(res);
+                    for (const wait of cache[key].promiseQueue) {
+                        wait.resolve(res);
+                    }
+                    return res;
+                })
+                    // eslint-disable-next-line promise/prefer-await-to-then
+                    .catch((err) => {
+                    // Reject the promise
+                    reject(err);
+                    // Handle the waiters based on the cacheFailures flag
+                    if (cacheFailures ?? false) {
+                        // If we are caching failures, store the error and reject the waiters
+                        cache[key].error = err;
+                        for (const wait of cache[key].promiseQueue) {
+                            wait.reject(err);
+                        }
+                        // Clear the waiters so we don't call them again
+                        cache[key].promiseQueue = [];
+                    }
+                    else {
+                        // If not caching failures for any queued requests we
+                        // have no value to either resolve or reject, so we
+                        // just resolve with the original request method
+                        for (const wait of cache[key].promiseQueue) {
+                            wait.resolve(wait.requestMethod());
+                        }
+                        delete cache[key];
+                    }
+                });
+            });
         }
     }
     /**
@@ -4027,7 +4095,14 @@ class AsyncCache {
      */
     static async get(key) {
         const cache = AsyncCache.getSharedCache();
-        return cache[key]?.response;
+        if (!Is.empty(cache[key].result)) {
+            // If the cache has already resulted in a value, resolve it
+            return cache[key].result;
+        }
+        else if (!Is.empty(cache[key].error)) {
+            // If the cache has already resulted in an error, reject it
+            throw cache[key].error;
+        }
     }
     /**
      * Set an entry into the cache.
@@ -4039,7 +4114,8 @@ class AsyncCache {
     static async set(key, value, ttlMs) {
         const cache = AsyncCache.getSharedCache();
         cache[key] = {
-            response: Promise.resolve(value),
+            result: value,
+            promiseQueue: [],
             expires: Date.now() + (ttlMs ?? 1000)
         };
     }

package/dist/types/utils/asyncCache.d.ts

@@ -7,9 +7,10 @@ export declare class AsyncCache {
      * @param key The key for the entry in the cache.
      * @param ttlMs The TTL of the entry in the cache.
      * @param requestMethod The method to call if not cached.
+     * @param cacheFailures Cache failure results, defaults to false.
      * @returns The response.
      */
-    static exec<T = unknown>(key: string, ttlMs: number | undefined, requestMethod: () => Promise<T>): Promise<T> | undefined;
+    static exec<T = unknown>(key: string, ttlMs: number | undefined, requestMethod: () => Promise<T>, cacheFailures?: boolean): Promise<T> | undefined;
     /**
      * Get an entry from the cache.
      * @param key The key to get from the cache.

package/docs/changelog.md

@@ -1,5 +1,19 @@
 # @twin.org/core - Changelog
 
+## [0.0.1-next.54](https://github.com/twinfoundation/framework/compare/core-v0.0.1-next.53...core-v0.0.1-next.54) (2025-05-06)
+
+
+### Miscellaneous Chores
+
+* **core:** Synchronize repo versions
+
+## [0.0.1-next.53](https://github.com/twinfoundation/framework/compare/core-v0.0.1-next.52...core-v0.0.1-next.53) (2025-05-01)
+
+
+### Features
+
+* async cache don't cache failures unless requested ([658ec4b](https://github.com/twinfoundation/framework/commit/658ec4b67a58a075de4702a3886d151e25ad3ddc))
+
 ## [0.0.1-next.52](https://github.com/twinfoundation/framework/compare/core-v0.0.1-next.51...core-v0.0.1-next.52) (2025-04-17)
 
 

package/docs/reference/classes/AsyncCache.md

@@ -16,7 +16,7 @@ Cache the results from asynchronous requests.
 
 ### exec()
 
-> `static` **exec**\<`T`\>(`key`, `ttlMs`, `requestMethod`): `undefined` \| `Promise`\<`T`\>
+> `static` **exec**\<`T`\>(`key`, `ttlMs`, `requestMethod`, `cacheFailures?`): `undefined` \| `Promise`\<`T`\>
 
 Execute an async request and cache the result.
 
@@ -46,6 +46,12 @@ The TTL of the entry in the cache.
 
 The method to call if not cached.
 
+##### cacheFailures?
+
+`boolean`
+
+Cache failure results, defaults to false.
+
 #### Returns
 
 `undefined` \| `Promise`\<`T`\>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/core",
-	"version": "0.0.1-next.52",
+	"version": "0.0.1-next.54",
 	"description": "Helper methods/classes for data type checking/validation/guarding/error handling",
 	"repository": {
 		"type": "git",