itlab-internal-services 2.13.2 → 2.13.3

package/dist/modules/cache/cache.module.d.ts

@@ -1,24 +1,35 @@
 import { DynamicModule } from '@nestjs/common';
 /**
- * Cache module responsible for setting up and configuring caching mechanisms.
+ * CacheModule
  *
- * This module provides a flexible caching solution using both Redis and an in-memory cache.
- * It attempts to connect to a Redis instance for persistent caching and falls back to an
- * in-memory cache if Redis is unavailable. The module uses `Keyv` for Redis integration
- * and `CacheableMemory` for the in-memory store. The module is designed to be imported
- * globally and provides a `CacheService` to manage cache interactions.
+ * This module is responsible for setting up and configuring caching mechanisms within the application.
+ * It provides a flexible caching solution that integrates with Redis for persistent caching and falls back
+ * to an in-memory cache if Redis is unavailable. The module leverages `Keyv` for Redis integration and
+ * `CacheableMemory` for the in-memory store. Designed to be imported globally, it offers a `CacheService`
+ * to manage cache interactions efficiently.
  */
 export declare class CacheModule {
     /**
-     * Configures the CacheModule with the necessary providers and imports.
+     * Configures the CacheModule globally with the necessary providers and imports.
      *
-     * This method sets up the cache stores, first attempting to connect to a Redis instance
-     * using configuration values from the environment. If Redis is unavailable, it falls back
-     * to using an in-memory store. It registers the cache stores with the `NestCacheModule`
-     * and makes the `CacheService` available globally for caching operations.
+     * This method sets up the cache stores, attempting to connect to a Redis instance using configuration
+     * values from the environment. If Redis is unavailable, it defaults to using an in-memory store.
+     * It registers the cache stores with the `NestCacheModule` and makes the `CacheService` available
+     * globally for caching operations.
      *
-     * @param namespace The namespace used for cache keys to avoid key collisions.
-     * @returns The configured dynamic module, including the cache providers and stores.
+     * @param {string} namespace - The namespace used for cache keys to avoid key collisions.
+     * @returns {DynamicModule} - The configured dynamic module, including the cache providers and stores.
      */
     static forRoot(namespace: string): DynamicModule;
+    /**
+     * Configures the CacheModule locally with the necessary providers and imports.
+     *
+     * This method sets up the cache stores similarly to `forRoot`, but the module is not global.
+     * It registers the cache stores with the `NestCacheModule` and makes the `CacheService` available
+     * for caching operations within the importing module.
+     *
+     * @param {string} namespace - The namespace used for cache keys to avoid key collisions.
+     * @returns {DynamicModule} - The configured dynamic module, including the cache providers and stores.
+     */
+    static register(namespace: string): DynamicModule;
 }

package/dist/modules/cache/cache.module.js

@@ -5,87 +5,59 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var CacheModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheModule = void 0;
-const identity_1 = require("@azure/identity");
-const redis_1 = require("@keyv/redis");
 const cache_manager_1 = require("@nestjs/cache-manager");
 const common_1 = require("@nestjs/common");
-const config_1 = require("@nestjs/config");
-const cacheable_1 = require("cacheable");
-const keyv_1 = require("keyv");
-const env_1 = require("../../env");
 const cache_service_1 = require("./cache.service");
 /**
- * Cache module responsible for setting up and configuring caching mechanisms.
+ * CacheModule
  *
- * This module provides a flexible caching solution using both Redis and an in-memory cache.
- * It attempts to connect to a Redis instance for persistent caching and falls back to an
- * in-memory cache if Redis is unavailable. The module uses `Keyv` for Redis integration
- * and `CacheableMemory` for the in-memory store. The module is designed to be imported
- * globally and provides a `CacheService` to manage cache interactions.
+ * This module is responsible for setting up and configuring caching mechanisms within the application.
+ * It provides a flexible caching solution that integrates with Redis for persistent caching and falls back
+ * to an in-memory cache if Redis is unavailable. The module leverages `Keyv` for Redis integration and
+ * `CacheableMemory` for the in-memory store. Designed to be imported globally, it offers a `CacheService`
+ * to manage cache interactions efficiently.
  */
 let CacheModule = CacheModule_1 = class CacheModule {
     /**
-     * Configures the CacheModule with the necessary providers and imports.
+     * Configures the CacheModule globally with the necessary providers and imports.
      *
-     * This method sets up the cache stores, first attempting to connect to a Redis instance
-     * using configuration values from the environment. If Redis is unavailable, it falls back
-     * to using an in-memory store. It registers the cache stores with the `NestCacheModule`
-     * and makes the `CacheService` available globally for caching operations.
+     * This method sets up the cache stores, attempting to connect to a Redis instance using configuration
+     * values from the environment. If Redis is unavailable, it defaults to using an in-memory store.
+     * It registers the cache stores with the `NestCacheModule` and makes the `CacheService` available
+     * globally for caching operations.
      *
-     * @param namespace The namespace used for cache keys to avoid key collisions.
-     * @returns The configured dynamic module, including the cache providers and stores.
+     * @param {string} namespace - The namespace used for cache keys to avoid key collisions.
+     * @returns {DynamicModule} - The configured dynamic module, including the cache providers and stores.
      */
     static forRoot(namespace) {
         return {
             global: true,
             module: CacheModule_1,
-            providers: [cache_service_1.CacheService],
+            imports: [cache_manager_1.CacheModule.register({ isGlobal: true, namespace })],
+            providers: [cache_service_1.CacheService, { provide: 'CACHE_NAMESPACE', useValue: namespace }],
+            exports: [cache_service_1.CacheService],
+        };
+    }
+    /**
+     * Configures the CacheModule locally with the necessary providers and imports.
+     *
+     * This method sets up the cache stores similarly to `forRoot`, but the module is not global.
+     * It registers the cache stores with the `NestCacheModule` and makes the `CacheService` available
+     * for caching operations within the importing module.
+     *
+     * @param {string} namespace - The namespace used for cache keys to avoid key collisions.
+     * @returns {DynamicModule} - The configured dynamic module, including the cache providers and stores.
+     */
+    static register(namespace) {
+        return {
+            global: false,
+            module: CacheModule_1,
+            imports: [cache_manager_1.CacheModule.register({ isGlobal: true, namespace })],
+            providers: [cache_service_1.CacheService, { provide: 'CACHE_NAMESPACE', useValue: namespace }],
             exports: [cache_service_1.CacheService],
-            imports: [
-                cache_manager_1.CacheModule.registerAsync({
-                    isGlobal: true,
-                    inject: [config_1.ConfigService],
-                    useFactory: (configService) => __awaiter(this, void 0, void 0, function* () {
-                        // Initialize in-memory cache store using CacheableMemory
-                        const memoryStore = new keyv_1.Keyv({ store: new cacheable_1.CacheableMemory({ lruSize: 5000 }), namespace });
-                        try {
-                            // Attempt to configure Redis store using provided environment variables
-                            const host = configService.getOrThrow(env_1.ENV_REDIS_HOST);
-                            const port = configService.getOrThrow(env_1.ENV_REDIS_PORT);
-                            const user = configService.getOrThrow(env_1.ENV_REDIS_USER);
-                            // Construct a Token Credential from Identity library
-                            const credential = new identity_1.WorkloadIdentityCredential();
-                            const redisScope = 'https://redis.azure.com/.default';
-                            // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
-                            const accessToken = yield credential.getToken(redisScope);
-                            const password = accessToken.token;
-                            const redisStore = (0, redis_1.createKeyv)({ username: user, password, socket: { host, port, tls: true, timeout: 5000 } }, { namespace });
-                            // Ping the Redis server to check if it's available
-                            yield redisStore.get('ping');
-                            // Log success if Redis is available
-                            new common_1.Logger('Cache').log('Redis is available.');
-                            return { stores: [redisStore, memoryStore] };
-                        }
-                        catch (error) {
-                            // Log error and fallback to memory store if Redis is unavailable
-                            new common_1.Logger('Cache').error('Redis is unavailable, falling back to memory store: ' + error);
-                            return { stores: [memoryStore] };
-                        }
-                    }),
-                }),
-            ],
         };
     }
 };

package/dist/modules/cache/cache.service.d.ts

@@ -1,71 +1,79 @@
+import { OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { Cache } from 'cache-manager';
 /**
- * Service to manage caching operations in a centralized manner.
+ * CacheService
  *
- * This class provides methods to interact with a cache system, allowing
- * for the retrieval, storage, and deletion of cached values. It handles
- * cache misses by executing a fallback function and asynchronously storing
- * the result. All cache operations are non-blocking and utilize background
- * processing for setting cache values.
+ * This service manages caching operations in a centralized manner, providing methods for
+ * retrieving, storing, and deleting cached values. It handles cache misses by executing a
+ * fallback function and asynchronously storing the result. The service supports both Redis
+ * and in-memory caching, using Redis for persistent storage and falling back to in-memory
+ * caching if Redis is unavailable.
  */
-export declare class CacheService {
+export declare class CacheService implements OnModuleInit {
     private readonly cache;
+    private readonly namespace;
+    private readonly configService;
+    /** Logger instance for tracking cache operations and debugging. */
     private readonly logger;
     /**
      * Constructor for the CacheService.
-     * @param cache The cache manager instance injected by NestJS.
+     *
+     * @param {Cache} cache - The cache manager instance injected by NestJS.
+     * @param {string} namespace - The namespace for cache keys to avoid collisions.
+     * @param {ConfigService} configService - Service for accessing configuration variables.
+     */
+    constructor(cache: Cache, namespace: string, configService: ConfigService);
+    /**
+     * Lifecycle hook that is called when the module is initialized.
+     *
+     * This method ensures that cache stores are set up when the module is loaded.
+     *
+     * @returns {Promise<void>} - Resolves when the cache stores are initialized.
+     */
+    onModuleInit(): Promise<void>;
+    /**
+     * Sets up the cache stores, attempting to connect to Redis and falling back to memory if necessary.
+     *
+     * @returns {Promise<void>} - Resolves when the cache stores are initialized.
      */
-    constructor(cache: Cache);
+    private setupStores;
     /**
      * Fetches the value associated with the given key from the cache.
      *
-     * @param key The cache key to retrieve the value.
-     * @returns The cached value, or null if the key does not exist in the cache.
+     * @param {string} key - The cache key to retrieve the value.
+     * @returns {Promise<T | null>} - The cached value, or null if the key does not exist.
      */
     fetch<T>(key: string): Promise<T | null>;
     /**
-     * Stores a value in the cache under the specified key.
-     *
-     * This method can optionally set an expiration time for the cached value.
+     * Stores a value in the cache under the specified key, with optional expiration.
      *
-     * @param key The cache key under which to store the value.
-     * @param value The value to be stored in the cache.
-     * @param expiration Optional expiration time in seconds for the cached value.
-     * @returns A promise that resolves once the cache operation completes.
+     * @param {string} key - The cache key under which to store the value.
+     * @param {T} value - The value to be stored in the cache.
+     * @param {number} [expiration] - Optional expiration time in seconds for the cached value.
+     * @returns {Promise<void>} - Resolves once the cache operation completes.
      */
     store<T>(key: string, value: T, expiration?: number): Promise<void>;
     /**
      * Removes the cached value associated with the given key.
      *
-     * This method will delete the value from the cache, ensuring that subsequent
-     * requests for the same key will result in a cache miss.
-     *
-     * @param key The cache key to remove from the cache.
-     * @returns A promise that resolves once the cache operation completes.
+     * @param {string} key - The cache key to remove from the cache.
+     * @returns {Promise<void>} - Resolves once the cache operation completes.
      */
     remove(key: string): Promise<void>;
     /**
-     * Clears all cached values in the cache.
-     *
-     * This operation removes all keys and values stored in the cache, effectively
-     * resetting the cache state.
+     * Clears all cached values in the cache, effectively resetting the cache state.
      *
-     * @returns A promise that resolves once the cache has been cleared.
+     * @returns {Promise<void>} - Resolves once the cache has been cleared.
      */
     clearAll(): Promise<void>;
     /**
-     * Retrieves the value from the cache, or executes the provided function
-     * to fetch and store the value if it is not already cached.
-     *
-     * This method helps optimize cache utilization by checking if the value is
-     * already cached before attempting to compute it. If the cache does not
-     * contain the value, the provided `fetcher` function is invoked, and the
-     * result is stored for future use.
+     * Retrieves the value from the cache, or executes the provided function to fetch and store the value if not cached.
      *
-     * @param key The cache key to check or store the value.
-     * @param fetcher A function that computes the value if it's not cached.
-     * @param expiration Optional expiration time in seconds for the cached value.
-     * @returns The cached value or the newly computed value.
+     * @param {string} key - The cache key to check or store the value.
+     * @param {() => Promise<T>} fetcher - Function that computes the value if it's not cached.
+     * @param {number} [expiration] - Optional expiration time in seconds for the cached value.
+     * @returns {Promise<T>} - The cached value or the newly computed value.
      */
     fetchOrStore<T>(key: string, fetcher: () => Promise<T>, expiration?: number): Promise<T>;
 }

package/dist/modules/cache/cache.service.js

@@ -23,32 +23,93 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var CacheService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheService = void 0;
+const identity_1 = require("@azure/identity");
+const redis_1 = require("@keyv/redis");
 const cache_manager_1 = require("@nestjs/cache-manager");
 const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const cacheable_1 = require("cacheable");
+const env_1 = require("../../env");
 /**
- * Service to manage caching operations in a centralized manner.
+ * CacheService
  *
- * This class provides methods to interact with a cache system, allowing
- * for the retrieval, storage, and deletion of cached values. It handles
- * cache misses by executing a fallback function and asynchronously storing
- * the result. All cache operations are non-blocking and utilize background
- * processing for setting cache values.
+ * This service manages caching operations in a centralized manner, providing methods for
+ * retrieving, storing, and deleting cached values. It handles cache misses by executing a
+ * fallback function and asynchronously storing the result. The service supports both Redis
+ * and in-memory caching, using Redis for persistent storage and falling back to in-memory
+ * caching if Redis is unavailable.
  */
 let CacheService = CacheService_1 = class CacheService {
     /**
      * Constructor for the CacheService.
-     * @param cache The cache manager instance injected by NestJS.
+     *
+     * @param {Cache} cache - The cache manager instance injected by NestJS.
+     * @param {string} namespace - The namespace for cache keys to avoid collisions.
+     * @param {ConfigService} configService - Service for accessing configuration variables.
      */
-    constructor(cache) {
+    constructor(cache, namespace, configService) {
         this.cache = cache;
-        // Logger instance for tracking cache operations and debugging.
+        this.namespace = namespace;
+        this.configService = configService;
+        /** Logger instance for tracking cache operations and debugging. */
         this.logger = new common_1.Logger(CacheService_1.name);
     }
+    /**
+     * Lifecycle hook that is called when the module is initialized.
+     *
+     * This method ensures that cache stores are set up when the module is loaded.
+     *
+     * @returns {Promise<void>} - Resolves when the cache stores are initialized.
+     */
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setupStores();
+        });
+    }
+    /**
+     * Sets up the cache stores, attempting to connect to Redis and falling back to memory if necessary.
+     *
+     * @returns {Promise<void>} - Resolves when the cache stores are initialized.
+     */
+    setupStores() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize in-memory cache store using CacheableMemory
+            const memoryStore = new redis_1.Keyv({ store: new cacheable_1.CacheableMemory(), namespace: this.namespace });
+            try {
+                // Configure Redis store using environment variables
+                const host = this.configService.getOrThrow(env_1.ENV_REDIS_HOST);
+                const port = this.configService.getOrThrow(env_1.ENV_REDIS_PORT);
+                const user = this.configService.getOrThrow(env_1.ENV_REDIS_USER);
+                // Obtain a token credential for Redis access
+                const credential = new identity_1.WorkloadIdentityCredential();
+                const redisScope = 'https://redis.azure.com/.default';
+                this.logger.log('Obtaining new Redis access token...');
+                const accessToken = yield credential.getToken(redisScope);
+                const { token: password, refreshAfterTimestamp } = accessToken;
+                this.logger.log(`New token received. Refresh at: ${new Date(refreshAfterTimestamp).toISOString()}`);
+                // Initialize Redis store using Keyv and Redis
+                const redisStore = (0, redis_1.createKeyv)({ username: user, password, socket: { host, port, tls: true, timeout: 5000 } }, { namespace: this.namespace });
+                // Check Redis server availability
+                yield redisStore.get('ping');
+                this.logger.log('Redis is available. Using Redis store for caching.');
+                const now = Date.now();
+                const refreshDelay = Math.max(refreshAfterTimestamp - now, 0); // Ensure non-negative delay
+                this.logger.log(`Next token refresh scheduled in ${refreshDelay / 1000 / 60} minutes.`);
+                setTimeout(() => __awaiter(this, void 0, void 0, function* () { return yield this.setupStores(); }), refreshDelay);
+                this.cache.stores = [redisStore, memoryStore];
+            }
+            catch (error) {
+                // Log error and fall back to memory store if Redis is unavailable
+                this.logger.error('Redis is unavailable, falling back to memory store: ' + error);
+                this.cache.stores = [memoryStore];
+            }
+        });
+    }
     /**
      * Fetches the value associated with the given key from the cache.
      *
-     * @param key The cache key to retrieve the value.
-     * @returns The cached value, or null if the key does not exist in the cache.
+     * @param {string} key - The cache key to retrieve the value.
+     * @returns {Promise<T | null>} - The cached value, or null if the key does not exist.
      */
     fetch(key) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -56,14 +117,12 @@ let CacheService = CacheService_1 = class CacheService {
         });
     }
     /**
-     * Stores a value in the cache under the specified key.
+     * Stores a value in the cache under the specified key, with optional expiration.
      *
-     * This method can optionally set an expiration time for the cached value.
-     *
-     * @param key The cache key under which to store the value.
-     * @param value The value to be stored in the cache.
-     * @param expiration Optional expiration time in seconds for the cached value.
-     * @returns A promise that resolves once the cache operation completes.
+     * @param {string} key - The cache key under which to store the value.
+     * @param {T} value - The value to be stored in the cache.
+     * @param {number} [expiration] - Optional expiration time in seconds for the cached value.
+     * @returns {Promise<void>} - Resolves once the cache operation completes.
      */
     store(key, value, expiration) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -73,11 +132,8 @@ let CacheService = CacheService_1 = class CacheService {
     /**
      * Removes the cached value associated with the given key.
      *
-     * This method will delete the value from the cache, ensuring that subsequent
-     * requests for the same key will result in a cache miss.
-     *
-     * @param key The cache key to remove from the cache.
-     * @returns A promise that resolves once the cache operation completes.
+     * @param {string} key - The cache key to remove from the cache.
+     * @returns {Promise<void>} - Resolves once the cache operation completes.
      */
     remove(key) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -85,12 +141,9 @@ let CacheService = CacheService_1 = class CacheService {
         });
     }
     /**
-     * Clears all cached values in the cache.
-     *
-     * This operation removes all keys and values stored in the cache, effectively
-     * resetting the cache state.
+     * Clears all cached values in the cache, effectively resetting the cache state.
      *
-     * @returns A promise that resolves once the cache has been cleared.
+     * @returns {Promise<void>} - Resolves once the cache has been cleared.
      */
     clearAll() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -98,35 +151,16 @@ let CacheService = CacheService_1 = class CacheService {
         });
     }
     /**
-     * Retrieves the value from the cache, or executes the provided function
-     * to fetch and store the value if it is not already cached.
+     * Retrieves the value from the cache, or executes the provided function to fetch and store the value if not cached.
      *
-     * This method helps optimize cache utilization by checking if the value is
-     * already cached before attempting to compute it. If the cache does not
-     * contain the value, the provided `fetcher` function is invoked, and the
-     * result is stored for future use.
-     *
-     * @param key The cache key to check or store the value.
-     * @param fetcher A function that computes the value if it's not cached.
-     * @param expiration Optional expiration time in seconds for the cached value.
-     * @returns The cached value or the newly computed value.
+     * @param {string} key - The cache key to check or store the value.
+     * @param {() => Promise<T>} fetcher - Function that computes the value if it's not cached.
+     * @param {number} [expiration] - Optional expiration time in seconds for the cached value.
+     * @returns {Promise<T>} - The cached value or the newly computed value.
      */
     fetchOrStore(key, fetcher, expiration) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.log(`Checking cache for key: ${key}`);
-            const cachedValue = yield this.fetch(key);
-            if (cachedValue) {
-                this.logger.log(`Cache hit for key: ${key}`);
-                return cachedValue;
-            }
-            this.logger.log(`Cache miss for key: ${key}. Fetching value.`);
-            const value = yield fetcher();
-            this.logger.log(`Storing value for key: ${key} with expiration: ${expiration !== null && expiration !== void 0 ? expiration : 'default'}`);
-            // Store the value in the background without blocking
-            this.store(key, value, expiration).catch((err) => {
-                this.logger.error(`Failed to store value for key: ${key}`, err);
-            });
-            return value;
+            return this.cache.wrap(key, fetcher, { ttl: expiration });
         });
     }
 };
@@ -134,5 +168,6 @@ exports.CacheService = CacheService;
 exports.CacheService = CacheService = CacheService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(cache_manager_1.CACHE_MANAGER)),
-    __metadata("design:paramtypes", [Object])
+    __param(1, (0, common_1.Inject)('CACHE_NAMESPACE')),
+    __metadata("design:paramtypes", [Object, String, config_1.ConfigService])
 ], CacheService);

package/dist/modules/content/content.module.js

@@ -33,7 +33,7 @@ let ContentModule = ContentModule_1 = class ContentModule {
      */
     static register(resource) {
         return {
-            global: true,
+            global: false,
             module: ContentModule_1,
             providers: [content_service_1.ContentService, { provide: 'CONTENT_RESOURCE', useValue: resource }],
             exports: [content_service_1.ContentService],

package/package.json

@@ -5,7 +5,7 @@
     "email": "timo.scheuermann@sv-informatik.de",
     "url": "https://timos.design"
   },
-  "version": "2.13.2",
+  "version": "2.13.3",
   "type": "commonjs",
   "files": [
     "dist"