@urga-panel/ur-panels-core 1.0.0

package/dist/services/main/httpServices/RequestHandlerService.js

@@ -0,0 +1,165 @@
+import { Service } from "../../../types/Service.js";
+import { RegisterServiceInfo } from "../../../types/ServiceRegisterInfo.js";
+export class RequestHandlerService extends Service {
+    ots;
+    static serviceInfo = {
+        name: "RequestHandlerService",
+        requiredServices: ["AuthService"],
+    };
+    handlers = {};
+    async onSetup(options) {
+        return { status: "success", message: "TestService setup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "TestService started" };
+    }
+    async onStop() {
+        return { status: "success", message: "TestService stopped" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "TestService destroyed" };
+    }
+    constructor(ots) {
+        super(ots);
+        this.ots = ots;
+    }
+    async addHandler(name, callback, options) {
+        this.handlers[name] = { callback, options };
+        this.log.OK("RequestHandlerService addHandler", name);
+    }
+    async requestCome({ params, request, url }) {
+        this.log.OK("RequestHandlerService requestCome", params);
+        let bodyData = 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 = {};
+                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 = 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;
+            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, name) {
+        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) {
+        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/dist/services/main/remoteApiControllerService/RemoteApiControllerService.d.ts

@@ -0,0 +1,36 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+export type apiConfig = {
+    tag: string;
+    api: string;
+    baseUrl: string;
+    auth: {
+        sellerId?: string;
+        username?: string;
+        password?: string;
+        type?: string;
+    };
+    serviceRef?: any;
+    service?: any;
+};
+export type RemoteApiControllerServiceOts = ServiceOts & {
+    usedService: {};
+};
+export declare class RemoteApiControllerService extends Service {
+    ots: RemoteApiControllerServiceOts;
+    static serviceInfo: {
+        name: string;
+        requiredServices: any[];
+    };
+    apis: {
+        [key: string]: apiConfig;
+    };
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    constructor(ots: RemoteApiControllerServiceOts);
+    addApi(apiName: string, serviceRef: any, apiConfig: apiConfig): void;
+}

package/dist/services/main/remoteApiControllerService/RemoteApiControllerService.js

@@ -0,0 +1,42 @@
+import { Service } from "../../../types/Service.js";
+export class RemoteApiControllerService extends Service {
+    ots;
+    static serviceInfo = {
+        name: "RemoteApiControllerService",
+        requiredServices: [],
+    };
+    apis = {};
+    async onSetup(options) {
+        return { status: "success", message: "onSetup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "onStart complete" };
+    }
+    async onStop() {
+        return { status: "success", message: "onStop complete" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "onDestroy complete" };
+    }
+    constructor(ots) {
+        super({ ...ots });
+        this.ots = ots;
+    }
+    addApi(apiName, serviceRef, apiConfig) {
+        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/dist/services/main/testServices/TestService.d.ts

@@ -0,0 +1,19 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+export type TestOts = ServiceOts & {
+    usedService: {};
+};
+export declare class TestService extends Service {
+    serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    };
+    constructor(ots: TestOts);
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    denemeYazi(): string;
+}

package/dist/services/main/testServices/TestService.js

@@ -0,0 +1,22 @@
+import { Service } from "../../../types/Service.js";
+export class TestService extends Service {
+    serviceInfo;
+    constructor(ots) {
+        super({ ...ots });
+    }
+    async onSetup(options) {
+        return { status: "success", message: "TestService setup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "TestService started" };
+    }
+    async onStop() {
+        return { status: "success", message: "TestService stopped" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "TestService destroyed" };
+    }
+    denemeYazi() {
+        return "deneme";
+    }
+}

package/dist/services/main/testServices/TestService2.d.ts

@@ -0,0 +1,18 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+export type Test2Ots = ServiceOts & {
+    usedService: {};
+};
+export declare class Test2Service extends Service {
+    serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    };
+    constructor(ots: Test2Ots);
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+}

package/dist/services/main/testServices/TestService2.js

@@ -0,0 +1,20 @@
+import { Service } from "../../../types/Service.js";
+export class Test2Service extends Service {
+    serviceInfo;
+    constructor(ots) {
+        super({ ...ots });
+        console.log("Test2Service initialized");
+    }
+    async onSetup(options) {
+        return { status: "success", message: "Test2Service setup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "Test2Service started" };
+    }
+    async onStop() {
+        return { status: "success", message: "Test2Service stopped" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "Test2Service destroyed" };
+    }
+}

package/dist/types/RegisterServiceInfo.d.ts

@@ -0,0 +1,13 @@
+import { Service } from "./Service.js";
+export interface ServiceConstructor<T extends Service> {
+    [x: string]: any;
+    new (ots: any): T;
+}
+export type RegisterServiceInfo = {
+    serviceName: string;
+    service: ServiceConstructor<Service>;
+    tag: string;
+    dynamicTag: boolean;
+    requiredServices?: string[];
+    isAbstract?: boolean;
+};

package/dist/types/RegisterServiceInfo.js

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

package/dist/types/Service.d.ts

@@ -0,0 +1,32 @@
+import { ServiceOts } from "./ServiceOts.js";
+import { ServiceResponse } from "./ServiceResponse.js";
+import { ServiceSetupOptions } from "./ServiceSetupOptions.js";
+export declare abstract class Service {
+    private opts;
+    static serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    };
+    tag: string;
+    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>;
+    setup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    start(): Promise<ServiceResponse>;
+    stop(): Promise<ServiceResponse>;
+    destroy(): Promise<ServiceResponse>;
+    constructor(opts: ServiceOts);
+    logSetup(): {
+        OK: any;
+        ERROR: any;
+        WARN: any;
+        l: any;
+    };
+}

package/dist/types/Service.js

@@ -0,0 +1,43 @@
+export class Service {
+    opts;
+    static serviceInfo;
+    tag = "";
+    log;
+    async setup(options) {
+        this.log.OK("setup called");
+        return this.onSetup(options);
+    }
+    async start() {
+        this.log.OK("start called");
+        return this.onStart();
+    }
+    async stop() {
+        this.log.OK("stop called");
+        return this.onStop();
+    }
+    async destroy() {
+        this.log.OK("destroy called");
+        return this.onDestroy();
+    }
+    constructor(opts) {
+        this.opts = opts;
+        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"].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/dist/types/ServiceConstructor.d.ts

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

package/dist/types/ServiceConstructor.js

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

package/dist/types/ServiceEntry.d.ts

@@ -0,0 +1,6 @@
+import { Service } from "./Service.js";
+import { ServiceStatus } from "./ServiceStatus.js";
+export type ServiceEntry<T extends Service> = {
+    serviceSelf: T | null;
+    status: ServiceStatus;
+};

package/dist/types/ServiceEntry.js

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

package/dist/types/ServiceOts.d.ts

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

package/dist/types/ServiceOts.js

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

package/dist/types/ServiceRegisterInfo.d.ts

@@ -0,0 +1,29 @@
+import { Service } from "./Service.js";
+import { ServiceConstructor } from "./ServiceConstructor.js";
+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 declare class RegisterServiceInfo {
+    serviceName: string;
+    service: ServiceConstructor<Service>;
+    abstractService: typeof Service;
+    tag: string;
+    dynamicTag: boolean;
+    requiredServices?: string[];
+    isAbstract: boolean;
+    constructor(params: abstractService | normalService);
+}
+export {};

package/dist/types/ServiceRegisterInfo.js

@@ -0,0 +1,25 @@
+export class RegisterServiceInfo {
+    serviceName;
+    service;
+    abstractService;
+    tag; // Static tag for the service
+    dynamicTag; // Dynamic tag for the service
+    requiredServices; // List of required services
+    isAbstract; // Whether the service is abstract
+    constructor(params) {
+        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/dist/types/ServiceResponse.d.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;
+};

package/dist/types/ServiceResponse.js

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

package/dist/types/ServiceSetupOptions.d.ts

@@ -0,0 +1,3 @@
+export type ServiceSetupOptions = {
+    [key: string]: unknown;
+};

package/dist/types/ServiceSetupOptions.js

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

package/dist/types/ServiceStatus.d.ts

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

package/dist/types/ServiceStatus.js

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

package/dist/types/_ServiceError.d.ts

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

package/dist/types/_ServiceError.js

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

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/test/**/*.test.ts']
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@urga-panel/ur-panels-core",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc && tsc-esm-fix dist",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "start": "npx cross-env MODE=DEBUG ts-node src/TestRun.ts",
+    "addServiceStatic": "npx ts-node src/addService/AddServiceStatic.ts"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "ts-node": "^10.9.2",
+    "tsc-esm-fix": "^3.1.2",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@types/jsonwebtoken": "^9.0.10",
+    "bcryptjs": "^3.0.2",
+    "js-yaml": "^4.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "yargs": "^18.0.0"
+  },
+  "bin": {
+    "urga-core-cli": "dist/addService/AddServiceStatic.js"
+  }
+}