@candlerip/shared 0.0.127 → 0.0.130

package/cache/common/cache-data/domains.d.ts

@@ -0,0 +1,4 @@
+import { Cache } from '../cache/index.js';
+type ElementOrArray<T> = T extends readonly (infer U)[] ? U | T : T;
+export type CacheData = ElementOrArray<Cache[keyof Cache]>;
+export {};

package/cache/common/cache-data/domains.js

@@ -0,0 +1 @@
+export {};

package/cache/common/cache-data/index.d.ts

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

package/cache/common/cache-data/index.js

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

package/cache/common/cache-key/index.d.ts

@@ -6,3 +6,4 @@ export * from './language-dictionary-cache-key/index.js';
 export * from './page-dictionary-cache-key/index.js';
 export * from './page-data-cache-key/index.js';
 export * from './page-data-dictionary-cache-key/index.js';
+export * from './candle-lighting-profiles-cache-key/index.js';

package/cache/common/cache-key/index.js

@@ -6,3 +6,4 @@ export * from './language-dictionary-cache-key/index.js';
 export * from './page-dictionary-cache-key/index.js';
 export * from './page-data-cache-key/index.js';
 export * from './page-data-dictionary-cache-key/index.js';
+export * from './candle-lighting-profiles-cache-key/index.js';

package/cache/common/index.d.ts

@@ -1,2 +1,3 @@
 export * from './cache/index.js';
 export * from './cache-key/index.js';
+export * from './cache-data/index.js';

package/cache/common/index.js

@@ -1,2 +1,3 @@
 export * from './cache/index.js';
 export * from './cache-key/index.js';
+export * from './cache-data/index.js';

package/cache/redis/workers/compose-redis-get-data/index.d.ts

@@ -0,0 +1,2 @@
+import { ComposeGetRedisData } from './type.js';
+export declare const composeGetRedisData: ComposeGetRedisData;

package/cache/redis/workers/compose-redis-get-data/index.js

@@ -0,0 +1,26 @@
+import { isString } from '../../../../common/index.js';
+export const composeGetRedisData = (props) => {
+    const { cacheKey } = props;
+    let objKey;
+    if ('objKey' in props && props.objKey) {
+        objKey = props.objKey;
+    }
+    let objKeys;
+    if ('objKeys' in props && props.objKeys) {
+        objKeys = props.objKeys;
+    }
+    let pathKeys;
+    if (objKey) {
+        const [key, value] = Object.entries(objKey)[0];
+        pathKeys = `$.[?(@.${key}==${isString(value) ? `"${value}"` : value})]`;
+    }
+    if (objKeys) {
+        pathKeys = objKeys?.map((it) => `$.${it}`);
+    }
+    return {
+        cacheKey,
+        objKey,
+        objKeys,
+        pathKeys,
+    };
+};

package/cache/redis/workers/compose-redis-get-data/type.d.ts

@@ -0,0 +1,11 @@
+import { CacheKey } from '../../../common/index.js';
+import { ObjKey, ObjKeys } from '../type.js';
+export type ComposeGetRedisData = (props: {
+    cacheKey: CacheKey;
+    objKey?: ObjKey;
+    objKeys?: ObjKeys;
+}) => {
+    cacheKey: CacheKey;
+    objKeys?: ObjKeys;
+    pathKeys: string | string[] | undefined;
+};

package/cache/redis/workers/compose-redis-get-data/type.js

@@ -0,0 +1 @@
+export {};

package/cache/redis/workers/index.js

@@ -1,5 +1,6 @@
-import { CustomErrorWorker, isArray, isString } from '../../../common/index.js';
+import { CustomErrorWorker } from '../../../common/index.js';
 import { createClient } from 'redis';
+import { composeGetRedisData } from './compose-redis-get-data/index.js';
 export const CacheWorker = (environmentMode, url, password, options) => {
     const _isEnabled = Boolean(options?.isEnabled);
     const customErrorWorker = CustomErrorWorker();
@@ -37,138 +38,99 @@ export const CacheWorker = (environmentMode, url, password, options) => {
             data: _client,
         };
     };
-    const getCache = async (key) => {
-        const { composeCustomError } = CustomErrorWorker({ info: { key } });
-        const { data: client, customError } = _getClient();
-        if (customError) {
-            return { customError };
-        }
-        let data;
-        try {
-            const cache = await client.get(key);
-            if (cache) {
-                data = JSON.parse(cache);
-            }
-        }
-        catch (err) {
-            return {
-                customError: composeCustomError('Error get data from Redis', { err }),
-            };
-        }
-        if (!data) {
-            return {
-                customError: composeCustomError('No data in Redis'),
-            };
-        }
-        return {
-            data,
-        };
-    };
-    const mGetCache = async (keys) => {
-        const { composeCustomError } = CustomErrorWorker({ info: { keys } });
+    const getCache = async (props) => {
+        const { composeCustomError } = CustomErrorWorker({ info: props });
+        const { cacheKey, objKeys, pathKeys } = composeGetRedisData(props);
         const { data: client, customError } = _getClient();
         if (customError) {
             return { customError };
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const data = {};
+        let data;
         try {
-            const cache = await client.mGet(keys);
-            if (!isArray(cache, isString)) {
+            data = await client.json.get(cacheKey, { path: pathKeys });
+            if (!data || data?.length === 0) {
                 return {
-                    customError: composeCustomError('Error get data from redis', { cache }),
+                    customError: composeCustomError('No data in Redis'),
                 };
             }
-            cache.forEach((it, i) => {
-                data[keys[i]] = JSON.parse(it);
-            });
         }
         catch (err) {
             return {
-                customError: composeCustomError('Error get data from redis', { err }),
-            };
-        }
-        if (Object.keys(data).length !== keys.length) {
-            return {
-                customError: composeCustomError('Missing data from redis', { data }),
+                customError: composeCustomError('Error get data by object keys from Redis', { err }),
             };
         }
-        return {
-            data,
-        };
-    };
-    const setCache = async (key, data) => {
-        const { composeCustomError } = CustomErrorWorker({ info: { key } });
-        const { data: client, customError } = _getClient();
-        if (customError) {
-            return { customError };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let normalizedData = {};
+        if (objKeys) {
+            objKeys.forEach((objKey) => {
+                normalizedData[objKey] = objKeys?.length === 1 ? data[0] : data[`$.${objKey}`][0];
+            });
         }
-        try {
-            await client.set(key, JSON.stringify(data));
+        else {
+            normalizedData = data;
         }
-        catch (err) {
+        if (Object.keys(normalizedData).some((key) => normalizedData[key] === null)) {
             return {
-                customError: composeCustomError('Error set data to redis', { err }),
+                customError: composeCustomError('Error get data by object keys from Redis', { data }),
             };
         }
         return {
-            data: null,
+            data: normalizedData,
         };
     };
-    const hGetCache = async (cacheKey, objKeys) => {
-        const { composeCustomError } = CustomErrorWorker({ info: { cacheKey, objKeys } });
+    const mGetCache = async (props) => {
+        const { composeCustomError } = CustomErrorWorker({ info: { props } });
+        const getRedisData = props.map((it) => composeGetRedisData(it));
         const { data: client, customError } = _getClient();
         if (customError) {
             return { customError };
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         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) {
+        try {
+            const promises = getRedisData.map((it) => client.json.get(it.cacheKey, { path: it.pathKeys }));
+            data = await Promise.all(promises);
+            console.error('***', data);
+            if (!data || data.some((it) => it.length === 0)) {
                 return {
-                    customError: composeCustomError('Error get data from Redis', { err }),
+                    customError: composeCustomError('No data in Redis'),
                 };
             }
         }
-        try {
-            data = await client.hmGet(cacheKey, objKeys);
-        }
         catch (err) {
             return {
                 customError: composeCustomError('Error get data by object keys from Redis', { err }),
             };
         }
-        if (data.some((item) => item === null)) {
-            return {
-                customError: composeCustomError('Error get data by object keys from Redis', { data }),
-            };
-        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const normalizedData = {};
+        getRedisData.forEach((it, index) => {
+            const { objKeys } = it;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let normalizedCacheKeyData = {};
+            if (objKeys) {
+                objKeys.forEach((objKey) => {
+                    normalizedCacheKeyData[objKey] = objKeys?.length === 1 ? data[index][0] : data[index][`$.${objKey}`][0];
+                });
+            }
+            else {
+                normalizedCacheKeyData = data[index];
+            }
+            normalizedData[it.cacheKey] = normalizedCacheKeyData;
+        });
         return {
-            data: data.reduce((acc, curr, index) => ({
-                ...acc,
-                [objKeys[index]]: curr,
-            }), {}),
+            data: normalizedData,
         };
     };
-    const hSetCache = async (key, data) => {
+    const setCache = async (key, data) => {
         const { composeCustomError } = CustomErrorWorker({ info: { key } });
         const { data: client, customError } = _getClient();
         if (customError) {
             return { customError };
         }
         try {
-            await client.del(key);
-            await _client.json.set(key, '$', data);
+            await client.json.set(key, '$', data);
         }
         catch (err) {
             return {
@@ -180,8 +142,6 @@ export const CacheWorker = (environmentMode, url, password, options) => {
         };
     };
     return {
-        hGetCache,
-        hSetCache,
         getCache,
         mGetCache,
         setCache,

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

@@ -1,19 +1,34 @@
 import { EnvironmentMode, TCustomError } from '../../../common/index.js';
-import { Cache } from '../../common/cache/domains.js';
+import { CacheKey, CandleLightingProfilesCacheKey, Cache, CacheData } from '../../common/index.js';
 import { createClient } from 'redis';
-import { CacheKey, 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 SetCache = <T extends keyof Cache>(key: T, data: Cache[T]) => Promise<TCustomError<null>>;
+export type GetCache = <T extends CacheData = never, C extends CacheKey = CacheKey>(props: GetCacheProps<C>) => Promise<TCustomError<T>>;
+export type GetCacheProps<C extends CacheKey> = C extends CandleLightingProfilesCacheKey ? {
+    cacheKey: C;
+    objKey?: ObjKey;
+} : {
+    cacheKey: C;
+    objKeys?: string[];
+};
+export type MGetCache = <T extends {
+    [key in CacheKey]?: CacheData;
+} = never, C extends CacheKey = CacheKey>(props: GetCacheProps<C>[]) => Promise<TCustomError<T>>;
+export type ObjKeys = string[];
+export type ObjKey = {
+    code: number;
+    _id?: never;
+} | {
+    code?: never;
+    _id: string;
+} | {
+    code?: never;
+    _id?: never;
+};

package/database/model/candle-lighting-profile/configs/index.d.ts

@@ -3,13 +3,13 @@ export declare const CandleLightingProfileDbSchema: mongoose.Schema<any, mongoos
     versionKey: false;
 }, {
     createdAt?: NativeDate | null | undefined;
-    burningSeconds?: number | null | undefined;
     code?: string | null | undefined;
+    burningSeconds?: number | null | undefined;
     isDefault?: boolean | null | undefined;
 }, mongoose.Document<unknown, {}, {
     createdAt?: NativeDate | null | undefined;
-    burningSeconds?: number | null | undefined;
     code?: string | null | undefined;
+    burningSeconds?: number | null | undefined;
     isDefault?: boolean | null | undefined;
 }, {
     id: string;
@@ -17,8 +17,8 @@ export declare const CandleLightingProfileDbSchema: mongoose.Schema<any, mongoos
     versionKey: false;
 }>> & Omit<{
     createdAt?: NativeDate | null | undefined;
-    burningSeconds?: number | null | undefined;
     code?: string | null | undefined;
+    burningSeconds?: number | null | undefined;
     isDefault?: boolean | null | undefined;
 } & {
     _id: mongoose.Types.ObjectId;
@@ -29,8 +29,8 @@ export declare const CandleLightingProfileDbSchema: mongoose.Schema<any, mongoos
 } | {
     [x: string]: mongoose.SchemaDefinitionProperty<any, any, mongoose.Document<unknown, {}, {
         createdAt?: NativeDate | null | undefined;
-        burningSeconds?: number | null | undefined;
         code?: string | null | undefined;
+        burningSeconds?: number | null | undefined;
         isDefault?: boolean | null | undefined;
     }, {
         id: string;
@@ -38,8 +38,8 @@ export declare const CandleLightingProfileDbSchema: mongoose.Schema<any, mongoos
         versionKey: false;
     }>> & Omit<{
         createdAt?: NativeDate | null | undefined;
-        burningSeconds?: number | null | undefined;
         code?: string | null | undefined;
+        burningSeconds?: number | null | undefined;
         isDefault?: boolean | null | undefined;
     } & {
         _id: mongoose.Types.ObjectId;
@@ -48,8 +48,8 @@ export declare const CandleLightingProfileDbSchema: mongoose.Schema<any, mongoos
     }> | undefined;
 }, {
     createdAt?: NativeDate | null | undefined;
-    burningSeconds?: number | null | undefined;
     code?: string | null | undefined;
+    burningSeconds?: number | null | undefined;
     isDefault?: boolean | null | undefined;
 } & {
     _id: mongoose.Types.ObjectId;

package/package.json

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