@urga-panel/ur-panels-core 1.0.20 → 1.0.22

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, namespace) {
-        //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,6 +150,10 @@ 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) {
                     // Namespace-aware service lookup: önce namespace'li ara, yoksa global'e fallback
@@ -164,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

package/dist/index.d.ts

@@ -13,3 +13,5 @@ export { ExtensionService } from "./services/abstract/extensionServices/Extensio
 export { ProjectInfoService } from "./services/abstract/project/ProjectInfoService.js";
 export { RequestHandlerService } from "./services/main/httpServices/RequestHandlerService.js";
 export { AuthService } from "./services/abstract/authServices/AuthService.js";
+export { LogService, ConsoleTransport, DatabaseTransport, parseLogConfigFromEnv, getDatabaseTransportConfigFromEnv } from "./services/main/logService/index.js";
+export type { ILogEntry, ILogTransport, LogServiceConfig, DatabaseTransportOptions, EnvLogConfig } from "./services/main/logService/index.js";

package/dist/index.js

@@ -15,6 +15,8 @@ export { ExtensionService } from "./services/abstract/extensionServices/Extensio
 export { ProjectInfoService } from "./services/abstract/project/ProjectInfoService.js";
 export { RequestHandlerService } from "./services/main/httpServices/RequestHandlerService.js";
 export { AuthService } from "./services/abstract/authServices/AuthService.js";
+// LogService exports
+export { LogService, ConsoleTransport, DatabaseTransport, parseLogConfigFromEnv, getDatabaseTransportConfigFromEnv } from "./services/main/logService/index.js";
 // export { PageControllerService } from "./services/pageServices/controller/PageControllerService.js";
 // export { ExtensionService } from "./services/extensionServices/controller/ExtensionService.js";
 // export { Test2Service } from "./testServices/TestService2";

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.js

@@ -89,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`,
                     };
@@ -117,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;
+}

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

@@ -0,0 +1,90 @@
+export class DatabaseTransport {
+    name = "DatabaseTransport";
+    levels;
+    minLevel;
+    getDatabaseService;
+    collectionName;
+    batchSize;
+    flushInterval;
+    logBuffer = [];
+    flushTimer;
+    logLevelOrder = {
+        debug: 0,
+        info: 1,
+        success: 2,
+        warn: 3,
+        error: 4
+    };
+    constructor(options) {
+        this.getDatabaseService = options.getDatabaseService;
+        this.collectionName = options.collectionName || "logs";
+        this.batchSize = options.batchSize || 10;
+        this.flushInterval = options.flushInterval || 5000; // 5 saniye
+        if (options.levels)
+            this.levels = options.levels;
+        if (options.minLevel)
+            this.minLevel = options.minLevel;
+        // Periyodik flush başlat
+        this.startFlushTimer();
+    }
+    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: sadece warn ve error
+        return entry.level === 'warn' || entry.level === 'error';
+    }
+    async log(entry) {
+        // Buffer'a ekle
+        this.logBuffer.push(entry);
+        // Eğer buffer dolmuşsa hemen flush et
+        if (this.logBuffer.length >= this.batchSize) {
+            await this.flush();
+        }
+    }
+    async flush() {
+        if (this.logBuffer.length === 0)
+            return;
+        try {
+            const dbService = this.getDatabaseService();
+            if (!dbService || !dbService.client) {
+                console.error('[DatabaseTransport] DatabaseService not ready');
+                return;
+            }
+            const db = dbService.client.db();
+            const logsCollection = db.collection(this.collectionName);
+            const documents = this.logBuffer.map(entry => ({
+                timestamp: entry.timestamp,
+                level: entry.level,
+                service: entry.tag,
+                namespace: entry.namespace,
+                message: entry.message,
+                args: entry.args,
+                createdAt: new Date()
+            }));
+            await logsCollection.insertMany(documents);
+            this.logBuffer = []; // Buffer'ı temizle
+        }
+        catch (error) {
+            console.error('[DatabaseTransport] Failed to write logs:', error);
+        }
+    }
+    async close() {
+        // Timer'ı durdur
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        // Kalan log'ları flush et
+        await this.flush();
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(async () => {
+            await this.flush();
+        }, this.flushInterval);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { LogLevel } from "../../../types/Service.js";
+export interface ILogEntry {
+    timestamp: Date;
+    level: LogLevel;
+    tag: string;
+    namespace?: string;
+    message: string;
+    args: any[];
+}
+export interface ILogTransport {
+    name: string;
+    levels?: LogLevel[];
+    minLevel?: LogLevel;
+    shouldLog(entry: ILogEntry): boolean;
+    log(entry: ILogEntry): void | Promise<void>;
+    flush?(): void | Promise<void>;
+    close?(): void | Promise<void>;
+}
+export interface LogServiceConfig {
+    transports: ILogTransport[];
+    minLevel?: LogLevel;
+    enabledNamespaces?: string[];
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/services/main/logService/utils/parseEnvConfig.d.ts

@@ -0,0 +1,27 @@
+import { LogLevel } from "../../../../types/Service.js";
+import { LogServiceConfig } from "../types.js";
+export interface EnvLogConfig {
+    LOG_LEVEL?: string;
+    LOG_CONSOLE_LEVELS?: string;
+    LOG_NAMESPACES?: string;
+    LOG_DATABASE_ENABLED?: string;
+    LOG_DATABASE_LEVELS?: string;
+}
+/**
+ * Environment variable'lardan LogService config'i oluşturur
+ *
+ * Örnek .env:
+ * LOG_LEVEL=info
+ * LOG_CONSOLE_LEVELS=debug,info,success,warn,error
+ * LOG_NAMESPACES=DatabaseService,AuthService
+ * LOG_DATABASE_ENABLED=true
+ * LOG_DATABASE_LEVELS=warn,error
+ */
+export declare function parseLogConfigFromEnv(env: EnvLogConfig): Partial<LogServiceConfig>;
+/**
+ * DatabaseTransport için config döner
+ */
+export declare function getDatabaseTransportConfigFromEnv(env: EnvLogConfig): {
+    enabled: boolean;
+    levels?: LogLevel[];
+};