@xrystal/core 3.6.0 → 3.6.2

package/README.md

@@ -1 +1,14 @@
-##  **DOCUMENT**
+##  **DOCUMENT**
+
+# LOG Schema
+     '
+          service: this.serviceName,
+          level,
+
+          message,
+          ...rest,
+          timestamp: new Date().toISOString(),
+
+          id: id || null,
+          env: this.environment
+     '

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.6.0",
+  "version": "3.6.2",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",

package/source/loader/logger/index.d.ts

@@ -17,7 +17,7 @@ export default class LoggerService {
     private getConsoleFormat;
     winston: CustomLogger;
     constructor();
-    runWithId: (id: string, callback: () => void) => void;
+    runWithId: <T>(id: string, callback: () => T) => T;
     load: (config: Record<string, any>) => Promise<void>;
     winstonLoader: ({ loadPath, loggerLevel }: {
         loadPath: string;

package/source/loader/logger/index.js

@@ -12,12 +12,8 @@ class KafkaTransport extends Transport {
         this.service = service;
     }
     log(info, callback) {
-        setImmediate(() => {
-            this.emit("logged", info);
-        });
-        this.service["logToKafka"](info).finally(() => {
-            callback();
-        });
+        setImmediate(() => this.emit("logged", info));
+        this.service["logToKafka"](info).finally(() => callback());
     }
 }
 const customLevels = {
@@ -51,9 +47,14 @@ export default class LoggerService {
     };
     getTracingFormat = format((info) => {
         const store = LoggerService.storage.getStore();
-        if (store) {
+        if (store && store.has("correlationId")) {
             info.id = store.get("correlationId");
         }
+        Object.keys(info).forEach(key => {
+            if (info[key] instanceof Headers) {
+                info[key] = Object.fromEntries(info[key].entries());
+            }
+        });
         return info;
     });
     getConsoleFormat() {
@@ -68,11 +69,8 @@ export default class LoggerService {
     winston = winston.createLogger({
         level: "debug",
         levels: customLevels,
-        transports: [
-            new winston.transports.Console({
-                format: this.getConsoleFormat()
-            })
-        ]
+        format: this.getConsoleFormat(),
+        transports: [new winston.transports.Console()]
     });
     constructor() {
         winston.addColors(customColors);
@@ -96,10 +94,7 @@ export default class LoggerService {
             });
             this.kafkaProducer = kafka.producer({
                 createPartitioner: Partitioners.DefaultPartitioner,
-                retry: {
-                    initialRetryTime: 500,
-                    retries: 5
-                }
+                retry: { initialRetryTime: 500, retries: 5 }
             });
             const connectKafka = async () => {
                 try {
@@ -121,7 +116,8 @@ export default class LoggerService {
     };
     winstonLoader = ({ loadPath, loggerLevel }) => {
         const { combine, timestamp, json, errors } = format;
-        const jsonFileFormat = combine(this.getTracingFormat(), timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), errors({ stack: true }), json({ replacer: this.safeReplacer }));
+        const tracing = this.getTracingFormat();
+        const jsonFileFormat = combine(tracing, timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), errors({ stack: true }), json({ replacer: this.safeReplacer }));
         const transports = [
             new winston.transports.Console({
                 format: this.getConsoleFormat()
@@ -144,13 +140,13 @@ export default class LoggerService {
         if (this.kafkaProducer) {
             transports.push(new KafkaTransport({ level: loggerLevel }, this));
         }
-        const winstonLogger = winston.createLogger({
+        this.winston = winston.createLogger({
             level: loggerLevel,
             levels: customLevels,
+            format: tracing,
             transports
         });
-        this.winston = winstonLogger;
-        return winstonLogger;
+        return this.winston;
     };
     async logToKafka(info) {
         if (!this.kafkaProducer || !this.isKafkaReady)
@@ -161,13 +157,13 @@ export default class LoggerService {
                 topic: this.kafkaTopic,
                 messages: [{
                         value: JSON.stringify({
-                            id: id || null,
                             service: this.serviceName,
-                            env: this.environment,
                             level,
                             message,
                             ...rest,
-                            timestamp: new Date().toISOString()
+                            timestamp: new Date().toISOString(),
+                            id: id || null,
+                            env: this.environment
                         }, this.safeReplacer)
                     }]
             });

package/x/dist/index.d.ts

@@ -1,2 +0,0 @@
-declare let tmp: any;
-export default tmp;

package/x/dist/index.js

@@ -1,8 +0,0 @@
-import coreLoader from "./project/index.js";
-let tmp;
-// => tmp project tool => xrystal
-await (async () => {
-    tmp = await coreLoader();
-})();
-//
-export default tmp;

package/x/dist/loader/configs/index.d.ts

@@ -1,13 +0,0 @@
-import SystemService from '../system/index';
-export default class ConfigsService {
-    protected _globalEnvFileName: string;
-    protected _systemService: SystemService;
-    static tmpFolderPath: string;
-    private _envLoadPath;
-    load: ({ tmpFolderPath, systemService, envLoadPath, globalEnvFileName }: {
-        tmpFolderPath: string;
-        systemService: SystemService;
-        envLoadPath: string;
-        globalEnvFileName?: string | null;
-    }) => any;
-}

package/x/dist/loader/configs/index.js

@@ -1,17 +0,0 @@
-export default class ConfigsService {
-    _globalEnvFileName = 'global';
-    _systemService;
-    static tmpFolderPath;
-    _envLoadPath = '';
-    load = ({ tmpFolderPath, systemService, envLoadPath, globalEnvFileName }) => {
-        ConfigsService.tmpFolderPath = tmpFolderPath;
-        this._systemService = systemService;
-        this._envLoadPath = `${envLoadPath}`;
-        /*
-        this._dynamicEnvLoader({
-            nodeEnv
-            globalEnvFileName
-        })
-        */
-    };
-}

package/x/dist/loader/events/index.d.ts

@@ -1,6 +0,0 @@
-export default class EventsService {
-    private logger;
-    load: ({}: {}) => any;
-    private _globalLoader;
-    get global(): any;
-}

package/x/dist/loader/events/index.js

@@ -1,25 +0,0 @@
-import LoggersLoader from '../logger/index';
-import { x, LoggerLayerEnum } from '../../utils/index';
-export default class EventsService {
-    logger = x.get(LoggersLoader);
-    load = ({}) => {
-        this._globalLoader();
-    };
-    _globalLoader = () => {
-        process.on("uncaughtException", (exception) => {
-            this.logger.winston.log({
-                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                message: `UncaughtException: ${exception}`,
-            });
-        });
-        process.on("unhandledRejection", (exception) => {
-            this.logger.winston.log({
-                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
-                message: `UnhandledRejection: ${exception}`,
-            });
-        });
-    };
-    get global() {
-        return this._globalLoader();
-    }
-}

package/x/dist/loader/index.d.ts

@@ -1,6 +0,0 @@
-import SystemService from "./system";
-import ConfigsService from "./configs";
-import LoggerService from "./logger";
-import EventsService from "./events";
-import LocalizationsService from "./localizations";
-export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService };

package/x/dist/loader/index.js

@@ -1,6 +0,0 @@
-import SystemService from "./system";
-import ConfigsService from "./configs";
-import LoggerService from "./logger";
-import EventsService from "./events";
-import LocalizationsService from "./localizations";
-export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService };

package/x/dist/loader/localizations/index.d.ts

@@ -1,14 +0,0 @@
-export default class LocalizationsService {
-    _instance: any;
-    load: ({ loadPath, fallbackLang, preloadLang, }: {
-        loadPath: string;
-        fallbackLang: string;
-        preloadLang: string;
-    }) => any;
-    i18next: ({ loadPath, fallbackLang, preloadLang, }: {
-        loadPath?: string;
-        fallbackLang?: string;
-        preloadLang?: any;
-    }) => any;
-    get instance(): any;
-}

package/x/dist/loader/localizations/index.js

@@ -1,32 +0,0 @@
-import i18next from "i18next";
-import Backend from 'i18next-fs-backend';
-import * as middleware from 'i18next-http-middleware';
-export default class LocalizationsService {
-    _instance = null;
-    load = ({ loadPath, fallbackLang, preloadLang, }) => {
-        this.i18next({
-            loadPath,
-            fallbackLang,
-            preloadLang,
-        });
-    };
-    i18next = ({ loadPath, fallbackLang, preloadLang, }) => {
-        if (this._instance) {
-            return this._instance;
-        }
-        i18next
-            .use(Backend)
-            .use(middleware.LanguageDetector)
-            .init({
-            fallbackLng: fallbackLang,
-            preload: preloadLang,
-            backend: { loadPath: `${loadPath}/{{lng}}.json` }
-        });
-        if (i18next)
-            this._instance = i18next;
-        return i18next;
-    };
-    get instance() {
-        return this._instance;
-    }
-}

package/x/dist/loader/logger/index.d.ts

@@ -1,28 +0,0 @@
-import winston from "winston";
-import "winston-daily-rotate-file";
-import { AsyncLocalStorage } from "node:async_hooks";
-interface CustomLogger extends winston.Logger {
-    critical: winston.LeveledLogMethod;
-    http: winston.LeveledLogMethod;
-}
-export default class LoggerService {
-    static readonly storage: AsyncLocalStorage<Map<string, string>>;
-    private serviceName;
-    private environment;
-    private kafkaProducer;
-    private kafkaTopic;
-    private isKafkaReady;
-    private safeReplacer;
-    private getTracingFormat;
-    private getConsoleFormat;
-    winston: CustomLogger;
-    constructor();
-    runWithId: (id: string, callback: () => void) => void;
-    load: (config: Record<string, any>) => Promise<void>;
-    winstonLoader: ({ loadPath, loggerLevel }: {
-        loadPath: string;
-        loggerLevel: string;
-    }) => CustomLogger;
-    private logToKafka;
-}
-export {};

package/x/dist/loader/logger/index.js

@@ -1,179 +0,0 @@
-import winston, { format } from "winston";
-import Transport from "winston-transport";
-import "winston-daily-rotate-file";
-import path from "node:path";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { Kafka, Partitioners, logLevel } from "kafkajs";
-import { LoggerLayerEnum } from "../../utils";
-class KafkaTransport extends Transport {
-    service;
-    constructor(opts, service) {
-        super(opts);
-        this.service = service;
-    }
-    log(info, callback) {
-        setImmediate(() => {
-            this.emit("logged", info);
-        });
-        this.service["logToKafka"](info).finally(() => {
-            callback();
-        });
-    }
-}
-const customLevels = {
-    critical: LoggerLayerEnum.CRITICAL,
-    error: LoggerLayerEnum.ERROR,
-    info: LoggerLayerEnum.INFO,
-    http: LoggerLayerEnum.HTTP,
-    debug: LoggerLayerEnum.DEBUG,
-};
-const customColors = {
-    critical: "red",
-    error: "magenta",
-    warn: "yellow",
-    info: "green",
-    http: "cyan",
-    debug: "blue"
-};
-export default class LoggerService {
-    static storage = new AsyncLocalStorage();
-    serviceName = "";
-    environment = "";
-    kafkaProducer = null;
-    kafkaTopic = "";
-    isKafkaReady = false;
-    safeReplacer = (key, value) => {
-        if (value instanceof Headers)
-            return Object.fromEntries(value.entries());
-        if (value instanceof Error)
-            return { message: value.message, stack: value.stack };
-        return value;
-    };
-    getTracingFormat = format((info) => {
-        const store = LoggerService.storage.getStore();
-        if (store) {
-            info.id = store.get("correlationId");
-        }
-        return info;
-    });
-    getConsoleFormat() {
-        return format.combine(this.getTracingFormat(), format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), format.colorize({ all: true }), format.printf((info) => {
-            const msg = typeof info.message === "object"
-                ? JSON.stringify(info.message, this.safeReplacer)
-                : info.message;
-            const idPart = info.id ? ` : id: ${info.id}` : "";
-            return `${info.timestamp} [${this.serviceName}] ${info.level}: ${msg}${idPart}`;
-        }));
-    }
-    winston = winston.createLogger({
-        level: "debug",
-        levels: customLevels,
-        transports: [
-            new winston.transports.Console({
-                format: this.getConsoleFormat()
-            })
-        ]
-    });
-    constructor() {
-        winston.addColors(customColors);
-    }
-    runWithId = (id, callback) => {
-        const store = new Map();
-        store.set("correlationId", id);
-        return LoggerService.storage.run(store, callback);
-    };
-    load = async (config) => {
-        this.serviceName = config?.serviceName || "service";
-        this.environment = config?.env || "dev";
-        this.kafkaTopic = config?.kafkaTopic || "logs";
-        const rawBrokers = config?.kafkaBrokers;
-        const brokers = rawBrokers ? String(rawBrokers).split(",").map((b) => b.trim()) : [];
-        if (brokers.length > 0) {
-            const kafka = new Kafka({
-                clientId: this.serviceName,
-                brokers: brokers,
-                logLevel: logLevel.NOTHING
-            });
-            this.kafkaProducer = kafka.producer({
-                createPartitioner: Partitioners.DefaultPartitioner,
-                retry: {
-                    initialRetryTime: 500,
-                    retries: 5
-                }
-            });
-            const connectKafka = async () => {
-                try {
-                    await this.kafkaProducer?.connect();
-                    this.isKafkaReady = true;
-                    this.winston.info("Kafka connected successfully");
-                }
-                catch (err) {
-                    this.isKafkaReady = false;
-                    setTimeout(connectKafka, 10000);
-                }
-            };
-            connectKafka();
-        }
-        this.winstonLoader({
-            loadPath: config?.loadPath || "./logs",
-            loggerLevel: config?.loggerLevel || "debug"
-        });
-    };
-    winstonLoader = ({ loadPath, loggerLevel }) => {
-        const { combine, timestamp, json, errors } = format;
-        const jsonFileFormat = combine(this.getTracingFormat(), timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), errors({ stack: true }), json({ replacer: this.safeReplacer }));
-        const transports = [
-            new winston.transports.Console({
-                format: this.getConsoleFormat()
-            }),
-            new winston.transports.DailyRotateFile({
-                filename: path.resolve(loadPath, "error", "%DATE%_error.log"),
-                level: "error",
-                format: jsonFileFormat,
-                maxSize: "2mb",
-                maxFiles: "7d"
-            }),
-            new winston.transports.DailyRotateFile({
-                filename: path.resolve(loadPath, "critical", "%DATE%_critical.log"),
-                level: "critical",
-                format: jsonFileFormat,
-                maxSize: "2mb",
-                maxFiles: "14d"
-            })
-        ];
-        if (this.kafkaProducer) {
-            transports.push(new KafkaTransport({ level: loggerLevel }, this));
-        }
-        const winstonLogger = winston.createLogger({
-            level: loggerLevel,
-            levels: customLevels,
-            transports
-        });
-        this.winston = winstonLogger;
-        return winstonLogger;
-    };
-    async logToKafka(info) {
-        if (!this.kafkaProducer || !this.isKafkaReady)
-            return;
-        try {
-            const { id, level, message, ...rest } = info;
-            await this.kafkaProducer.send({
-                topic: this.kafkaTopic,
-                messages: [{
-                        value: JSON.stringify({
-                            id: id || null,
-                            service: this.serviceName,
-                            env: this.environment,
-                            level,
-                            message,
-                            ...rest,
-                            timestamp: new Date().toISOString()
-                        }, this.safeReplacer)
-                    }]
-            });
-        }
-        catch (err) {
-            this.isKafkaReady = false;
-        }
-    }
-}

package/x/dist/loader/system/index.d.ts

@@ -1,8 +0,0 @@
-export default class SystemService {
-    private static _tmp;
-    load: ({ tmp, }: {
-        tmp: any;
-    }) => Promise<void>;
-    private _systemLoader;
-    static get tmp(): any;
-}

package/x/dist/loader/system/index.js

@@ -1,14 +0,0 @@
-export default class SystemService {
-    static _tmp;
-    load = async ({ tmp, }) => {
-        SystemService._tmp = tmp;
-        await this._systemLoader({});
-    };
-    _systemLoader = async ({}) => {
-        //console.log(this._tmp)
-    };
-    // => getters
-    static get tmp() {
-        return SystemService._tmp;
-    }
-}

package/x/dist/project/index.d.ts

@@ -1,6 +0,0 @@
-declare const coreLoader: () => Promise<{
-    _?: undefined;
-} | {
-    _: any;
-}>;
-export default coreLoader;

package/x/dist/project/index.js

@@ -1,63 +0,0 @@
-// => import dependencies
-import path from 'path';
-import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService } from '../loader/index';
-import { packageName, tmpFileDefaultName, tmpFileDefaultExt, findFileRecursively, TmpFileLoader, x, kafkaBrokers, systemLoggerLayer, } from '../utils/index';
-//
-let coreHasRun = false;
-const coreLoader = async () => {
-    if (coreHasRun)
-        return {};
-    try {
-        const ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt);
-        if (!ownerTmpFilePath) {
-            throw new Error(`${tmpFileDefaultName} file not found`);
-        }
-        const tmpFileObject = new TmpFileLoader({ filePath: ownerTmpFilePath });
-        const r = tmpFileObject.getResolvedTmpFile();
-        const { configs } = r;
-        const rootFolderPath = configs.rootFolderPath;
-        const services = [
-            SystemService,
-            ConfigsService,
-            LoggerService,
-            EventsService,
-            LocalizationsService
-        ];
-        services.forEach(service => x.set({ service, reference: service }));
-        const system = x.get(SystemService);
-        const configService = x.get(ConfigsService);
-        const logger = x.get(LoggerService);
-        const events = x.get(EventsService);
-        const i18n = x.get(LocalizationsService);
-        await system.load({
-            tmp: { _: r }
-        });
-        await configService.load({
-            tmpFolderPath: rootFolderPath,
-            systemService: system,
-            envLoadPath: path.join(rootFolderPath, configs.loaders.configs.envLoadPath),
-            ...(configs.loaders.configs.globalEnvFileName && { globalEnvFileName: configs.loaders.configs.globalEnvFileName })
-        });
-        await logger.load({
-            loadPath: path.join(rootFolderPath, configs.loaders.loggers.loadPath),
-            loggerLevel: systemLoggerLayer ?? configs.loaders.loggers.logLevel,
-            serviceName: configs.service,
-            env: process.env.NODE_ENV,
-            kafkaBrokers: kafkaBrokers ?? "",
-            kafkaTopic: configs.loaders.loggers.topic
-        });
-        await events.load({});
-        await i18n.load({
-            loadPath: path.resolve(rootFolderPath, configs.loaders.localization.loadPath),
-            fallbackLang: configs.loaders.localization.fallbackLang,
-            preloadLang: configs.loaders.localization.preloadLangs
-        });
-        coreHasRun = true;
-        return { _: r };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`[${packageName} core failure]: ${errorMessage}`);
-    }
-};
-export default coreLoader;

package/x/dist/utils/constants/index.d.ts

@@ -1,8 +0,0 @@
-export declare const packageName: string;
-export declare const tmpFileDefaultMainFolderName: string;
-export declare const tmpFileDefaultName: string;
-export declare const tmpFileDefaultExt = ".yml";
-export declare const defaultTmpFilePath: string;
-export declare const defaultOwnerTmpFilePath: string;
-export declare const systemLoggerLayer: string;
-export declare const kafkaBrokers: string;

package/x/dist/utils/constants/index.js

@@ -1,10 +0,0 @@
-import path from 'path';
-import { __dirname } from '../helpers/path';
-export const packageName = 'x';
-export const tmpFileDefaultMainFolderName = 'x';
-export const tmpFileDefaultName = 'tmp';
-export const tmpFileDefaultExt = '.yml';
-export const defaultTmpFilePath = path.resolve(__dirname(import.meta.url), `../../${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
-export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
-export const systemLoggerLayer = process.env.SYSTEM_LOGGER_LAYER;
-export const kafkaBrokers = process.env?.KAFKA_BROKERS;

package/x/dist/utils/helpers/date/index.d.ts

@@ -1,16 +0,0 @@
-import { PolarityTypeEnum } from "../../models";
-export declare function dateZoneConverter({ polarity, date, zone, factor }: {
-    polarity: PolarityTypeEnum;
-    date: Date;
-    zone: number;
-    factor?: number;
-}): string;
-export declare function convertDate(date: string, splitCharacter?: string, replaceCharacter?: string): string[];
-export declare function convertTime(time: string, splitCharacter?: string, replaceCharacter?: string): string[];
-export declare function getDateAndTime({ getDate, getTime, dateCharacter, timeCharacter, separatorCharacter }: {
-    getDate: boolean;
-    getTime: boolean;
-    dateCharacter: string;
-    timeCharacter: string;
-    separatorCharacter: string;
-}): string;

package/x/dist/utils/helpers/date/index.js

@@ -1,48 +0,0 @@
-import { PolarityTypeEnum } from "../../models";
-export function dateZoneConverter({ polarity, date, zone, factor = 1000 }) {
-    let convertedZoneTime = null;
-    if (polarity === PolarityTypeEnum.NEGATIVE) {
-        convertedZoneTime = date.getTime() - factor * zone;
-    }
-    else {
-        convertedZoneTime = date.getTime() + factor * zone;
-    }
-    return new Date(convertedZoneTime).toISOString();
-}
-export function convertDate(date, splitCharacter = '/', replaceCharacter = '-') {
-    const convertDate = date.split(splitCharacter).map((value, index) => index !== 2 ? replaceCharacter : value);
-    return convertDate;
-}
-export function convertTime(time, splitCharacter = ':', replaceCharacter = '-') {
-    const convertDate = time.split(splitCharacter).map((value, index) => index !== 2 ? replaceCharacter : value);
-    return convertDate;
-}
-export function getDateAndTime({ getDate = true, getTime = true, dateCharacter = '-', timeCharacter = ':', separatorCharacter = '&' }) {
-    const date = new Date();
-    let formattedDate = '';
-    if (!getDate && !getTime) {
-        throw new Error("Invalid options! Required one true value");
-    }
-    if (getDate) {
-        const day = date.getDate().toString().padStart(2, '0');
-        const month = (date.getMonth() + 1).toString().padStart(2, '0');
-        const year = date.getFullYear();
-        formattedDate = `${year}${dateCharacter}${month}${dateCharacter}${day}`;
-    }
-    if (getTime) {
-        const hours = date.getHours().toString().padStart(2, '0');
-        const minutes = date.getMinutes().toString().padStart(2, '0');
-        const seconds = date.getSeconds().toString().padStart(2, '0');
-        formattedDate = `${hours}${timeCharacter}${minutes}${timeCharacter}${seconds}`;
-    }
-    if (getDate && getTime) {
-        const day = date.getDate().toString().padStart(2, '0');
-        const month = (date.getMonth() + 1).toString().padStart(2, '0');
-        const year = date.getFullYear();
-        const hours = date.getHours().toString().padStart(2, '0');
-        const minutes = date.getMinutes().toString().padStart(2, '0');
-        const seconds = date.getSeconds().toString().padStart(2, '0');
-        formattedDate = `${year}${dateCharacter}${month}${dateCharacter}${day}${separatorCharacter}${hours}${timeCharacter}${minutes}${timeCharacter}${seconds}`;
-    }
-    return formattedDate;
-}