@wowistudio/grit 0.0.1 → 0.0.2

package/README.md

@@ -112,10 +112,19 @@ await Grit.retry(0)
   .fallback(slowerDbFetch)
   .attempt(fastCacheLookup)
 
+// Access the error within fallback
+const result = await Grit.retry(0)
+    .withTimeout(5000)
+    .withFallback(async (error, attempts) => {
+        console.log(`Failed after ${attempts} attempts with error: ${error.message}`);
+        return slowerDbFetch()
+    })
+    .attempt(fastCacheLookup);
+
 // Attempt return type is typesafe and will be a union of return type .fallback & .attempt
 const result: number | string = await Grit.retry(0)
   .withTimeout(100)
-  .fallback(() => 1)
+  .withFallback(() => 1)
   .attempt(() => 'a')
 ```
 

package/dist/builder.d.ts

@@ -1,5 +1,5 @@
 import { GritError } from "./exceptions.js";
-import type { DelayConfig, FunctionToExecute, TimeoutConfig } from "./types.js";
+import type { DelayConfig, FallbackFunction, FunctionToExecute, TimeoutConfig } from "./types.js";
 declare class GritBuilder<FallbackType = never> {
     #private;
     private retryCount?;
@@ -8,7 +8,7 @@ declare class GritBuilder<FallbackType = never> {
     fn: FunctionToExecute<any> | undefined;
     $delay: DelayConfig | undefined;
     $timeout: TimeoutConfig | undefined;
-    $fallback: FunctionToExecute<any> | undefined;
+    $fallback: FallbackFunction<FallbackType> | undefined;
     beforeRetryFn?: (retryCount: number) => void;
     logging: boolean;
     constructor(retryCount: number);
@@ -18,7 +18,7 @@ declare class GritBuilder<FallbackType = never> {
     withDelay(config: DelayConfig): this;
     withTimeout(timeout: TimeoutConfig): this;
     beforeRetry(fn: (retryCount: number) => void): this;
-    withFallback<T>(fallback: FunctionToExecute<T>): GritBuilder<T>;
+    withFallback<T>(fallback: FallbackFunction<T>): GritBuilder<T>;
     attempt<T = FallbackType>(fn: FunctionToExecute<T>): Promise<FallbackType extends never ? T : T | FallbackType>;
 }
 export { GritBuilder };

package/dist/grit.js

@@ -74,25 +74,24 @@ _Grit_instances = new WeakSet(), _Grit_currentDelay_get = function _Grit_current
 }, _Grit_withTimeout = function _Grit_withTimeout(promise) {
     let timer = undefined;
     const wrappedPromise = new Promise((resolve, reject) => {
-        // Use .then() instead of async IIFE to preserve stack traces
-        // eslint-disable-next-line promise/prefer-await-to-then, promise/prefer-catch
+        // promise.then(resolve, (error) => {
+        //     clearTimeout(timer);
+        //     timer = undefined;
+        //     reject(error);
+        // })
         promise.then(resolve, reject);
         if (this.timeout === Number.POSITIVE_INFINITY)
             return;
-        // We create the error outside of `setTimeout` to preserve the stack trace.
         const message = `Promise timed out after ${this.timeout} milliseconds`;
         const timeoutError = new TimeoutError(message);
         timer = setTimeout(() => {
+            console.log('timeout joe joe joe');
             reject(timeoutError);
         }, this.timeout);
     });
-    // eslint-disable-next-line promise/prefer-await-to-then
-    wrappedPromise.clear = () => {
+    const cancelablePromise = wrappedPromise.finally(() => {
         clearTimeout(timer);
         timer = undefined;
-    };
-    const cancelablePromise = wrappedPromise.finally(() => {
-        cancelablePromise.clear();
     });
     return cancelablePromise;
 }, _Grit_processError = function _Grit_processError(error) {
@@ -108,7 +107,6 @@ _Grit_instances = new WeakSet(), _Grit_currentDelay_get = function _Grit_current
     return __awaiter(this, void 0, void 0, function* () {
         try {
             __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_handleBeforeRetry).call(this);
-            console.log('this.timeout', this.timeout);
             if (this.timeout)
                 return yield __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_withTimeout).call(this, Promise.resolve(fn(this.attempts)));
             return yield fn(this.attempts);
@@ -116,7 +114,7 @@ _Grit_instances = new WeakSet(), _Grit_currentDelay_get = function _Grit_current
         catch (error) {
             if (this.retries >= this.retryCount) {
                 if (this.fallback)
-                    return this.fallback(this.attempts);
+                    return this.fallback(error, this.attempts);
                 throw error;
             }
             __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_processError).call(this, error);

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export type GritProps = {
     retryCount?: number;
     fn?: FunctionToExecute<any>;
-    fallback?: FunctionToExecute<any>;
+    fallback?: FallbackFunction<any>;
     onlyErrors?: (typeof Error)[];
     skipErrors?: (typeof Error)[];
     delay?: DelayConfig;
@@ -18,4 +18,5 @@ export type DelayConfig = number | number[] | {
     minDelay: number;
     maxDelay: number;
 };
-export type FunctionToExecute<T> = (attempts?: number) => (Promise<T> | T);
+export type FunctionToExecute<T> = (attempts: number) => (Promise<T> | T);
+export type FallbackFunction<T> = (error: Error, attempts: number) => (Promise<T> | T);

package/dist/utils.js

@@ -6,10 +6,15 @@ export const isPromise = (value) => {
     return value !== null && typeof value === "object" && typeof value.then === "function";
 };
 export const validateGritConfig = (config, retryCount) => {
+    if (retryCount !== 0 && !retryCount)
+        throw new GritError("Missing retry config (Grit.retry(<count>))");
+    if (typeof config === "number") {
+        if (config < 0)
+            throw new GritError("delay must be greater than 0");
+        return;
+    }
     if (!config)
         return;
-    if (!retryCount)
-        throw new GritError("Missing retry config (Grit.retry(<count>))");
     // validate array config
     if (Array.isArray(config)) {
         if (config.length !== retryCount)
@@ -20,11 +25,6 @@ export const validateGritConfig = (config, retryCount) => {
         }
         return;
     }
-    if (typeof config === "number") {
-        if (config <= 0)
-            throw new GritError("delay must be greater than 0");
-        return;
-    }
     if (!isObject(config))
         throw new GritError("Invalid backoff config");
     // validate delay config

package/package.json

@@ -6,7 +6,7 @@
   "files": [
     "/dist"
   ],
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "MIT",
   "exports": {
     ".": {