@experteam-mx/ngx-services 20.8.6 → 20.9.0

package/README.md

@@ -22,8 +22,12 @@ import { routes } from './app.routes'
 
 const envs = {
 	...environment,
-	authCookie: 'token',
-	cacheTtl: 3000
+	authCookie: 'token'
+	// cacheRoutes is opt-in; omit or leave empty until routes are registered:
+	// cacheRoutes: [
+	//   { pattern: '/api/catalogs', ttl: 60_000 },
+	//   { pattern: '/api/companies/.+/branches', ttl: 30_000 }
+	// ]
 } as Environment
 
 export const appConfig: ApplicationConfig = {
@@ -41,6 +45,8 @@ export const appConfig: ApplicationConfig = {
 
 `provideNgxServices` registers `ENVIRONMENT_TOKEN`, which is required by the API services and some interceptors in this package.
 
+`httpCachingInterceptor` caches only GET requests whose URL matches an entry in `cacheRoutes` (first matching RegExp pattern wins). With no routes configured, nothing is cached.
+
 ## NgModule compatibility
 
 `NgxServicesModule.forRoot(environment)` is still available for compatibility, but it is deprecated for new standalone applications and will be removed in `20.2.0`.

package/fesm2022/experteam-mx-ngx-services.mjs

@@ -5833,23 +5833,40 @@ function apiTokenInterceptor(req, next) {
     return next(req);
 }
 
-const DEFAULT_TTL = 10000; // ttl in ms
 const cache = new Map();
 const inFlightRequests = new Map();
 /**
- * Interceptor function to handle HTTP caching for GET requests. It retrieves cached responses
- * if available and valid; otherwise, it processes the request and caches the response for future use.
+ * Resolves the TTL for a URL from the first matching `cacheRoutes` entry.
+ * Returns `null` when there is no match or no routes configured.
+ */
+function resolveCacheTtl(url, cacheRoutes) {
+    if (!cacheRoutes?.length)
+        return null;
+    for (const route of cacheRoutes) {
+        if (new RegExp(route.pattern).test(url)) {
+            return route.ttl;
+        }
+    }
+    return null;
+}
+/**
+ * Interceptor function to handle opt-in HTTP caching for GET requests that match
+ * a configured `cacheRoutes` pattern. Non-matching GETs pass through uncached.
+ * Concurrent in-flight requests for the same key are deduplicated via `shareReplay`.
  *
- * @param {HttpRequest<any>} req - The HTTP request object being intercepted.
+ * @param {HttpRequest<unknown>} req - The HTTP request object being intercepted.
  * @param {HttpHandlerFn} next - The next HTTP handler function in the chain to process the request.
- * @return {Observable<HttpEvent<any>>} An observable that emits the HTTP event, either from cache
+ * @return {Observable<HttpEvent<unknown>>} An observable that emits the HTTP event, either from cache
  * or by invoking the next handler.
  */
 function httpCachingInterceptor(req, next) {
-    const { cacheTtl } = inject(ENVIRONMENT_TOKEN);
+    const { cacheRoutes } = inject(ENVIRONMENT_TOKEN);
     if (req.method !== 'GET')
         return next(req);
     const key = req.urlWithParams;
+    const routeTtl = resolveCacheTtl(key, cacheRoutes);
+    if (routeTtl === null)
+        return next(req);
     const cached = cache.get(key);
     if (cached) {
         const isExpired = Date.now() > cached.ttl;
@@ -5866,7 +5883,7 @@ function httpCachingInterceptor(req, next) {
         if (!(res instanceof HttpResponse)) {
             return;
         }
-        const ttl = Date.now() + (cacheTtl ?? DEFAULT_TTL);
+        const ttl = Date.now() + routeTtl;
         cache.set(key, { res, ttl });
     }), finalize(() => {
         inFlightRequests.delete(key);