astro-tokenkit 1.0.19 → 1.0.21

package/dist/index.d.ts

@@ -106,6 +106,14 @@ interface LoginOptions extends AuthOptions {
     /** Callback after failed login */
     onError?: OnErrorCallback;
 }
+/**
+ * OnRefresh callback
+ */
+type OnRefreshCallback = (bundle: TokenBundle, ctx: TokenKitContext) => void | Promise<void>;
+/**
+ * OnRefreshError callback
+ */
+type OnRefreshErrorCallback = (error: AuthError, ctx: TokenKitContext) => void | Promise<void>;
 /**
  * Auth configuration
  */
@@ -144,6 +152,12 @@ interface AuthConfig {
     fetch?: typeof fetch;
     /** Dangerously ignore certificate errors (bypass SSL validation) */
     dangerouslyIgnoreCertificateErrors?: boolean;
+    /** Enable debug logging for auth operations */
+    debug?: boolean;
+    /** Callback after successful refresh */
+    onRefresh?: OnRefreshCallback;
+    /** Callback after failed refresh */
+    onRefreshError?: OnRefreshErrorCallback;
 }
 /**
  * Refresh policy

package/dist/index.js

@@ -506,13 +506,13 @@ catch (e) {
  * Logger utility that respects the debug flag in the configuration
  */
 const logger = {
-    debug: (message, ...args) => {
-        if (getConfig().debug) {
+    debug: (message, force, ...args) => {
+        if (force || getConfig().debug) {
             console.debug(message, ...args);
         }
     },
-    info: (message, ...args) => {
-        if (getConfig().debug) {
+    info: (message, force, ...args) => {
+        if (force || getConfig().debug) {
             console.log(message, ...args);
         }
     },
@@ -638,11 +638,27 @@ class TokenManager {
      */
     refresh(ctx, refreshToken, options, headers) {
         return __awaiter(this, void 0, void 0, function* () {
+            logger.debug('[TokenKit] Starting token refresh', !!this.config.debug);
             try {
-                return yield this.performRefresh(ctx, refreshToken, options, headers);
+                const bundle = yield this.performRefresh(ctx, refreshToken, options, headers);
+                if (bundle) {
+                    if (this.config.onRefresh) {
+                        yield this.config.onRefresh(bundle, ctx);
+                    }
+                }
+                else {
+                    logger.debug('[TokenKit] Token refresh returned no bundle (invalid or expired)', !!this.config.debug);
+                    if (this.config.onRefreshError) {
+                        yield this.config.onRefreshError(new AuthError('Refresh token invalid or expired', 401), ctx);
+                    }
+                }
+                return bundle;
             }
             catch (error) {
-                clearTokens(ctx, this.config.cookies);
+                logger.debug(`[TokenKit] Token refresh failed: ${error.message}`, !!this.config.debug);
+                if (this.config.onRefreshError) {
+                    yield this.config.onRefreshError(error, ctx);
+                }
                 throw error;
             }
         });
@@ -721,14 +737,19 @@ class TokenManager {
             const tokens = retrieveTokens(ctx, this.config.cookies);
             // No tokens
             if (!tokens.accessToken || !tokens.refreshToken || !tokens.expiresAt) {
+                logger.debug('[TokenKit] No valid session found, refresh impossible', !!this.config.debug);
                 return null;
             }
             // Token expired or force refresh
-            if (force || isExpired(tokens.expiresAt, now, this.config.policy)) {
+            const expired = isExpired(tokens.expiresAt, now, this.config.policy);
+            if (force || expired) {
+                logger.debug(`[TokenKit] Token ${force ? 'force refresh' : 'expired'}, refreshing...`, !!this.config.debug);
                 const flightKey = this.createFlightKey(tokens.refreshToken);
                 const bundle = yield this.singleFlight.execute(flightKey, () => this.refresh(ctx, tokens.refreshToken, options, headers));
-                if (!bundle)
+                if (!bundle) {
+                    logger.debug('[TokenKit] Refresh returned no bundle, session lost', !!this.config.debug);
                     return null;
+                }
                 // Ensure tokens are stored in the current context (in case of shared flight)
                 storeTokens(ctx, bundle, this.config.cookies);
                 return {
@@ -740,19 +761,26 @@ class TokenManager {
             }
             // Proactive refresh
             if (shouldRefresh(tokens.expiresAt, now, tokens.lastRefreshAt, this.config.policy)) {
+                logger.debug('[TokenKit] Token near expiration, performing proactive refresh', !!this.config.debug);
                 const flightKey = this.createFlightKey(tokens.refreshToken);
-                const bundle = yield this.singleFlight.execute(flightKey, () => this.refresh(ctx, tokens.refreshToken, options, headers));
-                if (bundle) {
-                    // Ensure tokens are stored in the current context (in case of shared flight)
-                    storeTokens(ctx, bundle, this.config.cookies);
-                    return {
-                        accessToken: bundle.accessToken,
-                        expiresAt: bundle.accessExpiresAt,
-                        tokenType: bundle.tokenType,
-                        payload: (_d = (_c = bundle.sessionPayload) !== null && _c !== void 0 ? _c : parseJWTPayload(bundle.accessToken)) !== null && _d !== void 0 ? _d : undefined,
-                    };
+                try {
+                    const bundle = yield this.singleFlight.execute(flightKey, () => this.refresh(ctx, tokens.refreshToken, options, headers));
+                    if (bundle) {
+                        logger.debug('[TokenKit] Proactive refresh successful', !!this.config.debug);
+                        // Ensure tokens are stored in the current context (in case of shared flight)
+                        storeTokens(ctx, bundle, this.config.cookies);
+                        return {
+                            accessToken: bundle.accessToken,
+                            expiresAt: bundle.accessExpiresAt,
+                            tokenType: bundle.tokenType,
+                            payload: (_d = (_c = bundle.sessionPayload) !== null && _c !== void 0 ? _c : parseJWTPayload(bundle.accessToken)) !== null && _d !== void 0 ? _d : undefined,
+                        };
+                    }
                 }
-                // Refresh failed, check if tokens still exist
+                catch (error) {
+                    logger.debug(`[TokenKit] Proactive refresh failed: ${error.message}. Continuing with current token.`, !!this.config.debug);
+                }
+                // Refresh failed or returned no bundle, check if tokens still exist
                 const currentTokens = retrieveTokens(ctx, this.config.cookies);
                 if (!currentTokens.accessToken) {
                     return null;
@@ -794,7 +822,7 @@ class TokenManager {
                 }
                 catch (error) {
                     // Ignore logout endpoint errors
-                    logger.debug('[TokenKit] Logout endpoint failed:', error);
+                    logger.debug('[TokenKit] Logout endpoint failed:', !!this.config.debug, error);
                 }
                 finally {
                     clearTimeout(timeoutId);
@@ -939,7 +967,7 @@ function createMiddleware() {
             else if (config.context) {
                 contextStrategy = 'custom (external AsyncLocalStorage)';
             }
-            logger.debug(`[TokenKit] Middleware initialized (auth: ${authStatus}, context: ${contextStrategy})`);
+            logger.debug(`[TokenKit] Middleware initialized (auth: ${authStatus}, context: ${contextStrategy})`, !!config.debug);
             globalStorage[LOGGED_KEY] = true;
         }
         const runLogic = () => __awaiter(this, void 0, void 0, function* () {
@@ -951,7 +979,7 @@ function createMiddleware() {
                 }
                 catch (error) {
                     // Log only the message to avoid leaking sensitive data in the error object
-                    logger.debug('[TokenKit] Automatic token rotation failed:', error.message || error);
+                    logger.debug('[TokenKit] Automatic token rotation failed:', !!config.debug, error.message || error);
                 }
             }
             return next();
@@ -996,7 +1024,7 @@ class APIClient {
      * Get token manager
      */
     get tokenManager() {
-        var _a, _b;
+        var _a, _b, _c;
         const config = this.config;
         if (!config.auth)
             return undefined;
@@ -1012,8 +1040,8 @@ class APIClient {
         if (!this._localTokenManager ||
             this._lastUsedAuth !== config.auth ||
             this._lastUsedBaseURL !== config.baseURL) {
-            // Merge client-level fetch and SSL settings into auth config
-            const authConfig = Object.assign(Object.assign({}, config.auth), { fetch: (_a = config.auth.fetch) !== null && _a !== void 0 ? _a : config.fetch, dangerouslyIgnoreCertificateErrors: (_b = config.auth.dangerouslyIgnoreCertificateErrors) !== null && _b !== void 0 ? _b : config.dangerouslyIgnoreCertificateErrors });
+            // Merge client-level fetch, SSL and debug settings into auth config
+            const authConfig = Object.assign(Object.assign({}, config.auth), { fetch: (_a = config.auth.fetch) !== null && _a !== void 0 ? _a : config.fetch, dangerouslyIgnoreCertificateErrors: (_b = config.auth.dangerouslyIgnoreCertificateErrors) !== null && _b !== void 0 ? _b : config.dangerouslyIgnoreCertificateErrors, debug: (_c = config.auth.debug) !== null && _c !== void 0 ? _c : config.debug });
             this._localTokenManager = new TokenManager(authConfig, config.baseURL);
             this._lastUsedAuth = config.auth;
             this._lastUsedBaseURL = config.baseURL;
@@ -1101,8 +1129,11 @@ class APIClient {
     executeRequest(config, ctx, attempt) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e;
+            const method = config.method.toUpperCase();
+            const debug = this.config.debug;
             // Ensure valid session (if auth is enabled)
             if (this.tokenManager && !config.skipAuth) {
+                logger.debug(`[TokenKit] Ensuring valid session for ${method} ${config.url}`, !!debug);
                 yield this.tokenManager.ensure(ctx, config.auth, config.headers);
             }
             // Build full URL
@@ -1111,13 +1142,18 @@ class APIClient {
             const headers = this.buildHeaders(config, ctx, fullURL);
             // Build request init
             const init = {
-                method: config.method,
+                method,
                 headers,
                 signal: config.signal,
             };
-            // Add body for non-GET requests
-            if (config.data && config.method !== 'GET') {
+            // Add body for appropriate methods
+            const methodsWithNoBody = ['GET', 'HEAD', 'DELETE'];
+            if (config.data && !methodsWithNoBody.includes(method)) {
                 init.body = JSON.stringify(config.data);
+                // Add Content-Type if not already present
+                if (!headers['Content-Type'] && !headers['content-type']) {
+                    headers['Content-Type'] = 'application/json';
+                }
             }
             // Apply request interceptors
             let requestConfig = Object.assign({}, config);
@@ -1135,12 +1171,15 @@ class APIClient {
                 clearTimeout(timeoutId);
                 // Handle 401 (try refresh and retry once)
                 if (response.status === 401 && this.tokenManager && !config.skipAuth && attempt === 1) {
+                    logger.debug('[TokenKit] Received 401, attempting force refresh and retry...', !!debug);
                     // Clear and try fresh session (force refresh)
                     const session = yield this.tokenManager.ensure(ctx, config.auth, config.headers, true);
                     if (session) {
+                        logger.debug('[TokenKit] Force refresh successful, retrying request...', !!debug);
                         // Retry with new token
                         return this.executeRequest(config, ctx, attempt + 1);
                     }
+                    logger.debug('[TokenKit] Force refresh failed or returned no session', !!debug);
                 }
                 // Parse response
                 const apiResponse = yield this.parseResponse(response, fullURL);
@@ -1229,7 +1268,7 @@ class APIClient {
      */
     buildHeaders(config, ctx, targetURL) {
         var _a, _b;
-        const headers = Object.assign(Object.assign({ 'Content-Type': 'application/json' }, this.config.headers), config.headers);
+        const headers = Object.assign(Object.assign({}, this.config.headers), config.headers);
         // Add auth token if available (only for safe URLs)
         if (this.tokenManager && !config.skipAuth && this.isSafeURL(targetURL)) {
             const session = this.tokenManager.getSession(ctx);
@@ -1378,7 +1417,7 @@ function tokenKit(config) {
                 }
                 // Always inject the client-side script for idle monitoring
                 injectScript('page', `import 'astro-tokenkit/client-init';`);
-                logger.debug('[TokenKit] Integration initialized');
+                logger.debug('[TokenKit] Integration initialized', !!config.debug);
             },
         },
     };