@urga-panel/ur-panels-core 1.0.0

package/.eslintrc.js

@@ -0,0 +1,13 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'prettier'
+  ],
+  plugins: ['@typescript-eslint'],
+  env: {
+    node: true,
+    jest: true
+  },
+  rules: {}
+};

package/dist/ServiceManager.d.ts

@@ -0,0 +1,26 @@
+import { ExtensionService } from "./services/abstract/extensionServices/ExtensionService.js";
+import { RegisterServiceInfo } from "./types/RegisterServiceInfo.js";
+import { Service } from "./types/Service.js";
+import { ServiceEntry } from "./types/ServiceEntry.js";
+export interface ServiceConstructor<T extends Service> {
+    new (ots: any): T;
+    servcieInfo?: {};
+}
+export declare class _ServiceManager {
+    services: {
+        [key: string]: ServiceEntry<Service>;
+    };
+    constructor();
+    initServices(type: "ns" | "svelte" | "node" | "svelteBackend", services: Array<RegisterServiceInfo>): Promise<void>;
+    getService<T extends Service>(serviceName: string): T;
+    private setKey;
+    private quickService;
+    /**
+     * Returns all services that are ExtensionService instances (serviceSelf)
+     */
+    getExtensionServices(): {
+        [key: string]: ExtensionService;
+    };
+}
+declare const ServiceManager: _ServiceManager;
+export { ServiceManager };

package/dist/ServiceManager.js

@@ -0,0 +1,351 @@
+import { ExtensionService } from "./services/abstract/extensionServices/ExtensionService.js";
+import { NSPageControllerService } from "./services/abstract/pageServices/controllers/NSPageControllerService.js";
+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";
+export class _ServiceManager {
+    services = {
+        TestService: {
+            serviceSelf: undefined,
+            status: "waitSetup"
+        }
+    };
+    constructor() {
+    }
+    async initServices(type, 
+    // services: {
+    //     [key: string]: {
+    //         service:ServiceConstructor<Service>
+    //         ots: any;
+    //     };
+    //     // LayoutService?: ServiceConstructor<LayoutPageService>;
+    // }
+    services) {
+        //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) => {
+                            console.log("createChildService called for ---", tag);
+                            const _pageService = this.setKey(tag, {
+                                serviceSelf: new NSPageService({
+                                    usedService: {},
+                                    tag: tag,
+                                    type: type,
+                                }),
+                                status: "waitSetup",
+                            });
+                            return _pageService;
+                        },
+                    },
+                    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, PageCtor) => {
+                            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;
+                        },
+                    },
+                    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 = [];
+        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 = {};
+            if (Array.isArray(service.serviceInfo.requiredServices)) {
+                for (const reqName of service.serviceInfo.requiredServices) {
+                    usedService[reqName] = () => { return this.getService(reqName); };
+                }
+            }
+            const serviceInstance = this.setKey(tag, {
+                serviceSelf: new service({
+                    usedService,
+                    tag: tag,
+                    type: type,
+                    abilities: {
+                        createChildService: (tag, PageCtor) => {
+                            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;
+                        },
+                    }
+                }),
+                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();
+    //     }
+    // }
+    getService(serviceName) {
+        if (this.services[serviceName]) {
+        }
+        else {
+            console.log(`ServiceManager: Service ${serviceName} not found.`);
+            console.log("Available services:", Object.keys(this.services));
+            return undefined;
+        }
+        return this.services[serviceName].serviceSelf;
+    }
+    setKey(key, value) {
+        this.services[key] = value;
+        return this.services[key].serviceSelf;
+    }
+    async quickService(serviceName, serviceConstructor, usedService, ots = {}) {
+        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)
+     */
+    getExtensionServices() {
+        const result = {};
+        for (const [key, entry] of Object.entries(this.services)) {
+            if (entry.serviceSelf &&
+                entry.serviceSelf instanceof ExtensionService) {
+                result[key] = entry.serviceSelf;
+            }
+        }
+        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/dist/TestRun.d.ts

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

package/dist/TestRun.js

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

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+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";
+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";

package/dist/index.js

@@ -0,0 +1,22 @@
+// 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/dist/services/abstract/apiService/ApiService.d.ts

@@ -0,0 +1,17 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+export declare abstract class ApiService extends Service {
+    ots: any;
+    apis: {
+        [key: string]: {
+            handler: (...args: any[]) => Promise<any>;
+            options?: {
+                auth?: boolean;
+                role?: string;
+            };
+        };
+    };
+    protected onStart(): Promise<ServiceResponse>;
+    constructor(ots: any);
+    resposeHandler(response: any): Response;
+}

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

@@ -0,0 +1,33 @@
+import { Service } from "../../../types/Service.js";
+export class ApiService extends Service {
+    ots;
+    apis = {};
+    onStart() {
+        const requestHandlerService = this.ots.usedService.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(ots) {
+        super(ots);
+        this.ots = ots;
+        this.apis = {};
+    }
+    resposeHandler(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'
+            }
+        });
+    }
+}

package/dist/services/abstract/authServices/AuthService.d.ts

@@ -0,0 +1,75 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { RegisterServiceInfo } from "../../../types/ServiceRegisterInfo.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+import { RequestHandlerService } from "../../main/httpServices/RequestHandlerService.js";
+export type AuthOts = ServiceOts & {
+    usedService: {
+        RequestHandlerService: () => RequestHandlerService;
+    };
+};
+export declare abstract class AuthService extends Service {
+    ots: AuthOts;
+    static serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    };
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    constructor(ots: AuthOts);
+    protected abstract saveToken(token: string): Promise<void>;
+    protected abstract clearToken(): Promise<void>;
+    protected abstract getUserInfo({ userId, userName, userRole }: {
+        userId?: string;
+        userName?: string;
+        userRole?: string;
+    }): Promise<{
+        success: boolean;
+        message?: string;
+        user?: {
+            id: number;
+            username: string;
+            password: string;
+            role?: string;
+            databaseId?: string;
+        };
+    }>;
+    loginRequest({ username, password, params, request, url }: {
+        username: any;
+        password: any;
+        params: any;
+        request: any;
+        url: any;
+    }): Promise<any>;
+    checkToken({ accessToken, refreshToken, options }: {
+        accessToken: string;
+        refreshToken: string;
+        options?: {
+            role?: string;
+        };
+    }): Promise<{
+        valid: boolean;
+        newAccessToken?: string;
+        newRefreshToken?: string;
+        user?: any;
+    }>;
+    deneme({ params, request, url }: {
+        params: any;
+        request: any;
+        url: any;
+    }): Promise<any>;
+    getUserInfo_REQUEST({ params, request, url, user }: {
+        params: any;
+        request: any;
+        url: any;
+        user: any;
+    }): Promise<any>;
+    resposeHandler(response: any): Response;
+    getCookie(cookieHeader: string | null, name: string): string | undefined;
+    logout(): Promise<void>;
+    register(username: string, password: string): Promise<boolean>;
+}
+export declare const registerServiceInfo: RegisterServiceInfo;