@thorprovider/adapters 4.2.1 → 4.2.2

package/src/providers/medusa/live-smoke.test.ts

@@ -0,0 +1,412 @@
+/**
+ * Medusa Provider — Live Smoke Tests
+ *
+ * Exercises the adapter against a real Medusa backend (dev.erpthor.com).
+ * Guarded by MEDUSA_SMOKE_TEST=1 environment variable.
+ *
+ * Environment variables (all required when MEDUSA_SMOKE_TEST=1):
+ *   MEDUSA_BASE_URL          - Backend URL (e.g. https://dev.erpthor.com)
+ *   MEDUSA_PUBLISHABLE_KEY   - Publishable API key
+ *   MEDUSA_SECRET_KEY        - Secret admin API key (sk_...) for SDK Basic auth
+ *   MEDUSA_SALES_CHANNEL_ID  - Sales channel ID for scoped queries
+ *   MEDUSA_ADMIN_EMAIL       - Admin email for JWT auth (required for Thor admin endpoints)
+ *   MEDUSA_ADMIN_PASSWORD    - Admin password
+ *
+ * Optional:
+ *   MEDUSA_TEST_CUSTOMER_EMAIL    - Existing customer email for auth tests
+ *   MEDUSA_TEST_CUSTOMER_PASSWORD - Existing customer password
+ *
+ * Known issue: MedusaAdminClient uses x-medusa-access-token header which Medusa v2
+ * does not support. The backend requires Authorization: Bearer <JWT>. Group D tests
+ * work around this by obtaining a JWT via login and testing Thor admin endpoints directly.
+ */
+
+import { describe, expect, it, beforeAll } from 'vitest'
+import { MedusaProvider } from './index'
+import { MedusaAdminClient } from './admin'
+
+const runLive = process.env.MEDUSA_SMOKE_TEST === '1';
+
+function requiredEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) throw new Error(`Missing required env var: ${name}`);
+  return value;
+}
+
+function optionalEnv(name: string): string | undefined {
+  return process.env[name] || undefined;
+}
+
+if (!runLive) {
+  describe('Medusa live smoke', () => {
+    it.skip('disabled unless MEDUSA_SMOKE_TEST=1', () => {});
+  });
+} else {
+  const baseUrl = requiredEnv('MEDUSA_BASE_URL');
+  const publishableKey = requiredEnv('MEDUSA_PUBLISHABLE_KEY');
+  const secretKey = requiredEnv('MEDUSA_SECRET_KEY');
+  const salesChannelId = requiredEnv('MEDUSA_SALES_CHANNEL_ID');
+  const adminEmail = requiredEnv('MEDUSA_ADMIN_EMAIL');
+  const adminPassword = requiredEnv('MEDUSA_ADMIN_PASSWORD');
+
+  // --------------------------------------------------------------------------
+  // Group A: Thor Plugin Store Endpoints (custom /store/thor/*)
+  // --------------------------------------------------------------------------
+  describe('Group A: Thor Store Plugin Endpoints', () => {
+    let provider: MedusaProvider;
+
+    beforeAll(() => {
+      provider = new MedusaProvider({
+        baseUrl,
+        publishableKey,
+        currencyCode: 'USD',
+        adminConfig: { apiKey: secretKey },
+      });
+    });
+
+    it('GET /store/thor/capabilities', async () => {
+      // capabilities is fetched in constructor, wait a tick then access
+      await new Promise((r) => setTimeout(r, 2000))
+      const caps = provider.capabilities
+      expect(caps).toBeDefined()
+      expect(caps).toHaveProperty('advancedSearch')
+    });
+
+    it('GET /store/thor/categories (channel-scoped)', async () => {
+      const categories = await provider.getCategories({ limit: 5 });
+      expect(categories).toBeInstanceOf(Array);
+    });
+
+    it('GET /store/thor/config (storefront config)', async () => {
+      const config = await provider.getStorefrontConfig();
+      // May return null if no config set for this channel — should not throw
+      expect(config === null || typeof config === 'object').toBe(true);
+    });
+
+    it('GET /store/thor/site-config (designer config)', async () => {
+      const config = await provider.getDesignerConfig();
+      expect(config === null || typeof config === 'object').toBe(true);
+    });
+
+    it('GET /store/search (advanced search)', async () => {
+      // Search depends on MeiliSearch being running on the backend — may 500 if not available
+      try {
+        const result = await provider.searchProductsAdvanced({ query: 'test', first: 3 })
+        expect(result).toHaveProperty('products')
+        expect(result.products).toBeInstanceOf(Array)
+      } catch (e: any) {
+        // MeiliSearch not running is acceptable in dev
+        console.log('Search endpoint unavailable (MeiliSearch down):', e.message?.slice(0, 80));
+      }
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Group B: Standard Medusa Store Endpoints (via SDK)
+  // --------------------------------------------------------------------------
+  describe('Group B: Medusa Store Standard Endpoints', () => {
+    let provider: MedusaProvider;
+
+    beforeAll(() => {
+      provider = new MedusaProvider({
+        baseUrl,
+        publishableKey,
+        currencyCode: 'USD',
+        adminConfig: { apiKey: secretKey },
+      });
+    });
+
+    it('GET /store/products (list)', async () => {
+      const products = await provider.getProducts({ first: 3 });
+      expect(products).toBeInstanceOf(Array);
+      expect(products.length).toBeGreaterThan(0);
+      expect(products[0]).toHaveProperty('id');
+      expect(products[0]).toHaveProperty('title');
+    });
+
+    it('GET /store/products (by handle)', async () => {
+      const products = await provider.getProducts({ first: 1 });
+      expect(products.length).toBeGreaterThan(0);
+      const handle = products[0].handle;
+      expect(handle).toBeTruthy();
+
+      const product = await provider.getProduct(handle!);
+      expect(product).toBeDefined();
+      expect(product!.handle).toBe(handle);
+    });
+
+    it('GET /store/collections', async () => {
+      const collections = await provider.getCollections({});
+      expect(collections).toBeInstanceOf(Array);
+    });
+
+    it('GET /store/product-categories', async () => {
+      const categories = await provider.getCategories({ limit: 10 });
+      expect(categories).toBeInstanceOf(Array);
+    });
+
+    it('GET /store/regions', async () => {
+      const regions = await provider.getRegions();
+      expect(regions).toBeInstanceOf(Array);
+      expect(regions.length).toBeGreaterThan(0);
+      expect(regions[0]).toHaveProperty('id');
+    });
+
+    it('GET /store/regions/:id (countries)', async () => {
+      const regions = await provider.getRegions();
+      expect(regions.length).toBeGreaterThan(0);
+
+      const countries = await provider.getRegionCountries(regions[0].id);
+      expect(countries).toBeInstanceOf(Array);
+    });
+
+    describe('Cart lifecycle', () => {
+      let cartId: string;
+
+      it('POST /store/carts (create)', async () => {
+        const cart = await provider.createCart({})
+        expect(cart).toHaveProperty('id')
+        expect(cart.id).toBeTruthy()
+        cartId = cart.id as string
+      });
+
+      it('GET /store/carts/:id (retrieve)', async () => {
+        expect(cartId).toBeTruthy()
+        const cart = await provider.getCart(cartId as string)
+        expect(cart).toHaveProperty('id')
+        expect(cart!.id).toBe(cartId)
+      });
+
+      it('POST /store/carts/:id/line-items (add item)', async () => {
+        expect(cartId).toBeTruthy()
+        const products = await provider.getProducts({ first: 1 })
+        expect(products.length).toBeGreaterThan(0)
+        const variant = products[0].variants?.[0]
+        expect(variant).toBeDefined()
+
+        const cart = await provider.addToCart(cartId as string, [{
+          merchandiseId: variant!.id,
+          quantity: 1,
+        }])
+        expect(cart.lines.length).toBeGreaterThan(0)
+      });
+
+      it('POST /store/carts/:id/line-items/:lineId (update quantity)', async () => {
+        expect(cartId).toBeTruthy()
+        const cart = await provider.getCart(cartId as string)
+        expect(cart!.lines.length).toBeGreaterThan(0)
+        const lineId = cart!.lines[0].id as string
+
+        const updated = await provider.updateCart(cartId as string, [{
+          id: lineId,
+          merchandiseId: cart!.lines[0].merchandise.id,
+          quantity: 2,
+        }])
+        const line = updated.lines.find((l) => l.id === lineId)
+        expect(line?.quantity).toBe(2)
+      });
+
+      it('DELETE /store/carts/:id/line-items/:lineId (remove item)', async () => {
+        expect(cartId).toBeTruthy()
+        const cart = await provider.getCart(cartId as string)
+        expect(cart!.lines.length).toBeGreaterThan(0)
+        const lineId = cart!.lines[0].id as string
+
+        const updated = await provider.removeFromCart(cartId as string, [lineId])
+        expect(updated.lines.find((l) => l.id === lineId)).toBeUndefined()
+      });
+    });
+
+    it('GET /store/payment-providers', async () => {
+      const regions = await provider.getRegions()
+      expect(regions.length).toBeGreaterThan(0)
+
+      const methods = await provider.getPaymentMethods({ regionId: regions[0].id })
+      expect(methods).toBeInstanceOf(Array)
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Group C: Customer Authentication (login, profile, addresses)
+  // --------------------------------------------------------------------------
+  describe('Group C: Customer Authentication', () => {
+    const testEmail = optionalEnv('MEDUSA_TEST_CUSTOMER_EMAIL')
+    const testPassword = optionalEnv('MEDUSA_TEST_CUSTOMER_PASSWORD')
+
+    it('login with test customer', async () => {
+      if (!testEmail || !testPassword) {
+        console.log('Skipping: MEDUSA_TEST_CUSTOMER_EMAIL/PASSWORD not set')
+        return
+      }
+
+      const provider = new MedusaProvider({
+        baseUrl,
+        publishableKey,
+        currencyCode: 'USD',
+        auth: {
+          method: 'jwt',
+          storage: 'memory',
+        },
+      });
+
+      const authProvider = provider.auth
+      expect(authProvider).toBeDefined()
+
+      const result = await authProvider!.login({ email: testEmail, password: testPassword })
+      expect(result.token || result.customer).toBeTruthy()
+      expect(result.customer).toBeDefined()
+      expect(result.customer!.email).toBe(testEmail)
+
+      // getCurrentCustomer
+      const customer = await authProvider!.getCurrentCustomer()
+      expect(customer).toBeDefined()
+      expect(customer!.email).toBe(testEmail)
+
+      // getAddresses
+      const addresses = await authProvider!.getAddresses()
+      expect(addresses).toBeInstanceOf(Array)
+
+      // Logout
+      await authProvider!.logout()
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Group D: Admin Thor Plugin Endpoints (direct HTTP with JWT)
+  //
+  // NOTE: MedusaAdminClient uses x-medusa-access-token which is NOT supported
+  // by Medusa v2. These tests use direct fetch with Bearer JWT to verify the
+  // endpoints exist and respond correctly. This documents a real adapter bug.
+  // --------------------------------------------------------------------------
+  describe('Group D: Admin Thor Plugin Endpoints (direct JWT)', () => {
+    let jwt: string
+
+    beforeAll(async () => {
+      // Obtain admin JWT
+      const res = await fetch(`${baseUrl}/auth/user/emailpass`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email: adminEmail, password: adminPassword }),
+      })
+      const data = await res.json() as { token?: string }
+      expect(data.token).toBeTruthy()
+      jwt = data.token as string
+    })
+
+    async function adminFetch(path: string): Promise<any> {
+      const res = await fetch(`${baseUrl}${path}`, {
+        headers: { Authorization: `Bearer ${jwt}` },
+      })
+      if (!res.ok) {
+        const text = await res.text()
+        throw new Error(`${res.status} ${path}: ${text}`)
+      }
+      return res.json()
+    }
+
+    it('GET /admin/thor/sales-channels/:id/customers', async () => {
+      const result = await adminFetch(`/admin/thor/sales-channels/${salesChannelId}/customers?limit=5`)
+      expect(result).toHaveProperty('customers')
+      expect(result.customers).toBeInstanceOf(Array)
+    })
+
+    it('GET /admin/thor/sales-channels/:id/api-keys', async () => {
+      const result = await adminFetch(`/admin/thor/sales-channels/${salesChannelId}/api-keys`)
+      expect(result).toHaveProperty('api_keys')
+      expect(result.api_keys).toBeInstanceOf(Array)
+    })
+
+    it('GET /admin/thor/sales-channels/:id/categories', async () => {
+      const result = await adminFetch(`/admin/thor/sales-channels/${salesChannelId}/categories?limit=10`)
+      expect(result).toHaveProperty('categories')
+      expect(result.categories).toBeInstanceOf(Array)
+    })
+
+    it('GET /admin/thor/storefront-config/:id (may 404)', async () => {
+      const res = await fetch(`${baseUrl}/admin/thor/storefront-config/${salesChannelId}`, {
+        headers: { Authorization: `Bearer ${jwt}` },
+      })
+      // 200 or 404 are both acceptable
+      expect([200, 404]).toContain(res.status)
+    })
+
+    it('GET /admin/thor/site-config/:id (may 404)', async () => {
+      const res = await fetch(`${baseUrl}/admin/thor/site-config/${salesChannelId}`, {
+        headers: { Authorization: `Bearer ${jwt}` },
+      })
+      expect([200, 404]).toContain(res.status)
+    })
+
+    it('GET /admin/thor/site-config/:id/history (may 404)', async () => {
+      const res = await fetch(`${baseUrl}/admin/thor/site-config/${salesChannelId}/history`, {
+        headers: { Authorization: `Bearer ${jwt}` },
+      })
+      expect([200, 404]).toContain(res.status)
+    })
+
+    it('BUG: MedusaAdminClient x-medusa-access-token returns 401', async () => {
+      // This documents the adapter bug: MedusaAdminClient sends x-medusa-access-token
+      // but Medusa v2 only accepts Authorization: Bearer for admin routes.
+      const res = await fetch(`${baseUrl}/admin/thor/sales-channels/${salesChannelId}/customers?limit=1`, {
+        headers: { 'x-medusa-access-token': jwt },
+      })
+      expect(res.status).toBe(401)
+    })
+  });
+
+  // --------------------------------------------------------------------------
+  // Group E: Admin Standard Medusa Endpoints (via SDK with Basic auth)
+  // --------------------------------------------------------------------------
+  describe('Group E: Admin Standard Medusa Endpoints', () => {
+    let provider: MedusaProvider;
+
+    beforeAll(() => {
+      provider = new MedusaProvider({
+        baseUrl,
+        publishableKey,
+        currencyCode: 'USD',
+        adminConfig: { apiKey: secretKey },
+      });
+    });
+
+    it('GET /admin/products (list)', async () => {
+      const result = await provider.getAdminProducts({ limit: 3 })
+      expect(result).toHaveProperty('products')
+      expect(result.products).toBeInstanceOf(Array)
+      expect(result.products.length).toBeGreaterThan(0)
+    })
+
+    it('GET /admin/products/:id (retrieve)', async () => {
+      const list = await provider.getAdminProducts({ limit: 1 })
+      expect(list.products.length).toBeGreaterThan(0)
+      const id = list.products[0].id
+
+      const product = await provider.getAdminProduct(id)
+      expect(product).toBeDefined()
+      expect(product!.id).toBe(id)
+    })
+
+    it('GET /admin/orders (list)', async () => {
+      const result = await provider.getAdminOrders({ limit: 3 })
+      expect(result).toHaveProperty('orders')
+      expect(result.orders).toBeInstanceOf(Array)
+    })
+
+    it('GET /admin/customers (list)', async () => {
+      const result = await provider.getAdminCustomers({ limit: 3 })
+      expect(result).toHaveProperty('customers')
+      expect(result.customers).toBeInstanceOf(Array)
+    })
+
+    it('GET /admin/regions (list)', async () => {
+      const result = await provider.getAdminRegions()
+      expect(result).toBeInstanceOf(Array)
+      expect(result.length).toBeGreaterThan(0)
+    })
+
+    it('GET /admin/stock-locations (list)', async () => {
+      const result = await provider.getStockLocations()
+      expect(result).toBeInstanceOf(Array)
+    })
+  });
+}

package/src/resilience/README.md

@@ -1,3 +1,14 @@
+---
+title: Resilience Patterns
+purpose: Documents the Circuit Breaker and retry patterns for robust backend integration
+type: reference
+tags: [resilience, circuit-breaker, retry, fetch, patterns]
+related:
+  - ../../docs/fetch-reliability-solution.md
+  - ../../docs/RETRY_SOLUTION_SUMMARY.md
+updated: 2026-05-03
+---
+
 # Resilience Patterns
 
 **Framework-agnostic resilience patterns for robust backend integration.**
@@ -10,10 +21,17 @@ This module provides enterprise-grade resilience patterns for handling backend f
 
 ---
 
-## 📦 Export
+## 📦 Exports
 
 ```typescript
-import { CircuitBreaker, backendCircuitBreaker } from '@thorprovider/adapters/resilience';
+import {
+  CircuitBreaker,
+  backendCircuitBreaker,
+  CircuitBreakerOpenError,
+  type CircuitState,
+  type CircuitBreakerConfig,
+  type CircuitBreakerStats,
+} from '@thorprovider/adapters';
 ```
 
 ---
@@ -53,7 +71,7 @@ The Circuit Breaker pattern prevents cascading failures when the backend is unav
 ### Basic Usage
 
 ```typescript
-import { CircuitBreaker } from '@thorprovider/adapters/resilience';
+import { CircuitBreaker } from '@thorprovider/adapters';
 
 const breaker = new CircuitBreaker({
   failureThreshold: 5,      // Open after 5 failures
@@ -63,7 +81,7 @@ const breaker = new CircuitBreaker({
 
 // With fallback
 const data = await breaker.execute(
-  () => fetch('/api/data'),
+  () => fetch('/api/data').then(r => r.json()),
   { default: 'value' }  // Fallback if circuit is open
 );
 
@@ -81,11 +99,11 @@ try {
 interface CircuitBreakerConfig {
   /** Number of failures before opening circuit */
   failureThreshold: number;
-  
+
   /** Time in ms to wait before attempting recovery */
   resetTimeout: number;
-  
-  /** Name for logging/监控 */
+
+  /** Name for logging/monitoring */
   name?: string;
 }
 ```
@@ -103,7 +121,7 @@ console.log({
   failureCount: stats.failureCount,
   totalRequests: stats.totalRequests,
   totalFailures: stats.totalFailures,
-  totalSuccesses: stats.totalSuccesses
+  totalSuccesses: stats.totalSuccesses,
 });
 
 // Manual reset (force recovery)
@@ -117,35 +135,34 @@ breaker.manualReset();
 A pre-configured global instance for backend API calls:
 
 ```typescript
-import { backendCircuitBreaker } from '@thorprovider/adapters/resilience';
+import { backendCircuitBreaker } from '@thorprovider/adapters';
 
 // Use in adapters
 async function getProducts() {
   return backendCircuitBreaker.execute(
-    () => fetch('/api/products'),
+    () => commerce.getProducts(),
     [] // Empty array fallback
   );
 }
 ```
 
-**Configuration:**
+**Default configuration:**
 - `failureThreshold`: 5 failures
 - `resetTimeout`: 60,000ms (1 minute)
-- `name`: 'backend-api'
+- `name`: `'backend-api'`
 
 ---
 
 ## 🎨 Usage Patterns
 
-### Pattern 1: L2 Adapter with Graceful Degradation
+### Pattern 1: Adapter with Graceful Degradation
 
 ```typescript
-// packages/adapters/src/medusa/product-adapter.ts
-import { backendCircuitBreaker } from '@thorprovider/adapters/resilience';
+import { backendCircuitBreaker } from '@thorprovider/adapters';
 
 export async function getProducts(options: GetProductsOptions) {
   return backendCircuitBreaker.execute(
-    () => medusaClient.products.list(options),
+    () => commerce.getProducts(options),
     [] // Return empty array if backend is down
   );
 }
@@ -156,23 +173,23 @@ export async function getProducts(options: GetProductsOptions) {
 - ✅ User sees "No products" instead of error page
 - ✅ Backend gets time to recover
 
-### Pattern 2: L5 Server Component with Fallback UI
+### Pattern 2: Server Component with Fallback UI
 
 ```typescript
-// packages/core/app/products/page.tsx
-import { backendCircuitBreaker } from '@thorprovider/adapters/resilience';
-import { getProducts } from '@thorprovider/adapters/medusa';
+// app/products/page.tsx
+import { backendCircuitBreaker } from '@thorprovider/adapters';
+import { commerce } from '@/lib/commerce';
 
 export default async function ProductsPage() {
   const products = await backendCircuitBreaker.execute(
-    () => getProducts(),
-    [] // Fallback to empty array
+    () => commerce.getProducts(),
+    []
   );
-  
+
   if (products.length === 0) {
-    return <EmptyState message="Products temporarily unavailable" />;
+    return <p>Products temporarily unavailable</p>;
   }
-  
+
   return <ProductsGrid products={products} />;
 }
 ```
@@ -181,14 +198,13 @@ export default async function ProductsPage() {
 
 ```typescript
 // Critical operations should fail explicitly
-async function completeCheckout(data: CheckoutData) {
+async function completeCheckout(cartId: string) {
   try {
     return await backendCircuitBreaker.execute(
-      () => medusaClient.carts.complete(data)
-      // NO fallback - we want this to fail if backend is down
+      () => commerce.completeCheckout(cartId)
+      // NO fallback — we want this to fail if backend is down
     );
   } catch (error) {
-    // Show error message to user
     throw new Error('Checkout unavailable. Please try again later.');
   }
 }
@@ -198,10 +214,9 @@ async function completeCheckout(data: CheckoutData) {
 
 ## 🧪 Testing
 
-### Unit Test Example
-
 ```typescript
-import { CircuitBreaker } from '@thorprovider/adapters/resilience';
+import { describe, it, expect, vi } from 'vitest';
+import { CircuitBreaker } from '@thorprovider/adapters';
 
 describe('CircuitBreaker', () => {
   it('opens after threshold failures', async () => {
@@ -209,28 +224,28 @@ describe('CircuitBreaker', () => {
       failureThreshold: 3,
       resetTimeout: 1000,
     });
-    
-    const mockFn = jest.fn().mockRejectedValue(new Error('fail'));
-    
+
+    const mockFn = vi.fn().mockRejectedValue(new Error('fail'));
+
     // 3 failures
     await expect(breaker.execute(mockFn)).rejects.toThrow();
     await expect(breaker.execute(mockFn)).rejects.toThrow();
     await expect(breaker.execute(mockFn)).rejects.toThrow();
-    
+
     expect(breaker.state).toBe('OPEN');
   });
-  
+
   it('uses fallback when circuit is open', async () => {
     const breaker = new CircuitBreaker({
       failureThreshold: 1,
       resetTimeout: 1000,
     });
-    
-    const mockFn = jest.fn().mockRejectedValue(new Error('fail'));
-    
+
+    const mockFn = vi.fn().mockRejectedValue(new Error('fail'));
+
     // Open circuit
     await breaker.execute(mockFn, 'fallback').catch(() => {});
-    
+
     // Should return fallback immediately
     const result = await breaker.execute(mockFn, 'fallback');
     expect(result).toBe('fallback');
@@ -239,6 +254,12 @@ describe('CircuitBreaker', () => {
 });
 ```
 
+Run tests:
+
+```bash
+yarn workspace @thorprovider/adapters test
+```
+
 ---
 
 ## 📐 Architecture Decisions
@@ -271,29 +292,30 @@ describe('CircuitBreaker', () => {
 
 - Don't use for client-side only operations
 - Don't ignore OPEN state errors silently
-- Don't set failureThreshold too low (causes flapping)
-- Don't set resetTimeout too high (slow recovery)
+- Don't set `failureThreshold` too low (causes flapping)
+- Don't set `resetTimeout` too high (slow recovery)
 
 ---
 
 ## 🔮 Future Enhancements
 
-- [ ] **Retry Pattern**: Exponential backoff for transient failures
-- [ ] **Bulkhead Pattern**: Isolate resource pools
+- [ ] **Bulkhead Pattern**: Isolate resource pools per service
 - [ ] **Rate Limiting**: Prevent API abuse
 - [ ] **Metrics Export**: Prometheus/Datadog integration
 - [ ] **Health Check Integration**: Auto-open circuit on health check fail
 
+> ✅ **Retry Pattern** with exponential backoff is already implemented in `src/core/fetch-utils.ts`.
+
 ---
 
 ## 📚 References
 
-- [Martin Fowler - Circuit Breaker](https://martinfowler.com/bliki/CircuitBreaker.html)
-- [Microsoft - Resilience Patterns](https://docs.microsoft.com/en-us/azure/architecture/patterns/circuit-breaker)
+- [Martin Fowler — Circuit Breaker](https://martinfowler.com/bliki/CircuitBreaker.html)
+- [Microsoft — Resilience Patterns](https://docs.microsoft.com/en-us/azure/architecture/patterns/circuit-breaker)
 - [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki)
 
 ---
 
-**Last Updated**: March 24, 2026
+**Last Updated**: 2026-05-03
 **Status**: ✅ Active
 **Layer**: L2 (Adapters)