@urga-panel/ur-panels-core 1.0.0

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

@@ -0,0 +1,207 @@
+import { Service } from "../../../types/Service";
+import { RegisterServiceInfo } from "../../../types/ServiceRegisterInfo";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+
+
+
+export type HandlerList = {
+    [key: string]: {
+        callback({ params, request, url, user }: { params: any; request: any; url: any; user?: any }): Promise<any>;
+        options?: {
+            auth?: boolean;
+            role?: string;
+        }
+    }
+}
+
+
+export class RequestHandlerService extends Service {
+
+    static serviceInfo = {
+        name: "RequestHandlerService",
+        requiredServices: ["AuthService"],
+    }
+    handlers: HandlerList = {};
+
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        return { status: "success", message: "TestService setup complete" };
+    }
+
+    protected async onStart(): Promise<ServiceResponse> {
+        return { status: "success", message: "TestService started" };
+    }
+
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "TestService stopped" };
+    }
+
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "TestService destroyed" };
+    }
+
+    constructor(public ots: any) {
+        super(ots);
+    }
+    async addHandler(name: string, callback: ({ params, request, url, user }
+
+    ) => Promise<any>, options?: {
+        auth?: boolean;
+        role?: string;
+    }) {
+        this.handlers[name] = { callback, options };
+        this.log.OK("RequestHandlerService addHandler", name);
+    }
+
+    async requestCome({ params, request, url }): Promise<any> {
+        this.log.OK("RequestHandlerService requestCome", params);
+
+         let bodyData: any = null;
+         const contentType = request.headers.get('content-type');
+
+        try {
+            if (contentType?.includes('application/json')) {
+                bodyData = await request.json();
+            } else if (contentType?.includes('form')) {
+                const formData = await request.formData();
+                const data: Record<string, any> = {};
+                for (const [key, value] of formData.entries()) {
+                data[key] = value;
+                }
+                bodyData = data;
+            }
+        } catch (e) {
+            // JSON değilse veya body yoksa hata alınabilir, burada kontrol edebilirsiniz
+            bodyData = null;
+        }
+        const handlerName = params.path; // Assuming path is the handler name
+        const handler = this.handlers[handlerName];
+        if (!handler) {
+            this.log.ERROR("Handler not found:", handlerName);
+            //throw new Error(`Handler not found: ${handlerName}`);
+            return { status: "error", message: "An error occurred" };
+        }
+        const event = { params, request, url };
+        this.log.OK("RequestHandlerService requestCome event");
+        try {
+            let header = {};
+            let user: any = null;
+            if (handler.options?.auth) {
+
+                const authService = this.ots.usedService.AuthService();
+                if (!authService) {
+                    this.log.ERROR("AuthService not found");
+                    return this.resposeHandler({ status: "error", message: "Authentication service not available" });
+                }
+                
+                const cookieHeader = request.headers.get('cookie');
+                const accessToken = this.getCookie(cookieHeader, 'accessToken');
+                const refreshToken = this.getCookie(cookieHeader, 'refreshToken');
+                // Check authentication and role
+                const isAuthenticated = await authService.checkToken({
+                    accessToken,
+                    refreshToken,
+                    options: {
+                        role: handler.options?.role
+                    }
+                },);
+
+                console.log("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");
+                    header = {
+                        "Set-Cookie":
+                            `accessToken=${isAuthenticated.newAccessToken}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=900, refreshToken=${isAuthenticated.newRefreshToken}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=604800`,
+                    }
+                    // const response = new Response(JSON.stringify({ status: "success", message: "Authenticated with new token" }), {
+                    //     status: 200,
+                    //      headers: {
+
+                    //         'Content-Type': 'application/json'
+                    //     }
+                    // });
+                    // return response;
+                }
+                //return this.resposeHandler({ status: "success", message: "Authenticated with old token" });
+
+
+            }
+            
+            let response: Response;
+            if (bodyData !== null) {
+                response = await handler.callback({ ...bodyData, ...event, user });
+            } else {
+                response = await handler.callback({ ...event, user });
+            }
+
+            console.log("RequestHandlerService requestCome response");
+            console.log("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
+                const originalBody = await response.text();
+                response = new Response(originalBody, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: {
+                        ...Object.fromEntries(response.headers.entries()),
+                        ...header,
+                    }
+                });
+            }
+            this.log.OK("RequestHandlerService requestCome response", response);
+            
+            return response;
+        } catch (error) {
+            return { status: "error", message: error.message || "An error occurred" };
+        }
+
+
+    }
+    getCookie(cookieHeader: string | null, name: string): string | undefined {
+        if (!cookieHeader) return undefined;
+        const cookies = cookieHeader.split(';').map(c => c.trim());
+        for (const cookie of cookies) {
+            const [key, ...val] = cookie.split('=');
+            if (key === name) return val.join('=');
+        }
+        return undefined;
+    }
+
+    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'
+            }
+        });
+    }
+
+
+}
+
+const registerServiceInfo = new RegisterServiceInfo(
+    {
+        serviceName: "RequestHandlerService",
+        service: RequestHandlerService,
+        tag: "RequestHandlerService",
+        dynamicTag: false,
+        requiredServices: [],
+        isAbstract: false,
+    }
+);

package/src/services/main/remoteApiControllerService/RemoteApiControllerService.ts

@@ -0,0 +1,70 @@
+import { Service } from "../../../types/Service";
+import { ServiceOts } from "../../../types/ServiceOts";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+
+export type apiConfig = {
+    tag: string;
+    api: string;
+    baseUrl: string;
+    auth: {
+        sellerId?: string;
+        username?: string;
+        password?: string;
+        type?: string;
+    }
+    serviceRef?: any; 
+    service?: any; // This will be the actual service instance created
+}
+
+export type RemoteApiControllerServiceOts = ServiceOts & {
+    usedService: {
+    }
+}
+
+export class RemoteApiControllerService extends Service {
+    static serviceInfo = {
+        name: "RemoteApiControllerService",
+        requiredServices: [],
+    }
+    apis: { [key: string]: apiConfig } = {};
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        
+        return { status: "success", message: "onSetup complete" };
+    }
+    protected async onStart(): Promise<ServiceResponse> {
+        return { status: "success", message: "onStart complete" };
+    }
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "onStop complete" };
+    }
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "onDestroy complete" };
+    }
+    constructor(public ots: RemoteApiControllerServiceOts) {
+        super({ ...ots });
+    }
+    addApi(apiName: string, serviceRef: any, apiConfig: apiConfig): void {
+        if (this.apis[apiName]) {
+            console.warn(`API ${apiName} already exists. Overwriting.`);
+        }
+        this.apis[apiName] = apiConfig;
+        this.apis[apiName].serviceRef = serviceRef;
+        console.log(`API ${apiName} added with config:`, apiConfig);
+
+        // Create a service for each API
+        Object.keys(this.apis).forEach(async apiName => {
+            const service = this.ots.abilities.createChildService?.(apiName,
+                this.apis[apiName].serviceRef
+            );
+            if (service) {
+                this.apis[apiName].service = service;
+            }
+            await service.setup();
+            await service.start();
+        });
+    }
+
+}
+
+

package/src/services/main/testServices/TestService.ts

@@ -0,0 +1,36 @@
+import { Service } from "../../../types/Service";
+import { ServiceOts } from "../../../types/ServiceOts";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+
+export type TestOts = ServiceOts & {
+    usedService: {
+    }
+}
+
+export class TestService extends Service {
+    serviceInfo: { name: string; requiredServices: string[]; };
+    constructor(ots:TestOts) {
+        super({...ots});
+    }
+
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        return { status: "success", message: "TestService setup complete" };
+    }
+
+    protected async onStart(): Promise<ServiceResponse> {
+        return { status: "success", message: "TestService started" };
+    }
+
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "TestService stopped" };
+    }
+
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "TestService destroyed" };
+    }
+
+    denemeYazi() {
+        return "deneme";
+    }
+}

package/src/services/main/testServices/TestService2.ts

@@ -0,0 +1,34 @@
+import { Service } from "../../../types/Service";
+import { ServiceOts } from "../../../types/ServiceOts";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+
+
+export type Test2Ots = ServiceOts & {
+    usedService: {
+    }
+}
+
+export class Test2Service extends Service {
+    serviceInfo: { name: string; requiredServices: string[]; };
+    constructor(ots:Test2Ots) {
+        super({...ots});
+        console.log("Test2Service initialized");
+    }
+
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        return { status: "success", message: "Test2Service setup complete" };
+    }
+
+    protected async onStart(): Promise<ServiceResponse> {
+        return { status: "success", message: "Test2Service started" };
+    }
+
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "Test2Service stopped" };
+    }
+
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "Test2Service destroyed" };
+    }
+}

package/src/types/RegisterServiceInfo.ts

@@ -0,0 +1,19 @@
+import { Service } from "./Service";
+
+export interface ServiceConstructor<T extends Service> {
+    [x: string]: any;
+    new(ots: any): T;
+}
+export type RegisterServiceInfo = {
+    serviceName: string;
+    service: ServiceConstructor<Service>;
+    tag: string; // Static tag for the service
+    dynamicTag: boolean; // Dynamic tag for the service
+    // serviceCtor: any; // Service constructor
+    // serviceOts: any; // Service options
+    requiredServices?: string[]; // List of required services
+    // description?: string; // Service description
+    // version?: string; // Service version        
+    // type?: string; // Service type
+    isAbstract?: boolean; // Whether the service is abstract
+}

package/src/types/Service.ts

@@ -0,0 +1,61 @@
+import { ServiceOts } from "./ServiceOts";
+import { ServiceResponse } from "./ServiceResponse";
+import { ServiceSetupOptions } from "./ServiceSetupOptions";
+
+export abstract class Service {
+
+    static serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    }
+    public tag: string = "";
+    public log: {
+        OK: Function,
+        ERROR: Function,
+        l: Function,
+        WARN: Function
+    }
+
+    protected abstract onSetup(options?: ServiceSetupOptions):Promise<ServiceResponse>;
+    protected abstract onStart(): Promise<ServiceResponse>;
+    protected abstract onStop(): Promise<ServiceResponse>;
+    protected abstract onDestroy(): Promise<ServiceResponse>;
+
+    public async setup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        this.log.OK("setup called");
+        return this.onSetup(options);
+    }
+    public async start(): Promise<ServiceResponse> {
+        this.log.OK("start called");
+        return this.onStart();
+    }
+    public async stop(): Promise<ServiceResponse> {
+        this.log.OK("stop called");
+        return this.onStop();
+    }
+    public async destroy(): Promise<ServiceResponse> {
+        this.log.OK("destroy called");
+        return this.onDestroy();
+    }
+
+    constructor(private opts: ServiceOts) {
+        this.tag = opts.tag;
+        if (!opts.usedService["LogService"]) {
+            console.error("LogService not found for", opts.tag);
+            this.log = this.logSetup();
+            return;
+        }
+        else {
+            //console.log("LogService found for", opts.usedService["LogService"]);
+            this.log = (opts.usedService["LogService"] as unknown as any).logSetupForService(this.tag);
+        }
+    }
+    logSetup() {
+        return {
+            OK: console.log.bind(console, `[${this.tag}]` + "-[OK]"),
+            ERROR: console.error.bind(console, `[${this.tag}]` + "-[ERROR]"),
+            WARN: console.warn.bind(console, `[${this.tag}]` + "-[WARN]"),
+            l: console.log.bind(console, `[${this.tag}]`),
+        }
+    }
+}

package/src/types/ServiceConstructor.ts

@@ -0,0 +1,6 @@
+import { Service } from "./Service";
+import { ServiceOts } from "./ServiceOts";
+
+export interface ServiceConstructor<T extends Service> {
+    new(ots: ServiceOts): T;
+}

package/src/types/ServiceEntry.ts

@@ -0,0 +1,10 @@
+import { Service } from "./Service";
+import { ServiceConstructor } from "./ServiceConstructor";
+import { ServiceStatus } from "./ServiceStatus";
+
+export type ServiceEntry<T extends Service> = {
+    // serviceType: ServiceConstructor<T>;
+    serviceSelf: T | null;
+    status: ServiceStatus;
+    // create: (ots?: object) => void;
+};

package/src/types/ServiceOts.ts

@@ -0,0 +1,17 @@
+import { Service } from "./Service"
+import { ServiceConstructor } from "./ServiceConstructor"
+
+export type ServiceOts = {
+    usedService: {
+        [key: string]: () => Service
+    },
+    tag:string,
+    abilities?: {
+        createChildService?: (tag:string, PageCtor: ServiceConstructor<Service>)=> Service,
+    }
+    type: string
+    // funcs: {
+    //     stop: () => void,
+    //     destroy: () => void
+    // }
+}

package/src/types/ServiceRegisterInfo.ts

@@ -0,0 +1,48 @@
+import { Service } from "./Service";
+import { ServiceConstructor } from "./ServiceConstructor";
+
+type abstractService =  {
+    serviceName: string;
+    abstractService: typeof Service;
+    tag: string;
+    dynamicTag: boolean;
+    requiredServices?: string[];
+    isAbstract: true;
+}
+
+type normalService = {
+    serviceName: string;
+    service: ServiceConstructor<Service>;
+    tag: string;
+    dynamicTag: boolean;
+    requiredServices?: string[];
+    isAbstract: false;
+}
+
+export class RegisterServiceInfo {
+    serviceName: string;
+    service: ServiceConstructor<Service>;
+    abstractService: typeof Service;
+    tag: string; // Static tag for the service
+    dynamicTag: boolean; // Dynamic tag for the service
+    requiredServices?: string[]; // List of required services
+    isAbstract: boolean; // Whether the service is abstract
+
+    constructor(params: abstractService | normalService) {
+        this.serviceName = params.serviceName;
+        if ('abstractService' in params) {
+            this.abstractService = params.abstractService;
+        }
+        if ('service' in params) {
+            if (typeof params.service !== 'function') {
+                throw new Error("Service must be a constructor function");
+            }
+            this.service = params.service;
+        }
+        
+        this.tag = params.tag;
+        this.dynamicTag = params.dynamicTag;
+        this.requiredServices = params.requiredServices || [];
+        this.isAbstract = params.isAbstract || false;
+    }
+}

package/src/types/ServiceResponse.ts

@@ -0,0 +1,13 @@
+export type ServiceResponse<T = unknown> = {
+    status: "success" | "error";
+    data?: T;
+    error?: {
+        code: number;
+        message: string;
+        details?: string;
+    };
+    message?: string;
+    timestamp?: string;
+    requestId?: string;
+    [key: string]: unknown; // Allow additional properties      
+}

package/src/types/ServiceSetupOptions.ts

@@ -0,0 +1,5 @@
+export type ServiceSetupOptions = {
+    
+    //other options
+    [key:string]:unknown;
+}

package/src/types/ServiceStatus.ts

@@ -0,0 +1,2 @@
+export type ServiceStatus =
+    "waitSetup" | "running" | "error" | "waitStart" | "stop";

package/src/types/_ServiceError.ts

@@ -0,0 +1,5 @@
+export type ServiceError  = {
+    code:number,
+    error:Error,
+    message:string
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "strict": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "noEmitOnError": false, 
+    "forceConsistentCasingInFileNames": false,
+    "outDir": "./dist",
+    "resolveJsonModule": true,
+    "declaration": true,
+    "emitDeclarationOnly": false,     // hem .js hem .d.ts çıkar
+    
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "test"],
+  
+}