@common-stack/store-redis 8.2.5-alpha.33 → 8.2.5-alpha.35

package/lib/core/keyBuilder/sanitize-redis-key.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Sanitizes a Redis key component to ensure it's valid and safe
+ *
+ * Redis keys can contain any binary sequence, but for best practices and compatibility:
+ * - Avoid whitespace (spaces, tabs, newlines) - replace with underscores
+ * - Avoid pipes (|) which are used in Auth0 userIds - replace with hyphens
+ * - Avoid quotes and backslashes that could cause escaping issues - remove them
+ * - Avoid control characters - remove them
+ *
+ * @param str - The string component to sanitize
+ * @returns Sanitized string safe for use in Redis keys
+ *
+ * @example
+ * ```typescript
+ * sanitizeRedisKeyComponent('auth0|6120ecbb1e5c68006aabe17a')
+ * // Returns: 'auth0-6120ecbb1e5c68006aabe17a'
+ *
+ * sanitizeRedisKeyComponent('user name with spaces')
+ * // Returns: 'user_name_with_spaces'
+ * ```
+ */
+export declare const sanitizeRedisKeyComponent: (str: string) => string;
+/**
+ * Validates if a tenantId looks like a MongoDB ObjectId hash
+ * MongoDB ObjectIds are 24 character hexadecimal strings
+ *
+ * @param tenantId - The tenant ID to validate
+ * @returns true if the tenantId appears to be a hash, false otherwise
+ */
+export declare const isHashLikeTenantId: (tenantId: string) => boolean;
+/**
+ * Builds a standardized Redis key with proper tenant isolation and sanitization
+ *
+ * Key format: `{appName}:{tenantId}:{userId}:{...segments}`
+ * - All components are sanitized to remove invalid characters
+ * - TenantId is validated and replaced with 'default' if it appears to be a hash
+ * - Components can be skipped by passing null/undefined
+ *
+ * @param options - Key building options
+ * @param options.appName - Application name (e.g., 'CDMBASE_TEST')
+ * @param options.tenantId - Tenant identifier (validated against hash pattern)
+ * @param options.userId - User identifier (sanitized for Auth0 format)
+ * @param options.segments - Additional key segments (array of strings)
+ * @param options.logger - Optional logger for warnings
+ * @returns Constructed Redis key
+ *
+ * @example
+ * ```typescript
+ * buildRedisKey({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: 'default',
+ *   userId: 'auth0|6120ecbb',
+ *   segments: ['currentPagePermissions', 'hash123']
+ * })
+ * // Returns: 'CDMBASE_TEST:default:auth0-6120ecbb:currentPagePermissions:hash123'
+ * ```
+ */
+export interface BuildRedisKeyOptions {
+    appName: string;
+    tenantId?: string;
+    userId?: string;
+    segments?: string[];
+    logger?: {
+        warn: (message: string, ...args: unknown[]) => void;
+    };
+}
+export declare const buildRedisKey: ({ appName, tenantId, userId, segments, logger }: BuildRedisKeyOptions) => string;
+/**
+ * Builds a wildcard pattern for Redis key matching
+ * Useful for bulk operations like deleting all keys matching a pattern
+ *
+ * @param options - Pattern building options (same as buildRedisKey)
+ * @returns Redis key pattern with wildcards
+ *
+ * @example
+ * ```typescript
+ * buildRedisKeyPattern({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: 'default',
+ *   segments: ['currentPagePermissions']
+ * })
+ * // Returns: 'CDMBASE_TEST:default:*:currentPagePermissions:*'
+ * ```
+ */
+export declare const buildRedisKeyPattern: ({ appName, tenantId, userId, segments, }: Omit<BuildRedisKeyOptions, "logger">) => string;
+/**
+ * Sanitizes a complete Redis key by sanitizing each component
+ *
+ * @param key - Redis key to sanitize
+ * @returns Sanitized Redis key
+ *
+ * @example
+ * ```typescript
+ * sanitizeRedisKey('APP:tenant with spaces:cache:user|data')
+ * // Returns: 'APP:tenant_with_spaces:cache:user-data'
+ * ```
+ */
+export declare const sanitizeRedisKey: (key: string) => string;
+/**
+ * Escapes special Redis pattern characters for literal matching
+ *
+ * @param pattern - Pattern string to escape
+ * @returns Escaped pattern string
+ *
+ * @example
+ * ```typescript
+ * escapeRedisPattern('file*.txt')
+ * // Returns: 'file\\*.txt'
+ * ```
+ */
+export declare const escapeRedisPattern: (pattern: string) => string;
+/**
+ * Validates if a Redis key is properly formatted
+ *
+ * @param key - Redis key to validate
+ * @returns true if key is valid, false otherwise
+ */
+export declare const isValidRedisKey: (key: string) => boolean;

package/lib/core/keyBuilder/sanitize-redis-key.js

@@ -0,0 +1,120 @@
+/**
+ * Sanitizes a Redis key component to ensure it's valid and safe
+ *
+ * Redis keys can contain any binary sequence, but for best practices and compatibility:
+ * - Avoid whitespace (spaces, tabs, newlines) - replace with underscores
+ * - Avoid pipes (|) which are used in Auth0 userIds - replace with hyphens
+ * - Avoid quotes and backslashes that could cause escaping issues - remove them
+ * - Avoid control characters - remove them
+ *
+ * @param str - The string component to sanitize
+ * @returns Sanitized string safe for use in Redis keys
+ *
+ * @example
+ * ```typescript
+ * sanitizeRedisKeyComponent('auth0|6120ecbb1e5c68006aabe17a')
+ * // Returns: 'auth0-6120ecbb1e5c68006aabe17a'
+ *
+ * sanitizeRedisKeyComponent('user name with spaces')
+ * // Returns: 'user_name_with_spaces'
+ * ```
+ */
+const sanitizeRedisKeyComponent = (str) => {
+    if (!str)
+        return str;
+    return (str
+        .replace(/[\s\r\n\t]+/g, '_') // Replace whitespace with underscores
+        .replace(/\|/g, '-') // Replace pipes with hyphens (Auth0 userIds: auth0|123 -> auth0-123)
+        .replace(/["'\\]/g, '') // Remove quotes and backslashes
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x1F\x7F]/g, '') // Remove control characters
+        .trim());
+};
+/**
+ * Validates if a tenantId looks like a MongoDB ObjectId hash
+ * MongoDB ObjectIds are 24 character hexadecimal strings
+ *
+ * @param tenantId - The tenant ID to validate
+ * @returns true if the tenantId appears to be a hash, false otherwise
+ */
+const isHashLikeTenantId = (tenantId) => {
+    if (!tenantId || tenantId === 'default')
+        return false;
+    return /^[a-f0-9]{24,}$/i.test(tenantId);
+};
+const buildRedisKey = ({ appName, tenantId, userId, segments = [], logger }) => {
+    // Validate and sanitize tenantId
+    let sanitizedTenantId = tenantId || 'default';
+    if (sanitizedTenantId !== 'default' && isHashLikeTenantId(sanitizedTenantId)) {
+        if (logger) {
+            logger.warn('TenantId appears to be a hash (%s...), using "default" instead', sanitizedTenantId.substring(0, 16));
+        }
+        sanitizedTenantId = 'default';
+    }
+    // Build key parts
+    const parts = [sanitizeRedisKeyComponent(appName), sanitizeRedisKeyComponent(sanitizedTenantId)];
+    // Add userId if provided
+    if (userId) {
+        parts.push(sanitizeRedisKeyComponent(userId));
+    }
+    // Add additional segments
+    if (segments && segments.length > 0) {
+        parts.push(...segments.map((seg) => sanitizeRedisKeyComponent(seg)));
+    }
+    return parts.join(':');
+};
+/**
+ * Sanitizes a complete Redis key by sanitizing each component
+ *
+ * @param key - Redis key to sanitize
+ * @returns Sanitized Redis key
+ *
+ * @example
+ * ```typescript
+ * sanitizeRedisKey('APP:tenant with spaces:cache:user|data')
+ * // Returns: 'APP:tenant_with_spaces:cache:user-data'
+ * ```
+ */
+const sanitizeRedisKey = (key) => {
+    if (!key)
+        return '';
+    return key
+        .split(':')
+        .map(sanitizeRedisKeyComponent)
+        .join(':');
+};
+/**
+ * Escapes special Redis pattern characters for literal matching
+ *
+ * @param pattern - Pattern string to escape
+ * @returns Escaped pattern string
+ *
+ * @example
+ * ```typescript
+ * escapeRedisPattern('file*.txt')
+ * // Returns: 'file\\*.txt'
+ * ```
+ */
+const escapeRedisPattern = (pattern) => {
+    if (!pattern)
+        return '';
+    return pattern.replace(/[*?[\]^\\]/g, '\\$&');
+};
+/**
+ * Validates if a Redis key is properly formatted
+ *
+ * @param key - Redis key to validate
+ * @returns true if key is valid, false otherwise
+ */
+const isValidRedisKey = (key) => {
+    if (!key || typeof key !== 'string')
+        return false;
+    if (key.length > 512)
+        return false; // Redis key length limit
+    // Check for invalid characters (whitespace, pipes, etc.)
+    if (/[\s|"'\\]/.test(key))
+        return false;
+    return true;
+};
+
+export { buildRedisKey, escapeRedisPattern, isHashLikeTenantId, isValidRedisKey, sanitizeRedisKey, sanitizeRedisKeyComponent };

package/lib/core/upstash-redis.d.ts

@@ -0,0 +1,14 @@
+import { IRedisClient } from 'common/server';
+export declare class UpstashRedisClient implements IRedisClient {
+    private redis;
+    constructor(config: {
+        url: string;
+        token?: string;
+    });
+    get(key: string): Promise<any | null>;
+    set(key: string, value: string, options?: {
+        ex?: number;
+    }): Promise<string>;
+    delMulti(keys: string[]): Promise<any>;
+    del(key: string): Promise<number>;
+}

package/lib/core/upstash-redis.js

@@ -0,0 +1,27 @@
+import { Redis } from '@upstash/redis/cloudflare';
+
+class UpstashRedisClient {
+    redis;
+    constructor(config) {
+        this.redis = new Redis({ url: config.url, token: config.token });
+    }
+    async get(key) {
+        return await this.redis.get(key);
+    }
+    async set(key, value, options) {
+        if (options?.ex) {
+            return await this.redis.set(key, value, { ex: options?.ex });
+        }
+        else {
+            return await this.redis.set(key, value);
+        }
+    }
+    async delMulti(keys) {
+        return await Promise.all(keys.map((key) => this.redis.del(key)));
+    }
+    async del(key) {
+        return await this.redis.del(key);
+    }
+}
+
+export { UpstashRedisClient };

package/lib/index.d.ts

@@ -9,6 +9,7 @@
  * - Storage backends
  * - Redis patterns and utilities
  */
+export * from './core';
+export * from './services';
 export * from './interfaces';
 export * from './services';
-export * from './utils';

package/lib/index.js

@@ -1,3 +1,7 @@
-export { RedisNamespace } from './interfaces/redis-key-options.js';
-export { buildRedisKey, buildRedisKeyPattern, isValidRedisKey } from './utils/redis-key-builder.js';
-export { escapeRedisPattern, sanitizeKeyComponent, sanitizeRedisKey } from './utils/redis-key-sanitizer.js';
+export { IORedisClient } from './core/ioredis.js';
+export { UpstashRedisClient } from './core/upstash-redis.js';
+export { buildRedisKey, buildRedisKeyPattern } from './core/keyBuilder/index.js';
+export { RedisCacheManager } from './services/RedisCacheManager.js';
+export { escapeRedisPattern, isHashLikeTenantId, isValidRedisKey, sanitizeRedisKey, sanitizeRedisKeyComponent } from './core/keyBuilder/sanitize-redis-key.js';
+export { RedisNamespace, buildRedisKeyPatternWithNamespace, buildRedisKeyWithNamespace, extractNamespaceFromRedisKey, extractTenantIdFromRedisKey, isValidRedisKeyWithNamespace, parseRedisKey } from './core/keyBuilder/redis-key-builder.js';
+export { generateQueryCacheKey } from './core/keyBuilder/generate-query-cache-key.js';

package/lib/interfaces/index.d.ts

@@ -1,6 +1 @@
-/**
- * Interfaces for Redis store operations
- */
-export * from './redis-key-options';
-export * from './storage-backend';
-export * from './cache-manager';
+export * from './redis';

package/lib/interfaces/redis.d.ts

@@ -0,0 +1,11 @@
+export interface IRedisClient {
+    get?(key: string): Promise<string | null>;
+    get?(key: string, callback?: (...args: any[]) => void): any;
+    set(key: string, value: string, options?: {
+        ex?: number;
+    }): Promise<string>;
+    del(key: string): Promise<number>;
+    delMulti(keys: string[]): Promise<any>;
+    on?(event: string | symbol, callback: (...args: any[]) => void): any;
+    once?(event: string | symbol, callback: (...args: any[]) => void): any;
+}

package/lib/module.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/lib/module.js

@@ -0,0 +1,9 @@
+import { Feature } from '@common-stack/server-core';
+import { infraContainer } from './containers/container.js';
+
+var module = new Feature({
+    createContainerFunc: [infraContainer],
+    createMicroServiceContainerFunc: [infraContainer],
+});
+
+export { module as default };

package/lib/services/RedisCacheManager.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @file RedisCacheManager.ts
+ * @description Redis-based cache manager for GraphQL query caching
+ *
+ * This implementation provides sophisticated caching for GraphQL operations with:
+ * - Automatic query hashing for cache keys
+ * - Multi-tenant and user isolation
+ * - Wildcard-based cache invalidation
+ * - TTL-based expiration
+ * - Automatic key sanitization (handles Auth0 userIds with pipes)
+ *
+ * Migrated from @adminide-stack/platform-server to be shared across applications
+ */
+import type { Redis } from 'ioredis';
+import type { DocumentNode } from 'graphql';
+import type { ICacheContext, ICachePolicy, IRedisCacheManager } from 'common/server';
+/**
+ * Redis Cache Manager implementation
+ *
+ * Provides GraphQL query caching with automatic key generation and invalidation
+ */
+export declare class RedisCacheManager implements IRedisCacheManager {
+    protected readonly redisClient: Redis;
+    protected logger?: any;
+    constructor(redisClient: Redis, logger?: any);
+    /**
+     * Delete cached data for a GraphQL query
+     *
+     * @param query - GraphQL query to invalidate
+     * @param variables - Optional variables (if omitted, clears all variants)
+     * @param ctx - Cache context for tenant/user isolation
+     * @param shouldRemoveAll - If true, removes all related cache keys
+     */
+    del(query: string | DocumentNode, variables?: Record<string, unknown>, ctx?: ICacheContext, shouldRemoveAll?: boolean): Promise<void>;
+    /**
+     * Get cached data for a GraphQL query
+     *
+     * @param query - GraphQL query
+     * @param variables - Query variables
+     * @param ctx - Cache context
+     * @returns Cached data or null if cache miss
+     */
+    get<T>(query: string | DocumentNode, variables: Record<string, unknown>, ctx: ICacheContext): Promise<T | null>;
+    /**
+     * Set cached data for a GraphQL query
+     *
+     * @param query - GraphQL query
+     * @param variables - Query variables
+     * @param data - Data to cache
+     * @param ctx - Cache context
+     * @param cachePolicy - Cache policy (TTL, scope)
+     */
+    set<T>(query: string | DocumentNode, variables: Record<string, unknown>, data: T, ctx: ICacheContext, cachePolicy?: ICachePolicy): Promise<void>;
+    /**
+     * Extract query name from GraphQL query
+     */
+    private getQueryName;
+    /**
+     * Build wildcard pattern for query invalidation
+     */
+    private getWildCardQueryKey;
+    /**
+     * Generate cache key for a GraphQL query
+     *
+     * Format: APP_NAME:tenantId:userId:queryName:queryHash:variablesHash
+     */
+    private getCacheKey;
+    /**
+     * Get application name for key prefix
+     * Override this method to provide custom app name
+     */
+    protected getAppName(): string;
+    /**
+     * Log helper
+     */
+    private log;
+}

package/lib/services/RedisCacheManager.js

@@ -0,0 +1,185 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { isHashLikeTenantId, sanitizeRedisKeyComponent } from '../core/keyBuilder/sanitize-redis-key.js';
+import { generateQueryCacheKey } from '../core/keyBuilder/generate-query-cache-key.js';
+import { print } from 'graphql';
+import { injectable, inject } from 'inversify';
+
+/**
+ * @file RedisCacheManager.ts
+ * @description Redis-based cache manager for GraphQL query caching
+ *
+ * This implementation provides sophisticated caching for GraphQL operations with:
+ * - Automatic query hashing for cache keys
+ * - Multi-tenant and user isolation
+ * - Wildcard-based cache invalidation
+ * - TTL-based expiration
+ * - Automatic key sanitization (handles Auth0 userIds with pipes)
+ *
+ * Migrated from @adminide-stack/platform-server to be shared across applications
+ */
+var RedisCacheManager_1;
+/**
+ * Redis Cache Manager implementation
+ *
+ * Provides GraphQL query caching with automatic key generation and invalidation
+ */
+let RedisCacheManager = RedisCacheManager_1 = class RedisCacheManager {
+    redisClient;
+    logger;
+    constructor(redisClient, logger) {
+        this.redisClient = redisClient;
+        if (logger) {
+            this.logger = logger.child ? logger.child({ className: RedisCacheManager_1.name }) : logger;
+        }
+    }
+    /**
+     * Delete cached data for a GraphQL query
+     *
+     * @param query - GraphQL query to invalidate
+     * @param variables - Optional variables (if omitted, clears all variants)
+     * @param ctx - Cache context for tenant/user isolation
+     * @param shouldRemoveAll - If true, removes all related cache keys
+     */
+    async del(query, variables, ctx, shouldRemoveAll = false) {
+        const cacheKey = this.getCacheKey(query, variables ?? {}, ctx);
+        // If variables provided, delete exact match
+        if (variables && Object.keys(variables).length > 0) {
+            this.log('debug', `Deleting ${cacheKey} from redis`);
+            await this.redisClient.del(cacheKey);
+            return;
+        }
+        // Build wildcard pattern
+        const keysWithWildCard = shouldRemoveAll
+            ? this.getWildCardQueryKey(query, ctx)
+            : `${cacheKey.substring(0, cacheKey.lastIndexOf(':'))}:*`;
+        const cacheKeys = await this.redisClient.keys(keysWithWildCard);
+        this.log('debug', `Found ${cacheKeys.length} keys against pattern ${keysWithWildCard}`);
+        if (cacheKeys.length) {
+            this.log('debug', `Deleting ${cacheKeys.length} keys from redis`);
+            await this.redisClient.del(...cacheKeys);
+        }
+    }
+    /**
+     * Get cached data for a GraphQL query
+     *
+     * @param query - GraphQL query
+     * @param variables - Query variables
+     * @param ctx - Cache context
+     * @returns Cached data or null if cache miss
+     */
+    async get(query, variables, ctx) {
+        const cacheKey = this.getCacheKey(query, variables, ctx);
+        const cacheResponse = await this.redisClient.get(cacheKey);
+        if (cacheResponse) {
+            try {
+                const { data } = JSON.parse(JSON.parse(cacheResponse)?.value) ?? {};
+                const queryName = this.getQueryName(query);
+                this.log('debug', `Found cache for ${cacheKey}`);
+                return data?.[queryName] ?? null;
+            }
+            catch (error) {
+                this.log('warn', `Failed to parse cache data for ${cacheKey}:`, error);
+                return null;
+            }
+        }
+        this.log('debug', `No cache found for key ${cacheKey}`);
+        return null;
+    }
+    /**
+     * Set cached data for a GraphQL query
+     *
+     * @param query - GraphQL query
+     * @param variables - Query variables
+     * @param data - Data to cache
+     * @param ctx - Cache context
+     * @param cachePolicy - Cache policy (TTL, scope)
+     */
+    async set(query, variables, data, ctx, cachePolicy = { maxAge: 86400, scope: 'PUBLIC' }) {
+        const cacheKey = this.getCacheKey(query, variables, ctx);
+        const cacheTime = Date.now();
+        // Ensure maxAge is not negative or zero
+        const maxAge = Math.max(1, cachePolicy.maxAge);
+        if (cachePolicy.maxAge <= 0) {
+            this.log('warn', `Invalid maxAge (${cachePolicy.maxAge}) for cache key ${cacheKey}, using minimum value of 1 second`);
+        }
+        this.log('debug', `Set cache for key ${cacheKey} with maxAge ${maxAge}`);
+        await this.redisClient.set(cacheKey, JSON.stringify({
+            value: JSON.stringify({
+                data: { [this.getQueryName(query)]: data },
+                cachePolicy: { ...cachePolicy, maxAge },
+                cacheTime,
+            }),
+            expires: cacheTime + maxAge * 1000,
+        }).trim(), 'EX', maxAge);
+    }
+    /**
+     * Extract query name from GraphQL query
+     */
+    getQueryName(query) {
+        const queryStr = typeof query === 'string' ? query : print(query);
+        const [, queryName] = queryStr?.match(/{\s*(\w+)/) ?? [];
+        return queryName;
+    }
+    /**
+     * Build wildcard pattern for query invalidation
+     */
+    getWildCardQueryKey(query, ctx) {
+        const queryStr = typeof query === 'string' ? query : print(query);
+        const [, queryName] = queryStr?.match(/{\s*(\w+)/) ?? [];
+        const { tenantId } = ctx || {};
+        // Build pattern without namespace - just APP_NAME:tenantId:segments
+        const appName = this.getAppName();
+        const sanitizedTenantId = tenantId || 'default';
+        return `${appName}:${sanitizedTenantId}:*:${queryName || '*'}:*`;
+    }
+    /**
+     * Generate cache key for a GraphQL query
+     *
+     * Format: APP_NAME:tenantId:userId:queryName:queryHash:variablesHash
+     */
+    getCacheKey(query, variables, ctx) {
+        // Generate the legacy key WITHOUT tenantId/userId since we'll add them via manual construction
+        const legacyKey = generateQueryCacheKey({
+            query,
+            variables,
+            logger: this.logger,
+        });
+        // Build key without namespace - format: APP_NAME:tenantId:userId:legacyKey
+        const appName = this.getAppName();
+        // Validate tenantId - if it looks like a hash (all hex, 24+ chars), use 'default'
+        let tenantId = ctx?.tenantId || 'default';
+        if (isHashLikeTenantId(tenantId)) {
+            this.log('warn', `TenantId appears to be a hash (${tenantId.substring(0, 16)}...), using "default" instead`);
+            tenantId = 'default';
+        }
+        const userId = ctx?.userId || 'anonymous';
+        // Sanitize components (handles Auth0 userIds like "auth0|123")
+        const sanitizedAppName = sanitizeRedisKeyComponent(appName);
+        const sanitizedTenantId = sanitizeRedisKeyComponent(tenantId);
+        const sanitizedUserId = sanitizeRedisKeyComponent(userId);
+        return `${sanitizedAppName}:${sanitizedTenantId}:${sanitizedUserId}:${legacyKey}`;
+    }
+    /**
+     * Get application name for key prefix
+     * Override this method to provide custom app name
+     */
+    getAppName() {
+        return process.env.APP_NAME || 'COMMON_STACK';
+    }
+    /**
+     * Log helper
+     */
+    log(level, message, ...args) {
+        if (this.logger && typeof this.logger[level] === 'function') {
+            this.logger[level](message, ...args);
+        }
+    }
+};
+RedisCacheManager = RedisCacheManager_1 = __decorate([
+    injectable(),
+    __param(0, inject('REDIS_CLIENT')),
+    __param(1, inject('LOGGER')),
+    __metadata("design:paramtypes", [Function, Object])
+], RedisCacheManager);
+
+export { RedisCacheManager };

package/lib/services/index.d.ts

@@ -1,8 +1,4 @@
 /**
  * Redis service implementations
- *
- * Note: Actual implementations will be migrated from:
- * - @adminide-stack/platform-server/RedisCacheManager
- * - @adminide-stack/auth0-server-core/RedisStorageBackend
  */
-export {};
+export * from './RedisCacheManager';

package/lib/templates/constants/SERVER_TYPES.ts.template

@@ -1,7 +1,6 @@
 export const SERVER_TYPES = {
     RedisClient: Symbol.for('RedisClient'),
     RedisCacheManager: Symbol.for('RedisCacheManager'),
-    RedisStorageBackend: Symbol.for('RedisStorageBackend'),
     RedisConnectionPool: Symbol.for('RedisConnectionPool'),
     RedisKeyBuilder: Symbol.for('RedisKeyBuilder'),
 };

package/lib/templates/repositories/IRedisKeyBuilder.ts.template

@@ -22,11 +22,11 @@
  * This pattern helps prevent key collisions, makes debugging easier, and enables
  * efficient bulk operations through pattern matching.
  *
- * @see RedisKeyOptions - Configuration for key building
+ * @see IRedisKeyOptions - Configuration for key building
  * @see RedisNamespace - Standard namespaces for key organization
  */
 
-import { RedisKeyOptions } from './redisCommonTypes';
+import { IRedisKeyOptions } from 'common/server';
 
 export interface IRedisKeyBuilder {
     /**
@@ -56,7 +56,7 @@ export interface IRedisKeyBuilder {
      * });
      * // Result: "APP_NAME:tenant-123:user-456:session:session-789"
      */
-    buildKey(options: RedisKeyOptions): string;
+    buildKey(options: IRedisKeyOptions): string;
 
     /**
      * Build a Redis key pattern for wildcard matching
@@ -82,7 +82,7 @@ export interface IRedisKeyBuilder {
      *   segments: ['*']
      * });
      */
-    buildPattern(options: RedisKeyOptions): string;
+    buildPattern(options: IRedisKeyOptions): string;
 
     /**
      * Sanitize a key component to ensure it's valid and safe