@xrystal/core 3.10.2 → 3.10.4

package/bin/main-cli.js

@@ -22,6 +22,12 @@ import { findFileRecursively, resolveObjWithHandlebars } from "./helpers/index.m
 const setupCLI = async () => {
   const cli = new Command()
 
+  const isBun = !!process.versions.bun
+  const runtimeName = isBun ? "Bun" : "Node.js"
+  const packageManager = isBun ? "bun" : "npm"
+  const installCommand = isBun ? "bun install" : "npm install"
+  const devCommand = isBun ? "bun run dev:local" : "npm run dev:local"
+
   try {
     let ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt)
 
@@ -54,7 +60,7 @@ const setupCLI = async () => {
 
     cli
       .command("create <project-name> [target-path]")
-      .description("Project initializer with git setup")
+      .description(`Project initializer using ${runtimeName}`)
       .action(async (projectName, targetDir) => {
         let targetPath = ""
         const isCurrentDir = projectName === "."
@@ -75,7 +81,7 @@ const setupCLI = async () => {
           fs.mkdirSync(targetPath, { recursive: true })
         }
 
-        const spinner = ora("Cloning and initializing git...").start()
+        const spinner = ora(`${runtimeName} environment detected. Cloning template...`).start()
 
         try {
           execSync(`git clone --depth 1 ${templateRepoUri} "${targetPath}"`, { stdio: "ignore" })
@@ -91,9 +97,9 @@ const setupCLI = async () => {
           }
 
           spinner.succeed(chalk.green("Template cloned and git initialized!"))
-          console.log(chalk.blue(`\n📦 Installing dependencies with bun...`))
+          console.log(chalk.blue(`\n📦 Installing dependencies with ${packageManager}...`))
 
-          execSync("bun install", { cwd: targetPath, stdio: "inherit" })
+          execSync(installCommand, { cwd: targetPath, stdio: "inherit" })
 
           console.log(chalk.green("\n✅ Done!"))
 
@@ -102,7 +108,7 @@ const setupCLI = async () => {
             console.log(chalk.cyan(`\n   cd ${relativePath}`))
           }
 
-          console.log(chalk.cyan(`   bun run dev:local`))
+          console.log(chalk.cyan(`   ${devCommand}`))
 
         } catch (err) {
           spinner.fail(chalk.red("Failed!"))

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.10.2",
+  "version": "3.10.4",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",
@@ -37,8 +37,8 @@
     "start": "bun --env-file=../infrastructer/x/environments/.global.env --env-file=../infrastructer/x/environments/.dev.env source/index.js"
   },
   "dependencies": {
-    "@types/bcrypt": "^5.0.2",
     "@types/yaml": "^1.9.7",
+    "awilix": "^12.0.5",
     "chalk": "^5.6.2",
     "commander": "^13.0.0",
     "ejs": "^3.1.9",

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

@@ -1,9 +1,10 @@
 import ConfigsService from '../configs';
 export default class ClientsService {
     #private;
+    constructor({ configsService }: {
+        configsService: ConfigsService;
+    });
     static get instances(): Record<string, any>;
     static set instances(value: Record<string, any>);
-    load({ configs }: {
-        configs: ConfigsService;
-    }): Promise<void>;
+    load({}: {}): Promise<void>;
 }

package/source/loader/clients/index.js

@@ -1,16 +1,20 @@
 import { BaseApiClient, CoreServiceEnum } from '../../utils/index';
 export default class ClientsService {
     static #services = {};
+    #configs;
+    constructor({ configsService }) {
+        this.#configs = configsService;
+    }
     static get instances() {
         return this.#services;
     }
     static set instances(value) {
         this.#services = { ...this.#services, ...value };
     }
-    async load({ configs }) {
+    async load({}) {
         const baseClient = new BaseApiClient({
             clientName: CoreServiceEnum.BASE_API_CLIENT,
-            baseURL: configs.all.baseApiUri || ''
+            baseURL: this.#configs.all.baseApiUri || ''
         });
         ClientsService.instances[CoreServiceEnum.BASE_API_CLIENT] = baseClient;
     }

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

@@ -1,11 +1,11 @@
 import SystemService from '../system/index';
 export default class ConfigsService {
+    #private;
     private config;
-    protected _systemService: SystemService;
     publicFolderName: string;
-    load: ({ tmp, systemService }: {
-        tmp: any;
+    constructor({ systemService }: {
         systemService: SystemService;
-    }) => void;
+    });
+    load: ({}: {}) => void;
     get all(): Record<string, any>;
 }

package/source/loader/configs/index.js

@@ -1,10 +1,14 @@
 import path from 'node:path';
+import { publicFolderName } from 'source/utils';
 export default class ConfigsService {
     config = {};
-    _systemService;
-    publicFolderName = 'public';
-    load = ({ tmp, systemService }) => {
-        this._systemService = systemService;
+    publicFolderName = publicFolderName;
+    #systemService;
+    constructor({ systemService }) {
+        this.#systemService = systemService;
+    }
+    load = ({}) => {
+        const tmp = this.#systemService.tmp;
         const rawConfigs = tmp?.configs || tmp?.configs || {};
         this.config = {
             debug: process.env.SYSTEM_LOGGER_LAYER,

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

@@ -1,7 +1,10 @@
 import LoggerService from '../logger/index';
 export default class EventsService {
-    private logger;
-    load: ({ logger, }: {
+    #private;
+    constructor({ loggerService }: {
+        loggerService: LoggerService;
+    });
+    load: ({}: {
         logger: LoggerService;
     }) => any;
     private _globalLoader;

package/source/loader/events/index.js

@@ -1,19 +1,21 @@
 import { LoggerLayerEnum } from '../../utils/index';
 export default class EventsService {
-    logger;
-    load = ({ logger, }) => {
-        this.logger = logger;
+    #loggerService;
+    constructor({ loggerService }) {
+        this.#loggerService = loggerService;
+    }
+    load = ({}) => {
         this._globalLoader();
     };
     _globalLoader = () => {
         process.on("uncaughtException", (exception) => {
-            this.logger.winston.log({
+            this.#loggerService.winston.log({
                 level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
                 message: `UncaughtException: ${exception}`,
             });
         });
         process.on("unhandledRejection", (exception) => {
-            this.logger.winston.log({
+            this.#loggerService.winston.log({
                 level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
                 message: `UnhandledRejection: ${exception}`,
             });

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

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

package/source/loader/logger/index.js

@@ -34,10 +34,14 @@ const customColors = {
 export default class LoggerService {
     static storage = new AsyncLocalStorage();
     serviceName = "";
-    environment = "";
     kafkaProducer = null;
     kafkaTopic = "";
     isKafkaReady = false;
+    #configsService;
+    constructor({ configsService }) {
+        this.#configsService = configsService;
+        winston.addColors(customColors);
+    }
     safeReplacer = (key, value) => {
         if (value instanceof Headers)
             return Object.fromEntries(value.entries());
@@ -72,9 +76,6 @@ export default class LoggerService {
         format: this.getConsoleFormat(),
         transports: [new winston.transports.Console()]
     });
-    constructor() {
-        winston.addColors(customColors);
-    }
     runWithId = (id, callback) => {
         const store = new Map();
         store.set("correlationId", id);
@@ -82,7 +83,6 @@ export default class LoggerService {
     };
     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()) : [];
@@ -100,7 +100,6 @@ export default class LoggerService {
                 try {
                     await this.kafkaProducer?.connect();
                     this.isKafkaReady = true;
-                    this.winston.info("Kafka connected successfully");
                 }
                 catch (err) {
                     this.isKafkaReady = false;
@@ -163,7 +162,7 @@ export default class LoggerService {
                             ...rest,
                             timestamp: new Date().toISOString(),
                             id: id || null,
-                            env: this.environment
+                            env: this.#configsService.all.env
                         }, this.safeReplacer)
                     }]
             });

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

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

package/source/loader/system/index.js

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

package/source/project/index.js

@@ -24,42 +24,48 @@ const coreLoader = async ({}) => {
             LocalizationsService,
             ClientsService
         ];
-        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);
-        const clientsService = x.get(ClientsService);
-        await system.load({
-            tmp: core._
-        });
-        configService.load({
-            tmp: core._,
-            systemService: system,
-            ...(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({
-            logger
-        });
-        await i18n.load({
-            loadPath: path.resolve(rootFolderPath, configs.loaders.localization.loadPath),
-            fallbackLang: configs.loaders.localization.fallbackLang,
-            preloadLang: configs.loaders.localization.preloadLangs
-        });
-        await clientsService.load({
-            configs: configService,
-        });
+        x.registerServices(services);
+        x.initialize([
+            {
+                service: SystemService,
+                props: {
+                    tmp: core._
+                }
+            },
+            {
+                service: ConfigsService,
+                props: {
+                    ...(configs.loaders.configs.globalEnvFileName && { globalEnvFileName: configs.loaders.configs.globalEnvFileName })
+                }
+            },
+            {
+                service: LoggerService,
+                props: {
+                    loadPath: path.join(rootFolderPath, configs.loaders.loggers.loadPath),
+                    loggerLevel: systemLoggerLayer ?? configs.loaders.loggers.logLevel,
+                    serviceName: configs.service,
+                    kafkaBrokers: kafkaBrokers ?? "",
+                    kafkaTopic: configs.loaders.loggers.topic
+                }
+            },
+            {
+                service: EventsService,
+                props: {}
+            },
+            {
+                service: LocalizationsService,
+                props: {
+                    loadPath: path.resolve(rootFolderPath, configs.loaders.localization.loadPath),
+                    fallbackLang: configs.loaders.localization.fallbackLang,
+                    preloadLang: configs.loaders.localization.preloadLangs
+                }
+            },
+            {
+                service: ClientsService,
+                props: {}
+            },
+        ]);
         coreHasRun = true;
-        return {};
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

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

@@ -6,3 +6,4 @@ export declare const defaultTmpFilePath: string;
 export declare const defaultOwnerTmpFilePath: string;
 export declare const systemLoggerLayer: string;
 export declare const kafkaBrokers: string;
+export declare const publicFolderName = "public";

package/source/utils/constants/index.js

@@ -8,3 +8,4 @@ export const defaultTmpFilePath = path.resolve(__dirname(import.meta.url), `../.
 export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
 export const systemLoggerLayer = process.env.SYSTEM_LOGGER_LAYER;
 export const kafkaBrokers = process.env?.KAFKA_BROKERS;
+export const publicFolderName = 'public';

package/source/utils/models/classes/class.service-locator.d.ts

@@ -0,0 +1,12 @@
+export declare class Locator {
+    private _context;
+    constructor({}: {});
+    set: <T extends new (...args: any[]) => any>({ service, reference, args }: {
+        service: T;
+        reference: T;
+        args?: ConstructorParameters<T>;
+    }) => void;
+    get: <T>(service: new (...args: any) => T) => T;
+}
+declare const _default: Locator;
+export default _default;

package/source/utils/models/classes/class.service-locator.js

@@ -0,0 +1,16 @@
+// => // X Service Locator
+export class Locator {
+    _context = new Map();
+    constructor({}) {
+    }
+    set = ({ service, reference, args }) => {
+        this._context.set(service, new reference(...(args || [])));
+    };
+    get = (service) => {
+        if (!this._context.has(service)) {
+            throw new Error(`${service} not found in context.`);
+        }
+        return this._context.get(service);
+    };
+}
+export default new Locator({});

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

@@ -1,4 +1,10 @@
 import { ConfigsService, LoggerService } from '../../../loader';
+type CustomRequestOptions = Omit<RequestInit, 'body'> & {
+    body?: any;
+    version?: string;
+    retries?: number;
+    debug?: boolean;
+};
 export declare class ClientStore {
     private static _store;
     static get(clientName: string): any;
@@ -30,11 +36,7 @@ export declare abstract class Client {
 }
 export declare class BaseApiClient extends Client {
     constructor(config: any);
-    request(path: string, options?: RequestInit & {
-        version?: string;
-        retries?: number;
-        debug?: boolean;
-    }): Promise<Response>;
+    request(path: string, options?: CustomRequestOptions): Promise<Response>;
     private _execute;
 }
 export declare abstract class AuthenticatedApiClient extends BaseApiClient {
@@ -53,3 +55,4 @@ export declare class SoapClient extends Client {
     constructor(config: any);
     call(methodName: string, args: any): Promise<any>;
 }
+export {};

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

@@ -105,21 +105,21 @@ export class BaseApiClient extends Client {
             headers.set('x-internal-client', this.clientName);
         }
         const isDebugMode = options.debug !== undefined ? options.debug : this.debug;
+        const { version, retries, debug, ...fetchOptions } = options;
+        if (fetchOptions.body && typeof fetchOptions.body === 'object' && !(fetchOptions.body instanceof FormData)) {
+            fetchOptions.body = JSON.stringify(fetchOptions.body);
+        }
         if (isDebugMode) {
             const logPayload = {
                 method: options.method || 'GET',
                 url,
                 headers: Object.fromEntries(headers.entries()),
-                body: options.body ? (typeof options.body === 'string' ? JSON.parse(options.body) : options.body) : null
+                body: options.body
             };
             this.logger.winston.info(`${this.clientName} Request Details: ${JSON.stringify(logPayload, null, 2)}`);
         }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        const { version, retries, debug, ...fetchOptions } = options;
-        if (fetchOptions.body && typeof fetchOptions.body === 'object') {
-            fetchOptions.body = JSON.stringify(fetchOptions.body);
-        }
         const response = await fetch(url, { ...fetchOptions, headers, signal: controller.signal });
         clearTimeout(timeoutId);
         return response;

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

@@ -1,12 +1,18 @@
 export declare class X {
-    private _context;
-    constructor({}: {});
-    set: <T extends new (...args: any[]) => any>({ service, reference, args }: {
-        service: T;
-        reference: T;
-        args?: ConstructorParameters<T>;
-    }) => void;
-    get: <T>(service: new (...args: any) => T) => T;
+    private container;
+    constructor();
+    registerService(ServiceClass: any): void;
+    registerServices(services: any[]): void;
+    registerInstance(name: string, instance: any): void;
+    initialize(input: {
+        service: any;
+        props?: any;
+    } | {
+        service: any;
+        props?: any;
+    }[]): Promise<void>;
+    get<T>(name: string | any): T;
+    get cradle(): any;
 }
 declare const _default: X;
 export default _default;

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

@@ -1,16 +1,45 @@
-// => // X Service Locator
+import { createContainer, asClass, asValue, InjectionMode } from 'awilix';
 export class X {
-    _context = new Map();
-    constructor({}) {
+    container;
+    constructor() {
+        this.container = createContainer({
+            injectionMode: InjectionMode.PROXY,
+            strict: true
+        });
     }
-    set = ({ service, reference, args }) => {
-        this._context.set(service, new reference(...(args || [])));
-    };
-    get = (service) => {
-        if (!this._context.has(service)) {
-            throw new Error(`${service} not found in context.`);
+    registerService(ServiceClass) {
+        const name = ServiceClass.name.charAt(0).toLowerCase() + ServiceClass.name.slice(1);
+        this.container.register({
+            [name]: asClass(ServiceClass).singleton()
+        });
+    }
+    registerServices(services) {
+        services.forEach(ServiceClass => {
+            this.registerService(ServiceClass);
+        });
+    }
+    registerInstance(name, instance) {
+        this.container.register({
+            [name]: asValue(instance)
+        });
+    }
+    async initialize(input) {
+        const items = Array.isArray(input) ? input : [input];
+        for (const item of items) {
+            const instance = this.get(item.service);
+            if (instance && typeof instance.load === 'function') {
+                await instance.load(item.props);
+            }
         }
-        return this._context.get(service);
-    };
+    }
+    get(name) {
+        const resolveName = typeof name === 'function'
+            ? name.name.charAt(0).toLowerCase() + name.name.slice(1)
+            : name;
+        return this.container.resolve(resolveName);
+    }
+    get cradle() {
+        return this.container.cradle;
+    }
 }
-export default new X({});
+export default new X();

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

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

package/source/utils/models/index.js

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