mulink 1.2.2 → 1.2.4

package/dist/lib/{chunk-NXP26AJR.js → chunk-RXLPPBZQ.js}

@@ -1767,6 +1767,42 @@ export class BaseApiClient {
         // Handle HTTP errors
         if (!response.ok) {
           const errorData = await this.parseErrorResponse(response)
+          
+          // Handle token refresh for 401 errors (token expired)
+          if (response.status === 401 && !skipAuth && ${this.configuration.auth?.enabled ? "true" : "false"} && attempt === 0) {
+            try {
+              // Try to refresh token using auth client
+              const authModule = await import('${authPath}').catch(() => null)
+              if (authModule?.authClient || authModule?.AuthClient) {
+                const authClient = authModule.authClient || authModule.AuthClient.getInstance()
+                const tokens = authClient.getTokens?.()
+                
+                if (tokens?.refresh_token) {
+                  try {
+                    await authClient.refreshToken(tokens.refresh_token)
+                    // Token refreshed successfully - retry request with new token
+                    console.log('[API Client] Token refreshed, retrying request')
+                    // Update auth headers and retry
+                    requestConfig.headers = {
+                      ...requestConfig.headers,
+                      ...(await this.getAuthHeaders())
+                    }
+                    // Continue to retry the request
+                    continue
+                  } catch (refreshError: any) {
+                    // Token refresh failed - proceed with error handling
+                    console.warn('[API Client] Token refresh failed:', refreshError)
+                  }
+                }
+              }
+            } catch (refreshAttemptError) {
+              // Auth client not available - proceed with error handling
+              if (process.env.NODE_ENV === 'development') {
+                console.warn('[API Client] Could not attempt token refresh:', refreshAttemptError)
+              }
+            }
+          }
+          
           const apiError = new ApiError(
             errorData.message || \`HTTP \${response.status}: \${response.statusText}\`,
             response.status,
@@ -2001,7 +2037,8 @@ async get<TData>(
     const authErrorHandlerPath = errorHandling?.authErrorHandlerPath || "@/lib/auth-error-handler";
     const authErrorMiddlewareCode = enableAuthErrorHandling ? `
 // Authentication error middleware
-// Handles 401/403 errors and redirects to login when needed
+// Handles 401/403 errors after token refresh has been attempted by the base client
+// Note: Token refresh is handled automatically by the base client before this middleware runs
 export const authErrorMiddleware: RequestMiddleware = {
   name: 'auth-error',
   onError: async (error) => {
@@ -2022,7 +2059,7 @@ export const authErrorMiddleware: RequestMiddleware = {
         errorCode.toLowerCase() === 'user_account_inactive'
       )
 
-      console.warn('[Auth Middleware] Authentication error detected:', {
+      console.warn('[Auth Middleware] Authentication error detected (token refresh already attempted):', {
         status,
         message: errorMessage,
         errorCode,
@@ -2825,13 +2862,10 @@ var SchemaGenerator = class {
     const imports = ['import { z } from "zod"'];
     const schemaExports = [];
     const allSchemaDefinitions = [];
-    const orderedSchemas = this.orderSchemasByDependencies(schemas);
-    for (const schema of orderedSchemas) {
+    for (const schema of schemas) {
       const { definition, exportName } = this.generateSchemaDefinition(schema);
-      const zodDependencies = this.findSchemaDependencies(schema);
-      const stringDependencies = this.extractDependenciesFromDefinition(definition, exportName);
-      const allDependencies = [.../* @__PURE__ */ new Set([...zodDependencies, ...stringDependencies])];
-      allSchemaDefinitions.push({ definition, exportName, dependencies: allDependencies });
+      const dependencies = this.extractDependenciesFromDefinition(definition, exportName);
+      allSchemaDefinitions.push({ definition, exportName, dependencies });
       schemaExports.push(exportName);
     }
     for (const endpoint of endpoints) {
@@ -8714,6 +8748,40 @@ export function isAuthError(error: unknown): boolean {
   return false
 }
 
+/**
+ * Type guard to check if an error is a preventive unauthorized error
+ * Preventive errors occur when no authentication is provided (before API call)
+ * These should be handled silently without showing notifications
+ * 
+ * Optimized for performance: early returns and minimal string operations
+ */
+export function isPreventiveUnauthorizedError(error: unknown): boolean {
+  if (!isAuthError(error)) return false
+  
+  const apiError = error as ApiError
+  
+  // Early return if response exists (reactive error, not preventive)
+  if (apiError.response) return false
+  
+  // Extract error data once to minimize property access
+  const errorData = apiError.data as any
+  const errorCode = errorData?.error_code || errorData?.code
+  
+  // Fast path: check error code first (most reliable indicator)
+  if (errorCode && errorCode.toLowerCase() === 'unauthorized') {
+    return true
+  }
+  
+  // Fallback: check error message (only if no error code found)
+  const errorMessage = errorData?.detail || apiError.message
+  if (errorMessage) {
+    const msg = errorMessage.toLowerCase().trim()
+    return msg === 'unauthorized'
+  }
+  
+  return false
+}
+
 /**
  * Type guard to check if an error is an inactive account error
  * Auto-detected account status patterns from schema
@@ -8766,19 +8834,30 @@ export async function handleAuthError(error: unknown, redirectTo?: string): Prom
   }
 
   const apiError = error as ApiError
+  
+  // Extract error data once to avoid repeated property access
+  const errorData = apiError.data as any
+  const errorCode = errorData?.error_code || errorData?.code || ''
+  const errorMessage = errorData?.detail || apiError.message || ''
+  
+  // Check error types efficiently (single function call, no redundant checks)
+  const isPreventive = isPreventiveUnauthorizedError(error)
   const isInactive = isInactiveAccountError(error)
-  const errorMessage = apiError.data?.detail || apiError.message || ''
   
   console.warn('[Auth Error Handler] Authentication error detected:', {
     status: apiError.status,
     message: errorMessage,
+    errorCode,
     isInactive,
+    isPreventive,
   })
 
   const toastInstance = await getToast()
 
   // Show appropriate error message based on error type
-  if (toastInstance) {
+  // Skip toast for preventive unauthorized errors (no auth provided - silent handling)
+  // Show toast for reactive auth errors (session expired, account issues, etc.)
+  if (toastInstance && !isPreventive) {
     if (isInactive) {
       toastInstance.error('Your account has been deactivated. Please contact support for assistance.', {
         duration: 5000,
@@ -8843,6 +8922,7 @@ export function createAuthErrorHandler(redirectTo?: string) {
       metadata: {
         exports: [
           "isAuthError",
+          "isPreventiveUnauthorizedError",
           "isInactiveAccountError",
           "handleAuthError",
           "createAuthErrorHandler"
@@ -10060,5 +10140,5 @@ ${errorMessages}`,
 };
 
 export { BridgeCore, BridgeError, BridgeLogger, ConfigurationLoader, FileSystemManager, GenerationError, LogLevel, NextJsCodeGenerator, OpenApiSchemaParser, SchemaParseError, ValidationError, VersionChecker, __name, checkAndNotifyUpdates, createBridgeVersionChecker };
-//# sourceMappingURL=chunk-NXP26AJR.js.map
-//# sourceMappingURL=chunk-NXP26AJR.js.map
+//# sourceMappingURL=chunk-RXLPPBZQ.js.map
+//# sourceMappingURL=chunk-RXLPPBZQ.js.map