@meistrari/data-token 0.0.10 → 0.0.12

package/dist/adapters/hono.d.ts

@@ -23,4 +23,4 @@ export type DataTokenContext = {
  * app.get('/', c => c.json({ data: c.get('authData') }))
  * ```
  */
-export declare function createDataTokenMiddleware<Env extends DataTokenContext>(url: string, skipOnError?: boolean, getToken?: (c: Context<Env>) => string): import("hono").MiddlewareHandler<Env, string, {}>;
+export declare function createDataTokenMiddleware<Env extends DataTokenContext>(url: string | ((c: Context<Env>) => string), skipOnError?: boolean, getToken?: (c: Context<Env>) => string): import("hono").MiddlewareHandler<Env, string, {}>;

package/dist/adapters/hono.js

@@ -20,7 +20,8 @@ import { getValidator } from '..';
  */
 export function createDataTokenMiddleware(url, skipOnError = false, getToken = c => c.req.header('x-data-token') ?? '') {
     return createMiddleware(async (c, next) => {
-        const validator = getValidator(url);
+        const jwksUrl = typeof url === 'function' ? url(c) : url;
+        const validator = getValidator(jwksUrl);
         const token = getToken(c);
         const data = await validator(token).catch(() => {
             if (skipOnError) {

package/dist/index.js

@@ -1,12 +1,14 @@
 import { createRemoteJWKSet, errors, jwtVerify } from 'jose';
-import { ExponentialBackoff, handleType, retry } from 'cockatiel';
+import { createExponentialBackoff } from './retry';
 import { DataToken } from './types';
-const retryJWKS = retry(handleType(errors.JWKSTimeout)
-    .orWhen(err => err.message.includes('ECONNRESET')), { maxAttempts: 3, backoff: new ExponentialBackoff() });
+const retry = createExponentialBackoff({
+    maxRetries: 3,
+    jitter: true,
+});
 export function getValidator(jwksUrl, { algorithms } = { algorithms: ['RS256'] }) {
-    const JWKS = createRemoteJWKSet(new URL(jwksUrl));
+    const JWKS = createRemoteJWKSet(new URL(jwksUrl), { cacheMaxAge: 0, headers: { 'cache-control': 'no-cache', 'pragma': 'no-cache' } });
     return async (token) => {
-        const { payload } = await retryJWKS.execute(async () => jwtVerify(token, JWKS, { algorithms }));
+        const { payload } = await retry(async () => jwtVerify(token, JWKS, { algorithms }), err => err instanceof errors.JWKSTimeout || (err instanceof Error && err.message.includes('ECONNRESET')));
         return DataToken.parse(payload);
     };
 }

package/dist/retry.d.ts

@@ -0,0 +1,34 @@
+type BackoffOptions = {
+    /**
+     * Maximum number of retry attempts
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Initial delay in milliseconds
+     * @default 1000 (1 second)
+     */
+    baseDelay?: number;
+    /**
+     * Multiplier for exponential backoff
+     * @default 2
+     */
+    factor?: number;
+    /**
+     * Maximum delay cap in milliseconds
+     * @default 30000 (30 seconds)
+     */
+    maxDelay?: number;
+    /**
+     * Jitter to prevent synchronized retries in distributed systems
+     * @default true
+     */
+    jitter?: boolean;
+};
+/**
+ * Create an exponential backoff retry function
+ * @param userOptions Configuration options for backoff strategy
+ * @returns Retry function with exponential backoff
+ */
+declare function createExponentialBackoff(userOptions?: BackoffOptions): <T>(fn: () => Promise<T>, errorFilter?: (error: unknown) => boolean) => Promise<T>;
+export { createExponentialBackoff };

package/dist/retry.js

@@ -0,0 +1,65 @@
+const sleep = async (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Calculate delay for a specific retry attempt
+ * @param options Backoff configuration options
+ * @param attempt Current retry attempt (0-indexed)
+ * @returns Calculated delay in milliseconds
+ */
+function calculateDelay(options, attempt) {
+    // Basic exponential backoff calculation
+    let delay = options.baseDelay * options.factor ** attempt;
+    // Cap the delay at maxDelay
+    delay = Math.min(delay, options.maxDelay);
+    // Apply jitter if enabled
+    if (options.jitter) {
+        // Add random variation between 0.5x and 1.5x of the calculated delay
+        const jitterMultiplier = 0.5 + Math.random();
+        delay *= jitterMultiplier;
+    }
+    return Math.round(delay);
+}
+/**
+ * Create an exponential backoff retry function
+ * @param userOptions Configuration options for backoff strategy
+ * @returns Retry function with exponential backoff
+ */
+function createExponentialBackoff(userOptions = {}) {
+    // Merge default options with user-provided options
+    const options = {
+        maxRetries: 5,
+        baseDelay: 1000,
+        factor: 2,
+        maxDelay: 30000,
+        jitter: true,
+        ...userOptions,
+    };
+    /**
+     * Execute a function with exponential backoff retry strategy
+     * @param fn Function to execute
+     * @param errorFilter Optional function to determine if retry is needed
+     * @returns Promise resolving to the result of the function
+     */
+    return async function executeWithBackoff(fn, errorFilter) {
+        let lastError;
+        for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                // If no error filter is provided, or the error passes the filter
+                const shouldRetry = errorFilter
+                    ? errorFilter(error)
+                    : attempt < options.maxRetries;
+                if (!shouldRetry) {
+                    throw error;
+                }
+                lastError = error;
+                // Calculate and apply delay
+                const delay = calculateDelay(options, attempt);
+                await sleep(delay);
+            }
+        }
+        throw lastError;
+    };
+}
+export { createExponentialBackoff };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meistrari/data-token",
   "type": "module",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Internal library to verify and decode the API Gateway data token",
   "author": "Roz <roz@meistrari.com>",
   "license": "UNLICENSED",