@xrystal/core 3.9.0 → 3.9.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.9.0",
+  "version": "3.9.3",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",
@@ -49,8 +49,6 @@
     "i18next-http-middleware": "^3.8.2",
     "kafkajs": "^2.2.4",
     "moment-timezone": "^0.6.0",
-    "nodemailer": "^7.0.11",
-    "nodemailer-express-handlebars": "^7.0.0",
     "ora": "^9.0.0",
     "picocolors": "^1.1.1",
     "qs": "^6.14.1",
@@ -64,8 +62,6 @@
     "@types/bun": "^1.3.5",
     "@types/minimist": "^1.2.5",
     "@types/node": "^25.0.6",
-    "@types/nodemailer": "^7.0.4",
-    "@types/nodemailer-express-handlebars": "^4.0.6",
     "typescript": "^5.5.3"
   }
 }

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

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

package/source/loader/clients/index.js

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

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

@@ -1,66 +1,42 @@
-import nodemailer from 'nodemailer';
 import { ConfigsService, LoggerService } from '../../../loader';
-export declare abstract class Service {
+export declare class ClientStore {
+    private static _store;
+    static get(clientName: string): any;
+    static set(clientName: string, data: Record<string, any>): void;
+}
+export declare abstract class Client {
     protected configService: ConfigsService;
     protected logger: LoggerService;
     clientName: string;
     protected baseURL: string;
     protected version: string | null;
     protected timeout: number;
-    constructor({ clientName, baseURL, version, timeout }: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-        timeout?: number;
-    });
+    protected authConfigs: any;
+    constructor({ clientName, baseURL, version, timeout, auth }: any);
+    protected resolvePath(obj: any, path: string): any;
     static cryptoHashGenerate: ({ algorithm, input, digest }: {
         algorithm: string;
         input: string;
         digest?: string;
     }) => string;
-    static generateRandomNumber: ({ length }: {
-        length?: number;
-    }) => string;
 }
-export declare class BaseApiClient extends Service {
-    constructor(config: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-        timeout?: number;
-    });
+export declare class BaseApiClient extends Client {
+    constructor(config: any);
     request(path: string, options?: RequestInit & {
         version?: string;
     }): Promise<Response>;
 }
 export declare abstract class AuthenticatedApiClient extends BaseApiClient {
-    accessToken?: string;
-    constructor(config: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-        timeout?: number;
-    });
+    private _authPromise;
+    constructor(config: any);
     request(path: string, options?: RequestInit & {
         version?: string;
     }): Promise<Response>;
-    abstract authentication(): Promise<any>;
-}
-export declare class EmailClient extends Service {
-    constructor(config: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-        timeout?: number;
-    });
-    nodemailerLoader(config: any): nodemailer.Transporter<import("nodemailer/lib/smtp-transport").SentMessageInfo, import("nodemailer/lib/smtp-transport").Options>;
+    private _synchronizedAuthentication;
+    private internalLogin;
+    authentication(): Promise<any>;
 }
-export declare class SoapClient extends Service {
-    constructor(config: {
-        clientName: string;
-        baseURL: string;
-        version?: string;
-        timeout?: number;
-    });
+export declare class SoapClient extends Client {
+    constructor(config: any);
     call(methodName: string, args: any): Promise<any>;
 }

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

@@ -1,59 +1,66 @@
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-import nodemailer from 'nodemailer';
-import hbs from 'nodemailer-express-handlebars';
+import { createHash, createHmac } from 'node:crypto';
 import soap from 'soap';
 import { ConfigsService, LoggerService } from '../../../loader';
-import { TokensEnum, x } from '../../index';
-export class Service {
+import { x } from '../../index';
+export class ClientStore {
+    static _store = {};
+    static get(clientName) { return this._store[clientName] || {}; }
+    static set(clientName, data) {
+        this._store[clientName] = { ...this._store[clientName], ...data };
+    }
+}
+export class Client {
     configService = x.get(ConfigsService);
     logger = x.get(LoggerService);
     clientName;
     baseURL;
     version = null;
     timeout = 15000;
-    constructor({ clientName, baseURL, version, timeout }) {
+    authConfigs;
+    constructor({ clientName, baseURL, version, timeout, auth }) {
         this.clientName = clientName;
         this.baseURL = baseURL;
         this.version = version || null;
+        this.authConfigs = auth;
         if (timeout)
             this.timeout = timeout;
+        if (auth?.token) {
+            ClientStore.set(clientName, { accessToken: auth.token });
+        }
+    }
+    resolvePath(obj, path) {
+        return path.split('.').reduce((prev, curr) => prev ? prev[curr] : undefined, obj);
     }
     static cryptoHashGenerate = ({ algorithm, input, digest = 'hex' }) => {
         return createHash(algorithm).update(input).digest(digest);
     };
-    static generateRandomNumber = ({ length = 10 }) => {
-        let result = '';
-        for (let i = 0; i < length; i++) {
-            result += Math.floor(Math.random() * 10).toString();
-        }
-        return result;
-    };
 }
-export class BaseApiClient extends Service {
-    constructor(config) {
-        super(config);
-    }
-    // version opsiyonel yapıldı, default constructor'dan gelir ama istek anında ezilebilir
+export class BaseApiClient extends Client {
+    constructor(config) { super(config); }
     async request(path, options = {}) {
         const base = this.baseURL.replace(/\/$/, '');
-        // İstekte versiyon varsa onu, yoksa sınıftaki default versiyonu kullan
         const activeVersion = options.version !== undefined ? options.version : this.version;
         const ver = activeVersion ? `/${activeVersion.replace(/^\//, '')}` : '';
         const url = `${base}${ver}${path}`;
         const store = LoggerService.storage.getStore();
         const correlationId = store?.get('correlationId');
         const headers = new Headers(options.headers || {});
-        if (!headers.has('Content-Type'))
-            headers.set('Content-Type', 'application/json');
+        headers.set('Content-Type', 'application/json');
         if (correlationId)
             headers.set('x-correlation-id', correlationId);
-        if (process.env.INTERNAL_SECRET)
-            headers.set('X-Internal-Secret', process.env.INTERNAL_SECRET);
+        const systemSecret = this.configService.all.internalSecret || process.env.INTERNAL_SECRET;
+        if (systemSecret) {
+            const timestamp = Date.now().toString();
+            const signature = createHmac('sha256', systemSecret)
+                .update(timestamp + this.clientName)
+                .digest('hex');
+            headers.set('x-internal-signature', signature);
+            headers.set('x-internal-timestamp', timestamp);
+            headers.set('x-internal-client', this.clientName);
+        }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
-            // version alanını fetch options'dan ayıklıyoruz
             const { version, ...fetchOptions } = options;
             const response = await fetch(url, { ...fetchOptions, headers, signal: controller.signal });
             clearTimeout(timeoutId);
@@ -66,56 +73,67 @@ export class BaseApiClient extends Service {
     }
 }
 export class AuthenticatedApiClient extends BaseApiClient {
-    accessToken;
-    constructor(config) {
-        super(config);
-    }
+    _authPromise = null;
+    constructor(config) { super(config); }
     async request(path, options = {}) {
-        const injectToken = (h, t) => h.set('Cookie', `${TokensEnum.ACCESS_TOKEN}:${t}`);
+        const headerName = this.authConfigs?.header || 'Authorization';
+        const prefix = this.authConfigs?.prefix ?? 'Bearer';
+        const injectToken = (h, t) => {
+            const value = prefix ? `${prefix} ${t}` : t;
+            h.set(headerName, value);
+        };
+        let store = ClientStore.get(this.clientName);
         const headers = new Headers(options.headers || {});
-        if (this.accessToken)
-            injectToken(headers, this.accessToken);
+        if (store.accessToken)
+            injectToken(headers, store.accessToken);
         options.headers = headers;
         let response = await super.request(path, options);
         if (response.status === 401) {
-            await this.authentication();
-            if (this.accessToken) {
+            await this._synchronizedAuthentication();
+            store = ClientStore.get(this.clientName);
+            if (store.accessToken) {
                 const retryHeaders = new Headers(options.headers);
-                injectToken(retryHeaders, this.accessToken);
+                injectToken(retryHeaders, store.accessToken);
                 return super.request(path, { ...options, headers: retryHeaders });
             }
         }
         return response;
     }
-}
-export class EmailClient extends Service {
-    constructor(config) {
-        super(config);
+    async _synchronizedAuthentication() {
+        if (this._authPromise)
+            return this._authPromise;
+        this._authPromise = (async () => {
+            await this.authentication();
+            await this.internalLogin();
+        })().finally(() => { this._authPromise = null; });
+        return this._authPromise;
     }
-    nodemailerLoader(config) {
-        const transporter = nodemailer.createTransport({
-            host: config.host || this.baseURL,
-            port: config.port,
-            secure: config.secure ?? true,
-            auth: { user: config.username, pass: config.password }
-        });
-        const staticPath = this.configService.all.systemStaticFolderPath || 'source/statics';
-        transporter.use('compile', hbs({
-            viewEngine: {
-                extname: '.hbs',
-                layoutsDir: path.resolve(staticPath, 'email'),
-                defaultLayout: 'index'
-            },
-            viewPath: path.resolve(staticPath, 'email', 'templates'),
-            extName: '.hbs'
-        }));
-        return transporter;
+    async internalLogin() {
+        if (!this.authConfigs || !this.authConfigs.endpoint)
+            return;
+        const { endpoint, payload, method, tokenPath } = this.authConfigs;
+        try {
+            const response = await fetch(`${this.baseURL}${endpoint}`, {
+                method: method || 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            const data = await response.json();
+            const token = this.resolvePath(data, tokenPath || 'accessToken');
+            if (token)
+                ClientStore.set(this.clientName, { accessToken: token });
+            return data;
+        }
+        catch (error) {
+            throw error;
+        }
     }
-}
-export class SoapClient extends Service {
-    constructor(config) {
-        super(config);
+    async authentication() {
+        return true;
     }
+}
+export class SoapClient extends Client {
+    constructor(config) { super(config); }
     async call(methodName, args) {
         try {
             const client = await soap.createClientAsync(this.baseURL);

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

@@ -86,12 +86,17 @@ export declare enum WsKeyEnum {
     ROOM = "ws:room"
 }
 export declare enum TokensEnum {
+    INTERNAL_API_TOKEN = "internal_api_key",
     CSRF_TOKEN = "csrf_token",
     ACCESS_TOKEN = "access_token",
     REFRESH_TOKEN = "refresh_token",
     REFERENCE_TOKEN = "reference_token",
     PERSONAL_ACCESS_TOKEN = "personal_access_token"
 }
+export declare enum CoreServiceEnum {
+    BASE_API_CLIENT = "base_client_name",
+    SOAP_API_CLIENT = "soap_api_client"
+}
 export declare enum EndpointResourceEnum {
     EXAMPLE = "example",
     FULL = "full",

package/source/utils/models/enums/index.js

@@ -103,12 +103,18 @@ export var WsKeyEnum;
 })(WsKeyEnum || (WsKeyEnum = {}));
 export var TokensEnum;
 (function (TokensEnum) {
+    TokensEnum["INTERNAL_API_TOKEN"] = "internal_api_key";
     TokensEnum["CSRF_TOKEN"] = "csrf_token";
     TokensEnum["ACCESS_TOKEN"] = "access_token";
     TokensEnum["REFRESH_TOKEN"] = "refresh_token";
     TokensEnum["REFERENCE_TOKEN"] = "reference_token";
     TokensEnum["PERSONAL_ACCESS_TOKEN"] = "personal_access_token";
 })(TokensEnum || (TokensEnum = {}));
+export var CoreServiceEnum;
+(function (CoreServiceEnum) {
+    CoreServiceEnum["BASE_API_CLIENT"] = "base_client_name";
+    CoreServiceEnum["SOAP_API_CLIENT"] = "soap_api_client";
+})(CoreServiceEnum || (CoreServiceEnum = {}));
 export var EndpointResourceEnum;
 (function (EndpointResourceEnum) {
     EndpointResourceEnum["EXAMPLE"] = "example";