@urga-panel/ur-panels-core 1.0.0

package/src/ServiceManager.ts

@@ -0,0 +1,403 @@
+import { ExtensionService } from "./services/abstract/extensionServices/ExtensionService";
+import { NSPageControllerService } from "./services/abstract/pageServices/controllers/NSPageControllerService";
+import { SVPageControllerService } from "./services/abstract/pageServices/controllers/SVPageControllerService";
+import { NSPageService } from "./services/abstract/pageServices/pages/NsPageService";
+import { PageService } from "./services/abstract/pageServices/PageServices";
+import { RegisterServiceInfo } from "./types/RegisterServiceInfo";
+import { Service } from "./types/Service";
+import { ServiceEntry } from "./types/ServiceEntry";
+import { ServiceOts } from "./types/ServiceOts";
+
+export interface ServiceConstructor<T extends Service> {
+    new(ots: any): T;
+    servcieInfo?: {}
+}
+
+export class _ServiceManager {
+    public services: {
+        [key: string]: ServiceEntry<Service>,
+    } = {
+            TestService: {
+                serviceSelf: undefined,
+                status: "waitSetup"
+            }
+        };
+    constructor() {
+
+    }
+    async initServices(
+        type: "ns" | "svelte" | "node" | "svelteBackend",
+        // services: {
+        //     [key: string]: {
+        //         service:ServiceConstructor<Service>
+        //         ots: any;
+        //     };
+        //     // LayoutService?: ServiceConstructor<LayoutPageService>;
+        // }
+        services: Array<RegisterServiceInfo>
+    ) {
+        //debugger;
+        console.log("ServiceManager: Initializing services...");
+
+        // // TestService'i oluştur ve başlat
+        // const _TestService = this.setKey("TestService", {
+        //     serviceSelf: new TestService({
+        //         usedService: {},
+        //         tag: "TestService",
+        //     }),
+        //     status: "waitSetup",
+        // });
+        // await _TestService.setup();
+        // await _TestService.start();
+
+        // PageControllerService'i oluştur ve başlat
+        if(type == "ns") {
+            const _PageControllerService = this.setKey("NSPageControllerService", {
+                serviceSelf: new NSPageControllerService({
+                    usedService: {},
+                    abilities: {
+                        createChildService: (tag:string) => {
+                            console.log("createChildService called for ---", tag);
+                            const _pageService = this.setKey(tag, {
+                                serviceSelf: new NSPageService({
+                                    usedService: {},
+                                    tag: tag,
+                                    type: type,
+                                }),
+                                status: "waitSetup",
+                            });
+                            return _pageService as NSPageService;
+                        },
+                    },
+                    tag: "NSPageControllerService",
+                    type: type,
+                }),
+                status: "waitSetup",
+            });
+            await _PageControllerService.setup();
+            await _PageControllerService.start();
+        }
+        else if(type == "svelte") {
+            const _PageControllerService = this.setKey("SVPageControllerService", {
+                serviceSelf: new SVPageControllerService({
+                    usedService: {
+                       
+                    },
+                    abilities: {
+                        // Artık class referansını parametre olarak alıyor
+                         createChildService: (tag: string, PageCtor?: ServiceConstructor<Service>) => {
+                            console.log("createChildService called for ---", tag);
+                            const ServiceClass = PageCtor ?? PageService;
+                            const _pageService = this.setKey(tag, {
+                                serviceSelf: new ServiceClass({
+                                    usedService: {},
+                                    tag: tag,
+                                    type: type,
+                                }),
+                                status: "waitSetup",
+                            });
+                            return _pageService as Service;
+                        },
+                    },
+                    tag: "PageControllerService",
+                    type: type,
+                }),
+                status: "waitSetup",
+            });
+            await _PageControllerService.setup();
+            await _PageControllerService.start();
+        }
+        else if(type == "svelteBackend") {
+            // debugger;
+            // const _PageControllerService = this.setKey("RequestHandlerService", {
+            //     serviceSelf: new RequestHandlerService({
+            //         usedService: {
+            //              "AuthService": () => {
+            //                 debugger;
+            //                 return this.getService("AuthService")
+            //             },
+            //         },
+            //         abilities: {
+            //             // Artık class referansını parametre olarak alıyor
+            //              createChildService: (tag: string, PageCtor?: ServiceConstructor<Service>) => {
+            //                 console.log("createChildService called for ---", tag);
+            //                 const ServiceClass = PageCtor ?? PageService;
+            //                 const _pageService = this.setKey(tag, {
+            //                     serviceSelf: new ServiceClass({
+            //                         usedService: {},
+            //                         tag: tag,
+            //                         type: type,
+            //                     }),
+            //                     status: "waitSetup",
+            //                 });
+            //                 return _pageService as Service;
+            //             },
+            //         },
+            //         tag: "RequestHandlerService",
+            //         type: type,
+            //     }),
+            //     status: "waitSetup",
+            // });
+            // await _PageControllerService.setup();
+            // await _PageControllerService.start();
+        }
+        const createdServices: Service[] = [];
+        for (const serviceInfo of services) {
+            const { serviceName, service, tag, dynamicTag, isAbstract, requiredServices } = serviceInfo;
+            // Fill usedService according to requiredServices
+            //@ts-ignore
+            if(service.serviceInfo == null || service.serviceInfo == undefined) {
+                console.warn(`Service ${serviceName} does not have serviceInfo defined.`);
+                continue;
+            }
+            else{
+                console.log(`Service ${serviceName} has serviceInfo defined:`, service.serviceInfo);
+            }
+            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)}
+                }
+            }
+            const serviceInstance = this.setKey(tag, {
+                serviceSelf: new service({
+                    usedService,
+                    tag: tag,
+                    type: type,
+                    abilities: {
+                        createChildService: (tag: string, PageCtor?: ServiceConstructor<Service>) => {
+                            console.log("createChildService called for ---", tag);
+                            const ServiceClass = PageCtor ?? PageService;
+                            const _pageService = this.setKey(tag, {
+                                serviceSelf: new ServiceClass({
+                                    usedService: {},
+                                    tag: tag,
+                                    type: type,
+                                }),
+                                status: "waitSetup",
+                            });
+                            return _pageService as Service;
+                        },
+                    }
+                }),
+                status: "waitSetup",
+            });
+            await serviceInstance.setup();
+            createdServices.push(serviceInstance);
+        }
+        for (const serviceInstance of createdServices) {
+            if (typeof serviceInstance.start === "function") {
+                await serviceInstance.start();
+            }
+        }
+        // // Diğer servisleri oluştur ve başlat (TestService ve PageControllerService hariç)
+        // const excluded = ["TestService", "PageControllerService"];
+        // const createdServices: Service[] = [];
+        // for (const key of Object.keys(services)) {
+        //     if (excluded.includes(key)) continue;
+        //     const ServiceCtor = services[key].service;
+            
+        //     const serviceInstance = this.setKey(key, {
+        //         serviceSelf: new ServiceCtor({
+        //             usedService: {},
+        //             abilities: {
+        //                 // createChildService: (tag: string) => {
+        //                 //     console.log("createChildService called for ---", tag);
+        //                 //     const _pageService = this.setKey(tag, {
+        //                 //         serviceSelf: new PageService({
+        //                 //             usedService: {},
+        //                 //             tag: tag,
+        //                 //             type: type,
+        //                 //         }),
+        //                 //         status: "waitSetup",
+        //                 //     });
+        //                 //     return _pageService as PageService;
+        //                 // },
+        //                  createChildService: (tag: string, PageCtor?: ServiceConstructor<Service>) => {
+        //                     console.log("createChildService called for ---", tag);
+        //                     const ServiceClass = PageCtor ?? PageService;
+        //                     const _pageService = this.setKey(tag, {
+        //                         serviceSelf: new ServiceClass({
+        //                             usedService: {},
+        //                             tag: tag,
+        //                             type: type,
+        //                         }),
+        //                         status: "waitSetup",
+        //                     });
+        //                     return _pageService as Service;
+        //                 },
+        //             },
+        //             type: type,
+        //             tag: key,
+        //         }),
+        //         status: "waitSetup",
+        //     });
+        //     await serviceInstance.setup();
+        //     createdServices.push(serviceInstance);
+        // }
+        // for (const serviceInstance of createdServices) {
+        //     if (typeof serviceInstance.start === "function") {
+        //         await serviceInstance.start();
+        //     }
+        // }
+    }
+    // public createPage(callback: () => Promise<void>) {
+    //     return async ({ params, url }) => {
+    //         console.log("Available services:", Object.keys(this.services));
+    //         callback();
+    //     }
+
+    // }
+
+    public getService<T extends Service>(serviceName: string): T {
+        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;
+
+    }
+
+
+    private setKey(key: string, value: ServiceEntry<Service>) {
+        this.services[key] = value;
+        return this.services[key].serviceSelf;
+    }
+
+    private async quickService<T extends Service>(
+        serviceName: string,
+        serviceConstructor: ServiceConstructor<T>,
+        usedService?: { [key: string]: () => Service },
+        ots: Partial<ServiceOts> = {}
+    ) {
+        this.setKey(serviceName, {
+            serviceSelf: new serviceConstructor({
+                usedService: {
+
+                },
+                tag: serviceName,
+            }),
+            status: "waitSetup",
+        });
+        await this.services[serviceName].serviceSelf.setup();
+        this.services[serviceName].status = "waitStart";
+        return this.services[serviceName].serviceSelf;
+    }
+
+    /**
+     * Returns all services that are ExtensionService instances (serviceSelf)
+     */
+    public getExtensionServices(): { [key: string]: ExtensionService } {
+        const result: { [key: string]: ExtensionService } = {};
+        for (const [key, entry] of Object.entries(this.services)) {
+            if (
+                entry.serviceSelf &&
+                entry.serviceSelf instanceof ExtensionService
+            ) {
+                result[key] = entry.serviceSelf as ExtensionService;
+            }
+        }
+        return result;
+    }
+
+}
+
+const ServiceManager = new _ServiceManager();
+export { ServiceManager };
+
+// export function getPackageJsonFromHost(
+//   packageName: string,
+//   hostDir: string = process.cwd()
+// ): Record<string, any> | null {
+//   try {
+//     const dummyEntry = path.join(hostDir, 'index.js');
+//     const customRequire = createRequire(dummyEntry);
+
+//     // resolve the entry point of the package (e.g., index.js or main file)
+//     const resolvedPath = customRequire.resolve(packageName);
+
+//     // traverse up to find the package root (usually up to the nearest package.json)
+//      const packageRoot = findPackageRoot(resolvedPath);
+//     if (!packageRoot) return null;
+//     // console.log('resolvedPath', resolvedPath)
+//     // const parts = resolvedPath.split(path.sep);
+//     // const pkgIndex = parts.lastIndexOf('node_modules');
+//     // const packageRoot =
+//     //   pkgIndex !== -1 ? path.join(...parts.slice(0, pkgIndex + 2)) : null;
+
+//     // console.log('package root', packageRoot)
+//     // if (!packageRoot) return null;
+
+//     const pkgJsonPath = path.join(packageRoot, 'urga.config.yaml');
+//     if (!fs.existsSync(pkgJsonPath)) return null;
+
+//     const jsonData = fs.readFileSync(pkgJsonPath, 'utf-8');
+//     			const config = yaml.load(jsonData);
+
+//     return (config);
+//   } catch (err) {
+//     console.log(err)
+//     return null;
+//   }
+// }
+
+// export function isPackageInstalledInHost(
+//   packageName: string,
+//   hostDir: string = process.cwd()
+// ): boolean {
+//   try {
+//     console.log(path.join(hostDir, 'index.js'))
+//     const customRequire = createRequire(path.join(hostDir, 'index.js'));
+//     customRequire.resolve(packageName);
+//     return true;
+//   } catch(error) {
+//     console.error(`Package ${packageName} not found in host directory ${hostDir}`,error);
+//     return false;
+//   }
+// }
+
+// function findPackageRoot(startDir: string): string | null {
+//   let currentDir = startDir;
+
+//   while (true) {
+//     const pkgPath = path.join(currentDir, 'package.json');
+//     if (fs.existsSync(pkgPath)) {
+//       return currentDir;
+//     }
+
+//     const parentDir = path.dirname(currentDir);
+//     if (parentDir === currentDir) {
+//       // Root dizine ulaşıldı
+//       return null;
+//     }
+//     currentDir = parentDir;
+//   }
+// }
+//     return true;
+//   } catch(error) {
+//     console.error(`Package ${packageName} not found in host directory ${hostDir}`,error);
+//     return false;
+//   }
+// }
+
+// function findPackageRoot(startDir: string): string | null {
+//   let currentDir = startDir;
+
+//   while (true) {
+//     const pkgPath = path.join(currentDir, 'package.json');
+//     if (fs.existsSync(pkgPath)) {
+//       return currentDir;
+//     }
+
+//     const parentDir = path.dirname(currentDir);
+//     if (parentDir === currentDir) {
+//       // Root dizine ulaşıldı
+//       return null;
+//     }
+//     currentDir = parentDir;
+//   }
+// }
+// }

package/src/TestRun.ts

@@ -0,0 +1,17 @@
+import { ServiceManager } from './ServiceManager';
+
+async function main() {
+    //const serviceManager = new ServiceManager();
+
+    // const _service = new LayoutPageService({
+    //     tag: 'LayoutService',
+    //     usedService: {}
+    // });
+    // await serviceManager.initServices(
+    //     {
+    //         LayoutService: _service
+    //     }
+    // );
+}
+
+main().catch(console.error);

package/src/index.ts

@@ -0,0 +1,26 @@
+// Types
+export * from "./types/Service.js";
+export * from "./types/ServiceStatus.js";
+export * from "./types/ServiceConstructor.js";
+export * from "./types/ServiceEntry.js";
+export * from "./types/ServiceSetupOptions.js";
+export * from "./types/_ServiceError.js";
+export * from "./types/ServiceResponse.js";
+export * from "./types/ServiceOts.js";
+
+// Classes
+export { ServiceManager } from "./ServiceManager.js";
+export { NSPageControllerService } from "./services/abstract/pageServices/controllers/NSPageControllerService.js";
+export { SVPageControllerService } from "./services/abstract/pageServices/controllers/SVPageControllerService.js";
+export { ExtensionService } from "./services/abstract/extensionServices/ExtensionService.js";
+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 { PageControllerService } from "./services/pageServices/controller/PageControllerService.js";
+// export { ExtensionService } from "./services/extensionServices/controller/ExtensionService.js";
+// export { Test2Service } from "./testServices/TestService2";
+
+// Functions
+// export { add } from "./addService/AddServiceStatic";

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

@@ -0,0 +1,51 @@
+import { Service } from "../../../types/Service";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { RequestHandlerService } from "../../main/httpServices/RequestHandlerService";
+
+
+export abstract class ApiService extends Service  {
+   
+    apis: {
+        [key: string]: {
+            handler: (...args: any[]) => Promise<any>;
+            options?: { auth?: boolean; role?: string };
+        };
+    } = {};
+
+    protected onStart(): Promise<ServiceResponse> {
+        
+        const requestHandlerService = this.ots.usedService.RequestHandlerService() as RequestHandlerService;
+        Object.entries(this.apis).forEach(([name, { handler, options }]) => {
+            requestHandlerService.addHandler(
+                `${this.tag}/${name}`,
+                handler.bind(this),
+                options || { auth: true, role: "guest" }
+            );
+        });
+        return Promise.resolve({ status: "success", message: "ApiService started" });
+    }
+
+    constructor(public ots: any) {
+        super(ots);
+        this.apis = {};
+    }
+
+     resposeHandler(response: any): Response {
+        if (response.status === "success") {
+            return new Response(JSON.stringify(response), {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        return new Response(JSON.stringify(response), {
+            status: 400,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+   
+}