@urga-panel/ur-panels-core 1.0.19 → 1.0.21

package/dist/ServiceManager.d.ts

@@ -11,8 +11,8 @@ export declare class _ServiceManager {
         [key: string]: ServiceEntry<Service>;
     };
     constructor();
-    initServices(type: "ns" | "svelte" | "node" | "svelteBackend", services: Array<RegisterServiceInfo>): Promise<void>;
-    getService<T extends Service>(serviceName: string): T;
+    initServices(type: "ns" | "svelte" | "node" | "svelteBackend", services: Array<RegisterServiceInfo>, namespace?: string): Promise<void>;
+    getService<T extends Service>(serviceName: string, namespace?: string): T;
     private setKey;
     private quickService;
     /**

package/dist/ServiceManager.js

@@ -3,6 +3,7 @@ import { NSPageControllerService } from "./services/abstract/pageServices/contro
 import { SVPageControllerService } from "./services/abstract/pageServices/controllers/SVPageControllerService.js";
 import { NSPageService } from "./services/abstract/pageServices/pages/NsPageService.js";
 import { PageService } from "./services/abstract/pageServices/PageServices.js";
+import { LogService } from "./services/main/logService/LogService.js";
 export class _ServiceManager {
     services = {
         TestService: {
@@ -12,17 +13,30 @@ export class _ServiceManager {
     };
     constructor() {
     }
-    async initServices(type, 
-    // services: {
-    //     [key: string]: {
-    //         service:ServiceConstructor<Service>
-    //         ots: any;
-    //     };
-    //     // LayoutService?: ServiceConstructor<LayoutPageService>;
-    // }
-    services) {
-        //debugger;
-        console.log("ServiceManager: Initializing services...");
+    async initServices(type, services, namespace) {
+        const timestamp = new Date().toLocaleTimeString('tr-TR', { hour12: false });
+        const prefix = namespace ? `[ServiceManager:${namespace}]` : '[ServiceManager]';
+        console.log(`🚀 ${timestamp} ${prefix} Initializing services...`);
+        // İLK ÖNCE LogService'i başlat
+        let logService;
+        if (!namespace) { // LogService sadece global scope'ta oluşturulur
+            const logServiceKey = "LogService";
+            const logServiceEntry = this.setKey(logServiceKey, {
+                serviceSelf: new LogService({
+                    usedService: {},
+                    tag: "LogService",
+                    type: type,
+                }),
+                status: "waitSetup",
+            });
+            logService = logServiceEntry;
+            await logService.setup();
+            await logService.start();
+        }
+        else {
+            // Namespace'li servisler global LogService'i kullanır
+            logService = this.getService("LogService");
+        }
         // // TestService'i oluştur ve başlat
         // const _TestService = this.setKey("TestService", {
         //     serviceSelf: new TestService({
@@ -37,13 +51,13 @@ export class _ServiceManager {
         if (type == "ns") {
             const _PageControllerService = this.setKey("NSPageControllerService", {
                 serviceSelf: new NSPageControllerService({
-                    usedService: {},
+                    usedService: logService ? { "LogService": () => logService } : {},
                     abilities: {
                         createChildService: (tag) => {
                             //console.log("createChildService called for ---", tag);
                             const _pageService = this.setKey(tag, {
                                 serviceSelf: new NSPageService({
-                                    usedService: {},
+                                    usedService: logService ? { "LogService": () => logService } : {},
                                     tag: tag,
                                     type: type,
                                 }),
@@ -63,7 +77,7 @@ export class _ServiceManager {
         else if (type == "svelte") {
             const _PageControllerService = this.setKey("SVPageControllerService", {
                 serviceSelf: new SVPageControllerService({
-                    usedService: {},
+                    usedService: logService ? { "LogService": () => logService } : {},
                     abilities: {
                         // Artık class referansını parametre olarak alıyor
                         createChildService: (tag, PageCtor) => {
@@ -71,7 +85,7 @@ export class _ServiceManager {
                             const ServiceClass = PageCtor ?? PageService;
                             const _pageService = this.setKey(tag, {
                                 serviceSelf: new ServiceClass({
-                                    usedService: {},
+                                    usedService: logService ? { "LogService": () => logService } : {},
                                     tag: tag,
                                     type: type,
                                 }),
@@ -136,16 +150,31 @@ export class _ServiceManager {
                 //console.log(`Service ${serviceName} has serviceInfo defined:`, service.serviceInfo);
             }
             const usedService = {};
+            // LogService'i her zaman ekle (eğer varsa)
+            if (logService) {
+                usedService["LogService"] = () => logService;
+            }
             if (Array.isArray(service.serviceInfo.requiredServices)) {
                 for (const reqName of service.serviceInfo.requiredServices) {
-                    usedService[reqName] = () => { return this.getService(reqName); };
+                    // Namespace-aware service lookup: önce namespace'li ara, yoksa global'e fallback
+                    usedService[reqName] = () => {
+                        if (namespace) {
+                            const namespacedService = this.getService(`${namespace}:${reqName}`);
+                            if (namespacedService)
+                                return namespacedService;
+                        }
+                        return this.getService(reqName);
+                    };
                 }
             }
-            const serviceInstance = this.setKey(tag, {
+            // Namespace varsa key'i namespace:tag formatında oluştur
+            const serviceKey = namespace ? `${namespace}:${tag}` : tag;
+            const serviceInstance = this.setKey(serviceKey, {
                 serviceSelf: new service({
                     usedService,
                     tag: tag,
                     type: type,
+                    namespace: namespace,
                     ServiceManager: _this,
                     abilities: {
                         createChildService: (tag, PageCtor) => {
@@ -153,7 +182,7 @@ export class _ServiceManager {
                             const ServiceClass = PageCtor ?? PageService;
                             const _pageService = this.setKey(tag, {
                                 serviceSelf: new ServiceClass({
-                                    usedService: {},
+                                    usedService: logService ? { "LogService": () => logService } : {},
                                     tag: tag,
                                     type: type,
                                     //@ts-ignore
@@ -231,15 +260,21 @@ export class _ServiceManager {
     //         callback();
     //     }
     // }
-    getService(serviceName) {
-        if (this.services[serviceName]) {
+    getService(serviceName, namespace) {
+        // Namespace verilmişse önce namespace:serviceName formatında ara
+        if (namespace) {
+            const namespacedKey = `${namespace}:${serviceName}`;
+            if (this.services[namespacedKey]) {
+                return this.services[namespacedKey].serviceSelf;
+            }
         }
-        else {
-            //console.log(`ServiceManager: Service ${serviceName} not found.`);
-            //console.log("Available services:", Object.keys(this.services));
-            return undefined;
+        // Fallback: direkt isimle ara (core servisler için)
+        if (this.services[serviceName]) {
+            return this.services[serviceName].serviceSelf;
         }
-        return this.services[serviceName].serviceSelf;
+        //console.log(`ServiceManager: Service ${serviceName} not found.`);
+        //console.log("Available services:", Object.keys(this.services));
+        return undefined;
     }
     setKey(key, value) {
         this.services[key] = value;

package/dist/services/abstract/apiService/ApiService.js

@@ -4,8 +4,13 @@ export class ApiService extends Service {
     apis = {};
     onStart() {
         const requestHandlerService = this.ots.usedService.RequestHandlerService();
+        const namespace = this.ots.namespace;
         Object.entries(this.apis).forEach(([name, { handler, options }]) => {
-            requestHandlerService.addHandler(`${this.tag}/${name}`, handler.bind(this), options || { auth: true, role: "guest" });
+            // Namespace varsa handler key'i namespace:ServiceName/method formatında oluştur
+            const handlerKey = namespace
+                ? `${namespace}:${this.tag}/${name}`
+                : `${this.tag}/${name}`;
+            requestHandlerService.addHandler(handlerKey, handler.bind(this), options || { auth: true, role: "guest" });
         });
         return Promise.resolve({ status: "success", message: "ApiService started" });
     }

package/dist/services/abstract/authServices/AuthService.js

@@ -65,7 +65,7 @@ export class AuthService extends Service {
             });
         }
         catch (error) {
-            console.error("Logout error:", error);
+            this.log.error("Logout error:", error);
             return new Response(JSON.stringify({ status: "error", message: "An error occurred during logout" }), { status: 500, headers: { "Content-Type": "application/json" } });
         }
     }
@@ -92,7 +92,7 @@ export class AuthService extends Service {
                 if (typeof window === "undefined") {
                     bcrypt = await import("bcryptjs");
                 }
-                console.log("User authenticated:", result.user);
+                this.log.debug("User authenticated:", result.user);
                 const match = await bcrypt.compare(password, result.user.password);
                 if (!match) {
                     return this.resposeHandler({ success: false });
@@ -280,7 +280,6 @@ export class AuthService extends Service {
     //     //     const decoded = jwt.verify(token, 'gizliAnahtar');
     //     //     return !!decoded;
     //     // } catch (error) {
-    //     //     console.error('Token verification failed:', error);
     //     //     return false;
     //     // }
     // }

package/dist/services/abstract/pageServices/controllers/NSPageControllerService.js

@@ -2,7 +2,7 @@ import { PageControllerService } from "./PageControllerService.js";
 export class NSPageControllerService extends PageControllerService {
     serviceInfo;
     registerPage(tag, opt) {
-        console.log(`Registering page with tag: ${tag}`);
+        this.log.debug(`Registering page with tag: ${tag}`);
         const service = this.ots.abilities.createChildService?.(tag);
         // await service.setup();
         this.pages[tag] = {
@@ -12,7 +12,7 @@ export class NSPageControllerService extends PageControllerService {
         return service;
     }
     onLoaded() {
-        console.log("NSPageControllerService onLoaded called");
+        this.log.info("NSPageControllerService onLoaded called");
         // Implement any additional logic needed when the page is loaded
     }
 }

package/dist/services/abstract/webviewServices/WVFrontService.js

@@ -33,7 +33,7 @@ export class WVFrontService extends Service {
         this.oWebViewInterface.emit("gotoBack", "");
     }
     async sendFetchRequest(url, options) {
-        console.log("sendFetchRequest", url, options);
+        this.log.debug("sendFetchRequest", url, options);
         const id = `r_${Date.now()}_${++WVFrontService._requestIdCounter}`;
         return new Promise((resolve) => {
             const handler = (args) => {
@@ -66,14 +66,14 @@ export class WVFrontService extends Service {
                     }
                 }
                 catch (e) {
-                    console.error('sendFetchRequest: failed to decode response body', e);
+                    this.log.error('sendFetchRequest: failed to decode response body', e);
                     text = '';
                 }
                 const response = new Response(text, {
                     status: 200,
                     headers: { "Content-Type": "application/json" }
                 });
-                console.log("sendFetchRequest received (id)", id, envelope.param);
+                this.log.debug("sendFetchRequest received (id)", id, envelope.param);
                 // remove listeners
                 this.oWebViewInterface.removeListener('sendFetchRequest', handler);
                 this.oWebViewInterface.removeListener('sendFetchRequestResponse', handler);

package/dist/services/main/httpServices/RequestHandlerService.d.ts

@@ -36,10 +36,11 @@ export declare class RequestHandlerService extends Service {
         auth?: boolean;
         role?: string;
     }): Promise<void>;
-    requestCome({ params, request, url }: {
+    requestCome({ params, request, url, namespace }: {
         params: any;
         request: any;
         url: any;
+        namespace?: string;
     }): Promise<any>;
     getCookie(cookieHeader: string | null, name: string): string | undefined;
     resposeHandler(response: any): Response;

package/dist/services/main/httpServices/RequestHandlerService.js

@@ -27,7 +27,7 @@ export class RequestHandlerService extends Service {
         this.handlers[name] = { callback, options };
         this.log.OK("RequestHandlerService addHandler", name);
     }
-    async requestCome({ params, request, url }) {
+    async requestCome({ params, request, url, namespace }) {
         this.log.OK("RequestHandlerService requestCome", params);
         let bodyData = null;
         const contentType = request.headers.get('content-type');
@@ -49,9 +49,21 @@ export class RequestHandlerService extends Service {
             bodyData = null;
         }
         const handlerName = params.path; // Assuming path is the handler name
-        const handler = this.handlers[handlerName];
+        // Namespace-aware handler lookup: önce namespace:handlerName ara, yoksa handlerName ara
+        let handler = null;
+        if (namespace) {
+            const namespacedKey = `${namespace}:${handlerName}`;
+            handler = this.handlers[namespacedKey];
+            if (handler) {
+                this.log.OK("RequestHandlerService found namespaced handler:", namespacedKey);
+            }
+        }
+        // Fallback: namespace'siz ara (core handlers için - login, logout, etc.)
+        if (!handler) {
+            handler = this.handlers[handlerName];
+        }
         if (!handler) {
-            this.log.ERROR("Handler not found:", handlerName);
+            this.log.ERROR("Handler not found:", handlerName, "namespace:", namespace);
             //throw new Error(`Handler not found: ${handlerName}`);
             return { status: "error", message: "An error occurred" };
         }
@@ -77,14 +89,14 @@ export class RequestHandlerService extends Service {
                         role: handler.options?.role
                     }
                 });
-                console.log("isAuthenticated", isAuthenticated);
+                this.log.debug("isAuthenticated", isAuthenticated);
                 if (!isAuthenticated.valid) {
                     return this.resposeHandler({ status: "error", message: "Unauthorized" });
                 }
                 user = isAuthenticated.user || null;
                 if (isAuthenticated.newAccessToken) {
                     // Update cookies with new tokens
-                    console.log("update token");
+                    this.log.debug("update token");
                     header = {
                         "Set-Cookie": `panel_token=${isAuthenticated.newAccessToken}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=900, refreshToken=${isAuthenticated.newRefreshToken}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=604800`,
                     };
@@ -105,8 +117,8 @@ export class RequestHandlerService extends Service {
             else {
                 response = await handler.callback({ ...event, user });
             }
-            console.log("RequestHandlerService requestCome response");
-            console.log("Object.keys(header).length", Object.keys(header).length);
+            this.log.debug("RequestHandlerService requestCome response");
+            this.log.debug("Object.keys(header).length", Object.keys(header).length);
             // Eğer header içinde Set-Cookie veya başka header varsa response'a ekle
             if (Object.keys(header).length > 0) {
                 // Response zaten bir Response nesnesi ise, header'ları birleştirerek yeni bir Response oluştur

package/dist/services/main/logService/LogService.d.ts

@@ -0,0 +1,31 @@
+import { Service, ServiceLogger } from "../../../types/Service.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+import { ILogTransport } from "./types.js";
+export declare class LogService extends Service {
+    static serviceInfo: {
+        name: string;
+        requiredServices: any[];
+    };
+    private transports;
+    private minLevel;
+    private enabledNamespaces?;
+    private logLevelOrder;
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    /**
+     * Runtime'da yeni transport ekle
+     */
+    addTransport(transport: ILogTransport): void;
+    /**
+     * Transport'u kaldır
+     */
+    removeTransport(transportName: string): void;
+    /**
+     * Her service için özel logger döndürür
+     */
+    logSetupForService(tag: string, namespace?: string): ServiceLogger;
+    private writeLog;
+}

package/dist/services/main/logService/LogService.js

@@ -0,0 +1,131 @@
+import { Service } from "../../../types/Service.js";
+import { ConsoleTransport } from "./transports/ConsoleTransport.js";
+export class LogService extends Service {
+    static serviceInfo = {
+        name: "LogService",
+        requiredServices: []
+    };
+    transports = [];
+    minLevel = 'debug';
+    enabledNamespaces;
+    logLevelOrder = {
+        debug: 0,
+        info: 1,
+        success: 2,
+        warn: 3,
+        error: 4
+    };
+    async onSetup(options) {
+        // Default: sadece ConsoleTransport
+        const config = options?.config;
+        if (config) {
+            this.transports = config.transports;
+            if (config.minLevel)
+                this.minLevel = config.minLevel;
+            if (config.enabledNamespaces)
+                this.enabledNamespaces = config.enabledNamespaces;
+        }
+        else {
+            // Varsayılan: ConsoleTransport
+            this.transports = [new ConsoleTransport()];
+        }
+        this.log.success(`LogService initialized with ${this.transports.length} transport(s)`);
+        return { status: "success", message: "LogService setup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "LogService started" };
+    }
+    async onStop() {
+        // Tüm transport'ları flush et
+        await Promise.all(this.transports
+            .filter(t => t.flush)
+            .map(t => t.flush()));
+        return { status: "success", message: "LogService stopped" };
+    }
+    async onDestroy() {
+        // Tüm transport'ları kapat
+        await Promise.all(this.transports
+            .filter(t => t.close)
+            .map(t => t.close()));
+        this.transports = [];
+        return { status: "success", message: "LogService destroyed" };
+    }
+    /**
+     * Runtime'da yeni transport ekle
+     */
+    addTransport(transport) {
+        this.transports.push(transport);
+        this.log.info(`Transport added: ${transport.name}`);
+    }
+    /**
+     * Transport'u kaldır
+     */
+    removeTransport(transportName) {
+        const index = this.transports.findIndex(t => t.name === transportName);
+        if (index !== -1) {
+            const transport = this.transports[index];
+            if (transport.close) {
+                transport.close();
+            }
+            this.transports.splice(index, 1);
+            this.log.info(`Transport removed: ${transportName}`);
+        }
+    }
+    /**
+     * Her service için özel logger döndürür
+     */
+    logSetupForService(tag, namespace) {
+        return {
+            debug: (...args) => this.writeLog('debug', tag, namespace, ...args),
+            info: (...args) => this.writeLog('info', tag, namespace, ...args),
+            success: (...args) => this.writeLog('success', tag, namespace, ...args),
+            warn: (...args) => this.writeLog('warn', tag, namespace, ...args),
+            error: (...args) => this.writeLog('error', tag, namespace, ...args),
+            // Backward compatibility
+            OK: (...args) => this.writeLog('success', tag, namespace, ...args),
+            ERROR: (...args) => this.writeLog('error', tag, namespace, ...args),
+            WARN: (...args) => this.writeLog('warn', tag, namespace, ...args),
+            l: (...args) => this.writeLog('info', tag, namespace, ...args),
+        };
+    }
+    writeLog(level, tag, namespace, ...args) {
+        // Level filtreleme (LogService seviyesinde)
+        if (this.logLevelOrder[level] < this.logLevelOrder[this.minLevel]) {
+            return;
+        }
+        // Namespace filtreleme
+        if (this.enabledNamespaces && this.enabledNamespaces.length > 0) {
+            const fullName = namespace ? `${namespace}:${tag}` : tag;
+            const isEnabled = this.enabledNamespaces.some(ns => fullName.includes(ns) || tag.includes(ns));
+            if (!isEnabled)
+                return;
+        }
+        const entry = {
+            timestamp: new Date(),
+            level,
+            tag,
+            namespace,
+            message: args[0],
+            args: args.slice(1)
+        };
+        // Her transport için kontrol et ve logla
+        for (const transport of this.transports) {
+            // Transport seviyesinde filtreleme
+            if (!transport.shouldLog(entry)) {
+                continue;
+            }
+            try {
+                const result = transport.log(entry);
+                // Eğer Promise dönerse bekle
+                if (result instanceof Promise) {
+                    result.catch(err => {
+                        console.error(`[LogService] Transport ${transport.name} failed:`, err);
+                    });
+                }
+            }
+            catch (err) {
+                console.error(`[LogService] Transport ${transport.name} failed:`, err);
+            }
+        }
+    }
+}

package/dist/services/main/logService/index.d.ts

@@ -0,0 +1,7 @@
+export { LogService } from "./LogService.js";
+export { ConsoleTransport } from "./transports/ConsoleTransport.js";
+export { DatabaseTransport } from "./transports/DatabaseTransport.js";
+export { parseLogConfigFromEnv, getDatabaseTransportConfigFromEnv } from "./utils/parseEnvConfig.js";
+export type { ILogEntry, ILogTransport, LogServiceConfig } from "./types.js";
+export type { DatabaseTransportOptions } from "./transports/DatabaseTransport.js";
+export type { EnvLogConfig } from "./utils/parseEnvConfig.js";

package/dist/services/main/logService/index.js

@@ -0,0 +1,4 @@
+export { LogService } from "./LogService.js";
+export { ConsoleTransport } from "./transports/ConsoleTransport.js";
+export { DatabaseTransport } from "./transports/DatabaseTransport.js";
+export { parseLogConfigFromEnv, getDatabaseTransportConfigFromEnv } from "./utils/parseEnvConfig.js";

package/dist/services/main/logService/transports/ConsoleTransport.d.ts

@@ -0,0 +1,16 @@
+import { ILogEntry, ILogTransport } from "../types.js";
+import { LogLevel } from "../../../../types/Service.js";
+export declare class ConsoleTransport implements ILogTransport {
+    name: string;
+    levels?: LogLevel[];
+    minLevel?: LogLevel;
+    private logLevelOrder;
+    constructor(options?: {
+        levels?: LogLevel[];
+        minLevel?: LogLevel;
+    });
+    shouldLog(entry: ILogEntry): boolean;
+    private getLogPrefix;
+    private getIcon;
+    log(entry: ILogEntry): void;
+}

package/dist/services/main/logService/transports/ConsoleTransport.js

@@ -0,0 +1,62 @@
+export class ConsoleTransport {
+    name = "ConsoleTransport";
+    levels;
+    minLevel;
+    logLevelOrder = {
+        debug: 0,
+        info: 1,
+        success: 2,
+        warn: 3,
+        error: 4
+    };
+    constructor(options) {
+        if (options?.levels)
+            this.levels = options.levels;
+        if (options?.minLevel)
+            this.minLevel = options.minLevel;
+    }
+    shouldLog(entry) {
+        // Eğer spesifik level'lar belirtilmişse
+        if (this.levels && this.levels.length > 0) {
+            return this.levels.includes(entry.level);
+        }
+        // Eğer minimum level belirtilmişse
+        if (this.minLevel) {
+            return this.logLevelOrder[entry.level] >= this.logLevelOrder[this.minLevel];
+        }
+        // Varsayılan: her şeyi logla
+        return true;
+    }
+    getLogPrefix(entry) {
+        if (entry.namespace) {
+            return `[${entry.namespace}:${entry.tag}]`;
+        }
+        return `[${entry.tag}]`;
+    }
+    getIcon(level) {
+        const icons = {
+            debug: '🔍',
+            info: 'ℹ️',
+            success: '✅',
+            warn: '⚠️',
+            error: '❌'
+        };
+        return icons[level];
+    }
+    log(entry) {
+        const timestamp = entry.timestamp.toLocaleTimeString('tr-TR', { hour12: false });
+        const prefix = this.getLogPrefix(entry);
+        const icon = this.getIcon(entry.level);
+        const formattedArgs = [`${icon} ${timestamp} ${prefix}`, entry.message, ...entry.args];
+        switch (entry.level) {
+            case 'error':
+                console.error(...formattedArgs);
+                break;
+            case 'warn':
+                console.warn(...formattedArgs);
+                break;
+            default:
+                console.log(...formattedArgs);
+        }
+    }
+}

package/dist/services/main/logService/transports/DatabaseTransport.d.ts

@@ -0,0 +1,28 @@
+import { ILogEntry, ILogTransport } from "../types.js";
+import { LogLevel } from "../../../../types/Service.js";
+export interface DatabaseTransportOptions {
+    levels?: LogLevel[];
+    minLevel?: LogLevel;
+    getDatabaseService: () => any;
+    collectionName?: string;
+    batchSize?: number;
+    flushInterval?: number;
+}
+export declare class DatabaseTransport implements ILogTransport {
+    name: string;
+    levels?: LogLevel[];
+    minLevel?: LogLevel;
+    private getDatabaseService;
+    private collectionName;
+    private batchSize;
+    private flushInterval;
+    private logBuffer;
+    private flushTimer?;
+    private logLevelOrder;
+    constructor(options: DatabaseTransportOptions);
+    shouldLog(entry: ILogEntry): boolean;
+    log(entry: ILogEntry): Promise<void>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private startFlushTimer;
+}