@dignetwork/dig-sdk 0.0.1-alpha.18 → 0.0.1-alpha.181

package/dist/utils/DigCache.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigCache = void 0;
+// src/cache/DigCache.ts
+const node_cache_1 = __importDefault(require("node-cache"));
+const redis_1 = require("redis");
+class DigCache {
+    /**
+     * Constructor with the same signature as NodeCache.
+     * @param options - NodeCache options
+     */
+    constructor(options) {
+        // Determine whether to use Redis based on the environment variable
+        this.useRedis = process.env.USE_REDIS === 'true';
+        if (this.useRedis) {
+            // Ensure REDIS_URL is provided
+            const redisUrl = process.env.REDIS_URL;
+            if (!redisUrl) {
+                throw new Error("REDIS_URL environment variable is not set.");
+            }
+            const client = (0, redis_1.createClient)({ url: redisUrl });
+            client.on("error", (err) => console.error("Redis Client Error", err));
+            // Initialize connection in the initialize method
+            this.cache = client;
+        }
+        else {
+            // Initialize NodeCache with provided options
+            this.cache = new node_cache_1.default(options);
+        }
+    }
+    /**
+     * Initializes the Redis connection if Redis is being used.
+     * Call this method before performing any cache operations.
+     */
+    async initialize() {
+        if (this.useRedis) {
+            try {
+                await this.cache.connect();
+                console.log("Connected to Redis successfully.");
+            }
+            catch (error) {
+                console.error("Failed to connect to Redis:", error);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Gracefully disconnects the Redis client if Redis is being used.
+     * Call this method when your application is shutting down.
+     */
+    async disconnect() {
+        if (this.useRedis) {
+            try {
+                await this.cache.quit();
+                console.log("Disconnected from Redis successfully.");
+            }
+            catch (error) {
+                console.error("Error disconnecting Redis:", error);
+            }
+        }
+    }
+    async set(key, value, ttl) {
+        if (this.useRedis) {
+            try {
+                const serializedValue = JSON.stringify(value);
+                if (ttl !== undefined) {
+                    // Redis TTL is in seconds
+                    const result = await this.cache.set(key, serializedValue, { EX: ttl });
+                    return result === "OK";
+                }
+                else {
+                    const result = await this.cache.set(key, serializedValue);
+                    return result === "OK";
+                }
+            }
+            catch (error) {
+                console.error(`Redis set error for key "${key}":`, error);
+                return false;
+            }
+        }
+        else {
+            try {
+                const result = this.cache.set(key, value, ttl ?? 0);
+                return result;
+            }
+            catch (error) {
+                console.error(`NodeCache set error for key "${key}":`, error);
+                return false;
+            }
+        }
+    }
+    async get(key) {
+        if (this.useRedis) {
+            try {
+                const value = await this.cache.get(key);
+                if (value === null) {
+                    return undefined;
+                }
+                return JSON.parse(value);
+            }
+            catch (error) {
+                console.error(`Redis get error for key "${key}":`, error);
+                return undefined;
+            }
+        }
+        else {
+            try {
+                const value = this.cache.get(key);
+                return value;
+            }
+            catch (error) {
+                console.error(`NodeCache get error for key "${key}":`, error);
+                return undefined;
+            }
+        }
+    }
+    async del(key) {
+        if (this.useRedis) {
+            try {
+                const result = await this.cache.del(key);
+                return result;
+            }
+            catch (error) {
+                console.error(`Redis del error for key "${key}":`, error);
+                return 0;
+            }
+        }
+        else {
+            try {
+                const result = this.cache.del(key);
+                return result;
+            }
+            catch (error) {
+                console.error(`NodeCache del error for key "${key}":`, error);
+                return 0;
+            }
+        }
+    }
+    async has(key) {
+        if (this.useRedis) {
+            try {
+                const result = await this.cache.exists(key);
+                return result > 0;
+            }
+            catch (error) {
+                console.error(`Redis exists error for key "${key}":`, error);
+                return false;
+            }
+        }
+        else {
+            try {
+                const result = this.cache.has(key);
+                return result;
+            }
+            catch (error) {
+                console.error(`NodeCache has error for key "${key}":`, error);
+                return false;
+            }
+        }
+    }
+    async flushAll() {
+        if (this.useRedis) {
+            try {
+                await this.cache.flushAll();
+                return true;
+            }
+            catch (error) {
+                console.error("Redis flushAll error:", error);
+                return false;
+            }
+        }
+        else {
+            try {
+                this.cache.flushAll();
+                return true;
+            }
+            catch (error) {
+                console.error("NodeCache flushAll error:", error);
+                return false;
+            }
+        }
+    }
+    async keys(pattern = "*") {
+        if (this.useRedis) {
+            try {
+                const result = await this.cache.keys(pattern);
+                return result;
+            }
+            catch (error) {
+                console.error(`Redis keys error with pattern "${pattern}":`, error);
+                return [];
+            }
+        }
+        else {
+            try {
+                const result = this.cache.keys();
+                return result;
+            }
+            catch (error) {
+                return [];
+            }
+        }
+    }
+    async ttl(key, ttl) {
+        if (this.useRedis) {
+            try {
+                if (ttl === undefined || ttl === 0) {
+                    return (await this.cache.del(key)) > 0;
+                }
+                else {
+                    return await this.cache.expire(key, ttl);
+                }
+            }
+            catch (error) {
+                console.error(`Redis ttl error for key "${key}":`, error);
+                return false;
+            }
+        }
+        else {
+            try {
+                if (ttl === undefined || ttl === 0) {
+                    return this.cache.del(key) > 0;
+                }
+                return this.cache.ttl(key, ttl);
+            }
+            catch (error) {
+                console.error(`NodeCache ttl error for key "${key}":`, error);
+                return false;
+            }
+        }
+    }
+}
+exports.DigCache = DigCache;

package/dist/utils/Environment.d.ts

@@ -0,0 +1,21 @@
+export declare class Environment {
+    private static cliMode;
+    private static isValidIp;
+    private static isValidHostnameOrIp;
+    private static isValidPort;
+    private static isValidFilePath;
+    private static getNumberEnvVar;
+    static get DIG_USERNAME(): string | undefined;
+    static get DIG_PASSWORD(): string | undefined;
+    static get TRUSTED_FULLNODE(): string | undefined;
+    static get TRUSTED_FULLNODE_PORT(): number | undefined;
+    static get PUBLIC_IP(): string | undefined;
+    static get DISK_SPACE_LIMIT_BYTES(): number | undefined;
+    static get MERCENARY_MODE(): boolean | undefined;
+    static get DEBUG(): boolean | undefined;
+    static get DIG_FOLDER_PATH(): string | undefined;
+    static get REMOTE_NODE(): boolean | undefined;
+    static set CLI_MODE(mode: boolean);
+    static get CLI_MODE(): boolean | undefined;
+}
+//# sourceMappingURL=Environment.d.ts.map

package/dist/utils/Environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Environment.d.ts","sourceRoot":"","sources":["../../src/utils/Environment.ts"],"names":[],"mappings":"AAGA,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAC,OAAO,CAAkB;IAGxC,OAAO,CAAC,MAAM,CAAC,SAAS;IAOxB,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAUlC,OAAO,CAAC,MAAM,CAAC,WAAW;IAK1B,OAAO,CAAC,MAAM,CAAC,eAAe;IAK9B,OAAO,CAAC,MAAM,CAAC,eAAe;IAO9B,MAAM,KAAK,YAAY,IAAI,MAAM,GAAG,SAAS,CAG5C;IAGD,MAAM,KAAK,YAAY,IAAI,MAAM,GAAG,SAAS,CAG5C;IAGD,MAAM,KAAK,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAGhD;IAGD,MAAM,KAAK,qBAAqB,IAAI,MAAM,GAAG,SAAS,CAGrD;IAGD,MAAM,KAAK,SAAS,IAAI,MAAM,GAAG,SAAS,CAGzC;IAGD,MAAM,KAAK,sBAAsB,IAAI,MAAM,GAAG,SAAS,CAEtD;IAGD,MAAM,KAAK,cAAc,IAAI,OAAO,GAAG,SAAS,CAG/C;IAGD,MAAM,KAAK,KAAK,IAAI,OAAO,GAAG,SAAS,CAGtC;IAGD,MAAM,KAAK,eAAe,IAAI,MAAM,GAAG,SAAS,CAG/C;IAGD,MAAM,KAAK,WAAW,IAAI,OAAO,GAAG,SAAS,CAG5C;IAED,MAAM,KAAK,QAAQ,CAAC,IAAI,EAAE,OAAO,EAEhC;IAED,MAAM,KAAK,QAAQ,IAAI,OAAO,GAAG,SAAS,CAEzC;CACF"}

package/dist/utils/Environment.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class Environment {
+    // Helper to validate if a string is a valid IP address (IPv4)
+    static isValidIp(ip) {
+        const ipPattern = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+        return ipPattern.test(ip);
+    }
+    // Helper to validate if a string is a valid hostname or IP address
+    static isValidHostnameOrIp(hostname) {
+        // Hostname regex (simple, allows subdomains but not special characters)
+        const hostnamePattern = /^(([a-zA-Z0-9](-*[a-zA-Z0-9])*)\.)*([a-zA-Z0-9](-*[a-zA-Z0-9])*)\.?$/;
+        const ipv6Pattern = /^(([0-9a-fA-F]{1,4}:){7}([0-9a-fA-F]{1,4}|:)|(([0-9a-fA-F]{1,4}:){1,7}|:):(([0-9a-fA-F]{1,4}:){1,6}|:):([0-9a-fA-F]{1,4}|:):([0-9a-fA-F]{1,4}|:)|::)$/;
+        return this.isValidIp(hostname) || ipv6Pattern.test(hostname) || hostnamePattern.test(hostname);
+    }
+    // Helper to validate if a number is a valid port (between 1 and 65535)
+    static isValidPort(port) {
+        return port > 0 && port <= 65535;
+    }
+    // Helper to validate if a string is a valid file path
+    static isValidFilePath(filePath) {
+        return fs_1.default.existsSync(filePath) && path_1.default.isAbsolute(filePath);
+    }
+    // Helper to get and validate number env variables
+    static getNumberEnvVar(envVar) {
+        const value = process.env[envVar];
+        const parsedValue = Number(value);
+        return !isNaN(parsedValue) ? parsedValue : undefined;
+    }
+    // Static getter for DIG_USERNAME (string, non-empty)
+    static get DIG_USERNAME() {
+        const value = process.env["DIG_USERNAME"];
+        return value && value.trim().length > 0 ? value : undefined;
+    }
+    // Static getter for DIG_PASSWORD (string, non-empty)
+    static get DIG_PASSWORD() {
+        const value = process.env["DIG_PASSWORD"];
+        return value && value.trim().length > 0 ? value : undefined;
+    }
+    // Static getter for TRUSTED_FULLNODE (valid IP or hostname)
+    static get TRUSTED_FULLNODE() {
+        const value = process.env["TRUSTED_FULLNODE"];
+        return value && this.isValidHostnameOrIp(value) ? value : undefined;
+    }
+    // Static getter for TRUSTED_FULLNODE_PORT (valid port)
+    static get TRUSTED_FULLNODE_PORT() {
+        const port = this.getNumberEnvVar("TRUSTED_FULLNODE_PORT");
+        return port && this.isValidPort(port) ? port : undefined;
+    }
+    // Static getter for PUBLIC_IP (valid IP)
+    static get PUBLIC_IP() {
+        const value = process.env["PUBLIC_IP"];
+        return value;
+    }
+    // Static getter for DISK_SPACE_LIMIT_BYTES (number, optional)
+    static get DISK_SPACE_LIMIT_BYTES() {
+        return this.getNumberEnvVar("DISK_SPACE_LIMIT_BYTES");
+    }
+    // Static getter for MERCENARY_MODE (boolean: "true" or "false")
+    static get MERCENARY_MODE() {
+        const value = process.env["MERCENARY_MODE"];
+        return value === "true" ? true : value === "false" ? false : undefined;
+    }
+    // Static getter for MERCENARY_MODE (boolean: "true" or "false")
+    static get DEBUG() {
+        const value = process.env["DIG_DEBUG"];
+        return value === "true" ? true : value === "false" ? false : undefined;
+    }
+    // Static getter for DIG_FOLDER_PATH (valid file path)
+    static get DIG_FOLDER_PATH() {
+        const value = process.env["DIG_FOLDER_PATH"];
+        return value && this.isValidFilePath(value) ? value : undefined;
+    }
+    // Static getter for REMOTE_NODE (boolean: "1" or "0", mapped to true/false)
+    static get REMOTE_NODE() {
+        const value = process.env["REMOTE_NODE"];
+        return value === "1" ? true : value === "0" ? false : undefined;
+    }
+    static set CLI_MODE(mode) {
+        this.cliMode = mode;
+    }
+    static get CLI_MODE() {
+        return Environment.cliMode;
+    }
+}
+exports.Environment = Environment;
+Environment.cliMode = false;

package/dist/utils/FileCache.d.ts

@@ -1,6 +1,6 @@
 export declare class FileCache<T> {
     private cacheDir;
-    constructor(relativeFilePath: string);
+    constructor(relativeFilePath: string, baseDir?: string);
     private ensureDirectoryExists;
     private getCacheFilePath;
     get(key: string): T | null;

package/dist/utils/FileCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileCache.d.ts","sourceRoot":"","sources":["../../src/utils/FileCache.ts"],"names":[],"mappings":"AAIA,qBAAa,SAAS,CAAC,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAS;gBAEb,gBAAgB,EAAE,MAAM;IAMpC,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,gBAAgB;IAKjB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAY1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAO/B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASzB,aAAa,IAAI,MAAM,EAAE;CAUjC"}
+{"version":3,"file":"FileCache.d.ts","sourceRoot":"","sources":["../../src/utils/FileCache.ts"],"names":[],"mappings":"AAIA,qBAAa,SAAS,CAAC,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAS;gBAEb,gBAAgB,EAAE,MAAM,EAAE,OAAO,GAAE,MAAwB;IAMvE,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,gBAAgB;IAKjB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAY1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAO/B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASzB,aAAa,IAAI,MAAM,EAAE;CAUjC"}

package/dist/utils/FileCache.js

@@ -8,8 +8,8 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("./config");
 class FileCache {
-    constructor(relativeFilePath) {
-        this.cacheDir = path_1.default.join(config_1.DIG_FOLDER_PATH, relativeFilePath);
+    constructor(relativeFilePath, baseDir = config_1.DIG_FOLDER_PATH) {
+        this.cacheDir = path_1.default.join(baseDir, relativeFilePath);
         this.ensureDirectoryExists();
     }
     // Ensure the directory exists or create it

package/dist/utils/FileTransfer.d.ts

@@ -0,0 +1,47 @@
+import { Readable } from "stream";
+export declare class FileTransfer {
+    private static certPath;
+    private static keyPath;
+    constructor();
+    /** ------------------------ UPLOAD FUNCTIONALITY ------------------------ **/
+    /**
+     * Upload a file to the server using a stream.
+     * @param filePath - Local path of the file.
+     * @param uploadUrl - Server URL to upload the file.
+     * @param headers - Additional headers for the request.
+     * @returns Promise<void>
+     */
+    uploadFile(filePath: string, uploadUrl: string, headers: Record<string, string>): Promise<void>;
+    /**
+     * Perform a POST request.
+     * @param url - The URL to POST to.
+     * @param data - Data to send.
+     * @param headers - Headers for the POST request.
+     * @returns Promise<void>
+     */
+    postRequest(url: string, data: string, headers: Record<string, string>): Promise<void>;
+    /** ------------------------ DOWNLOAD FUNCTIONALITY ------------------------ **/
+    /**
+     * Download data from a URL.
+     * @param url - The URL to download data from.
+     * @returns Promise<string>
+     */
+    downloadData(url: string): Promise<string>;
+    /**
+     * Stream data from a URL.
+     * @param url - The URL to stream data from.
+     * @returns Promise<Readable>
+     */
+    streamData(url: string): Promise<Readable>;
+    /** ------------------------ HEAD REQUEST FUNCTIONALITY ------------------------ **/
+    /**
+     * Perform a HEAD request to check if a resource exists on the server.
+     * @param url - The URL to check.
+     * @returns Promise<{ success: boolean; headers?: Record<string, string> }>
+     */
+    headRequest(url: string): Promise<{
+        success: boolean;
+        headers?: Record<string, string>;
+    }>;
+}
+//# sourceMappingURL=FileTransfer.d.ts.map

package/dist/utils/FileTransfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileTransfer.d.ts","sourceRoot":"","sources":["../../src/utils/FileTransfer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;;IAU/B,8EAA8E;IAE9E;;;;;;OAMG;IACU,UAAU,CACrB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC;IA0ChB;;;;;;OAMG;IACU,WAAW,CACtB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC;IAsChB,gFAAgF;IAEhF;;;;OAIG;IACU,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA0CvD;;;;OAIG;IACU,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAuCvD,oFAAoF;IAEpF;;;;OAIG;IACU,WAAW,CACtB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;CA8BnE"}

package/dist/utils/FileTransfer.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTransfer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const url_1 = require("url");
+const ssl_1 = require("../utils/ssl");
+class FileTransfer {
+    constructor() {
+        if (!FileTransfer.certPath || !FileTransfer.keyPath) {
+            const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+            FileTransfer.certPath = certPath;
+            FileTransfer.keyPath = keyPath;
+        }
+    }
+    /** ------------------------ UPLOAD FUNCTIONALITY ------------------------ **/
+    /**
+     * Upload a file to the server using a stream.
+     * @param filePath - Local path of the file.
+     * @param uploadUrl - Server URL to upload the file.
+     * @param headers - Additional headers for the request.
+     * @returns Promise<void>
+     */
+    async uploadFile(filePath, uploadUrl, headers) {
+        const fileStream = fs_1.default.createReadStream(filePath);
+        const fileSize = fs_1.default.statSync(filePath).size;
+        return new Promise((resolve, reject) => {
+            const url = new url_1.URL(uploadUrl);
+            const options = {
+                hostname: url.hostname,
+                port: url.port || 443,
+                path: url.pathname,
+                method: "PUT",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/octet-stream",
+                    "Content-Length": fileSize,
+                },
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Upload failed with status ${res.statusCode}: ${res.statusMessage}`));
+                }
+            });
+            req.on("error", (err) => reject(err));
+            fileStream.pipe(req);
+            fileStream.on("error", (err) => reject(err));
+        });
+    }
+    /**
+     * Perform a POST request.
+     * @param url - The URL to POST to.
+     * @param data - Data to send.
+     * @param headers - Headers for the POST request.
+     * @returns Promise<void>
+     */
+    async postRequest(url, data, headers) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 443,
+                path: urlObj.pathname,
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/json",
+                    "Content-Length": Buffer.byteLength(data),
+                },
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`POST request failed with status ${res.statusCode}: ${res.statusMessage}`));
+                }
+            });
+            req.on("error", (err) => reject(err));
+            req.write(data);
+            req.end();
+        });
+    }
+    /** ------------------------ DOWNLOAD FUNCTIONALITY ------------------------ **/
+    /**
+     * Download data from a URL.
+     * @param url - The URL to download data from.
+     * @returns Promise<string>
+     */
+    async downloadData(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 443,
+                path: urlObj.pathname + urlObj.search,
+                method: "GET",
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                let data = "";
+                if (res.statusCode === 200) {
+                    res.on("data", (chunk) => (data += chunk));
+                    res.on("end", () => resolve(data));
+                }
+                else if (res.statusCode === 301 || res.statusCode === 302) {
+                    const redirectUrl = res.headers.location;
+                    if (redirectUrl) {
+                        this.downloadData(redirectUrl).then(resolve).catch(reject);
+                    }
+                    else {
+                        reject(new Error("Redirected without a location header"));
+                    }
+                }
+                else {
+                    reject(new Error(`Failed to retrieve data from ${url}. Status code: ${res.statusCode}`));
+                }
+            });
+            req.on("error", (error) => reject(error));
+            req.end();
+        });
+    }
+    /**
+     * Stream data from a URL.
+     * @param url - The URL to stream data from.
+     * @returns Promise<Readable>
+     */
+    async streamData(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 443,
+                path: urlObj.pathname + urlObj.search,
+                method: "GET",
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve(res); // Return the readable stream
+                }
+                else if (res.statusCode === 301 || res.statusCode === 302) {
+                    const redirectUrl = res.headers.location;
+                    if (redirectUrl) {
+                        this.streamData(redirectUrl).then(resolve).catch(reject);
+                    }
+                    else {
+                        reject(new Error("Redirected without a location header"));
+                    }
+                }
+                else {
+                    reject(new Error(`Failed to retrieve stream from ${url}. Status code: ${res.statusCode}`));
+                }
+            });
+            req.on("error", (error) => reject(error));
+            req.end();
+        });
+    }
+    /** ------------------------ HEAD REQUEST FUNCTIONALITY ------------------------ **/
+    /**
+     * Perform a HEAD request to check if a resource exists on the server.
+     * @param url - The URL to check.
+     * @returns Promise<{ success: boolean; headers?: Record<string, string> }>
+     */
+    async headRequest(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 443,
+                path: urlObj.pathname,
+                method: "HEAD",
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve({
+                        success: true,
+                        headers: res.headers,
+                    });
+                }
+                else {
+                    resolve({ success: false });
+                }
+            });
+            req.on("error", (err) => reject(err));
+            req.end();
+        });
+    }
+}
+exports.FileTransfer = FileTransfer;

package/dist/utils/NconfManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NconfManager.d.ts","sourceRoot":"","sources":["../../src/utils/NconfManager.ts"],"names":[],"mappings":"AAQA,qBAAa,YAAY;IACvB,OAAO,CAAC,cAAc,CAAS;gBAEnB,YAAY,EAAE,MAAM;YAKlB,gBAAgB;IAejB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAMjD,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAStD,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS7C,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAKhC,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAI3D"}
+{"version":3,"file":"NconfManager.d.ts","sourceRoot":"","sources":["../../src/utils/NconfManager.ts"],"names":[],"mappings":"AAUA,qBAAa,YAAY;IACvB,OAAO,CAAC,cAAc,CAAS;gBAEnB,YAAY,EAAE,MAAM;YAKpB,gBAAgB;IAmBf,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAMjD,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAStD,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS7C,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAKhC,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAI3D"}