badmfck-api-server 3.7.3 → 3.7.4

package/dist/apiServer/APIService.d.ts

@@ -5,7 +5,6 @@ import { IBaseEndpoint } from './BaseEndpoint';
 import { HTTPRequestVO, IError, TransferPacketVO } from './structures/Interfaces';
 import { Req } from "badmfck-signal";
 import http from 'http';
-import { IWebsocket } from './Websocket';
 export interface IMonitorUser {
     login: string;
     password: string;
@@ -40,7 +39,6 @@ export interface APIServiceOptions {
         monitor?: IMonitorUser[];
         documentation?: IMonitorUser[];
     };
-    websocket?: IWebsocket[];
     monitor?: IMonitorUser[];
     appVersion?: string;
     fileTempDir: string;

package/dist/apiServer/APIService.js

@@ -95,7 +95,7 @@ async function Initializer(services) {
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
     static nextLogID = 0;
-    version = "3.7.3";
+    version = "3.7.4";
     options;
     monitor = null;
     started = new Date();

package/dist/apiServer/TimeframeService.d.ts

@@ -0,0 +1,26 @@
+import Signal, { Req } from "badmfck-signal";
+import { BaseService } from "./BaseService";
+export declare const REQ_TIMEFRAME_TASK_ADD: Req<ITimeframeTask<any>, void>;
+export declare const S_TIMEFRAME_TASK_EXECUTED: Signal<ITimeframeTask<any>>;
+export interface ITimeframeTask<T = any> {
+    name: string;
+    start: number;
+    params?: T;
+    repeat: number;
+    callback: (params?: T) => Promise<void>;
+    executed: number;
+    retries?: number;
+    maxRetries?: number;
+}
+export declare class TimeframeService extends BaseService {
+    TICK_INTERVAL_MS: number;
+    RETRY_DELAY_MS: number;
+    GRACE_WINDOW_MS: number;
+    tasks: ITimeframeTask<any>[];
+    intervalId: any;
+    static wait(ms: number): Promise<void>;
+    constructor();
+    init(): Promise<void>;
+    finishService(): Promise<void>;
+    loop(): Promise<void>;
+}

package/dist/apiServer/TimeframeService.js

@@ -0,0 +1,98 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeframeService = exports.S_TIMEFRAME_TASK_EXECUTED = exports.REQ_TIMEFRAME_TASK_ADD = void 0;
+const badmfck_signal_1 = __importStar(require("badmfck-signal"));
+const BaseService_1 = require("./BaseService");
+const LogService_1 = require("./LogService");
+exports.REQ_TIMEFRAME_TASK_ADD = new badmfck_signal_1.Req(undefined, "REQ_TIMEFRAME_TASK_ADD");
+exports.S_TIMEFRAME_TASK_EXECUTED = new badmfck_signal_1.default("S_TIMEFRAME_TASK_EXECUTED");
+class TimeframeService extends BaseService_1.BaseService {
+    TICK_INTERVAL_MS = 1000;
+    RETRY_DELAY_MS = 10_000;
+    GRACE_WINDOW_MS = 30_000;
+    tasks = [];
+    intervalId = 0;
+    static async wait(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    constructor() {
+        super("TimeframeService");
+    }
+    async init() {
+        super.init();
+        exports.REQ_TIMEFRAME_TASK_ADD.listener = async (req) => {
+            (0, LogService_1.logInfo)("Add tack to TimeframeService: " + req.name);
+            this.tasks.push(req);
+        };
+        this.intervalId = setInterval(() => {
+            this.loop();
+        }, this.TICK_INTERVAL_MS);
+    }
+    async finishService() {
+        clearInterval(this.intervalId);
+    }
+    async loop() {
+        const now = Date.now();
+        for (let i = 0; i < this.tasks.length; i++) {
+            const task = this.tasks[i];
+            if (!task)
+                continue;
+            if (now >= task.start && (!task.executed || task.executed < task.start)) {
+                if (now - task.start <= this.GRACE_WINDOW_MS) {
+                    try {
+                        (0, LogService_1.logInfo)("Timeframe Servie - execute task ", task.name);
+                        if (task.callback.length > 0 && task.params)
+                            task.callback(task.params);
+                        else
+                            task.callback();
+                        task.executed = Date.now();
+                        task.retries = 0;
+                        (0, LogService_1.logInfo)("Timeframe Servie - task executed ", task.name);
+                        if (task.repeat) {
+                            task.start += task.repeat;
+                        }
+                        else {
+                            this.tasks.splice(i, 1);
+                            i--;
+                        }
+                    }
+                    catch (e) {
+                        task.retries = (task.retries || 0) + 1;
+                        if (task.retries > (task.maxRetries ?? 0)) {
+                            console.warn(`Task ${task.name} failed too many times`);
+                            this.tasks.splice(i, 1);
+                            i--;
+                        }
+                        else {
+                            task.start = now + 10_000;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+exports.TimeframeService = TimeframeService;

package/dist/apiServer/WebsocketServerService.d.ts

@@ -0,0 +1,9 @@
+import { BaseService } from "./BaseService";
+export interface IWebsocket {
+}
+export interface IWebSocketServiceOptions {
+}
+export declare class WebsocketServerService extends BaseService {
+    constructor();
+    init(options?: IWebSocketServiceOptions): Promise<void>;
+}

package/dist/apiServer/WebsocketServerService.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketServerService = void 0;
+const BaseService_1 = require("./BaseService");
+const getDefaultWebSocketServiceOptions = () => {
+    return {
+        endpoint: "/ws"
+    };
+};
+class WebsocketServerService extends BaseService_1.BaseService {
+    constructor() {
+        super("WebsocketServerService");
+    }
+    async init(options) {
+        super.init();
+    }
+}
+exports.WebsocketServerService = WebsocketServerService;

package/dist/apiServer/helper/UID.d.ts

@@ -4,6 +4,8 @@ export declare class UID {
     private static nextUniqueTRXID;
     static generate(): string;
     static generateRandomNumberBase(count: number): string;
+    static generateNumeric(year?: string): bigint;
+    static getDateFromNumeric(uid: number | bigint): Date;
     static generateNumberic(year?: string): number;
     static getNextDescendingIndex(): number;
     static getNext(): string;

package/dist/apiServer/helper/UID.js

@@ -24,6 +24,29 @@ class UID {
             base += Math.round(Math.random() * 9);
         return base;
     }
+    static generateNumeric(year) {
+        if (!year)
+            year = new Date().getFullYear().toString();
+        const yearSuffix = year.substring(2);
+        const now = BigInt(Date.now());
+        const delta = now - BigInt(UID.epoch);
+        const counter = UID.nextUniqueID++;
+        if (UID.nextUniqueID > 99) {
+            UID.nextUniqueID = 1;
+        }
+        const counterStr = counter.toString().padStart(2, '0');
+        const idStr = `${yearSuffix}${delta.toString()}${counterStr}`;
+        return BigInt(idStr);
+    }
+    static getDateFromNumeric(uid) {
+        const uidStr = uid.toString();
+        const yearSuffix = uidStr.substring(0, 2);
+        const counterDigits = 2;
+        const deltaStr = uidStr.substring(2, uidStr.length - counterDigits);
+        const delta = BigInt(deltaStr);
+        const timestamp = BigInt(UID.epoch) + delta;
+        return new Date(Number(timestamp));
+    }
     static generateNumberic(year) {
         if (!year)
             year = new Date().getFullYear() + "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "3.7.3",
+  "version": "3.7.4",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",