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

package/lib/containers/container.d.ts

@@ -0,0 +1,2 @@
+import { interfaces } from 'inversify';
+export declare const infraContainer: (settings: any) => interfaces.ContainerModule;

package/lib/containers/container.js

@@ -0,0 +1,3 @@
+import {ContainerModule}from'inversify';import {SERVER_TYPES}from'common/server';import {RedisCacheManager}from'../services/RedisCacheManager.js';const infraContainer = (settings) => new ContainerModule((bind) => {
+    bind(SERVER_TYPES.RedisCacheManager).to(RedisCacheManager).inSingletonScope();
+});export{infraContainer};//# sourceMappingURL=container.js.map

package/lib/containers/container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.js","sources":["../../src/containers/container.ts"],"sourcesContent":["import { ContainerModule, interfaces } from 'inversify';\nimport { SERVER_TYPES, IRedisCacheManager } from 'common/server';\nimport { RedisCacheManager } from '../services/RedisCacheManager';\n\nexport const infraContainer: (settings: any) => interfaces.ContainerModule = (settings: any) =>\n    new ContainerModule((bind: interfaces.Bind) => {\n        bind<IRedisCacheManager>(SERVER_TYPES.RedisCacheManager).to(RedisCacheManager).inSingletonScope();\n    });\n"],"names":[],"mappings":"kJAIO,MAAM,cAAc,GAAkD,CAAC,QAAa,KACvF,IAAI,eAAe,CAAC,CAAC,IAAqB,KAAI;AAC1C,IAAA,IAAI,CAAqB,YAAY,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,gBAAgB,EAAE,CAAC;AACtG,CAAC"}

package/lib/containers/index.d.ts

@@ -0,0 +1 @@
+export * from './container';

package/lib/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ioredis';
+export * from './upstash-redis';
+export * from './keyBuilder';

package/lib/core/ioredis.d.ts

@@ -0,0 +1,15 @@
+import Redis from 'ioredis';
+import { IRedisClient } from 'common/server';
+export declare class IORedisClient implements IRedisClient {
+    private redis;
+    constructor(config: {
+        url: 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>;
+    on(event: string, cb: (...args: any[]) => void): Redis;
+}

package/lib/core/ioredis.js

@@ -0,0 +1,27 @@
+import Redis from'ioredis';class IORedisClient {
+    redis;
+    constructor(config) {
+        this.redis = new Redis(config.url);
+    }
+    async get(key) {
+        const data = await this.redis.get(key);
+        return data;
+    }
+    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 this.redis.del(keys);
+    }
+    async del(key) {
+        return await this.redis.del(key);
+    }
+    on(event, cb) {
+        return this.redis.on(event, cb);
+    }
+}export{IORedisClient};//# sourceMappingURL=ioredis.js.map

package/lib/core/ioredis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ioredis.js","sources":["../../src/core/ioredis.ts"],"sourcesContent":["import Redis from 'ioredis';\nimport { IRedisClient } from 'common/server';\n\nexport class IORedisClient implements IRedisClient {\n    private redis: Redis;\n\n    constructor(config: { url: string }) {\n        this.redis = new Redis(config.url);\n    }\n\n    async get(key: string): Promise<any | null> {\n        const data = await this.redis.get(key);\n        return data;\n    }\n\n    async set(key: string, value: string, options?: { ex?: number }): Promise<string> {\n        if (options?.ex) {\n            return await this.redis.set(key, value, 'EX', options?.ex);\n        } else {\n            return await this.redis.set(key, value);\n        }\n    }\n\n    async delMulti(keys: string[]): Promise<any> {\n        return await this.redis.del(keys);\n    }\n\n    async del(key: string): Promise<number> {\n        return await this.redis.del(key);\n    }\n\n    on(event: string, cb: (...args: any[]) => void) {\n        return this.redis.on(event, cb);\n    }\n}\n"],"names":[],"mappings":"iCAGa,aAAa,CAAA;AACd,IAAA,KAAK,CAAQ;AAErB,IAAA,WAAA,CAAY,MAAuB,EAAA;QAC/B,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;KACtC;IAED,MAAM,GAAG,CAAC,GAAW,EAAA;QACjB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACvC,QAAA,OAAO,IAAI,CAAC;KACf;AAED,IAAA,MAAM,GAAG,CAAC,GAAW,EAAE,KAAa,EAAE,OAAyB,EAAA;AAC3D,QAAA,IAAI,OAAO,EAAE,EAAE,EAAE;AACb,YAAA,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;SAC9D;aAAM;YACH,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;SAC3C;KACJ;IAED,MAAM,QAAQ,CAAC,IAAc,EAAA;QACzB,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;KACrC;IAED,MAAM,GAAG,CAAC,GAAW,EAAA;QACjB,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;KACpC;IAED,EAAE,CAAC,KAAa,EAAE,EAA4B,EAAA;QAC1C,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;KACnC;AACJ"}

package/lib/core/keyBuilder/generate-query-cache-key.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @file generate-query-cache-key.ts
+ * @description Generates consistent cache keys for GraphQL queries
+ *
+ * This utility creates deterministic cache keys by hashing GraphQL queries and variables,
+ * with proper sanitization for Redis key compatibility (e.g., Auth0 userIds with pipes).
+ *
+ * Key format: queryName:queryHash[:variablesHash]
+ * - Query is hashed using SHA-256 for consistent, compact keys
+ * - Variables are optionally hashed if provided
+ * - All components are sanitized for Redis key safety
+ */
+import { DocumentNode } from 'graphql/language/index.js';
+export type GenerateQueryCacheKeyOptions = {
+    query: string | DocumentNode;
+    variables: Record<string, unknown>;
+    userId?: string;
+    tenantId?: string;
+    appName?: string;
+    logger?: any;
+};
+/**
+ * Generates a cache key for GraphQL queries using standardized Redis key builder
+ *
+ * Key format: `[appName]:[tenantId]:[userId]:queryName:queryHash[:variablesHash]`
+ * or legacy format: `[tenantId]:[userId]:queryName:queryHash[:variablesHash]`
+ * - Query and variables are hashed for consistent, compact keys
+ * - Uses buildRedisKey for proper sanitization and validation
+ * - Optional components are omitted if not provided
+ *
+ * @param options - Cache key generation options
+ * @returns Generated cache key string
+ *
+ * @example
+ * ```typescript
+ * // With appName (recommended)
+ * generateQueryCacheKey({
+ *   query: GetUserDocument,
+ *   variables: { userId: '123' },
+ *   userId: 'auth0|123',
+ *   tenantId: 'default',
+ *   appName: 'MY_APP',
+ *   logger: myLogger
+ * })
+ * // Returns: 'MY_APP:default:auth0-123:user:hash1:hash2'
+ *
+ * // Legacy format without appName (for backward compatibility)
+ * generateQueryCacheKey({
+ *   query: GetUserDocument,
+ *   variables: { userId: '123' },
+ *   userId: 'auth0|123',
+ *   tenantId: 'default',
+ * })
+ * // Returns: 'default:auth0-123:user:hash1:hash2'
+ * ```
+ */
+export declare const generateQueryCacheKey: ({ query, variables, logger, userId, tenantId, appName, }: GenerateQueryCacheKeyOptions) => string;

package/lib/core/keyBuilder/generate-query-cache-key.js

@@ -0,0 +1,82 @@
+import {createHash}from'crypto';import {print}from'graphql/language/index.js';import {buildRedisKey}from'./sanitize-redis-key.js';/**
+ * @file generate-query-cache-key.ts
+ * @description Generates consistent cache keys for GraphQL queries
+ *
+ * This utility creates deterministic cache keys by hashing GraphQL queries and variables,
+ * with proper sanitization for Redis key compatibility (e.g., Auth0 userIds with pipes).
+ *
+ * Key format: queryName:queryHash[:variablesHash]
+ * - Query is hashed using SHA-256 for consistent, compact keys
+ * - Variables are optionally hashed if provided
+ * - All components are sanitized for Redis key safety
+ */
+/**
+ * Generates a cache key for GraphQL queries using standardized Redis key builder
+ *
+ * Key format: `[appName]:[tenantId]:[userId]:queryName:queryHash[:variablesHash]`
+ * or legacy format: `[tenantId]:[userId]:queryName:queryHash[:variablesHash]`
+ * - Query and variables are hashed for consistent, compact keys
+ * - Uses buildRedisKey for proper sanitization and validation
+ * - Optional components are omitted if not provided
+ *
+ * @param options - Cache key generation options
+ * @returns Generated cache key string
+ *
+ * @example
+ * ```typescript
+ * // With appName (recommended)
+ * generateQueryCacheKey({
+ *   query: GetUserDocument,
+ *   variables: { userId: '123' },
+ *   userId: 'auth0|123',
+ *   tenantId: 'default',
+ *   appName: 'MY_APP',
+ *   logger: myLogger
+ * })
+ * // Returns: 'MY_APP:default:auth0-123:user:hash1:hash2'
+ *
+ * // Legacy format without appName (for backward compatibility)
+ * generateQueryCacheKey({
+ *   query: GetUserDocument,
+ *   variables: { userId: '123' },
+ *   userId: 'auth0|123',
+ *   tenantId: 'default',
+ * })
+ * // Returns: 'default:auth0-123:user:hash1:hash2'
+ * ```
+ */
+const generateQueryCacheKey = ({ query, variables, logger, userId, tenantId, appName, }) => {
+    const normalizedQuery = (typeof query === 'string' ? query : print(query)).trim();
+    const [, queryName] = normalizedQuery?.match(/{\s*(\w+)/) ?? [];
+    // Log the data right before hashing
+    if (logger && typeof logger.trace === 'function') {
+        logger.trace('About to hash normalized query: [%s]', normalizedQuery);
+        logger.trace('About to hash variables: [%j]', variables);
+    }
+    const queryHash = createHash('sha256').update(normalizedQuery).digest('hex');
+    const variablesHash = variables ? createHash('sha256').update(JSON.stringify(variables)).digest('hex') : null;
+    // Build segments: queryName, queryHash, and optional variablesHash
+    const segments = [queryName, queryHash];
+    if (variablesHash) {
+        segments.push(variablesHash);
+    }
+    // If appName is provided, use the full standardized format
+    if (appName) {
+        return buildRedisKey({
+            appName,
+            tenantId,
+            userId,
+            segments,
+        });
+    }
+    // Legacy format for backward compatibility (no appName)
+    // Still uses buildRedisKey for sanitization, but strips the appName prefix
+    const fullKey = buildRedisKey({
+        appName: '__temp__',
+        tenantId,
+        userId,
+        segments,
+    });
+    // Remove the temporary appName prefix: __temp__:
+    return fullKey.substring('__temp__:'.length);
+};export{generateQueryCacheKey};//# sourceMappingURL=generate-query-cache-key.js.map

package/lib/core/keyBuilder/generate-query-cache-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-query-cache-key.js","sources":["../../../src/core/keyBuilder/generate-query-cache-key.ts"],"sourcesContent":["/**\n * @file generate-query-cache-key.ts\n * @description Generates consistent cache keys for GraphQL queries\n *\n * This utility creates deterministic cache keys by hashing GraphQL queries and variables,\n * with proper sanitization for Redis key compatibility (e.g., Auth0 userIds with pipes).\n *\n * Key format: queryName:queryHash[:variablesHash]\n * - Query is hashed using SHA-256 for consistent, compact keys\n * - Variables are optionally hashed if provided\n * - All components are sanitized for Redis key safety\n */\n\nimport { createHash } from 'crypto';\nimport { DocumentNode, print } from 'graphql/language/index.js';\nimport { buildRedisKey } from './sanitize-redis-key';\n\nexport type GenerateQueryCacheKeyOptions = {\n    query: string | DocumentNode;\n    variables: Record<string, unknown>;\n    userId?: string;\n    tenantId?: string;\n    appName?: string;\n    logger?: any;\n};\n\n/**\n * Generates a cache key for GraphQL queries using standardized Redis key builder\n *\n * Key format: `[appName]:[tenantId]:[userId]:queryName:queryHash[:variablesHash]`\n * or legacy format: `[tenantId]:[userId]:queryName:queryHash[:variablesHash]`\n * - Query and variables are hashed for consistent, compact keys\n * - Uses buildRedisKey for proper sanitization and validation\n * - Optional components are omitted if not provided\n *\n * @param options - Cache key generation options\n * @returns Generated cache key string\n *\n * @example\n * ```typescript\n * // With appName (recommended)\n * generateQueryCacheKey({\n *   query: GetUserDocument,\n *   variables: { userId: '123' },\n *   userId: 'auth0|123',\n *   tenantId: 'default',\n *   appName: 'MY_APP',\n *   logger: myLogger\n * })\n * // Returns: 'MY_APP:default:auth0-123:user:hash1:hash2'\n *\n * // Legacy format without appName (for backward compatibility)\n * generateQueryCacheKey({\n *   query: GetUserDocument,\n *   variables: { userId: '123' },\n *   userId: 'auth0|123',\n *   tenantId: 'default',\n * })\n * // Returns: 'default:auth0-123:user:hash1:hash2'\n * ```\n */\nexport const generateQueryCacheKey = ({\n    query,\n    variables,\n    logger,\n    userId,\n    tenantId,\n    appName,\n}: GenerateQueryCacheKeyOptions): string => {\n    const normalizedQuery = (typeof query === 'string' ? query : print(query)).trim();\n    const [, queryName] = normalizedQuery?.match(/{\\s*(\\w+)/) ?? [];\n\n    // Log the data right before hashing\n    if (logger && typeof logger.trace === 'function') {\n        logger.trace('About to hash normalized query: [%s]', normalizedQuery);\n        logger.trace('About to hash variables: [%j]', variables);\n    }\n\n    const queryHash = createHash('sha256').update(normalizedQuery).digest('hex');\n    const variablesHash = variables ? createHash('sha256').update(JSON.stringify(variables)).digest('hex') : null;\n\n    // Build segments: queryName, queryHash, and optional variablesHash\n    const segments = [queryName, queryHash];\n    if (variablesHash) {\n        segments.push(variablesHash);\n    }\n\n    // If appName is provided, use the full standardized format\n    if (appName) {\n        return buildRedisKey({\n            appName,\n            tenantId,\n            userId,\n            segments,\n        });\n    }\n\n    // Legacy format for backward compatibility (no appName)\n    // Still uses buildRedisKey for sanitization, but strips the appName prefix\n    const fullKey = buildRedisKey({\n        appName: '__temp__',\n        tenantId,\n        userId,\n        segments,\n    });\n\n    // Remove the temporary appName prefix: __temp__:\n    return fullKey.substring('__temp__:'.length);\n};\n"],"names":[],"mappings":"kIAAA;;;;;;;;;;;AAWG;AAeH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACU,MAAA,qBAAqB,GAAG,CAAC,EAClC,KAAK,EACL,SAAS,EACT,MAAM,EACN,MAAM,EACN,QAAQ,EACR,OAAO,GACoB,KAAY;IACvC,MAAM,eAAe,GAAG,CAAC,OAAO,KAAK,KAAK,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;AAClF,IAAA,MAAM,GAAG,SAAS,CAAC,GAAG,eAAe,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;;IAGhE,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,UAAU,EAAE;AAC9C,QAAA,MAAM,CAAC,KAAK,CAAC,sCAAsC,EAAE,eAAe,CAAC,CAAC;AACtE,QAAA,MAAM,CAAC,KAAK,CAAC,+BAA+B,EAAE,SAAS,CAAC,CAAC;KAC5D;AAED,IAAA,MAAM,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC7E,IAAA,MAAM,aAAa,GAAG,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;;AAG9G,IAAA,MAAM,QAAQ,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;IACxC,IAAI,aAAa,EAAE;AACf,QAAA,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;KAChC;;IAGD,IAAI,OAAO,EAAE;AACT,QAAA,OAAO,aAAa,CAAC;YACjB,OAAO;YACP,QAAQ;YACR,MAAM;YACN,QAAQ;AACX,SAAA,CAAC,CAAC;KACN;;;IAID,MAAM,OAAO,GAAG,aAAa,CAAC;AAC1B,QAAA,OAAO,EAAE,UAAU;QACnB,QAAQ;QACR,MAAM;QACN,QAAQ;AACX,KAAA,CAAC,CAAC;;IAGH,OAAO,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;AACjD"}

package/lib/core/keyBuilder/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Redis Utilities
+ *
+ * Utility functions for Redis key building, sanitization, and cache key generation.
+ * These utilities provide consistent Redis key formatting across applications.
+ */
+export * from './sanitize-redis-key';
+export * from './redis-key-builder';
+export * from './generate-query-cache-key';
+import { type RedisKeyBuilderOptions } from './redis-key-builder';
+/**
+ * Simplified buildRedisKey that uses APP_NAME from environment
+ */
+export declare function buildRedisKey(options: Omit<RedisKeyBuilderOptions, 'appName'>): string;
+/**
+ * Simplified buildRedisKeyPattern that uses APP_NAME from environment
+ */
+export declare function buildRedisKeyPattern(options: Omit<RedisKeyBuilderOptions, 'appName'>): string;

package/lib/core/keyBuilder/index.js

@@ -0,0 +1,20 @@
+import {buildRedisKeyWithNamespace,buildRedisKeyPatternWithNamespace}from'./redis-key-builder.js';export{RedisNamespace,extractNamespaceFromRedisKey,extractTenantIdFromRedisKey,isValidRedisKeyWithNamespace,parseRedisKey}from'./redis-key-builder.js';import'crypto';import'graphql/language/index.js';/**
+ * Redis Utilities
+ *
+ * Utility functions for Redis key building, sanitization, and cache key generation.
+ * These utilities provide consistent Redis key formatting across applications.
+ */
+/**
+ * Simplified buildRedisKey that uses APP_NAME from environment
+ */
+function buildRedisKey(options) {
+    const appName = process.env.APP_NAME || 'APP';
+    return buildRedisKeyWithNamespace({ ...options, appName });
+}
+/**
+ * Simplified buildRedisKeyPattern that uses APP_NAME from environment
+ */
+function buildRedisKeyPattern(options) {
+    const appName = process.env.APP_NAME || 'APP';
+    return buildRedisKeyPatternWithNamespace({ ...options, appName });
+}export{buildRedisKey,buildRedisKeyPattern,buildRedisKeyPatternWithNamespace,buildRedisKeyWithNamespace};//# sourceMappingURL=index.js.map

package/lib/core/keyBuilder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/core/keyBuilder/index.ts"],"sourcesContent":["/**\n * Redis Utilities\n *\n * Utility functions for Redis key building, sanitization, and cache key generation.\n * These utilities provide consistent Redis key formatting across applications.\n */\n\nexport * from './sanitize-redis-key';\nexport * from './redis-key-builder';\nexport * from './generate-query-cache-key';\n\n// Re-export with simplified API for common use cases\nimport {\n    buildRedisKeyWithNamespace,\n    buildRedisKeyPatternWithNamespace,\n    type RedisKeyBuilderOptions,\n} from './redis-key-builder';\n\n/**\n * Simplified buildRedisKey that uses APP_NAME from environment\n */\nexport function buildRedisKey(options: Omit<RedisKeyBuilderOptions, 'appName'>): string {\n    const appName = process.env.APP_NAME || 'APP';\n    return buildRedisKeyWithNamespace({ ...options, appName });\n}\n\n/**\n * Simplified buildRedisKeyPattern that uses APP_NAME from environment\n */\nexport function buildRedisKeyPattern(options: Omit<RedisKeyBuilderOptions, 'appName'>): string {\n    const appName = process.env.APP_NAME || 'APP';\n    return buildRedisKeyPatternWithNamespace({ ...options, appName });\n}\n"],"names":[],"mappings":"0SAAA;;;;;AAKG;AAaH;;AAEG;AACG,SAAU,aAAa,CAAC,OAAgD,EAAA;IAC1E,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,KAAK,CAAC;IAC9C,OAAO,0BAA0B,CAAC,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;AAC/D,CAAC;AAED;;AAEG;AACG,SAAU,oBAAoB,CAAC,OAAgD,EAAA;IACjF,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,KAAK,CAAC;IAC9C,OAAO,iCAAiC,CAAC,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;AACtE"}

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

@@ -0,0 +1,152 @@
+/**
+ * Centralized Redis Key Builder
+ *
+ * Enforces consistent Redis key formatting across the entire application.
+ * Standard format: <APP_NAME>:<tenantId>:<namespace>:<...segments>
+ *
+ * Key Design Principles:
+ * 1. All keys MUST start with APP_NAME for application isolation
+ * 2. All keys SHOULD include tenantId for multi-tenancy (use 'default' if no tenant context)
+ * 3. Keys are sanitized to remove invalid Redis characters
+ * 4. Use namespaces to organize keys by domain/feature
+ */
+/**
+ * Options for building Redis keys with namespace support
+ */
+export interface RedisKeyBuilderOptions {
+    /** Application name for key prefix (e.g., 'CDMBASE_TEST') */
+    appName: string;
+    /** Tenant ID for multi-tenancy. Use 'default' for global/system keys */
+    tenantId?: string;
+    /** Optional user ID for user-specific keys */
+    userId?: string;
+    /** Namespace for organizing keys (e.g., 'cache', 'session', 'tenant', 'config') */
+    namespace: string;
+    /** Additional key segments (e.g., ['user', userId] or ['query', queryName]) */
+    segments: string[];
+}
+/**
+ * Builds a standardized Redis key with namespace and consistent formatting
+ *
+ * Format: <APP_NAME>:<tenantId>:<namespace>:<segment1>:<segment2>:...
+ *
+ * @param options - Key building options
+ * @returns Formatted and sanitized Redis key
+ *
+ * @example
+ * ```typescript
+ * // Cache key with tenant
+ * buildRedisKeyWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: 'tenant-123',
+ *   namespace: 'cache',
+ *   segments: ['user', userId, 'profile']
+ * });
+ * // => "CDMBASE_TEST:tenant-123:cache:user:auth0-123:profile"
+ *
+ * // Global configuration key
+ * buildRedisKeyWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: 'default',
+ *   namespace: 'config',
+ *   segments: ['extension', 'permissions']
+ * });
+ * // => "CDMBASE_TEST:default:config:extension:permissions"
+ *
+ * // Session key without tenant
+ * buildRedisKeyWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   namespace: 'session',
+ *   segments: ['abc123']
+ * });
+ * // => "CDMBASE_TEST:default:session:abc123"
+ * ```
+ */
+export declare function buildRedisKeyWithNamespace(options: RedisKeyBuilderOptions): string;
+/**
+ * Builds a wildcard pattern for Redis KEYS command with namespace support
+ *
+ * @param options - Key building options (segments can include '*' wildcards)
+ * @returns Redis key pattern for matching multiple keys
+ *
+ * @example
+ * ```typescript
+ * // Match all cache keys for a tenant
+ * buildRedisKeyPatternWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: 'tenant-123',
+ *   namespace: 'cache',
+ *   segments: ['*']
+ * });
+ * // => "CDMBASE_TEST:tenant-123:cache:*"
+ *
+ * // Match all user cache keys across all tenants
+ * buildRedisKeyPatternWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: '*',
+ *   namespace: 'cache',
+ *   segments: ['user', '*']
+ * });
+ * // => "CDMBASE_TEST:*:cache:user:*"
+ * ```
+ */
+export declare function buildRedisKeyPatternWithNamespace(options: RedisKeyBuilderOptions): string;
+/**
+ * Common namespaces used across the application
+ * These provide a standardized vocabulary for organizing Redis keys
+ */
+export declare const RedisNamespace: {
+    /** GraphQL/API response caching */
+    readonly CACHE: "cache";
+    /** User session data */
+    readonly SESSION: "session";
+    /** Tenant information cache */
+    readonly TENANT: "tenant";
+    /** Configuration and settings */
+    readonly CONFIG: "config";
+    /** Extension/plugin data */
+    readonly EXTENSION: "extension";
+    /** Contribution points */
+    readonly CONTRIBUTION: "contribution";
+    /** Request-scoped storage */
+    readonly STORAGE: "storage";
+    /** Permission and access control */
+    readonly PERMISSION: "permission";
+    /** Temporary/TTL based data */
+    readonly TEMP: "temp";
+};
+export type RedisNamespaceType = (typeof RedisNamespace)[keyof typeof RedisNamespace];
+/**
+ * Extracts tenant ID from a Redis key if present
+ *
+ * @param key - Redis key to parse
+ * @returns Tenant ID or null if not found/parseable
+ */
+export declare function extractTenantIdFromRedisKey(key: string): string | null;
+/**
+ * Extracts namespace from a Redis key if present
+ *
+ * @param key - Redis key to parse
+ * @returns Namespace or null if not found/parseable
+ */
+export declare function extractNamespaceFromRedisKey(key: string): string | null;
+/**
+ * Validates if a key follows the standard format with namespace
+ *
+ * @param key - Redis key to validate
+ * @returns True if key follows standard format
+ */
+export declare function isValidRedisKeyWithNamespace(key: string): boolean;
+/**
+ * Parses a Redis key into its components
+ *
+ * @param key - Redis key to parse
+ * @returns Parsed key components or null if invalid
+ */
+export interface ParsedRedisKey {
+    appName: string;
+    tenantId: string;
+    namespace: string;
+    segments: string[];
+}
+export declare function parseRedisKey(key: string): ParsedRedisKey | null;

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

@@ -0,0 +1,181 @@
+import {sanitizeRedisKeyComponent}from'./sanitize-redis-key.js';/**
+ * Centralized Redis Key Builder
+ *
+ * Enforces consistent Redis key formatting across the entire application.
+ * Standard format: <APP_NAME>:<tenantId>:<namespace>:<...segments>
+ *
+ * Key Design Principles:
+ * 1. All keys MUST start with APP_NAME for application isolation
+ * 2. All keys SHOULD include tenantId for multi-tenancy (use 'default' if no tenant context)
+ * 3. Keys are sanitized to remove invalid Redis characters
+ * 4. Use namespaces to organize keys by domain/feature
+ */
+/**
+ * Builds a standardized Redis key with namespace and consistent formatting
+ *
+ * Format: <APP_NAME>:<tenantId>:<namespace>:<segment1>:<segment2>:...
+ *
+ * @param options - Key building options
+ * @returns Formatted and sanitized Redis key
+ *
+ * @example
+ * ```typescript
+ * // Cache key with tenant
+ * buildRedisKeyWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: 'tenant-123',
+ *   namespace: 'cache',
+ *   segments: ['user', userId, 'profile']
+ * });
+ * // => "CDMBASE_TEST:tenant-123:cache:user:auth0-123:profile"
+ *
+ * // Global configuration key
+ * buildRedisKeyWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: 'default',
+ *   namespace: 'config',
+ *   segments: ['extension', 'permissions']
+ * });
+ * // => "CDMBASE_TEST:default:config:extension:permissions"
+ *
+ * // Session key without tenant
+ * buildRedisKeyWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   namespace: 'session',
+ *   segments: ['abc123']
+ * });
+ * // => "CDMBASE_TEST:default:session:abc123"
+ * ```
+ */
+function buildRedisKeyWithNamespace(options) {
+    const { appName, tenantId = 'default', userId, namespace, segments } = options;
+    // Sanitize all components
+    const sanitizedAppName = sanitizeRedisKeyComponent(appName);
+    const sanitizedTenantId = sanitizeRedisKeyComponent(tenantId);
+    const sanitizedNamespace = sanitizeRedisKeyComponent(namespace);
+    const sanitizedSegments = segments.map(sanitizeRedisKeyComponent);
+    // Build key with consistent format, including userId if provided
+    const parts = [sanitizedAppName, sanitizedTenantId];
+    if (userId) {
+        parts.push(sanitizeRedisKeyComponent(userId));
+    }
+    parts.push(sanitizedNamespace, ...sanitizedSegments);
+    return parts.join(':');
+}
+/**
+ * Builds a wildcard pattern for Redis KEYS command with namespace support
+ *
+ * @param options - Key building options (segments can include '*' wildcards)
+ * @returns Redis key pattern for matching multiple keys
+ *
+ * @example
+ * ```typescript
+ * // Match all cache keys for a tenant
+ * buildRedisKeyPatternWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: 'tenant-123',
+ *   namespace: 'cache',
+ *   segments: ['*']
+ * });
+ * // => "CDMBASE_TEST:tenant-123:cache:*"
+ *
+ * // Match all user cache keys across all tenants
+ * buildRedisKeyPatternWithNamespace({
+ *   appName: 'CDMBASE_TEST',
+ *   tenantId: '*',
+ *   namespace: 'cache',
+ *   segments: ['user', '*']
+ * });
+ * // => "CDMBASE_TEST:*:cache:user:*"
+ * ```
+ */
+function buildRedisKeyPatternWithNamespace(options) {
+    // For patterns, allow '*' to pass through without sanitization
+    const { appName, tenantId = '*', userId, namespace, segments } = options;
+    const sanitizedAppName = sanitizeRedisKeyComponent(appName);
+    const sanitizedTenantId = tenantId === '*' ? '*' : sanitizeRedisKeyComponent(tenantId);
+    const sanitizedNamespace = sanitizeRedisKeyComponent(namespace);
+    const sanitizedSegments = segments.map((seg) => (seg === '*' ? '*' : sanitizeRedisKeyComponent(seg)));
+    // Build pattern with userId if provided
+    const parts = [sanitizedAppName, sanitizedTenantId];
+    if (userId !== undefined) {
+        parts.push(userId === '*' ? '*' : sanitizeRedisKeyComponent(userId));
+    }
+    parts.push(sanitizedNamespace, ...sanitizedSegments);
+    return parts.join(':');
+}
+/**
+ * Common namespaces used across the application
+ * These provide a standardized vocabulary for organizing Redis keys
+ */
+const RedisNamespace = {
+    /** GraphQL/API response caching */
+    CACHE: 'cache',
+    /** User session data */
+    SESSION: 'session',
+    /** Tenant information cache */
+    TENANT: 'tenant',
+    /** Configuration and settings */
+    CONFIG: 'config',
+    /** Extension/plugin data */
+    EXTENSION: 'extension',
+    /** Contribution points */
+    CONTRIBUTION: 'contribution',
+    /** Request-scoped storage */
+    STORAGE: 'storage',
+    /** Permission and access control */
+    PERMISSION: 'permission',
+    /** Temporary/TTL based data */
+    TEMP: 'temp',
+};
+/**
+ * Extracts tenant ID from a Redis key if present
+ *
+ * @param key - Redis key to parse
+ * @returns Tenant ID or null if not found/parseable
+ */
+function extractTenantIdFromRedisKey(key) {
+    const parts = key.split(':');
+    // Format: APP_NAME:tenantId:namespace:...
+    if (parts.length >= 3) {
+        return parts[1];
+    }
+    return null;
+}
+/**
+ * Extracts namespace from a Redis key if present
+ *
+ * @param key - Redis key to parse
+ * @returns Namespace or null if not found/parseable
+ */
+function extractNamespaceFromRedisKey(key) {
+    const parts = key.split(':');
+    // Format: APP_NAME:tenantId:namespace:...
+    if (parts.length >= 3) {
+        return parts[2];
+    }
+    return null;
+}
+/**
+ * Validates if a key follows the standard format with namespace
+ *
+ * @param key - Redis key to validate
+ * @returns True if key follows standard format
+ */
+function isValidRedisKeyWithNamespace(key) {
+    const parts = key.split(':');
+    // Minimum format: APP_NAME:tenantId:namespace
+    return parts.length >= 3 && parts[0].length > 0 && parts[1].length > 0 && parts[2].length > 0;
+}
+function parseRedisKey(key) {
+    const parts = key.split(':');
+    if (parts.length < 3) {
+        return null;
+    }
+    return {
+        appName: parts[0],
+        tenantId: parts[1],
+        namespace: parts[2],
+        segments: parts.slice(3),
+    };
+}export{RedisNamespace,buildRedisKeyPatternWithNamespace,buildRedisKeyWithNamespace,extractNamespaceFromRedisKey,extractTenantIdFromRedisKey,isValidRedisKeyWithNamespace,parseRedisKey};//# sourceMappingURL=redis-key-builder.js.map

package/lib/core/keyBuilder/redis-key-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-key-builder.js","sources":["../../../src/core/keyBuilder/redis-key-builder.ts"],"sourcesContent":["/**\n * Centralized Redis Key Builder\n *\n * Enforces consistent Redis key formatting across the entire application.\n * Standard format: <APP_NAME>:<tenantId>:<namespace>:<...segments>\n *\n * Key Design Principles:\n * 1. All keys MUST start with APP_NAME for application isolation\n * 2. All keys SHOULD include tenantId for multi-tenancy (use 'default' if no tenant context)\n * 3. Keys are sanitized to remove invalid Redis characters\n * 4. Use namespaces to organize keys by domain/feature\n */\n\nimport { sanitizeRedisKeyComponent } from './sanitize-redis-key';\n\n/**\n * Options for building Redis keys with namespace support\n */\nexport interface RedisKeyBuilderOptions {\n    /** Application name for key prefix (e.g., 'CDMBASE_TEST') */\n    appName: string;\n    /** Tenant ID for multi-tenancy. Use 'default' for global/system keys */\n    tenantId?: string;\n    /** Optional user ID for user-specific keys */\n    userId?: string;\n    /** Namespace for organizing keys (e.g., 'cache', 'session', 'tenant', 'config') */\n    namespace: string;\n    /** Additional key segments (e.g., ['user', userId] or ['query', queryName]) */\n    segments: string[];\n}\n\n/**\n * Builds a standardized Redis key with namespace and consistent formatting\n *\n * Format: <APP_NAME>:<tenantId>:<namespace>:<segment1>:<segment2>:...\n *\n * @param options - Key building options\n * @returns Formatted and sanitized Redis key\n *\n * @example\n * ```typescript\n * // Cache key with tenant\n * buildRedisKeyWithNamespace({\n *   appName: 'CDMBASE_TEST',\n *   tenantId: 'tenant-123',\n *   namespace: 'cache',\n *   segments: ['user', userId, 'profile']\n * });\n * // => \"CDMBASE_TEST:tenant-123:cache:user:auth0-123:profile\"\n *\n * // Global configuration key\n * buildRedisKeyWithNamespace({\n *   appName: 'CDMBASE_TEST',\n *   tenantId: 'default',\n *   namespace: 'config',\n *   segments: ['extension', 'permissions']\n * });\n * // => \"CDMBASE_TEST:default:config:extension:permissions\"\n *\n * // Session key without tenant\n * buildRedisKeyWithNamespace({\n *   appName: 'CDMBASE_TEST',\n *   namespace: 'session',\n *   segments: ['abc123']\n * });\n * // => \"CDMBASE_TEST:default:session:abc123\"\n * ```\n */\nexport function buildRedisKeyWithNamespace(options: RedisKeyBuilderOptions): string {\n    const { appName, tenantId = 'default', userId, namespace, segments } = options;\n\n    // Sanitize all components\n    const sanitizedAppName = sanitizeRedisKeyComponent(appName);\n    const sanitizedTenantId = sanitizeRedisKeyComponent(tenantId);\n    const sanitizedNamespace = sanitizeRedisKeyComponent(namespace);\n    const sanitizedSegments = segments.map(sanitizeRedisKeyComponent);\n\n    // Build key with consistent format, including userId if provided\n    const parts = [sanitizedAppName, sanitizedTenantId];\n\n    if (userId) {\n        parts.push(sanitizeRedisKeyComponent(userId));\n    }\n\n    parts.push(sanitizedNamespace, ...sanitizedSegments);\n\n    return parts.join(':');\n}\n\n/**\n * Builds a wildcard pattern for Redis KEYS command with namespace support\n *\n * @param options - Key building options (segments can include '*' wildcards)\n * @returns Redis key pattern for matching multiple keys\n *\n * @example\n * ```typescript\n * // Match all cache keys for a tenant\n * buildRedisKeyPatternWithNamespace({\n *   appName: 'CDMBASE_TEST',\n *   tenantId: 'tenant-123',\n *   namespace: 'cache',\n *   segments: ['*']\n * });\n * // => \"CDMBASE_TEST:tenant-123:cache:*\"\n *\n * // Match all user cache keys across all tenants\n * buildRedisKeyPatternWithNamespace({\n *   appName: 'CDMBASE_TEST',\n *   tenantId: '*',\n *   namespace: 'cache',\n *   segments: ['user', '*']\n * });\n * // => \"CDMBASE_TEST:*:cache:user:*\"\n * ```\n */\nexport function buildRedisKeyPatternWithNamespace(options: RedisKeyBuilderOptions): string {\n    // For patterns, allow '*' to pass through without sanitization\n    const { appName, tenantId = '*', userId, namespace, segments } = options;\n\n    const sanitizedAppName = sanitizeRedisKeyComponent(appName);\n    const sanitizedTenantId = tenantId === '*' ? '*' : sanitizeRedisKeyComponent(tenantId);\n    const sanitizedNamespace = sanitizeRedisKeyComponent(namespace);\n    const sanitizedSegments = segments.map((seg) => (seg === '*' ? '*' : sanitizeRedisKeyComponent(seg)));\n\n    // Build pattern with userId if provided\n    const parts = [sanitizedAppName, sanitizedTenantId];\n\n    if (userId !== undefined) {\n        parts.push(userId === '*' ? '*' : sanitizeRedisKeyComponent(userId));\n    }\n\n    parts.push(sanitizedNamespace, ...sanitizedSegments);\n\n    return parts.join(':');\n}\n\n/**\n * Common namespaces used across the application\n * These provide a standardized vocabulary for organizing Redis keys\n */\nexport const RedisNamespace = {\n    /** GraphQL/API response caching */\n    CACHE: 'cache',\n    /** User session data */\n    SESSION: 'session',\n    /** Tenant information cache */\n    TENANT: 'tenant',\n    /** Configuration and settings */\n    CONFIG: 'config',\n    /** Extension/plugin data */\n    EXTENSION: 'extension',\n    /** Contribution points */\n    CONTRIBUTION: 'contribution',\n    /** Request-scoped storage */\n    STORAGE: 'storage',\n    /** Permission and access control */\n    PERMISSION: 'permission',\n    /** Temporary/TTL based data */\n    TEMP: 'temp',\n} as const;\n\nexport type RedisNamespaceType = (typeof RedisNamespace)[keyof typeof RedisNamespace];\n\n/**\n * Extracts tenant ID from a Redis key if present\n *\n * @param key - Redis key to parse\n * @returns Tenant ID or null if not found/parseable\n */\nexport function extractTenantIdFromRedisKey(key: string): string | null {\n    const parts = key.split(':');\n    // Format: APP_NAME:tenantId:namespace:...\n    if (parts.length >= 3) {\n        return parts[1];\n    }\n    return null;\n}\n\n/**\n * Extracts namespace from a Redis key if present\n *\n * @param key - Redis key to parse\n * @returns Namespace or null if not found/parseable\n */\nexport function extractNamespaceFromRedisKey(key: string): string | null {\n    const parts = key.split(':');\n    // Format: APP_NAME:tenantId:namespace:...\n    if (parts.length >= 3) {\n        return parts[2];\n    }\n    return null;\n}\n\n/**\n * Validates if a key follows the standard format with namespace\n *\n * @param key - Redis key to validate\n * @returns True if key follows standard format\n */\nexport function isValidRedisKeyWithNamespace(key: string): boolean {\n    const parts = key.split(':');\n    // Minimum format: APP_NAME:tenantId:namespace\n    return parts.length >= 3 && parts[0].length > 0 && parts[1].length > 0 && parts[2].length > 0;\n}\n\n/**\n * Parses a Redis key into its components\n *\n * @param key - Redis key to parse\n * @returns Parsed key components or null if invalid\n */\nexport interface ParsedRedisKey {\n    appName: string;\n    tenantId: string;\n    namespace: string;\n    segments: string[];\n}\n\nexport function parseRedisKey(key: string): ParsedRedisKey | null {\n    const parts = key.split(':');\n    if (parts.length < 3) {\n        return null;\n    }\n\n    return {\n        appName: parts[0],\n        tenantId: parts[1],\n        namespace: parts[2],\n        segments: parts.slice(3),\n    };\n}\n"],"names":[],"mappings":"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"}