@candlerip/shared3 0.0.121 → 0.0.123

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@candlerip/shared3",
-  "version": "0.0.121",
+  "version": "0.0.123",
   "type": "module",
   "exports": {
     ".": "./src/index.js",

package/src/aws/app-config/get-app-config/util.js

@@ -11,45 +11,63 @@ export const getAppConfig = async (props) => {
         resp = await client.send(new appConfigSdk.ListApplicationsCommand());
     }
     catch (err) {
-        return composeCustomError('Error during list AppConfig Applications', { err });
+        return {
+            customError: composeCustomError('Error during list AppConfig Applications', { err }),
+        };
     }
     const applications = resp.Items;
     if (!applications) {
-        return composeCustomError('No AppConfig Applications found');
+        return {
+            customError: composeCustomError('No AppConfig Applications found'),
+        };
     }
     const application = applications.find((it) => it.Name === projectName);
     if (!application) {
-        return composeCustomError('AppConfig Application not found');
+        return {
+            customError: composeCustomError('AppConfig Application not found'),
+        };
     }
     const applicationId = application.Id;
     try {
         resp = await client.send(new appConfigSdk.ListEnvironmentsCommand({ ApplicationId: applicationId }));
     }
     catch (err) {
-        return composeCustomError('Error during list AppConfig Environments', { err });
+        return {
+            customError: composeCustomError('Error during list AppConfig Environments', { err }),
+        };
     }
     const environments = resp.Items;
     if (!environments) {
-        return composeCustomError('No AppConfig Environments found');
+        return {
+            customError: composeCustomError('No AppConfig Environments found'),
+        };
     }
     const environment = environments.find((it) => it.Name === environmentMode);
     if (!environment) {
-        return composeCustomError('AppConfig Environment not found');
+        return {
+            customError: composeCustomError('AppConfig Environment not found'),
+        };
     }
     const environmentId = environment.Id;
     try {
         resp = await client.send(new appConfigSdk.ListConfigurationProfilesCommand({ ApplicationId: applicationId }));
     }
     catch (err) {
-        return composeCustomError('Error during list AppConfig Configuration Profiles', { err });
+        return {
+            customError: composeCustomError('Error during list AppConfig Configuration Profiles', { err }),
+        };
     }
     const configurationProfiles = resp.Items;
     if (!configurationProfiles) {
-        return composeCustomError('No AppConfig Configuration Profiles found');
+        return {
+            customError: composeCustomError('No AppConfig Configuration Profiles found'),
+        };
     }
     const configurationProfile = configurationProfiles.find((it) => it.Name === `${environmentMode}-profile`);
     if (!configurationProfile) {
-        return composeCustomError('AppConfig Configuration Profile not found');
+        return {
+            customError: composeCustomError('AppConfig Configuration Profile not found'),
+        };
     }
     const configurationProfileId = configurationProfile.Id;
     client = new appConfigDataSdk.AppConfigDataClient();
@@ -61,7 +79,9 @@ export const getAppConfig = async (props) => {
         }));
     }
     catch (err) {
-        return composeCustomError('Error during get AppConfig initial configuration token', { err });
+        return {
+            customError: composeCustomError('Error during get AppConfig initial configuration token', { err }),
+        };
     }
     const ConfigurationToken = resp.InitialConfigurationToken;
     let appConfig;
@@ -71,7 +91,9 @@ export const getAppConfig = async (props) => {
         appConfig = JSON.parse(appConfigStr);
     }
     catch (err) {
-        return composeCustomError('Error during get AppConfig', { err });
+        return {
+            customError: composeCustomError('Error during get AppConfig', { err }),
+        };
     }
     return {
         data: appConfig,

package/src/backend/cache/cache/singleton.js

@@ -8,10 +8,14 @@ export const CacheSingleton = (() => {
     let _customErrorWorker;
     const checkErrorStatus = () => {
         if (!_isEnabled) {
-            return _customErrorWorker.composeCustomError('Cache disabled');
+            return {
+                customError: _customErrorWorker.composeCustomError('Cache disabled'),
+            };
         }
         if (_err) {
-            return _customErrorWorker.composeCustomError('Error connect Cache', { err: _err });
+            return {
+                customError: _customErrorWorker.composeCustomError('Error connect Cache', { err: _err }),
+            };
         }
         return;
     };
@@ -44,10 +48,14 @@ export const CacheSingleton = (() => {
             }
         }
         catch (err) {
-            return _customErrorWorker.composeCustomError('Error get data from Redis', { err });
+            return {
+                customError: _customErrorWorker.composeCustomError('Error get data from Redis', { err }),
+            };
         }
         if (!data) {
-            return _customErrorWorker.composeCustomError('No data in Redis');
+            return {
+                customError: _customErrorWorker.composeCustomError('No data in Redis'),
+            };
         }
         return {
             data,
@@ -63,17 +71,23 @@ export const CacheSingleton = (() => {
         try {
             const cache = await _client.mGet(keys);
             if (!isArray(cache, isString)) {
-                return _customErrorWorker.composeCustomError('Error get data from redis', { cache });
+                return {
+                    customError: _customErrorWorker.composeCustomError('Error get data from redis', { cache }),
+                };
             }
             cache.forEach((it, i) => {
                 data[keys[i]] = JSON.parse(it);
             });
         }
         catch (err) {
-            return _customErrorWorker.composeCustomError('Error get data from redis', { err });
+            return {
+                customError: _customErrorWorker.composeCustomError('Error get data from redis', { err }),
+            };
         }
         if (Object.keys(data).length !== keys.length) {
-            return _customErrorWorker.composeCustomError('Missing data from redis', { data });
+            return {
+                customError: _customErrorWorker.composeCustomError('Missing data from redis', { data }),
+            };
         }
         return {
             data,
@@ -89,7 +103,9 @@ export const CacheSingleton = (() => {
             await _client.set(key, JSON.stringify(data));
         }
         catch (err) {
-            return _customErrorWorker.composeCustomError('Error set data to redis', { err });
+            return {
+                customError: _customErrorWorker.composeCustomError('Error set data to redis', { err }),
+            };
         }
         return {
             data: null,

package/src/backend/database/model/error-log/util.js

@@ -1,7 +1,7 @@
 import * as mongoose from 'mongoose';
+const ErrorLogSchema = new mongoose.Schema({
+    customError: { type: mongoose.Schema.Types.Mixed },
+}, { timestamps: true, versionKey: false });
 export const getErrorLogModel = () => {
-    const ErrorLogSchema = new mongoose.Schema({
-        customError: { type: mongoose.Schema.Types.Mixed },
-    }, { timestamps: true, versionKey: false });
     return mongoose.models?.errorLogs || mongoose.model('errorLogs', ErrorLogSchema);
 };

package/src/backend/database/model/translation/util.js

@@ -1,9 +1,9 @@
 import * as mongoose from 'mongoose';
+const TranslationSchema = new mongoose.Schema({
+    id: { type: String },
+    en: { type: String },
+    hu: { type: String },
+}, { timestamps: true, versionKey: false });
 export const getTranslationLogModel = () => {
-    const TranslationSchema = new mongoose.Schema({
-        id: { type: String },
-        en: { type: String },
-        hu: { type: String },
-    }, { timestamps: true, versionKey: false });
     return mongoose.models?.translations || mongoose.model('translations', TranslationSchema);
 };

package/src/backend/database/mutation/error-log/create-error-log/util.js

@@ -7,7 +7,9 @@ export const createErrorLog = async (customError) => {
         data = await getErrorLogModel().create({ customError });
     }
     catch (err) {
-        return composeCustomError('Create error log failed', { err });
+        return {
+            customError: composeCustomError('Create error log failed', { err }),
+        };
     }
     return {
         data,

package/src/backend/database/mutation/translation/get-translations/util.js

@@ -13,15 +13,19 @@ export const getTranslations = async (ids) => {
         resp = await getTranslationLogModel().find(query);
     }
     catch (err) {
-        return _customErrorWorker.composeCustomError('Get translations failed', { err, query });
+        return {
+            customError: _customErrorWorker.composeCustomError('Get translations failed', { err, query }),
+        };
     }
     if (ids && resp.length !== ids.length) {
-        return _customErrorWorker.composeCustomError('Missing ids from translations', {
-            info: {
-                missing: ids.filter((it) => !resp.find((it2) => it2.id === it)).join(', '),
-                value: ids,
-            },
-        });
+        return {
+            customError: _customErrorWorker.composeCustomError('Missing ids from translations', {
+                info: {
+                    missing: ids.filter((it) => !resp.find((it2) => it2.id === it)).join(', '),
+                    value: ids,
+                },
+            }),
+        };
     }
     const data = resp.map((it) => ({ ...it, _id: it._id.toString() }));
     return {

package/src/backend/database/mutation/translation/get-translations-as-dictionary/util.js

@@ -43,7 +43,9 @@ export const getTranslationsAsDictionary = async (language, ids) => {
         data = await getTranslationLogModel().aggregate(aggregates);
     }
     catch (err) {
-        return _customErrorWorker.composeCustomError('Get translations failed', { err });
+        return {
+            customError: _customErrorWorker.composeCustomError('Get translations failed', { err }),
+        };
     }
     return {
         data: data[0],

package/src/backend/environment/load-env-file/util.js

@@ -6,7 +6,9 @@ export const loadEnvFile = (environmentMode, projectName) => {
     const envFile = dotenv.config({ path: `./${fileName}` });
     const { error: err, parsed } = envFile;
     if (err || !parsed) {
-        return composeCustomError(`Error loading ${fileName}`, { err });
+        return {
+            customError: composeCustomError(`Error loading ${fileName}`, { err }),
+        };
     }
     const environmentVariables = ENVIRONMENT_VARIABLES_CONFIG[projectName];
     return {

package/src/backend/message-broker/message-broker/singleton.js

@@ -8,7 +8,9 @@ export const MessageBrokerSingleton = (() => {
     let _customErrorWorker;
     const checkErrorStatus = () => {
         if (_errorMessage) {
-            return _customErrorWorker.composeCustomError(_errorMessage);
+            return {
+                customError: _customErrorWorker.composeCustomError(_errorMessage),
+            };
         }
         return;
     };

package/src/dictionary/language/default.d.ts

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

package/src/dictionary/language/default.js

@@ -0,0 +1 @@
+export const DEFAULT_LANGUAGE = 'en';

package/src/dictionary/language/index.d.ts

@@ -2,3 +2,4 @@ export * from './config.js';
 export * from './type.js';
 export * from './validate.js';
 export * from './type-guard.js';
+export * from './default.js';

package/src/dictionary/language/index.js

@@ -2,3 +2,4 @@ export * from './config.js';
 export * from './type.js';
 export * from './validate.js';
 export * from './type-guard.js';
+export * from './default.js';

package/src/error/custom-error/compose-custom-error/index.d.ts

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

package/src/error/custom-error/compose-custom-error/index.js

@@ -0,0 +1,7 @@
+import { serializeInfo } from '../serialize-info/index.js';
+export const composeCustomError = (message, projectName, info) => ({
+    id: Math.random().toString(16).slice(2).toUpperCase(),
+    info: serializeInfo(info),
+    message,
+    projectName,
+});

package/src/error/custom-error/compose-custom-error/type.d.ts

@@ -0,0 +1,2 @@
+import { CustomError } from '../type.js';
+export type ComposeCustomError = (message: CustomError['message'], projectName: CustomError['projectName'], info?: CustomError['info']) => CustomError;

package/src/error/custom-error/compose-custom-error/type.js

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

package/src/error/custom-error/index.d.ts

@@ -1,3 +1,5 @@
 export * from './type.js';
+export * from './compose-custom-error/index.js';
 export * from './console-custom-error/index.js';
-export * from './worker.js';
+export * from './serialize-info/index.js';
+export * from './worker/index.js';

package/src/error/custom-error/index.js

@@ -1,3 +1,5 @@
 export * from './type.js';
+export * from './compose-custom-error/index.js';
 export * from './console-custom-error/index.js';
-export * from './worker.js';
+export * from './serialize-info/index.js';
+export * from './worker/index.js';

package/src/error/custom-error/serialize-info/index.d.ts

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

package/src/error/custom-error/serialize-info/index.js

@@ -0,0 +1,9 @@
+export const serializeInfo = (info) => {
+    if (!info) {
+        return;
+    }
+    if (info?.err) {
+        info.err = JSON.stringify(info?.err, Object.getOwnPropertyNames(info?.err));
+    }
+    return info;
+};

package/src/error/custom-error/serialize-info/type.d.ts

@@ -0,0 +1,2 @@
+import { CustomError } from '../type.js';
+export type SerializeInfo = (info?: CustomError['info']) => CustomError['info'];

package/src/error/custom-error/serialize-info/type.js

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

package/src/error/custom-error/worker/index.d.ts

@@ -0,0 +1,6 @@
+import { CustomError } from '../type.js';
+import { Info, Message } from './type.js';
+export declare const customErrorWorker: (info?: Info) => {
+    addInfo: (info?: Info) => void;
+    composeCustomError: (message: Message, info?: Info) => CustomError;
+};

package/src/error/custom-error/worker/index.js

@@ -0,0 +1,19 @@
+import { ProjectSingleton } from '../../../project/index.js';
+import { composeCustomError as composeCustomErrorFunc } from '../compose-custom-error/index.js';
+export const customErrorWorker = (info) => {
+    let _info = info;
+    const addInfo = (info) => {
+        _info = {
+            ..._info,
+            ...info,
+        };
+    };
+    const composeCustomError = (message, info) => composeCustomErrorFunc(message, ProjectSingleton.getProjectName(), {
+        ..._info,
+        ...info,
+    });
+    return {
+        addInfo,
+        composeCustomError,
+    };
+};

package/src/error/custom-error/worker/type.d.ts

@@ -0,0 +1,3 @@
+import { CustomError } from '../type.js';
+export type Message = CustomError['message'];
+export type Info = CustomError['info'];

package/src/error/custom-error/worker/type.js

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

package/src/type/array/validate.js

@@ -2,13 +2,19 @@ import { customErrorWorker } from '../../error/index.js';
 export const validateArray = (data, name, valid) => {
     const { composeCustomError } = customErrorWorker({ data, name, valid });
     if (!data) {
-        return composeCustomError(`Missing ${name}`);
+        return {
+            customError: composeCustomError(`Missing ${name}`),
+        };
     }
     if (!Array.isArray(data)) {
-        return composeCustomError(`Invalid ${name}`);
+        return {
+            customError: composeCustomError(`Invalid ${name}`),
+        };
     }
     if (!data.every((it) => valid.includes(it))) {
-        return composeCustomError(`Invalid ${name}`);
+        return {
+            customError: composeCustomError(`Invalid ${name}`),
+        };
     }
     return {
         data,

package/src/type/string/comma-separated/validate.js

@@ -4,14 +4,20 @@ import { isString } from '../type-guard.js';
 export const validateCommaSeparatedString = (data, name, valid) => {
     const { composeCustomError } = customErrorWorker({ data, name, valid });
     if (!data) {
-        return composeCustomError(`Missing ${name}`);
+        return {
+            customError: composeCustomError(`Missing ${name}`),
+        };
     }
     if (!isString(data)) {
-        return composeCustomError(`${name} not string`);
+        return {
+            customError: composeCustomError(`${name} not string`),
+        };
     }
     const parsedArr = data.split(',');
     if (parsedArr.length === 0) {
-        return composeCustomError(`Invalid ${name}`);
+        return {
+            customError: composeCustomError(`Invalid ${name}`),
+        };
     }
     return validateArray(parsedArr, name, valid);
 };

package/src/type/string/validate.js

@@ -3,14 +3,20 @@ import { isString } from './type-guard.js';
 export const validateString = (data, name, regexp) => {
     const { composeCustomError } = customErrorWorker({ data, name, regexp: JSON.stringify(regexp) });
     if (!data) {
-        return composeCustomError(`Missing ${name}`);
+        return {
+            customError: composeCustomError(`Missing ${name}`),
+        };
     }
     if (!isString(data)) {
-        return composeCustomError(`${name} not string`);
+        return {
+            customError: composeCustomError(`${name} not string`),
+        };
     }
     if (regexp) {
         if (!regexp.test(data)) {
-            return composeCustomError(`Invalid ${name}`);
+            return {
+                customError: composeCustomError(`Invalid ${name}`),
+            };
         }
     }
     return {

package/src/type/type/validate.js

@@ -4,13 +4,19 @@ export const validateType = (data, name, valids) => {
     const _customErrorWorker = customErrorWorker();
     _customErrorWorker.addInfo({ data, name, valids });
     if (!data) {
-        return _customErrorWorker.composeCustomError(`Missing ${name}`);
+        return {
+            customError: _customErrorWorker.composeCustomError(`Missing ${name}`),
+        };
     }
     if (!isString(data)) {
-        return _customErrorWorker.composeCustomError(`Invalid ${name}`);
+        return {
+            customError: _customErrorWorker.composeCustomError(`Invalid ${name}`),
+        };
     }
     if (!valids.includes(data)) {
-        return _customErrorWorker.composeCustomError(`Invalid ${name}`);
+        return {
+            customError: _customErrorWorker.composeCustomError(`Invalid ${name}`),
+        };
     }
     return {
         data: data,

package/src/error/custom-error/worker.d.ts

@@ -1,7 +0,0 @@
-import { CustomError } from './type.js';
-export declare const customErrorWorker: (info?: CustomError["info"]) => {
-    addInfo: (info?: CustomError["info"]) => void;
-    composeCustomError: (message: CustomError["message"], info?: CustomError["info"]) => {
-        customError: CustomError;
-    };
-};

package/src/error/custom-error/worker.js

@@ -1,34 +0,0 @@
-import { ProjectSingleton } from '../../project/index.js';
-export const customErrorWorker = (info) => {
-    let _info = info;
-    const _serializeInfo = (info) => {
-        if (!info) {
-            return;
-        }
-        if (info?.err) {
-            info.err = JSON.stringify(info.err);
-        }
-        return info;
-    };
-    const addInfo = (info) => {
-        _info = {
-            ..._info,
-            ..._serializeInfo(info),
-        };
-    };
-    const composeCustomError = (message, info) => ({
-        customError: {
-            id: Math.random().toString(16).slice(2).toUpperCase(),
-            info: {
-                ..._info,
-                ..._serializeInfo(info),
-            },
-            message,
-            projectName: ProjectSingleton.getProjectName(),
-        },
-    });
-    return {
-        addInfo,
-        composeCustomError,
-    };
-};