@xrystal/core 3.18.2 → 3.18.7

package/package.json

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

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

@@ -1,5 +1,30 @@
 import SystemService from '../system/index';
 import { IService } from '../../utils';
+export interface IConfig {
+    worker: boolean;
+    nodeEnv: string;
+    debug: string;
+    https: string;
+    httpsfileEncoding: string;
+    httpsCertfile: string;
+    httpsKeyfile: string;
+    rootFolderPath: string;
+    projectName: string;
+    serviceName: string;
+    projectNamePrefixEnv: string;
+    projectNameEnv: string;
+    projectNameSuffixEnv: string;
+    systemStaticFolderPath: string;
+    systemLoggerLayer: string;
+    kafkaBrokers: string;
+    kafkaLogsTopic: string;
+    baseApiUri: string;
+    port: number;
+    internalSecret: string;
+    secret: string;
+    cwd: string;
+    env: string;
+}
 export default class ConfigsService implements IService {
     #private;
     private config;
@@ -8,6 +33,7 @@ export default class ConfigsService implements IService {
     constructor({ systemService }: {
         systemService: SystemService;
     });
-    load: ({}: {}) => void;
-    get all(): Record<string, any>;
+    load: ({}: {}) => Promise<void>;
+    setConfig(newConfigs: any): void;
+    get all(): IConfig;
 }

package/source/loader/configs/index.js

@@ -1,43 +1,61 @@
 import path from 'node:path';
 import { Constants } from '../../utils';
+import { pathToFileURL } from 'node:url';
 export default class ConfigsService {
-    config = {};
+    config;
     publicFolderName = Constants.publicFolderName;
     kafkaLogsTopic = Constants.kafkaLogsTopic;
     #systemService;
     constructor({ systemService }) {
         this.#systemService = systemService;
     }
-    load = ({}) => {
+    load = async ({}) => {
         const tmp = this.#systemService.tmp;
-        const rawConfigs = tmp?.configs || tmp?.configs || {};
+        const extendConfigs = tmp.configs.loaders.configs.loadPath;
+        let importedModule;
+        const cwd = process.cwd();
+        if (extendConfigs.startsWith('@/')) {
+            const fullPath = path.join(cwd, extendConfigs.slice(2));
+            importedModule = await import(pathToFileURL(fullPath).href);
+        }
+        else {
+            const fullPath = path.resolve(tmp.configs.rootFolderPath, extendConfigs);
+            importedModule = await import(pathToFileURL(fullPath).href);
+        }
         this.config = {
             worker: process.env.WORKER === 'true' ? true : false || false,
-            nodeEnv: process.env.NODE_ENV === 'true' ? true : false || false,
+            nodeEnv: process.env.NODE_ENV,
             debug: process.env.SYSTEM_LOGGER_LAYER,
             https: process.env.HTTPS,
             httpsfileEncoding: process.env.ENCODING || 'utf8',
             httpsCertfile: process.env.HTTPS_CERT_FILE,
             httpsKeyfile: process.env.HTTPS_KEY_FILE,
-            rootFolderPath: rawConfigs.rootFolderPath || 'x',
+            rootFolderPath: tmp.configs.rootFolderPath || 'x',
             projectName: tmp.project.name,
-            serviceName: rawConfigs.service,
+            serviceName: tmp.configs.service,
             projectNamePrefixEnv: process.env.PROJECT_NAME_PREFIX || '',
             projectNameEnv: process.env.PROJECT_NAME || '',
             projectNameSuffixEnv: process.env.PROJECT_NAME_SUFFIX || '',
-            systemStaticFolderPath: path.resolve(rawConfigs.rootFolderPath, this.publicFolderName),
+            systemStaticFolderPath: path.resolve(tmp.configs.rootFolderPath, this.publicFolderName),
             systemLoggerLayer: process.env.SYSTEM_LOGGER_LAYER,
             kafkaBrokers: process.env?.KAFKA_BROKERS,
             kafkaLogsTopic: this.kafkaLogsTopic,
             baseApiUri: process.env.HTTPS === 'true' ? process.env.SYSTEM_HTTPS_BASE_API_URI : process.env.SYSTEM_BASE_API_URI,
-            port: process.env.PORT || rawConfigs.port || 3000,
+            port: Number(process.env.PORT),
             internalSecret: process.env.INTERNAL_SECRET,
             secret: process.env.SECRET,
-            cwd: process.cwd(),
+            cwd,
             env: process.env.NODE_ENV,
-            ...rawConfigs
+            ...importedModule.configs,
         };
     };
+    setConfig(newConfigs) {
+        const mergedData = {
+            ...this.config,
+            ...newConfigs
+        };
+        this.config = Object.freeze(mergedData);
+    }
     get all() {
         return this.config;
     }

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

@@ -2,11 +2,11 @@ import winston from "winston";
 import "winston-daily-rotate-file";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { LoggerLayerEnum, IService } from "../../utils";
-interface CustomLogger extends winston.Logger {
+export interface ICustomLogger extends winston.Logger {
     critical: winston.LeveledLogMethod;
     http: winston.LeveledLogMethod;
 }
-interface LogOptions {
+export interface ILog {
     level: LoggerLayerEnum;
     message: any;
     payload?: any;
@@ -17,9 +17,9 @@ export default class LoggerService implements IService {
     static readonly storage: AsyncLocalStorage<Map<string, string>>;
     private serviceName;
     private kafkaProducer;
-    private kafkaTopic;
+    private kafkaLogsTopic;
     private isKafkaReady;
-    winston: CustomLogger;
+    winston: ICustomLogger;
     constructor({ configsService }: {
         configsService: any;
     });
@@ -27,13 +27,12 @@ export default class LoggerService implements IService {
     winstonLoader: ({ loadPath, loggerLevel }: {
         loadPath: string;
         loggerLevel: string;
-    }) => CustomLogger;
+    }) => ICustomLogger;
     private safeReplacer;
     private getTracingFormat;
     private getConsoleFormat;
     runWithId: <T>(id: string, callback: () => T) => T;
     logToKafka(info: any): Promise<void>;
     log(level: LoggerLayerEnum, message: any, payload?: any, code?: string | number): void;
-    log(options: LogOptions): void;
+    log(options: ILog): void;
 }
-export {};

package/source/loader/logger/index.js

@@ -35,13 +35,13 @@ export default class LoggerService {
     static storage = new AsyncLocalStorage();
     serviceName = "";
     kafkaProducer = null;
-    kafkaTopic = "";
+    kafkaLogsTopic = "";
     isKafkaReady = false;
     winston;
     #configsService;
     constructor({ configsService }) {
         this.#configsService = configsService;
-        this.kafkaTopic = this.#configsService?.all.kafkaTopic;
+        this.kafkaLogsTopic = this.#configsService?.all.kafkaLogsTopic;
         winston.addColors(customColors);
         this.winston = winston.createLogger({
             level: this.#configsService.all.systemLoggerLayer,
@@ -152,7 +152,7 @@ export default class LoggerService {
         try {
             const { id, level, message, payload, code } = info;
             await this.kafkaProducer.send({
-                topic: this.kafkaTopic,
+                topic: this.kafkaLogsTopic,
                 messages: [{
                         value: JSON.stringify({
                             service: this.serviceName,

package/source/utils/models/classes/class.x.d.ts

@@ -1,5 +1,5 @@
 import { LifetimeType } from 'awilix';
-export declare class X {
+declare class X {
     private container;
     private initializedNames;
     constructor();
@@ -12,14 +12,14 @@ export declare class X {
     register(Dependency: any, lifetime?: LifetimeType): this;
     registerAll(dependencies: any[], lifetime?: LifetimeType): this;
     registerInstance(name: string, instance: any): this;
-    initialize(input?: {
+    initialize<T = any>(input?: {
         service: any;
-        props?: any;
+        props?: T;
     } | {
         service: any;
-        props?: any;
+        props?: T;
     }[], verbose?: boolean): Promise<this>;
-    get<T>(target: string | any): T;
+    get<T>(target: any): T;
     get cradle(): any;
     private isRegistered;
 }

package/source/utils/models/classes/class.x.js

@@ -1,7 +1,7 @@
 import { createContainer, asClass, asValue, InjectionMode, listModules, Lifetime } from 'awilix';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-export class X {
+class X {
     container;
     initializedNames = new Set();
     constructor() {
@@ -28,7 +28,6 @@ export class X {
             modules = listModules(resolvedPatterns);
         }
         catch (err) {
-            console.error(`[DI][CRITICAL] Path resolution failed: ${err.message}`);
             return this;
         }
         for (const m of modules) {
@@ -43,11 +42,8 @@ export class X {
                 }
                 return false;
             });
-            if (isPathExcluded) {
-                if (verbose)
-                    console.log(`[DI][${source}] Excluded: ${m.name}`);
+            if (isPathExcluded)
                 continue;
-            }
             try {
                 const fileUrl = pathToFileURL(m.path).href;
                 const loaded = await import(fileUrl);
@@ -66,14 +62,12 @@ export class X {
                         this.container.register({
                             [name]: asClass(dependency).setLifetime(lifetime)
                         });
-                        if (verbose)
-                            console.log(`[DI][${source}] Registered: ${name}`);
                     }
                 }
             }
             catch (err) {
                 if (verbose)
-                    console.error(`[DI][${source}] Load Error in ${m.name}:`, err.message);
+                    console.error(`[DI][${source}] Load Error:`, err.message);
             }
         }
         return this;
@@ -126,8 +120,6 @@ export class X {
                     const props = propsMap.get(key) || {};
                     await instance.load(props);
                     this.initializedNames.add(key);
-                    if (verbose)
-                        console.log(`[DI] Initialized: ${key}`);
                 }
                 catch (err) {
                     console.error(`[DI] Initialization Failed: ${key} ->`, err.message);

package/source/utils/models/classes/configs.project.d.ts

@@ -0,0 +1 @@
+export declare const configs: {};

package/source/utils/models/classes/configs.project.js

@@ -0,0 +1 @@
+export const configs = {};

package/source/utils/models/index.d.ts

@@ -1,4 +1,4 @@
-import x, { X } from './classes/class.x';
+import x from './classes/class.x';
 import locator, { Locator } from './classes/class.service-locator';
 export * from './classes/class.tmp-file-loader';
 export * from './classes/class.response';
@@ -6,4 +6,4 @@ export * from './classes/class.services';
 export * from './classes/class.interfaces';
 export * from './types';
 export * from './enums';
-export { x, X, locator, Locator };
+export { x, locator, Locator };

package/source/utils/models/index.js

@@ -1,4 +1,4 @@
-import x, { X } from './classes/class.x';
+import x from './classes/class.x';
 import locator, { Locator } from './classes/class.service-locator';
 export * from './classes/class.tmp-file-loader';
 export * from './classes/class.response';
@@ -6,4 +6,4 @@ export * from './classes/class.services';
 export * from './classes/class.interfaces';
 export * from './types';
 export * from './enums';
-export { x, X, locator, Locator };
+export { x, locator, Locator };

package/x/tmp.yml

@@ -7,7 +7,7 @@ configs:
 
   loaders:
     configs:
-      envLoadPath: environments
+      loadPath: '@/source/utils/models/classes/configs.project.ts'
 
     loggers:
       loadPath: logs