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

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,115 @@
+/**
+ * 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};//# sourceMappingURL=sanitize-redis-key.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-redis-key.js","sources":["../../../src/core/keyBuilder/sanitize-redis-key.ts"],"sourcesContent":["/**\n * Sanitizes a Redis key component to ensure it's valid and safe\n *\n * Redis keys can contain any binary sequence, but for best practices and compatibility:\n * - Avoid whitespace (spaces, tabs, newlines) - replace with underscores\n * - Avoid pipes (|) which are used in Auth0 userIds - replace with hyphens\n * - Avoid quotes and backslashes that could cause escaping issues - remove them\n * - Avoid control characters - remove them\n *\n * @param str - The string component to sanitize\n * @returns Sanitized string safe for use in Redis keys\n *\n * @example\n * ```typescript\n * sanitizeRedisKeyComponent('auth0|6120ecbb1e5c68006aabe17a')\n * // Returns: 'auth0-6120ecbb1e5c68006aabe17a'\n *\n * sanitizeRedisKeyComponent('user name with spaces')\n * // Returns: 'user_name_with_spaces'\n * ```\n */\nexport const sanitizeRedisKeyComponent = (str: string): string => {\n    if (!str) return str;\n    return (\n        str\n            .replace(/[\\s\\r\\n\\t]+/g, '_') // Replace whitespace with underscores\n            .replace(/\\|/g, '-') // Replace pipes with hyphens (Auth0 userIds: auth0|123 -> auth0-123)\n            .replace(/[\"'\\\\]/g, '') // Remove quotes and backslashes\n            // eslint-disable-next-line no-control-regex\n            .replace(/[\\x00-\\x1F\\x7F]/g, '') // Remove control characters\n            .trim()\n    );\n};\n\n/**\n * Validates if a tenantId looks like a MongoDB ObjectId hash\n * MongoDB ObjectIds are 24 character hexadecimal strings\n *\n * @param tenantId - The tenant ID to validate\n * @returns true if the tenantId appears to be a hash, false otherwise\n */\nexport const isHashLikeTenantId = (tenantId: string): boolean => {\n    if (!tenantId || tenantId === 'default') return false;\n    return /^[a-f0-9]{24,}$/i.test(tenantId);\n};\n\n/**\n * Builds a standardized Redis key with proper tenant isolation and sanitization\n *\n * Key format: `{appName}:{tenantId}:{userId}:{...segments}`\n * - All components are sanitized to remove invalid characters\n * - TenantId is validated and replaced with 'default' if it appears to be a hash\n * - Components can be skipped by passing null/undefined\n *\n * @param options - Key building options\n * @param options.appName - Application name (e.g., 'CDMBASE_TEST')\n * @param options.tenantId - Tenant identifier (validated against hash pattern)\n * @param options.userId - User identifier (sanitized for Auth0 format)\n * @param options.segments - Additional key segments (array of strings)\n * @param options.logger - Optional logger for warnings\n * @returns Constructed Redis key\n *\n * @example\n * ```typescript\n * buildRedisKey({\n *   appName: 'CDMBASE_TEST',\n *   tenantId: 'default',\n *   userId: 'auth0|6120ecbb',\n *   segments: ['currentPagePermissions', 'hash123']\n * })\n * // Returns: 'CDMBASE_TEST:default:auth0-6120ecbb:currentPagePermissions:hash123'\n * ```\n */\nexport interface BuildRedisKeyOptions {\n    appName: string;\n    tenantId?: string;\n    userId?: string;\n    segments?: string[];\n    logger?: {\n        warn: (message: string, ...args: unknown[]) => void;\n    };\n}\n\nexport const buildRedisKey = ({ appName, tenantId, userId, segments = [], logger }: BuildRedisKeyOptions): string => {\n    // Validate and sanitize tenantId\n    let sanitizedTenantId = tenantId || 'default';\n    if (sanitizedTenantId !== 'default' && isHashLikeTenantId(sanitizedTenantId)) {\n        if (logger) {\n            logger.warn(\n                'TenantId appears to be a hash (%s...), using \"default\" instead',\n                sanitizedTenantId.substring(0, 16),\n            );\n        }\n        sanitizedTenantId = 'default';\n    }\n\n    // Build key parts\n    const parts: string[] = [sanitizeRedisKeyComponent(appName), sanitizeRedisKeyComponent(sanitizedTenantId)];\n\n    // Add userId if provided\n    if (userId) {\n        parts.push(sanitizeRedisKeyComponent(userId));\n    }\n\n    // Add additional segments\n    if (segments && segments.length > 0) {\n        parts.push(...segments.map((seg) => sanitizeRedisKeyComponent(seg)));\n    }\n\n    return parts.join(':');\n};\n\n/**\n * Builds a wildcard pattern for Redis key matching\n * Useful for bulk operations like deleting all keys matching a pattern\n *\n * @param options - Pattern building options (same as buildRedisKey)\n * @returns Redis key pattern with wildcards\n *\n * @example\n * ```typescript\n * buildRedisKeyPattern({\n *   appName: 'CDMBASE_TEST',\n *   tenantId: 'default',\n *   segments: ['currentPagePermissions']\n * })\n * // Returns: 'CDMBASE_TEST:default:*:currentPagePermissions:*'\n * ```\n */\nexport const buildRedisKeyPattern = ({\n    appName,\n    tenantId,\n    userId,\n    segments = [],\n}: Omit<BuildRedisKeyOptions, 'logger'>): string => {\n    const parts: string[] = [sanitizeRedisKeyComponent(appName), tenantId ? sanitizeRedisKeyComponent(tenantId) : '*'];\n\n    // Add userId or wildcard\n    parts.push(userId ? sanitizeRedisKeyComponent(userId) : '*');\n\n    // Add segments with wildcards\n    if (segments && segments.length > 0) {\n        parts.push(...segments.map((seg) => (seg === '*' ? '*' : sanitizeRedisKeyComponent(seg))));\n    } else {\n        parts.push('*');\n    }\n\n    return parts.join(':');\n};\n\n/**\n * Sanitizes a complete Redis key by sanitizing each component\n *\n * @param key - Redis key to sanitize\n * @returns Sanitized Redis key\n *\n * @example\n * ```typescript\n * sanitizeRedisKey('APP:tenant with spaces:cache:user|data')\n * // Returns: 'APP:tenant_with_spaces:cache:user-data'\n * ```\n */\nexport const sanitizeRedisKey = (key: string): string => {\n    if (!key) return '';\n    return key.split(':').map(sanitizeRedisKeyComponent).join(':');\n};\n\n/**\n * Escapes special Redis pattern characters for literal matching\n *\n * @param pattern - Pattern string to escape\n * @returns Escaped pattern string\n *\n * @example\n * ```typescript\n * escapeRedisPattern('file*.txt')\n * // Returns: 'file\\\\*.txt'\n * ```\n */\nexport const escapeRedisPattern = (pattern: string): string => {\n    if (!pattern) return '';\n    return pattern.replace(/[*?[\\]^\\\\]/g, '\\\\$&');\n};\n\n/**\n * Validates if a Redis key is properly formatted\n *\n * @param key - Redis key to validate\n * @returns true if key is valid, false otherwise\n */\nexport const isValidRedisKey = (key: string): boolean => {\n    if (!key || typeof key !== 'string') return false;\n    if (key.length > 512) return false; // Redis key length limit\n    // Check for invalid characters (whitespace, pipes, etc.)\n    if (/[\\s|\"'\\\\]/.test(key)) return false;\n    return true;\n};\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;AAoBG;AACU,MAAA,yBAAyB,GAAG,CAAC,GAAW,KAAY;AAC7D,IAAA,IAAI,CAAC,GAAG;AAAE,QAAA,OAAO,GAAG,CAAC;AACrB,IAAA,QACI,GAAG;AACE,SAAA,OAAO,CAAC,cAAc,EAAE,GAAG,CAAC;AAC5B,SAAA,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;AACnB,SAAA,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;;AAEtB,SAAA,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC;SAC/B,IAAI,EAAE,EACb;AACN,EAAE;AAEF;;;;;;AAMG;AACU,MAAA,kBAAkB,GAAG,CAAC,QAAgB,KAAa;AAC5D,IAAA,IAAI,CAAC,QAAQ,IAAI,QAAQ,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK,CAAC;AACtD,IAAA,OAAO,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC7C,EAAE;AAuCW,MAAA,aAAa,GAAG,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,EAAE,EAAE,MAAM,EAAwB,KAAY;;AAEhH,IAAA,IAAI,iBAAiB,GAAG,QAAQ,IAAI,SAAS,CAAC;IAC9C,IAAI,iBAAiB,KAAK,SAAS,IAAI,kBAAkB,CAAC,iBAAiB,CAAC,EAAE;QAC1E,IAAI,MAAM,EAAE;AACR,YAAA,MAAM,CAAC,IAAI,CACP,gEAAgE,EAChE,iBAAiB,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,CACrC,CAAC;SACL;QACD,iBAAiB,GAAG,SAAS,CAAC;KACjC;;AAGD,IAAA,MAAM,KAAK,GAAa,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAAE,yBAAyB,CAAC,iBAAiB,CAAC,CAAC,CAAC;;IAG3G,IAAI,MAAM,EAAE;QACR,KAAK,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,CAAC,CAAC;KACjD;;IAGD,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;AACjC,QAAA,KAAK,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,yBAAyB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KACxE;AAED,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC3B,EAAE;AAwCF;;;;;;;;;;;AAWG;AACU,MAAA,gBAAgB,GAAG,CAAC,GAAW,KAAY;AACpD,IAAA,IAAI,CAAC,GAAG;AAAE,QAAA,OAAO,EAAE,CAAC;AACpB,IAAA,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACnE,EAAE;AAEF;;;;;;;;;;;AAWG;AACU,MAAA,kBAAkB,GAAG,CAAC,OAAe,KAAY;AAC1D,IAAA,IAAI,CAAC,OAAO;AAAE,QAAA,OAAO,EAAE,CAAC;IACxB,OAAO,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;AAClD,EAAE;AAEF;;;;;AAKG;AACU,MAAA,eAAe,GAAG,CAAC,GAAW,KAAa;AACpD,IAAA,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;AAAE,QAAA,OAAO,KAAK,CAAC;AAClD,IAAA,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG;QAAE,OAAO,KAAK,CAAC;;AAEnC,IAAA,IAAI,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC;AAAE,QAAA,OAAO,KAAK,CAAC;AACxC,IAAA,OAAO,IAAI,CAAC;AAChB"}

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,23 @@
+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};//# sourceMappingURL=upstash-redis.js.map

package/lib/core/upstash-redis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstash-redis.js","sources":["../../src/core/upstash-redis.ts"],"sourcesContent":["import { Redis } from '@upstash/redis/cloudflare';\nimport { IRedisClient } from 'common/server';\n\nexport class UpstashRedisClient implements IRedisClient {\n    private redis: Redis;\n\n    constructor(config: { url: string; token?: string }) {\n        this.redis = new Redis({ url: config.url, token: config.token });\n    }\n\n    async get(key: string): Promise<any | null> {\n        return await this.redis.get(key);\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 Promise.all(keys.map((key) => this.redis.del(key)));\n    }\n\n    async del(key: string): Promise<number> {\n        return await this.redis.del(key);\n    }\n}\n"],"names":[],"mappings":"oDAGa,kBAAkB,CAAA;AACnB,IAAA,KAAK,CAAQ;AAErB,IAAA,WAAA,CAAY,MAAuC,EAAA;QAC/C,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;KACpE;IAED,MAAM,GAAG,CAAC,GAAW,EAAA;QACjB,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;KACpC;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,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;SAChE;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,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KACpE;IAED,MAAM,GAAG,CAAC,GAAW,EAAA;QACjB,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;KACpC;AACJ"}

package/lib/graphql/schema/base-services.graphql

@@ -0,0 +1,134 @@
+"""
+Standard Redis namespaces for organizing keys.
+Using namespaces helps prevent key collisions and makes bulk operations easier.
+"""
+enum RedisNamespace {
+    """Cache-related keys"""
+    cache
+    """Session data keys"""
+    session
+    """Tenant-specific keys"""
+    tenant
+    """Configuration keys"""
+    config
+    """Extension-related keys"""
+    extension
+    """Contribution-related keys"""
+    contribution
+    """Storage keys"""
+    storage
+    """Permission keys"""
+    permission
+    """Temporary keys"""
+    temp
+    """Queue-related keys"""
+    queue
+    """Lock keys"""
+    lock
+}
+
+"""
+Options for building Redis keys with standardized format.
+Example: APP_NAME:tenant-123:cache:user:profile
+"""
+input RedisKeyOptions {
+    """Tenant ID for multi-tenant isolation (defaults to 'default')"""
+    tenantId: String
+    """Namespace to categorize keys (e.g., 'cache', 'session', 'storage')"""
+    namespace: String!
+    """Additional key segments to append"""
+    segments: [String!]!
+    """Optional user ID for user-specific keys"""
+    userId: String
+}
+
+"""
+Context for cache operations.
+Provides tenant, user, and organization isolation for cached data.
+"""
+input CacheContext {
+    """Tenant identifier for multi-tenant applications"""
+    tenantId: String
+    """User identifier for user-specific caching"""
+    userId: String
+    """Organization identifier for org-level caching"""
+    orgId: String
+}
+
+"""
+Cache policy for controlling cache behavior.
+"""
+input CachePolicy {
+    """Maximum age in seconds (TTL)"""
+    maxAge: Int!
+    """Cache scope (PUBLIC, PRIVATE, etc.)"""
+    scope: String
+}
+
+"""
+Options for scanning Redis keys.
+Used for iterating through keys matching a pattern.
+"""
+input RedisScanOptions {
+    """Pattern to match keys (supports wildcards)"""
+    match: String
+    """Number of keys to return per iteration"""
+    count: Int
+    """Optional Redis data type to filter by"""
+    type: RedisDataType
+}
+
+"""
+Redis data types for filtering scan operations
+"""
+enum RedisDataType {
+    string
+    list
+    set
+    zset
+    hash
+    stream
+}
+
+"""
+Result from a Redis SCAN operation
+"""
+type RedisScanResult {
+    """Next cursor position (0 means scan is complete)"""
+    cursor: String!
+    """Array of keys matching the scan criteria"""
+    keys: [String!]!
+}
+
+"""
+Options for Redis bulk operations.
+Used when performing operations on multiple keys.
+"""
+input RedisBulkOptions {
+    """Whether to use Redis pipeline for batch operations"""
+    pipeline: Boolean
+    """Whether to wrap operations in a MULTI/EXEC transaction"""
+    transaction: Boolean
+}
+
+"""
+Redis connection configuration
+"""
+input RedisConnectionConfig {
+    """Redis server host"""
+    host: String
+    """Redis server port"""
+    port: Int
+    """Optional password for authentication"""
+    password: String
+    """Database number to use"""
+    db: Int
+    """Prefix to add to all keys"""
+    keyPrefix: String
+    """Maximum retry attempts"""
+    maxRetriesPerRequest: Int
+    """Whether to check connection is ready"""
+    enableReadyCheck: Boolean
+    """Whether to delay connection until first command"""
+    lazyConnect: Boolean
+}

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 @@
-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';//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

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,4 @@
+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};//# sourceMappingURL=module.js.map

package/lib/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sources":["../src/module.ts"],"sourcesContent":["import { Feature } from '@common-stack/server-core';\nimport { infraContainer } from './containers';\n\nexport default new Feature({\n    createContainerFunc: [infraContainer],\n    createMicroServiceContainerFunc: [infraContainer],\n});\n"],"names":[],"mappings":"uGAGA,aAAe,IAAI,OAAO,CAAC;IACvB,mBAAmB,EAAE,CAAC,cAAc,CAAC;IACrC,+BAA+B,EAAE,CAAC,cAAc,CAAC;AACpD,CAAA,CAAC"}

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;
+}