gg-tools-kit 1.0.0

package/dist/GGToolsKit.d.ts

@@ -0,0 +1,8 @@
+import Init from "./containers/InitContainers";
+import Protections from "./containers/ProtectionsContainer";
+import Utils from "./containers/UtilsContainer";
+export default class GGToolsKit {
+    static Init: typeof Init;
+    static Protections: typeof Protections;
+    static Utils: typeof Utils;
+}

package/dist/GGToolsKit.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InitContainers_1 = __importDefault(require("./containers/InitContainers"));
+const ProtectionsContainer_1 = __importDefault(require("./containers/ProtectionsContainer"));
+const UtilsContainer_1 = __importDefault(require("./containers/UtilsContainer"));
+class GGToolsKit {
+}
+// Initialization Container
+GGToolsKit.Init = InitContainers_1.default;
+// Protections Container
+GGToolsKit.Protections = ProtectionsContainer_1.default;
+// Utils Container
+GGToolsKit.Utils = UtilsContainer_1.default;
+exports.default = GGToolsKit;

package/dist/containers/InitContainers.d.ts

@@ -0,0 +1,7 @@
+export default class Init {
+    static initBackendProject(TypeScript?: boolean, projectPath?: string): void;
+    static installPackages(TypeScript?: boolean, projectPath?: string): void;
+    static createFullProject(TypeScript?: boolean, projectPath?: string): void;
+    static installAudioLibrary(): void;
+    static installVideoLibrary(): void;
+}

package/dist/containers/InitContainers.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InitProj_1 = __importDefault(require("../projFilesControl/InitProj"));
+const InstallSecondaryLibraries_1 = __importDefault(require("../projFilesControl/InstallSecondaryLibraries"));
+class Init {
+    // Project Initialization
+    static initBackendProject(TypeScript = false, projectPath = process.cwd()) {
+        return InitProj_1.default.initBackendProject(TypeScript, projectPath);
+    }
+    static installPackages(TypeScript = false, projectPath = process.cwd()) {
+        return InitProj_1.default.installPackages(TypeScript, projectPath);
+    }
+    static createFullProject(TypeScript = false, projectPath = process.cwd()) {
+        return InitProj_1.default.createFullProject(TypeScript, projectPath);
+    }
+    // Secondary Libraries Control
+    static installAudioLibrary() {
+        return InstallSecondaryLibraries_1.default.installAudioLibrary();
+    }
+    static installVideoLibrary() {
+        return InstallSecondaryLibraries_1.default.installVideoLibrary();
+    }
+}
+exports.default = Init;

package/dist/containers/ProtectionsContainer.d.ts

@@ -0,0 +1,21 @@
+import Compression from "../protections/Compression";
+import HelmetProtection from "../protections/HelmetProtection";
+import Logger from "../protections/Logger";
+import XSSProtection from "../protections/XSSProtection";
+export default class Protections {
+    compression: Compression;
+    helmet: HelmetProtection;
+    logger: Logger;
+    xss: XSSProtection;
+    constructor();
+    getAllMiddlewares(): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>[];
+    configure(config: {
+        compression?: any;
+        helmet?: any;
+        logger?: {
+            format?: string;
+            filePath?: string;
+        };
+        xss?: any;
+    }): void;
+}

package/dist/containers/ProtectionsContainer.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Compression_1 = __importDefault(require("../protections/Compression"));
+const HelmetProtection_1 = __importDefault(require("../protections/HelmetProtection"));
+const Logger_1 = __importDefault(require("../protections/Logger"));
+const XSSProtection_1 = __importDefault(require("../protections/XSSProtection"));
+class Protections {
+    constructor() {
+        // Initialize all protection classes
+        this.compression = new Compression_1.default();
+        this.helmet = new HelmetProtection_1.default();
+        this.logger = new Logger_1.default("dev"); // default logger format
+        this.xss = new XSSProtection_1.default();
+    }
+    // Method to get all middlewares
+    getAllMiddlewares() {
+        return [
+            this.compression.init(),
+            this.helmet.getMiddleware(),
+            this.logger.getMiddleware(),
+            (req, res, next) => this.xss.cleanBody(req, res, next), // prevent losing "this"
+        ];
+    }
+    // Method to apply custom configuration
+    configure(config) {
+        // Compression
+        if (config.compression) {
+            this.compression.setOptions(config.compression);
+        }
+        // Helmet
+        if (config.helmet) {
+            this.helmet.setOptions(config.helmet);
+        }
+        // Logger
+        if (config.logger) {
+            const { format, filePath } = config.logger;
+            if (filePath) {
+                this.logger.setLogFile(filePath);
+            }
+            if (format) {
+                this.logger.setFormat(format);
+            }
+        }
+        // XSS
+        if (config.xss) {
+            this.xss.setOptions(config.xss);
+        }
+    }
+}
+exports.default = Protections;

package/dist/containers/UtilsContainer.d.ts

@@ -0,0 +1,32 @@
+import RequestData from "../utils/RequestData";
+import { Request } from "express";
+export default class Utils {
+    private static audio;
+    private static video;
+    private static file;
+    private static date;
+    static getAudioDuration(filePath: string): Promise<string>;
+    static getVideoDuration(filePath: string): Promise<string>;
+    static getFileSize(filePath: string, unit?: "B" | "b" | "KB" | "kb" | "MB" | "mb" | "GB" | "gb"): string;
+    static getFileExtension(filePath: string): string;
+    static isImageFile(filePath: string): boolean;
+    static isVideoFile(filePath: string): boolean;
+    static isAudioFile(filePath: string): boolean;
+    static isDocumentFile(filePath: string): boolean;
+    static isArchiveFile(filePath: string): boolean;
+    static today(separator?: string): string;
+    static nowTime(separator?: string): string;
+    static getRequestIp(req: Request): string;
+    static getRequestMethod(req: Request): string;
+    static getRequestApi(req: Request): string;
+    static getRequestUserAgent(req: Request): string;
+    static getReqInfos(req: Request): ReturnType<typeof RequestData.getReqInfos>;
+    static shuffleArray<T>(array: T[]): T[];
+    static removeDuplicatesFromArray<T>(array: T[]): T[];
+    static getRandomElement<T>(array: T[]): T | undefined;
+    static flattenArray<T>(array: T[][]): T[];
+    static maxFromArray(array: number[]): number | undefined;
+    static minFromArray(array: number[]): number | undefined;
+    static sumArray(array: number[]): number;
+    static averageArray(array: number[]): number | undefined;
+}

package/dist/containers/UtilsContainer.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Audio_1 = __importDefault(require("../utils/Audio"));
+const Vidoe_1 = __importDefault(require("../utils/Vidoe"));
+const Files_1 = __importDefault(require("../utils/Files"));
+const Date_1 = __importDefault(require("../utils/Date"));
+const RequestData_1 = __importDefault(require("../utils/RequestData"));
+const Array_1 = __importDefault(require("../utils/Array"));
+class Utils {
+    // Audio Utils
+    static getAudioDuration(filePath) {
+        return this.audio.getAudioDuration(filePath);
+    }
+    // Video Utils
+    static getVideoDuration(filePath) {
+        return this.video.getVideoDuration(filePath);
+    }
+    // File Utils
+    static getFileSize(filePath, unit = "KB") {
+        return this.file.getFileSize(filePath, unit);
+    }
+    static getFileExtension(filePath) {
+        return this.file.getFileExtension(filePath);
+    }
+    static isImageFile(filePath) {
+        return this.file.isImageFile(filePath);
+    }
+    static isVideoFile(filePath) {
+        return this.file.isVideoFile(filePath);
+    }
+    static isAudioFile(filePath) {
+        return this.file.isAudioFile(filePath);
+    }
+    static isDocumentFile(filePath) {
+        return this.file.isDocumentFile(filePath);
+    }
+    static isArchiveFile(filePath) {
+        return this.file.isArchiveFile(filePath);
+    }
+    // Date Utils
+    static today(separator = "/") {
+        return this.date.today(separator);
+    }
+    static nowTime(separator = ":") {
+        return this.date.nowTime(separator);
+    }
+    // RequestData Utils
+    static getRequestIp(req) {
+        return RequestData_1.default.getRequestIp(req);
+    }
+    static getRequestMethod(req) {
+        return RequestData_1.default.getRequestMethod(req);
+    }
+    static getRequestApi(req) {
+        return RequestData_1.default.getRequestApi(req);
+    }
+    static getRequestUserAgent(req) {
+        return RequestData_1.default.getRequestUserAgent(req);
+    }
+    static getReqInfos(req) {
+        return RequestData_1.default.getReqInfos(req);
+    }
+    // Array Utils
+    static shuffleArray(array) {
+        return Array_1.default.shuffle(array);
+    }
+    static removeDuplicatesFromArray(array) {
+        return Array_1.default.removeDuplicates(array);
+    }
+    static getRandomElement(array) {
+        return Array_1.default.getRandomElement(array);
+    }
+    static flattenArray(array) {
+        return Array_1.default.flatten(array);
+    }
+    static maxFromArray(array) {
+        return Array_1.default.max(array);
+    }
+    static minFromArray(array) {
+        return Array_1.default.min(array);
+    }
+    static sumArray(array) {
+        return Array_1.default.sum(array);
+    }
+    static averageArray(array) {
+        return Array_1.default.average(array);
+    }
+}
+Utils.audio = Audio_1.default;
+Utils.video = Vidoe_1.default;
+Utils.file = Files_1.default;
+Utils.date = Date_1.default;
+exports.default = Utils;

package/dist/projFilesControl/InitProj.d.ts

@@ -0,0 +1,8 @@
+export default class InitProj {
+    static initBackendProject(TypeScript?: boolean, projectPath?: string): void;
+    private static createIndexFiles;
+    static installPackages(TypeScript?: boolean, projectPath?: string): void;
+    private static createTsConfig;
+    private static updatePackageJson;
+    static createFullProject(TypeScript?: boolean, projectPath?: string): void;
+}

package/dist/projFilesControl/InitProj.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+class InitProj {
+    // Initialize a backend project structure
+    static initBackendProject(TypeScript = false, projectPath = process.cwd()) {
+        const language = TypeScript
+            ? "typescript"
+            : "javascript";
+        try {
+            // Main src directory
+            const srcPath = path_1.default.join(projectPath, "src");
+            // Backend folders structure
+            const folders = [
+                "src",
+                "src/controllers",
+                "src/models",
+                "src/routes",
+                "src/middlewares",
+                "src/utils",
+            ];
+            // Create all folders
+            folders.forEach((folder) => {
+                const folderPath = path_1.default.join(projectPath, folder);
+                if (!fs_1.default.existsSync(folderPath)) {
+                    fs_1.default.mkdirSync(folderPath, { recursive: true });
+                    console.log(`✓ Created: ${folder}`);
+                }
+                else {
+                    console.log(`🩸 Already exists: ${folder}`);
+                }
+            });
+            // Create index files for each folder
+            this.createIndexFiles(projectPath, language);
+            console.log(`\n✅ Backend project (${language.toUpperCase()}) created successfully!`);
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize project: ${error.message}`);
+        }
+    }
+    // Create index files in main folders
+    static createIndexFiles(projectPath, language) {
+        const fileExtension = language === "typescript" ? "ts" : "js";
+        // TypeScript version
+        const tsContent = `import express from "express";
+
+const app = express();
+app.use(express.json());
+
+app.get("/", (req, res) => {
+    res.json({ message: "Hello from Express + TypeScript!" });
+});
+
+app.listen(3000, () => console.log("Server running on port 3000"));
+`;
+        // JavaScript version
+        const jsContent = `const express = require("express");
+
+const app = express();
+app.use(express.json());
+
+app.get("/", (req, res) => {
+    res.json({ message: "Hello from Express + JavaScript!" });
+});
+
+app.listen(3000, () => console.log("Server running on port 3000"));
+`;
+        const content = language === "typescript" ? tsContent : jsContent;
+        fs_1.default.writeFileSync(path_1.default.join(projectPath, "src", `index.${fileExtension}`), content);
+    }
+    // Install essential packages
+    static installPackages(TypeScript = false, projectPath = process.cwd()) {
+        try {
+            console.log("\n📦 Installing packages...\n");
+            // Core packages for both languages
+            const corePackages = [
+                "express",
+                "compression@1.7.4",
+                "helmet",
+                "morgan",
+                "xss",
+                "dotenv",
+                "cors",
+            ];
+            // TypeScript specific packages
+            const tsDevPackages = [
+                "@types/express",
+                "@types/compression",
+                "@types/morgan",
+                "@types/cors",
+                "@types/node",
+                "typescript",
+                "ts-node",
+                "ts-node-dev",
+            ];
+            // Install core packages
+            console.log("Installing core packages...");
+            (0, child_process_1.execSync)(`npm install ${corePackages.join(" ")}`, {
+                cwd: projectPath,
+                stdio: "inherit",
+            });
+            // Install TypeScript packages if needed
+            if (TypeScript) {
+                console.log("\nInstalling TypeScript packages...");
+                (0, child_process_1.execSync)(`npm install --save-dev ${tsDevPackages.join(" ")}`, {
+                    cwd: projectPath,
+                    stdio: "inherit",
+                });
+                // Create tsconfig.json
+                this.createTsConfig(projectPath);
+            }
+            // Update package.json
+            this.updatePackageJson(TypeScript, projectPath);
+            console.log("\n✅ All packages installed successfully!");
+        }
+        catch (error) {
+            throw new Error(`Failed to install packages: ${error.message}`);
+        }
+    }
+    // Create tsconfig.json for TypeScript projects
+    static createTsConfig(projectPath) {
+        const tsConfig = {
+            compilerOptions: {
+                target: "ES2020",
+                module: "commonjs",
+                lib: ["ES2020"],
+                outDir: "./dist",
+                rootDir: "./src",
+                strict: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                resolveJsonModule: true,
+                moduleResolution: "node",
+            },
+            include: ["src/**/*"],
+            exclude: ["node_modules", "dist"],
+        };
+        fs_1.default.writeFileSync(path_1.default.join(projectPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+        console.log("✓ Created tsconfig.json");
+    }
+    // Update package.json based on project type
+    static updatePackageJson(TypeScript, projectPath) {
+        const packageJsonPath = path_1.default.join(projectPath, "package.json");
+        if (!fs_1.default.existsSync(packageJsonPath)) {
+            console.log("⚠ package.json not found, skipping update");
+            return;
+        }
+        try {
+            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+            if (TypeScript) {
+                // TypeScript project - remove type field or set to commonjs
+                delete packageJson.type;
+                // Add TypeScript scripts
+                packageJson.scripts = {
+                    ...packageJson.scripts,
+                    dev: "ts-node-dev --respawn --transpile-only src/index.ts",
+                    build: "tsc",
+                    start: "node dist/index.js",
+                };
+            }
+            else {
+                // JavaScript project - set type to module (ES6)
+                packageJson.type = "module";
+                // Add JavaScript scripts
+                packageJson.scripts = {
+                    ...packageJson.scripts,
+                    dev: "node src/index.js",
+                    start: "node src/index.js",
+                };
+            }
+            fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+            console.log(`✓ Updated package.json (type: ${TypeScript ? "TypeScript (no type field)" : "module"})`);
+        }
+        catch (error) {
+            console.error("❌ Failed to update package.json:", error.message);
+        }
+    }
+    // Create complete project (structure + packages)
+    static createFullProject(TypeScript = false, projectPath = process.cwd()) {
+        console.log("🚀 Creating full backend project...\n");
+        // Create structure
+        this.initBackendProject(TypeScript, projectPath);
+        // Install packages
+        this.installPackages(TypeScript, projectPath);
+        console.log("\n🎉 Project setup completed!");
+    }
+}
+exports.default = InitProj;

package/dist/projFilesControl/InstallSecondaryLibraries.d.ts

@@ -0,0 +1,4 @@
+export default class ControlSecondaryLibraries {
+    static installAudioLibrary(): void;
+    static installVideoLibrary(): void;
+}

package/dist/projFilesControl/InstallSecondaryLibraries.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+class ControlSecondaryLibraries {
+    // Install audio library using npm
+    static installAudioLibrary() {
+        try {
+            (0, child_process_1.execSync)("npm install music-metadata", { stdio: "inherit" });
+            console.log("✓ Audio library installed successfully.");
+        }
+        catch (error) {
+            throw new Error(`Failed to install audio library: ${error.message}`);
+        }
+    }
+    // Install video library using npm
+    static installVideoLibrary() {
+        try {
+            (0, child_process_1.execSync)("npm install get-video-duration", { stdio: "inherit" });
+            console.log("✓ Video library installed successfully.");
+        }
+        catch (error) {
+            throw new Error(`Failed to install video library: ${error.message}`);
+        }
+    }
+}
+exports.default = ControlSecondaryLibraries;

package/dist/protections/Compression.d.ts

@@ -0,0 +1,14 @@
+interface InputCompressionOptions {
+    threshold?: number;
+    level?: number;
+    memLevel?: number;
+    chunkSize?: number;
+    [key: string]: any;
+}
+export default class Compression {
+    private options;
+    constructor(options?: InputCompressionOptions);
+    init(): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    setOptions(options: InputCompressionOptions): void;
+}
+export {};

package/dist/protections/Compression.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const compression_1 = __importDefault(require("compression"));
+class Compression {
+    constructor(options = {}) {
+        // Extract zlib-specific options
+        const { level, memLevel, chunkSize, ...restOptions } = options;
+        // Default compression options and user overrides
+        this.options = {
+            // Minimum response size in bytes to compress
+            threshold: 1024, // 1KB
+            zlib: {
+                // Compression level (0-9)
+                level: level ?? 6, // Default is 6
+                // Memory level (1-9)
+                memLevel: memLevel ?? 8, // Default is 8
+                // Size of the buffer for compression
+                chunkSize: chunkSize ?? 16384, // 16KB
+            },
+            // If user provides options, they will override defaults
+            ...restOptions,
+        };
+    }
+    // Middleware to apply compression
+    init() {
+        return (0, compression_1.default)(this.options);
+    }
+    // Method to update compression options
+    setOptions(options) {
+        // Extract zlib-specific options
+        const { level, memLevel, chunkSize, ...restOptions } = options;
+        // Build updated zlib options
+        const zlibOptions = { ...this.options.zlib };
+        if (level !== undefined)
+            zlibOptions.level = level;
+        if (memLevel !== undefined)
+            zlibOptions.memLevel = memLevel;
+        if (chunkSize !== undefined)
+            zlibOptions.chunkSize = chunkSize;
+        // Merge new options with existing ones
+        this.options = {
+            ...this.options,
+            ...restOptions,
+            zlib: zlibOptions,
+        };
+    }
+}
+exports.default = Compression;

package/dist/protections/HelmetProtection.d.ts

@@ -0,0 +1,6 @@
+export default class HelmetProtection {
+    private options;
+    constructor(options?: object);
+    setOptions(options: object): void;
+    getMiddleware(): (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, next: (err?: unknown) => void) => void;
+}

package/dist/protections/HelmetProtection.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helmet_1 = __importDefault(require("helmet"));
+class HelmetProtection {
+    constructor(options = {}) {
+        // Default Helmet options
+        this.options = {
+            frameguard: { action: "sameorigin" },
+            hsts: { maxAge: 31536000, includeSubDomains: true, preload: true },
+            referrerPolicy: { policy: "no-referrer" },
+            noSniff: true,
+            ieNoOpen: true,
+            hidePoweredBy: true,
+            crossOriginResourcePolicy: { policy: "cross-origin" },
+            crossOriginOpenerPolicy: { policy: "same-origin" },
+            contentSecurityPolicy: {
+                directives: {
+                    "default-src": ["'self'"],
+                    "img-src": ["'self'", "data:", process.env.FRONTEND_URL],
+                    "media-src": ["'self'", "data:", process.env.FRONTEND_URL],
+                },
+            },
+            ...options, // If user provides options, they will override defaults
+        };
+    }
+    // Method to update Helmet options
+    setOptions(options) {
+        this.options = { ...this.options, ...options }; // Merge new options with existing ones
+    }
+    // Middleware to apply Helmet protection
+    getMiddleware() {
+        return (0, helmet_1.default)(this.options);
+    }
+}
+exports.default = HelmetProtection;

package/dist/protections/Logger.d.ts

@@ -0,0 +1,9 @@
+export default class Logger {
+    private format;
+    private stream;
+    constructor(format: string);
+    constructor(format: string, filePath: string);
+    getMiddleware(): (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse<import("node:http").IncomingMessage>, callback: (err?: Error) => void) => void;
+    setFormat(format: string): void;
+    setLogFile(filePath: string): void;
+}

package/dist/protections/Logger.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const morgan_1 = __importDefault(require("morgan"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class Logger {
+    constructor(format, filePath) {
+        this.format = format;
+        if (filePath) {
+            // convert path to full path
+            const fullPath = path_1.default.resolve(filePath);
+            // create a write stream (in append mode)
+            const accessLogStream = fs_1.default.createWriteStream(fullPath, { flags: "a" });
+            this.stream = {
+                write: (message) => {
+                    accessLogStream.write(message);
+                },
+            };
+        }
+        else {
+            // Default to console
+            this.stream = {
+                write: (message) => {
+                    process.stdout.write(message);
+                },
+            };
+        }
+    }
+    // Middleware to log requests
+    getMiddleware() {
+        return (0, morgan_1.default)(this.format, { stream: this.stream });
+    }
+    // Method to update log format
+    setFormat(format) {
+        this.format = format;
+    }
+    // Method to update log file path
+    setLogFile(filePath) {
+        const fullPath = path_1.default.resolve(filePath);
+        const accessLogStream = fs_1.default.createWriteStream(fullPath, { flags: "a" });
+        this.stream = {
+            write: (message) => {
+                accessLogStream.write(message);
+            },
+        };
+    }
+}
+exports.default = Logger;

package/dist/protections/XSSProtection.d.ts

@@ -0,0 +1,9 @@
+import { IFilterXSSOptions } from "xss";
+import { Request, Response, NextFunction } from "express";
+export default class XSSProtection {
+    private filter;
+    constructor(options?: IFilterXSSOptions);
+    cleanBody: (req: Request, res: Response, next: NextFunction) => void;
+    cleanText(text: string): string;
+    setOptions(options?: IFilterXSSOptions): void;
+}

package/dist/protections/XSSProtection.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const xss_1 = __importStar(require("xss"));
+class XSSProtection {
+    constructor(options = {}) {
+        // Middleware to clean request body
+        this.cleanBody = (req, res, next) => {
+            if (req.body) {
+                for (const key in req.body) {
+                    // Only clean string fields
+                    if (typeof req.body[key] === "string") {
+                        req.body[key] = (0, xss_1.default)(req.body[key]);
+                    }
+                }
+            }
+            next();
+        };
+        // Default XSS filter options can be set here
+        this.filter = new xss_1.FilterXSS(options);
+    }
+    // Method to clean arbitrary text
+    cleanText(text) {
+        return this.filter.process(text);
+    }
+    // Method to update XSS filter options
+    setOptions(options = {}) {
+        this.filter = new xss_1.FilterXSS(options);
+    }
+}
+exports.default = XSSProtection;

package/dist/utils/Array.d.ts

@@ -0,0 +1,10 @@
+export default class ArrayUtils {
+    static shuffle<T>(array: T[]): T[];
+    static removeDuplicates<T>(array: T[]): T[];
+    static getRandomElement<T>(array: T[]): T | undefined;
+    static flatten<T>(array: T[][]): T[];
+    static max(array: number[]): number | undefined;
+    static min(array: number[]): number | undefined;
+    static sum(array: number[]): number;
+    static average(array: number[]): number | undefined;
+}

package/dist/utils/Array.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ArrayUtils {
+    // Randomly rearranging the array elements
+    static shuffle(array) {
+        for (let i = array.length - 1; i >= 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [array[i], array[j]] = [array[j], array[i]];
+        }
+        return array;
+    }
+    // Remove duplicate elements from the array
+    static removeDuplicates(array) {
+        return [...new Set(array)];
+    }
+    // Get a random element from the array
+    static getRandomElement(array) {
+        if (array.length === 0)
+            return undefined;
+        const index = Math.floor(Math.random() * array.length);
+        return array[index];
+    }
+    // Flatten a nested array
+    static flatten(array) {
+        return array.reduce((acc, val) => acc.concat(val), []);
+    }
+    // Get the maximum value in a numeric array
+    static max(array) {
+        if (array.length === 0)
+            return undefined;
+        return Math.max(...array);
+    }
+    // Get the minimum value in a numeric array
+    static min(array) {
+        if (array.length === 0)
+            return undefined;
+        return Math.min(...array);
+    }
+    // Calculate the sum of a numeric array
+    static sum(array) {
+        return array.reduce((acc, val) => acc + val, 0);
+    }
+    // Calculate the average of a numeric array
+    static average(array) {
+        if (array.length === 0)
+            return undefined;
+        const sum = this.sum(array);
+        return sum / array.length;
+    }
+}
+exports.default = ArrayUtils;

package/dist/utils/Audio.d.ts

@@ -0,0 +1,6 @@
+export default class AudioUtils {
+    private static calculateAudioDuration;
+    private static formatDuration;
+    private static verifyFileType;
+    static getAudioDuration(filePath: string): Promise<string>;
+}

package/dist/utils/Audio.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const musicMetadata = __importStar(require("music-metadata"));
+class AudioUtils {
+    // Calculate the duration of the sound in seconds
+    static async calculateAudioDuration(filePath) {
+        try {
+            const metadata = await musicMetadata.parseFile(filePath);
+            return metadata.format.duration ?? 0;
+        }
+        catch (err) {
+            console.error("Error reading audio metadata:", err.message);
+            return 0;
+        }
+    }
+    // Length format as hh:mm:ss
+    static formatDuration(seconds) {
+        seconds = Math.floor(seconds);
+        const hrs = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secs = seconds % 60;
+        const hh = hrs > 0 ? String(hrs).padStart(2, "0") + ":" : "";
+        const mm = String(minutes).padStart(2, "0");
+        const ss = String(secs).padStart(2, "0");
+        return hh + mm + ":" + ss;
+    }
+    // Verify supported file types
+    static async verifyFileType(filePath) {
+        if (!filePath.endsWith(".mp3") && !filePath.endsWith(".wav")) {
+            console.warn("File type not supported.");
+            return false;
+        }
+        return true;
+    }
+    // Get formatted duration
+    static async getAudioDuration(filePath) {
+        if (!(await this.verifyFileType(filePath))) {
+            return "00:00";
+        }
+        const seconds = await this.calculateAudioDuration(filePath);
+        return this.formatDuration(seconds);
+    }
+}
+exports.default = AudioUtils;

package/dist/utils/Date.d.ts

@@ -0,0 +1,4 @@
+export default class DateUtils {
+    static today(separator?: string): string;
+    static nowTime(separator?: string): string;
+}

package/dist/utils/Date.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DateUtils {
+    // Get current date in YYYY/MM/DD or other format
+    static today(separator = "/") {
+        const date = new Date();
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        return `${year}${separator}${month}${separator}${day}`;
+    }
+    // Get current time in HH:MM:SS or other format
+    static nowTime(separator = ":") {
+        const date = new Date();
+        const hours = `${date.getHours() < 12 ? "AM" : "PM"} ${String(date.getHours() % 12 || 12).padStart(2, "0")}`;
+        const minutes = String(date.getMinutes()).padStart(2, "0");
+        const seconds = String(date.getSeconds()).padStart(2, "0");
+        return `${hours}${separator}${minutes}${separator}${seconds}`;
+    }
+    ;
+}
+exports.default = DateUtils;

package/dist/utils/Files.d.ts

@@ -0,0 +1,15 @@
+export default class FileUtils {
+    private static readonly imageExtensions;
+    private static readonly videoExtensions;
+    private static readonly audioExtensions;
+    private static readonly documentExtensions;
+    private static readonly archiveExtensions;
+    private static getRawSize;
+    static getFileSize(filePath: string, unit?: "B" | "b" | "KB" | "kb" | "MB" | "mb" | "GB" | "gb"): string;
+    static getFileExtension(filePath: string): string;
+    static isImageFile(filePath: string): boolean;
+    static isVideoFile(filePath: string): boolean;
+    static isAudioFile(filePath: string): boolean;
+    static isDocumentFile(filePath: string): boolean;
+    static isArchiveFile(filePath: string): boolean;
+}

package/dist/utils/Files.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class FileUtils {
+    // Get raw file size in bytes
+    static getRawSize(filePath) {
+        try {
+            const stats = fs_1.default.statSync(filePath);
+            return stats.size;
+        }
+        catch (err) {
+            throw new Error(`Error getting file size: ${err.message}`);
+        }
+    }
+    // Get size in defrined unit
+    static getFileSize(filePath, unit = "KB") {
+        const bytes = this.getRawSize(filePath);
+        switch (unit) {
+            case "B":
+            case "b":
+                return `${bytes} B`;
+            case "KB":
+            case "kb":
+                return `${(bytes / 1024).toFixed(2)} KB`;
+            case "MB":
+            case "mb":
+                return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+            case "GB":
+            case "gb":
+                return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+            default:
+                return `${(bytes / 1024).toFixed(2)} KB`;
+        }
+    }
+    // Get file extension
+    static getFileExtension(filePath) {
+        return path_1.default.extname(filePath).slice(1);
+    }
+    // Check if file is an image
+    static isImageFile(filePath) {
+        const ext = this.getFileExtension(filePath).toLowerCase();
+        return this.imageExtensions.includes(ext);
+    }
+    // Check if file is a video
+    static isVideoFile(filePath) {
+        const ext = this.getFileExtension(filePath).toLowerCase();
+        return this.videoExtensions.includes(ext);
+    }
+    // Check if file is an audio
+    static isAudioFile(filePath) {
+        const ext = this.getFileExtension(filePath).toLowerCase();
+        return this.audioExtensions.includes(ext);
+    }
+    // Check if file is a document
+    static isDocumentFile(filePath) {
+        const ext = this.getFileExtension(filePath).toLowerCase();
+        return this.documentExtensions.includes(ext);
+    }
+    // Check if file is a compressed archive
+    static isArchiveFile(filePath) {
+        const ext = this.getFileExtension(filePath).toLowerCase();
+        return this.archiveExtensions.includes(ext);
+    }
+}
+// Supported image extensions
+FileUtils.imageExtensions = [
+    "jpg",
+    "jpeg",
+    "png",
+    "gif",
+    "bmp",
+    "webp",
+    "tiff",
+    "svg",
+];
+// Supported video extensions
+FileUtils.videoExtensions = [
+    "mp4",
+    "avi",
+    "mov",
+    "wmv",
+    "flv",
+    "mkv",
+    "webm",
+];
+// Supported audio extensions
+FileUtils.audioExtensions = [
+    "mp3",
+    "wav",
+    "flac",
+    "aac",
+    "ogg",
+    "m4a",
+];
+// Supported document extensions
+FileUtils.documentExtensions = [
+    "pdf",
+    "doc",
+    "docx",
+    "xls",
+    "xlsx",
+    "ppt",
+    "pptx",
+    "txt",
+    "rtf",
+];
+// Supported archive extensions
+FileUtils.archiveExtensions = [
+    "zip",
+    "rar",
+    "7z",
+    "tar",
+    "gz",
+    "bz2",
+];
+exports.default = FileUtils;

package/dist/utils/RequestData.d.ts

@@ -0,0 +1,15 @@
+import { Request } from "express";
+interface RequestInfo {
+    ip: string;
+    method: string;
+    api: string;
+    userAgent: string;
+}
+export default class RequestData {
+    static getRequestIp(req: Request): string;
+    static getRequestMethod(req: Request): string;
+    static getRequestApi(req: Request): string;
+    static getRequestUserAgent(req: Request): string;
+    static getReqInfos(req: Request): RequestInfo;
+}
+export {};

package/dist/utils/RequestData.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RequestData {
+    static getRequestIp(req) {
+        const forwarded = req.headers["x-forwarded-for"];
+        const forwardedIp = Array.isArray(forwarded)
+            ? forwarded[0]
+            : forwarded?.split(",")[0]?.trim();
+        return (forwardedIp ||
+            req.socket.remoteAddress?.replace(/^::ffff:/, "") ||
+            "Unknown");
+    }
+    static getRequestMethod(req) {
+        return req.method;
+    }
+    static getRequestApi(req) {
+        return req.originalUrl;
+    }
+    static getRequestUserAgent(req) {
+        return req.headers["user-agent"] || "Unknown";
+    }
+    static getReqInfos(req) {
+        const ip = this.getRequestIp(req);
+        const method = this.getRequestMethod(req);
+        const api = this.getRequestApi(req);
+        const userAgent = this.getRequestUserAgent(req);
+        return { ip, method, api, userAgent };
+    }
+}
+exports.default = RequestData;

package/dist/utils/Vidoe.d.ts

@@ -0,0 +1,4 @@
+export default class VideoUtils {
+    private static formatDuration;
+    static getVideoDuration(filePath: string): Promise<string>;
+}

package/dist/utils/Vidoe.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_video_duration_1 = require("get-video-duration");
+class VideoUtils {
+    // Format duration as hh:mm:ss
+    static formatDuration(seconds) {
+        seconds = Math.floor(seconds);
+        const hrs = Math.floor(seconds / 3600);
+        const mins = Math.floor((seconds % 3600) / 60);
+        const secs = seconds % 60;
+        const hh = hrs > 0 ? String(hrs).padStart(2, "0") + ":" : "";
+        const mm = String(mins).padStart(2, "0");
+        const ss = String(secs).padStart(2, "0");
+        return hh + mm + ":" + ss;
+    }
+    // Get formatted duration
+    static async getVideoDuration(filePath) {
+        try {
+            const seconds = await (0, get_video_duration_1.getVideoDurationInSeconds)(filePath);
+            return this.formatDuration(seconds);
+        }
+        catch (err) {
+            console.error("Error reading video metadata:", err.message);
+            return "00:00";
+        }
+    }
+}
+exports.default = VideoUtils;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "gg-tools-kit",
+  "version": "1.0.0",
+  "description": "A Node.js toolkit for utilities and protections",
+  "main": "dist/GGToolsKit.js",
+  "types": "dist/GGToolsKit.d.ts",
+  "scripts": {
+    "dev": "ts-node-dev --respawn --transpile-only src/GGToolsKit.ts",
+    "build": "tsc",
+    "start": "node dist/GGToolsKit.js"
+  },
+  "keywords": [],
+  "author": "MohenedGG",
+  "license": "ISC",
+  "type": "commonjs",
+  "files": ["dist"],
+  "dependencies": {
+    "compression": "^1.7.4",
+    "cookie-parser": "^1.4.7",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "express-compression": "^1.0.2",
+    "get-video-duration": "^5.0.0",
+    "helmet": "^8.1.0",
+    "hpp": "^0.2.3",
+    "morgan": "^1.10.1",
+    "music-metadata": "^11.10.3",
+    "xss": "^1.0.15"
+  },
+  "devDependencies": {
+    "@types/compression": "^1.8.1",
+    "@types/express": "^5.0.6",
+    "@types/helmet": "^0.0.48",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^25.0.0",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.9.3"
+  }
+}