@candlerip/shared 0.0.124 → 0.0.129

package/cache/redis/workers/index.js

@@ -1,4 +1,4 @@
-import { CustomErrorWorker, isArray, isString } from '../../../common/index.js';
+import { CustomErrorWorker } from '../../../common/index.js';
 import { createClient } from 'redis';
 export const CacheWorker = (environmentMode, url, password, options) => {
     const _isEnabled = Boolean(options?.isEnabled);
@@ -37,64 +37,45 @@ export const CacheWorker = (environmentMode, url, password, options) => {
             data: _client,
         };
     };
-    const getCache = async (key) => {
-        const { composeCustomError } = CustomErrorWorker({ info: { key } });
+    const getCache = async (cacheKey, objKeys) => {
+        const { composeCustomError } = CustomErrorWorker({ info: { cacheKey, objKeys } });
         const { data: client, customError } = _getClient();
         if (customError) {
             return { customError };
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let data;
+        const pathKeys = objKeys?.map((it) => `$.${it}`);
         try {
-            const cache = await client.get(key);
-            if (cache) {
-                data = JSON.parse(cache);
+            data = await client.json.get(cacheKey, { path: pathKeys });
+            if (!data) {
+                return {
+                    customError: composeCustomError('No data in Redis'),
+                };
             }
         }
         catch (err) {
             return {
-                customError: composeCustomError('Error get data from Redis', { err }),
-            };
-        }
-        if (!data) {
-            return {
-                customError: composeCustomError('No data in Redis'),
+                customError: composeCustomError('Error get data by object keys from Redis', { err }),
             };
         }
-        return {
-            data,
-        };
-    };
-    const mGetCache = async (keys) => {
-        const { composeCustomError } = CustomErrorWorker({ info: { keys } });
-        const { data: client, customError } = _getClient();
-        if (customError) {
-            return { customError };
-        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const data = {};
-        try {
-            const cache = await client.mGet(keys);
-            if (!isArray(cache, isString)) {
-                return {
-                    customError: composeCustomError('Error get data from redis', { cache }),
-                };
-            }
-            cache.forEach((it, i) => {
-                data[keys[i]] = JSON.parse(it);
+        let normalizedData = {};
+        if (objKeys) {
+            objKeys.forEach((objKey) => {
+                normalizedData[objKey] = data[`$.${objKey}`][0];
             });
         }
-        catch (err) {
-            return {
-                customError: composeCustomError('Error get data from redis', { err }),
-            };
+        else {
+            normalizedData = data;
         }
-        if (Object.keys(data).length !== keys.length) {
+        if (Object.keys(normalizedData).some((key) => normalizedData[key] === null)) {
             return {
-                customError: composeCustomError('Missing data from redis', { data }),
+                customError: composeCustomError('Error get data by object keys from Redis', { data }),
             };
         }
         return {
-            data,
+            data: normalizedData,
         };
     };
     const setCache = async (key, data) => {
@@ -104,65 +85,7 @@ export const CacheWorker = (environmentMode, url, password, options) => {
             return { customError };
         }
         try {
-            await client.set(key, JSON.stringify(data));
-        }
-        catch (err) {
-            return {
-                customError: composeCustomError('Error set data to redis', { err }),
-            };
-        }
-        return {
-            data: null,
-        };
-    };
-    const hGetCache = async (cacheKey, objKeys) => {
-        const { composeCustomError } = CustomErrorWorker({ info: { cacheKey, objKeys } });
-        const { data: client, customError } = _getClient();
-        if (customError) {
-            return { customError };
-        }
-        let data;
-        if (!objKeys) {
-            try {
-                data = await client.hGetAll(cacheKey);
-                if (Object.keys(data).length === 0) {
-                    return {
-                        customError: composeCustomError('No data in Redis'),
-                    };
-                }
-                return {
-                    data,
-                };
-            }
-            catch (err) {
-                return {
-                    customError: composeCustomError('Error get data from Redis', { err }),
-                };
-            }
-        }
-        try {
-            data = await client.hmGet(cacheKey, objKeys);
-        }
-        catch (err) {
-            return {
-                customError: composeCustomError('Error get data by object keys from Redis', { err }),
-            };
-        }
-        return {
-            data: data.reduce((acc, curr, index) => ({
-                ...acc,
-                [objKeys[index]]: curr,
-            }), {}),
-        };
-    };
-    const hSetCache = async (key, data) => {
-        const { composeCustomError } = CustomErrorWorker({ info: { key } });
-        const { data: client, customError } = _getClient();
-        if (customError) {
-            return { customError };
-        }
-        try {
-            await client.hSet(key, data);
+            await client.json.set(key, '$', data);
         }
         catch (err) {
             return {
@@ -174,10 +97,7 @@ export const CacheWorker = (environmentMode, url, password, options) => {
         };
     };
     return {
-        hGetCache,
-        hSetCache,
         getCache,
-        mGetCache,
         setCache,
     };
 };

package/cache/redis/workers/type.d.ts

@@ -1,19 +1,13 @@
 import { EnvironmentMode, TCustomError } from '../../../common/index.js';
 import { Cache } from '../../common/cache/domains.js';
 import { createClient } from 'redis';
-import { CacheKey, CommonPageDictionaryCacheKey } from '../../common/index.js';
+import { CommonPageDictionaryCacheKey } from '../../common/index.js';
 export type TCacheWorker = (environmentMode: EnvironmentMode, url: string, password: string, options?: {
     isEnabled?: boolean;
 }) => {
     getCache: GetCache;
-    hGetCache: HGetCache;
-    hSetCache: HSetCache;
-    mGetCache: MGetCache;
     setCache: SetCache;
 };
-export type GetCache = <T extends CacheKey = never, D extends Cache[T] = Cache[T]>(key: T) => Promise<TCustomError<D>>;
-export type MGetCache = <T extends CacheKey = never, D extends Pick<Cache, T> = Pick<Cache, T>>(keys: T[]) => Promise<TCustomError<D>>;
-export type SetCache = <T extends CacheKey = never>(key: T, data: Cache[T]) => Promise<TCustomError<null>>;
 export type GetClient = () => TCustomError<ReturnType<typeof createClient>>;
-export type HGetCache = <T extends CommonPageDictionaryCacheKey, D extends Cache[T]>(cacheKey: T, objKeys?: string[]) => Promise<TCustomError<D>>;
-export type HSetCache = <T extends CommonPageDictionaryCacheKey>(key: T, data: Cache[T]) => Promise<TCustomError<null>>;
+export type GetCache = <T extends CommonPageDictionaryCacheKey, D extends Cache[T]>(cacheKey: T, objKeys?: string[]) => Promise<TCustomError<D>>;
+export type SetCache = <T extends CommonPageDictionaryCacheKey>(key: T, data: Cache[T]) => Promise<TCustomError<null>>;

package/common/translation/translation-code/page/utils/filter-page-translation-codes/index.js

@@ -15,5 +15,6 @@ export const filterPageTranslationCodes = (variant, options) => PAGE_TRANSLATION
         if (isPageMenu(variant) && code === `pageMenu.${variant}`) {
             return false;
         }
+        return true;
     }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@candlerip/shared",
-  "version": "0.0.124",
+  "version": "0.0.129",
   "type": "module",
   "engines": {
     "node": "=22.19.0"