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

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

@@ -20,7 +20,7 @@ export class _ServiceManager {
     //     };
     //     // LayoutService?: ServiceConstructor<LayoutPageService>;
     // }
-    services) {
+    services, namespace) {
         //debugger;
         console.log("ServiceManager: Initializing services...");
         // // TestService'i oluştur ve başlat
@@ -138,14 +138,25 @@ export class _ServiceManager {
             const usedService = {};
             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) => {
@@ -231,15 +242,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/project/ProjectInfoService.d.ts

@@ -38,7 +38,7 @@ export declare abstract class ProjectInfoService extends Service {
     getMenuPages(userGroup?: string): {
         [key: string]: ProjectsPages[string];
     };
-    getMobilePages(limit?: number): {
+    getMobilePages(userGroup?: string, limit?: number): {
         [key: string]: ProjectsPages[string];
     };
 }

package/dist/services/abstract/project/ProjectInfoService.js

@@ -65,13 +65,30 @@ export class ProjectInfoService extends Service {
         });
         return result;
     }
-    getMobilePages(limit = 4) {
+    getMobilePages(userGroup, limit = 4) {
         const result = {};
         let count = 0;
         for (const [key, page] of Object.entries(this.pages)) {
             if (page.showInMobile) {
-                result[key] = page;
-                count++;
+                // Apply the same group access control logic as getMenuPages
+                if (userGroup && userGroup == 'admin') {
+                    // If onlyForGroup is true, admin cannot see this page
+                    if (page.onlyForGroup !== true) {
+                        result[key] = page;
+                        count++;
+                    }
+                }
+                else if (userGroup) {
+                    // Check if the page is accessible by the user group
+                    if (page.userGroup === userGroup) {
+                        result[key] = page;
+                        count++;
+                    }
+                }
+                else {
+                    result[key] = page;
+                    count++;
+                }
                 if (count >= limit)
                     break;
             }

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" };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urga-panel/ur-panels-core",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/ServiceManager.ts

@@ -34,7 +34,8 @@ export class _ServiceManager {
         //     };
         //     // LayoutService?: ServiceConstructor<LayoutPageService>;
         // }
-        services: Array<RegisterServiceInfo>
+        services: Array<RegisterServiceInfo>,
+        namespace?: string
     ) {
         //debugger;
         console.log("ServiceManager: Initializing services...");
@@ -157,14 +158,24 @@ export class _ServiceManager {
             const usedService: { [key: string]: () => Service } = {};
             if (Array.isArray(service.serviceInfo.requiredServices)) {
                 for (const reqName of service.serviceInfo.requiredServices) {
-                    usedService[reqName] = () => {return this.getService<Service>(reqName)}
+                    // Namespace-aware service lookup: önce namespace'li ara, yoksa global'e fallback
+                    usedService[reqName] = () => {
+                        if (namespace) {
+                            const namespacedService = this.getService<Service>(`${namespace}:${reqName}`);
+                            if (namespacedService) return namespacedService;
+                        }
+                        return this.getService<Service>(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: string, PageCtor?: ServiceConstructor<Service>) => {
@@ -253,16 +264,21 @@ export class _ServiceManager {
 
     // }
 
-    public getService<T extends Service>(serviceName: string): T {
+    public getService<T extends Service>(serviceName: string, namespace?: string): T {
+        // Namespace verilmişse önce namespace:serviceName formatında ara
+        if (namespace) {
+            const namespacedKey = `${namespace}:${serviceName}`;
+            if (this.services[namespacedKey]) {
+                return this.services[namespacedKey].serviceSelf as T;
+            }
+        }
+        // Fallback: direkt isimle ara (core servisler için)
         if (this.services[serviceName]) {
-        } else {
-            //console.log(`ServiceManager: Service ${serviceName} not found.`);
-            //console.log("Available services:", Object.keys(this.services));
-            return undefined as T;
+            return this.services[serviceName].serviceSelf as T;
         }
-
-        return this.services[serviceName].serviceSelf as T;
-
+        //console.log(`ServiceManager: Service ${serviceName} not found.`);
+        //console.log("Available services:", Object.keys(this.services));
+        return undefined as T;
     }
 
 

package/src/services/abstract/apiService/ApiService.ts

@@ -15,9 +15,15 @@ export abstract class ApiService extends Service  {
     protected onStart(): Promise<ServiceResponse> {
         
         const requestHandlerService = this.ots.usedService.RequestHandlerService() as RequestHandlerService;
+        const namespace = this.ots.namespace as string | undefined;
+        
         Object.entries(this.apis).forEach(([name, { handler, options }]) => {
+            // Namespace varsa handler key'i namespace:ServiceName/method formatında oluştur
+            const handlerKey = namespace 
+                ? `${namespace}:${this.tag}/${name}`
+                : `${this.tag}/${name}`;
             requestHandlerService.addHandler(
-                `${this.tag}/${name}`,
+                handlerKey,
                 handler.bind(this),
                 options || { auth: true, role: "guest" }
             );

package/src/services/abstract/project/ProjectInfoService.ts

@@ -107,13 +107,28 @@ export abstract class ProjectInfoService extends Service {
         return result;
     }
 
-    getMobilePages(limit: number = 4): { [key: string]: ProjectsPages[string] } {
+    getMobilePages(userGroup?: string, limit: number = 4): { [key: string]: ProjectsPages[string] } {
         const result: { [key: string]: ProjectsPages[string] } = {};
         let count = 0;
         for (const [key, page] of Object.entries(this.pages)) {
             if (page.showInMobile) {
-                result[key] = page;
-                count++;
+                // Apply the same group access control logic as getMenuPages
+                if (userGroup && userGroup == 'admin') {
+                    // If onlyForGroup is true, admin cannot see this page
+                    if (page.onlyForGroup !== true) {
+                        result[key] = page;
+                        count++;
+                    }
+                } else if (userGroup) {
+                    // Check if the page is accessible by the user group
+                    if (page.userGroup === userGroup) {
+                        result[key] = page;
+                        count++;
+                    }
+                } else {
+                    result[key] = page;
+                    count++;
+                }
                 if (count >= limit) break;
             }
         }

package/src/services/main/httpServices/RequestHandlerService.ts

@@ -53,7 +53,7 @@ export class RequestHandlerService extends Service {
         this.log.OK("RequestHandlerService addHandler", name);
     }
 
-    async requestCome({ params, request, url }): Promise<any> {
+    async requestCome({ params, request, url, namespace }: { params: any; request: any; url: any; namespace?: string }): Promise<any> {
         this.log.OK("RequestHandlerService requestCome", params);
 
          let bodyData: any = null;
@@ -75,9 +75,23 @@ 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" };
         }