@companix/utils-nodejs 0.0.1

package/dist/cache.d.ts

@@ -0,0 +1,21 @@
+interface CacheOptions<T> {
+    cacheDir?: string;
+    source: string;
+    rotation?: number;
+    fetchData: () => Promise<T>;
+}
+export interface CacheFile<T> {
+    timestamp: number;
+    data: T;
+}
+export declare class LocalCache<T> {
+    private path;
+    private rotation;
+    private fetchData;
+    private getData;
+    constructor({ source, cacheDir, rotation, fetchData }: CacheOptions<T>);
+    get(): Promise<CacheFile<T>>;
+    getCacheValue(): CacheFile<T> | null;
+    reset(): Promise<CacheFile<T>>;
+}
+export {};

package/dist/cache.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCache = void 0;
+const fs_1 = require("fs");
+const fs_2 = require("./fs");
+const common_request_1 = require("./common-request");
+class LocalCache {
+    path;
+    rotation;
+    fetchData;
+    getData = (0, common_request_1.commonQuery)(() => this.fetchData());
+    constructor({ source, cacheDir = 'caches', rotation, fetchData }) {
+        this.path = `${cacheDir}/${source}`;
+        this.rotation = rotation ?? null;
+        this.fetchData = fetchData;
+    }
+    async get() {
+        const value = this.getCacheValue();
+        if (value) {
+            return value;
+        }
+        return this.reset();
+    }
+    getCacheValue() {
+        if ((0, fs_1.existsSync)(this.path)) {
+            const cache = (0, fs_2.getFileData)(this.path);
+            if (cache) {
+                if (this.rotation && Date.now() > cache.timestamp + this.rotation) {
+                    return null;
+                }
+                return cache;
+            }
+        }
+        return null;
+    }
+    async reset() {
+        return this.getData().then((data) => {
+            const cache = {
+                timestamp: Date.now(),
+                data
+            };
+            (0, fs_1.writeFileSync)(this.path, JSON.stringify(cache));
+            return cache;
+        });
+    }
+}
+exports.LocalCache = LocalCache;

package/dist/colors.d.ts

@@ -0,0 +1,9 @@
+export declare const colors: {
+    bold: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    red: (text: string) => string;
+    magentaBright: (text: string) => string;
+    cyanBright: (text: string) => string;
+    yellowBright: (text: string) => string;
+};

package/dist/colors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.colors = {
+    bold: (text) => `\x1B[1m${text}\x1B[0m`,
+    green: (text) => `\x1B[32m${text}\x1B[39m`,
+    yellow: (text) => `\x1B[33m${text}\x1B[39m`,
+    red: (text) => `\x1B[31m${text}\x1B[39m`,
+    magentaBright: (text) => `\x1B[95m${text}\x1B[39m`,
+    cyanBright: (text) => `\x1B[96m${text}\x1B[39m`,
+    yellowBright: (text) => `\x1B[38;5;3m${text}\x1B[39m`
+};

package/dist/common-request.d.ts

@@ -0,0 +1 @@
+export declare const commonQuery: <T>(request: () => Promise<T>) => () => Promise<T>;

package/dist/common-request.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonQuery = void 0;
+const utils_js_1 = require("@companix/utils-js");
+const commonQuery = (request) => {
+    const state = { isLoading: false };
+    const subscribers = new utils_js_1.EventBroadcaster();
+    return () => {
+        if (!state.isLoading) {
+            state.isLoading = true;
+            return request().then((value) => {
+                state.isLoading = false;
+                subscribers.emit(value);
+                return value;
+            });
+        }
+        return new Promise((resolve) => {
+            const unsubscribe = subscribers.subscribe((value) => {
+                unsubscribe();
+                resolve(value);
+            });
+        });
+    };
+};
+exports.commonQuery = commonQuery;

package/dist/context.d.ts

@@ -0,0 +1,4 @@
+export declare const createContext: <T>() => {
+    provide: (value: T, fn: () => void) => void;
+    use: () => T;
+};

package/dist/context.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const createContext = () => {
+    const storage = new node_async_hooks_1.AsyncLocalStorage();
+    return {
+        provide: (value, fn) => {
+            return storage.run(value, fn);
+        },
+        use: () => {
+            const store = storage.getStore();
+            if (!store) {
+                throw new Error('useContext called outside of context');
+            }
+            return store;
+        }
+    };
+};
+exports.createContext = createContext;

package/dist/file-driver.d.ts

@@ -0,0 +1,9 @@
+export declare class FileDriver<T> {
+    private path;
+    private file;
+    constructor(path: string, defaultValue: T);
+    getData(): T;
+    change(mutate: (value: T) => void): void;
+    save(): void;
+    remove(): void;
+}

package/dist/file-driver.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileDriver = void 0;
+const fs_1 = require("fs");
+const fs_2 = require("./fs");
+class FileDriver {
+    path;
+    file;
+    constructor(path, defaultValue) {
+        this.path = path;
+        if (!(0, fs_1.existsSync)(path)) {
+            (0, fs_1.writeFileSync)(path, JSON.stringify(defaultValue));
+        }
+        this.file = (0, fs_2.getFileData)(path);
+    }
+    getData() {
+        return this.file;
+    }
+    change(mutate) {
+        mutate(this.file);
+        (0, fs_1.writeFileSync)(this.path, JSON.stringify(this.file));
+    }
+    save() {
+        (0, fs_1.writeFileSync)(this.path, JSON.stringify(this.file));
+    }
+    remove() {
+        (0, fs_1.rmSync)(this.path);
+    }
+}
+exports.FileDriver = FileDriver;

package/dist/fs.d.ts

@@ -0,0 +1,3 @@
+export declare const getFilesList: (path: string) => string[];
+export declare const getFileData: <T = any>(path: string) => T;
+export declare const getFolderSize: (path: string) => Promise<string>;

package/dist/fs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFolderSize = exports.getFileData = exports.getFilesList = void 0;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const getFilesList = (path) => {
+    return (0, fs_1.readdirSync)(path).filter((s) => {
+        return !s.startsWith('.');
+    });
+};
+exports.getFilesList = getFilesList;
+const getFileData = (path) => {
+    return JSON.parse((0, fs_1.readFileSync)(path, { encoding: 'utf-8' }));
+};
+exports.getFileData = getFileData;
+const getFolderSize = (path) => {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(`du -sk "${path}"`, (error, stdout, stderr) => {
+            if (error) {
+                return reject(`error: ${error.message}`);
+            }
+            if (stderr) {
+                return reject(`stderr: ${stderr}`);
+            }
+            resolve(stdout.split('\t')[0]);
+        });
+    });
+};
+exports.getFolderSize = getFolderSize;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './logger';
+export * from './perfomance';
+export * from './limiter';
+export * from './fs';
+export * from './cache';
+export * from './file-driver';
+export * from './common-request';
+export * from './context';

package/dist/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logger"), exports);
+__exportStar(require("./perfomance"), exports);
+__exportStar(require("./limiter"), exports);
+__exportStar(require("./fs"), exports);
+__exportStar(require("./cache"), exports);
+__exportStar(require("./file-driver"), exports);
+__exportStar(require("./common-request"), exports);
+__exportStar(require("./context"), exports);

package/dist/limiter.d.ts

@@ -0,0 +1,26 @@
+interface LimiterOptions {
+    name: string;
+    limit: number;
+    interval: number;
+    threshold?: number;
+}
+export declare class FrequencyLimiter {
+    private readonly logger;
+    private readonly limit;
+    private readonly interval;
+    private resetTimestamp;
+    private usedWeight;
+    private resolvedWeight;
+    private threshold;
+    private tasks;
+    constructor({ interval, threshold, name, limit }: LimiterOptions);
+    wrap<T>(weight: number, request: () => Promise<T>, id?: string): Promise<T>;
+}
+export declare class HeadersLimiter {
+    apiLimitTrackers: Record<string, number>;
+    apiLimitLastUpdated: number;
+    constructor(headers: Record<string, any>);
+    getRateLimitStates(): Record<string, number>;
+    updateApiLimitState(responseHeaders: Record<string, any>): void;
+}
+export {};

package/dist/limiter.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadersLimiter = exports.FrequencyLimiter = void 0;
+const logger_1 = require("./logger");
+const utils_js_1 = require("@companix/utils-js");
+class FrequencyLimiter {
+    logger;
+    limit;
+    interval;
+    resetTimestamp = Date.now();
+    usedWeight = 0;
+    resolvedWeight = 0;
+    threshold;
+    tasks = new Set();
+    constructor({ interval, threshold, name, limit }) {
+        this.interval = interval;
+        this.limit = limit;
+        this.threshold = threshold ?? 1500;
+        this.logger = new logger_1.JSLogger(`LIMITTER${name ? `-${name.toUpperCase()}` : ''}`);
+    }
+    async wrap(weight, request, id = (0, utils_js_1.generateCode)(8)) {
+        this.tasks.add(id);
+        if (Date.now() > this.resetTimestamp) {
+            if (this.usedWeight >= this.limit) {
+                if (this.resolvedWeight !== this.usedWeight) {
+                    this.logger.warn(`WAIT (${this.resolvedWeight}/${this.usedWeight}). [${this.tasks.size}]`, 'NOT RESOLVED');
+                    await (0, utils_js_1.sleep)(1500);
+                    return this.wrap(weight, request, id);
+                }
+            }
+            this.resetTimestamp = Date.now() + this.interval;
+            this.usedWeight = 0;
+            this.resolvedWeight = 0;
+        }
+        if (this.usedWeight + weight <= this.limit) {
+            this.usedWeight += weight;
+            return request().finally(() => {
+                this.tasks.delete(id);
+                this.resolvedWeight += weight;
+            });
+        }
+        const wait = this.resetTimestamp - Date.now() + this.threshold;
+        this.logger.warn(`WAIT: ${wait}. [${this.tasks.size}]`, 'VIOLATION');
+        await (0, utils_js_1.sleep)(wait);
+        return this.wrap(weight, request, id);
+    }
+}
+exports.FrequencyLimiter = FrequencyLimiter;
+class HeadersLimiter {
+    apiLimitTrackers;
+    apiLimitLastUpdated;
+    constructor(headers) {
+        this.apiLimitTrackers = headers;
+    }
+    getRateLimitStates() {
+        return {
+            ...this.apiLimitTrackers,
+            lastUpdated: this.apiLimitLastUpdated
+        };
+    }
+    updateApiLimitState(responseHeaders) {
+        const delta = {};
+        for (const headerKey in this.apiLimitTrackers) {
+            const headerValue = responseHeaders[headerKey];
+            const value = parseInt(headerValue);
+            if (headerValue !== undefined && !isNaN(value)) {
+                this.apiLimitTrackers[headerKey] = value;
+                delta[headerKey] = {
+                    updated: true,
+                    valueParsed: value,
+                    valueRaw: headerValue
+                };
+            }
+            else {
+                delta[headerKey] = {
+                    updated: false,
+                    valueParsed: value,
+                    valueRaw: headerValue
+                };
+            }
+        }
+        this.apiLimitLastUpdated = new Date().getTime();
+    }
+}
+exports.HeadersLimiter = HeadersLimiter;

package/dist/logger.d.ts

@@ -0,0 +1,21 @@
+export type LogLevel = 'log' | 'error' | 'warn' | 'debug' | 'verbose' | 'fatal' | 'magneta';
+interface Options {
+    bold?: boolean;
+}
+export declare class JSLogger {
+    private readonly service;
+    private write;
+    private pid;
+    constructor(service: string);
+    log(message: string, context: string): void;
+    error(message: string, context: string): void;
+    warn(message: string, context: string): void;
+    debug(message: string, context: string): void;
+    verbose(message: string, context: string, opts?: Options): void;
+    fatal(message: string, context: string): void;
+    console(message: string, level: LogLevel, opts?: Options): void;
+    private print;
+    private colorize;
+    private getColorByLogLevel;
+}
+export {};

package/dist/logger.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSLogger = void 0;
+const colors_1 = require("./colors");
+class JSLogger {
+    service;
+    write;
+    pid = 8000;
+    constructor(service) {
+        this.service = service;
+        this.write = (buffer) => process.stdout.write(buffer);
+        this.pid = process.pid;
+    }
+    log(message, context) {
+        this.print(message, context, 'log');
+    }
+    error(message, context) {
+        this.print(message, context, 'error');
+    }
+    warn(message, context) {
+        this.print(message, context, 'warn');
+    }
+    debug(message, context) {
+        this.print(message, context, 'debug');
+    }
+    verbose(message, context, opts) {
+        this.print(message, context, 'verbose', opts);
+    }
+    fatal(message, context) {
+        this.print(message, context, 'fatal');
+    }
+    console(message, level, opts) {
+        this.write(this.colorize(`${this.service}: ${message}`, level, opts) + '\n');
+    }
+    print(message, context, logLevel, opts) {
+        const log = this.colorize(logLevel.toUpperCase().padStart(7, ' '), logLevel);
+        const ctx = colors_1.colors.yellowBright(`[${context}]`);
+        const text = this.colorize(message, logLevel, opts);
+        const service = this.colorize(`[${this.service}]`, logLevel);
+        const time = new Date().toLocaleTimeString('ru', { timeZone: 'UTC' });
+        this.write(`${time} - ${this.pid} ${service} - ${log} ${ctx} ${text}\n`);
+    }
+    colorize(message, logLevel, opts) {
+        return this.getColorByLogLevel(logLevel, opts)(message);
+    }
+    getColorByLogLevel(level, opts) {
+        switch (level) {
+            case 'debug':
+                return colors_1.colors.magentaBright;
+            case 'warn':
+                return colors_1.colors.yellow;
+            case 'error':
+                if (opts?.bold) {
+                    return (text) => `\x1B[30m\x1B[41m${text}\x1B[0m`;
+                }
+                return colors_1.colors.red;
+            case 'verbose':
+                if (opts?.bold) {
+                    return (text) => `\x1B[106m${text}\x1B[49m`;
+                }
+                return colors_1.colors.cyanBright;
+            case 'fatal':
+                return colors_1.colors.bold;
+            default:
+                return colors_1.colors.green;
+        }
+    }
+}
+exports.JSLogger = JSLogger;

package/dist/perfomance.d.ts

@@ -0,0 +1,11 @@
+export declare class InspectPerfomance {
+    private readonly name;
+    private moment;
+    private memory;
+    constructor(name: string);
+    start(): void;
+    done(): {
+        memory: string;
+        time: string;
+    };
+}

package/dist/perfomance.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectPerfomance = void 0;
+class InspectPerfomance {
+    name;
+    moment = 0;
+    memory = 0;
+    constructor(name) {
+        this.name = name;
+    }
+    start() {
+        this.moment = performance.now();
+        this.memory = process.memoryUsage().heapUsed;
+    }
+    done() {
+        const time = performance.now() - this.moment;
+        const memoryCost = process.memoryUsage().heapUsed - this.memory;
+        console.log(`${this.name}: Memory increase: ${memoryCost / 1024} KB`);
+        console.log(`${this.name}: Execution time: ${time} ms`);
+        return {
+            memory: `${memoryCost / 1024} KB`,
+            time: `${time} ms`
+        };
+    }
+}
+exports.InspectPerfomance = InspectPerfomance;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@companix/utils-nodejs",
+  "version": "0.0.01",
+  "main": "dist/index.js",
+  "types": "./src/index.ts",
+  "author": "Pavel Victorov",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "@companix/utils-js": "file:../utils-js"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.9"
+  }
+}