@ug.software/opposer 3.0.10

package/lib/cjs/playground/index.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Playground;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const index_js_1 = __importDefault(require("../system/index.js"));
+const index_js_2 = require("../server/decorators/index.js");
+const index_js_3 = require("../orm/index.js");
+const index_js_4 = require("../server/index.js");
+// @ts-ignore
+const _dirname = typeof __dirname !== 'undefined'
+    ? __dirname
+    : // @ts-ignore
+        path_1.default.dirname((0, url_1.fileURLToPath)(import.meta.url));
+async function generateMap(server, models, controllers) {
+    var map = {
+        models: {},
+        controllers: {},
+    };
+    var allModels = await index_js_1.default.getAllModels(models);
+    const internalModels = ['usr', 'rl', 'se', 'ke', 'crp', 'sh', 'User', 'Role', 'Session', 'Key', 'ChangeRequestPassword', 'ScheduleHistory'];
+    if (Array.isArray(allModels)) {
+        var modelsMap = allModels
+            .filter((m) => !internalModels.includes(m.name))
+            .reduce((__models, m) => {
+            var fields = (0, index_js_2.getFieldsMetadata)(m.entity);
+            const meta = index_js_3.MetadataStore.getEntity(m.entity);
+            if (Array.isArray(fields)) {
+                var model = fields.reduce((__model, field) => {
+                    __model[field.name] = field.model?.type || 'string';
+                    return __model;
+                }, {});
+                __models[m.name] = {
+                    description: meta?.description || 'Database Entity Definition',
+                    model: model,
+                };
+            }
+            return __models;
+        }, {});
+        map.models = modelsMap;
+    }
+    var allControllers = await index_js_1.default.getAllControllers(controllers);
+    if (Array.isArray(allControllers)) {
+        var controllersMap = allControllers.reduce((__controllers, controller) => {
+            var controllerMetadata = (0, index_js_2.getControllerMetadata)(controller);
+            var allMethods = (0, index_js_2.getMethodMetadata)(controller);
+            var allPayloads = (0, index_js_2.getPayloadMetadata)(controller);
+            if (Array.isArray(allMethods)) {
+                var methods = allMethods.reduce((__methods, method) => {
+                    var payload = allPayloads.find((x) => x.name === method.name);
+                    if (payload) {
+                        var fields = (0, index_js_2.getFieldsMetadata)(payload.dto);
+                        if (Array.isArray(fields)) {
+                            __methods[method.name] = {
+                                payload: fields.reduce((__fields, field) => {
+                                    __fields[field.name] = field.model?.type || 'string';
+                                    return __fields;
+                                }, {}),
+                            };
+                        }
+                    }
+                    return __methods;
+                }, {});
+                __controllers[controllerMetadata.name] = methods;
+            }
+            return __controllers;
+        }, {});
+        map.controllers = controllersMap;
+        const mapPath = path_1.default.resolve(process.cwd(), 'opposer-map.json');
+        fs_1.default.writeFileSync(mapPath, JSON.stringify(map, null, 2));
+        return map;
+    }
+    return map;
+}
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.js': 'text/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+};
+async function Playground(req, res, next) {
+    const server = req.server;
+    const models = index_js_4.Context.get('models');
+    const controllers = index_js_4.Context.get('controllers');
+    // Public map endpoint for the Swagger UI
+    if (req.url === '/opposer-map.json') {
+        const map = await generateMap(server, models, controllers);
+        res.status(200).json(map);
+        return;
+    }
+    // Base playground route - Serve static files from build/client
+    if (req.url.startsWith('/playground')) {
+        await generateMap(server, models, controllers);
+        const _buildPath = path_1.default.resolve(_dirname, 'build', 'client');
+        let relativePath = req.url.replace('/playground', '');
+        if (relativePath === '' || relativePath === '/') {
+            relativePath = '/index.html';
+        }
+        let filePath = path_1.default.join(_buildPath, relativePath);
+        // If file doesn't exist, fallback to index.html only if it's a likely page request
+        if (!fs_1.default.existsSync(filePath) || fs_1.default.statSync(filePath).isDirectory()) {
+            const isAsset = /\.(js|css|png|jpg|gif|svg|ico|json|map)$/.test(relativePath);
+            if (!isAsset) {
+                filePath = path_1.default.join(_buildPath, 'index.html');
+            }
+            else {
+                res.status(404).json({ message: `Asset ${relativePath} not found.` });
+                return;
+            }
+        }
+        const ext = path_1.default.extname(filePath).toLowerCase();
+        const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+        try {
+            console.log('filePath', filePath);
+            const content = fs_1.default.readFileSync(filePath);
+            res.setHeader('Content-Type', contentType);
+            res.status(200).end(content);
+        }
+        catch (error) {
+            console.log('error', error);
+            res.status(500).json({ message: 'Error serving playground file.' });
+        }
+        return;
+    }
+    next();
+}

package/lib/cjs/scheduler/controllers/index.d.ts

@@ -0,0 +1,19 @@
+import { PayloadRequest } from '../../interfaces/controller.js';
+export default class SchedulerController {
+    private get db();
+    listTasks(): Promise<{
+        readonly success: true;
+        readonly data: any;
+    }>;
+    getHistory(): Promise<{
+        readonly success: true;
+        readonly data: any;
+    }>;
+    runTask(payload: PayloadRequest<{
+        name: string;
+        data?: any;
+    }>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    }>;
+}

package/lib/cjs/scheduler/controllers/index.js

@@ -0,0 +1,62 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../server/decorators/index.js");
+const index_js_2 = require("../../server/helpers/index.js");
+const index_js_3 = __importDefault(require("../index.js"));
+const history_js_1 = __importDefault(require("../models/history.js"));
+const index_js_4 = require("../../server/index.js");
+let SchedulerController = class SchedulerController {
+    get db() {
+        return index_js_4.Context.get('db');
+    }
+    async listTasks() {
+        return (0, index_js_2.Success)(index_js_3.default.getTasks());
+    }
+    async getHistory() {
+        const historyRepo = this.db.getRepository(history_js_1.default);
+        const history = await historyRepo.find({
+            pagination: { page: 0, take: 50 }, // Last 50 runs
+        });
+        const sortedHistory = history.sort((a, b) => new Date(b.st).getTime() - new Date(a.st).getTime());
+        return (0, index_js_2.Success)(sortedHistory);
+    }
+    async runTask(payload) {
+        const { name, data } = payload.data;
+        const result = await index_js_3.default.runTask(name, data);
+        return (0, index_js_2.Success)(result);
+    }
+};
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerController.prototype, "listTasks", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerController.prototype, "getHistory", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SchedulerController.prototype, "runTask", null);
+SchedulerController = __decorate([
+    (0, index_js_1.Controller)('scheduler')
+], SchedulerController);
+exports.default = SchedulerController;

package/lib/cjs/scheduler/decorators/index.d.ts

@@ -0,0 +1,9 @@
+import "reflect-metadata";
+export declare const SCHEDULE_METADATA_KEY: unique symbol;
+export interface ScheduleOptions {
+    name: string;
+    interval: number;
+    enabled?: boolean;
+}
+export declare function Schedule(options: ScheduleOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function getScheduleMetadata(target: any): any;

package/lib/cjs/scheduler/decorators/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEDULE_METADATA_KEY = void 0;
+exports.Schedule = Schedule;
+exports.getScheduleMetadata = getScheduleMetadata;
+require("reflect-metadata");
+exports.SCHEDULE_METADATA_KEY = Symbol("opposer:schedule");
+function Schedule(options) {
+    return (target, propertyKey, descriptor) => {
+        const schedules = Reflect.getMetadata(exports.SCHEDULE_METADATA_KEY, target.constructor) || [];
+        schedules.push({
+            ...options,
+            propertyKey,
+            enabled: options.enabled !== false,
+        });
+        Reflect.defineMetadata(exports.SCHEDULE_METADATA_KEY, schedules, target.constructor);
+    };
+}
+function getScheduleMetadata(target) {
+    return Reflect.getMetadata(exports.SCHEDULE_METADATA_KEY, target) || [];
+}

package/lib/cjs/scheduler/handlers/index.d.ts

@@ -0,0 +1,19 @@
+import { PayloadRequest } from '../../interfaces/controller.js';
+export default class SchedulerHandler {
+    private get db();
+    listTasks(): Promise<{
+        readonly success: true;
+        readonly data: any;
+    }>;
+    getHistory(): Promise<{
+        readonly success: true;
+        readonly data: any;
+    }>;
+    runTask(payload: PayloadRequest<{
+        name: string;
+        data?: any;
+    }>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    }>;
+}

package/lib/cjs/scheduler/handlers/index.js

@@ -0,0 +1,62 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../server/decorators/index.js");
+const index_js_2 = require("../../server/helpers/index.js");
+const index_js_3 = __importDefault(require("../index.js"));
+const history_js_1 = __importDefault(require("../models/history.js"));
+const index_js_4 = require("../../server/index.js");
+let SchedulerHandler = class SchedulerHandler {
+    get db() {
+        return index_js_4.Context.get('db');
+    }
+    async listTasks() {
+        return (0, index_js_2.Success)(index_js_3.default.getTasks());
+    }
+    async getHistory() {
+        const historyRepo = this.db.getRepository(history_js_1.default);
+        const history = await historyRepo.find({
+            pagination: { page: 0, take: 50 }, // Last 50 runs
+        });
+        const sortedHistory = history.sort((a, b) => new Date(b.st).getTime() - new Date(a.st).getTime());
+        return (0, index_js_2.Success)(sortedHistory);
+    }
+    async runTask(payload) {
+        const { name, data } = payload.data;
+        const result = await index_js_3.default.runTask(name, data);
+        return (0, index_js_2.Success)(result);
+    }
+};
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerHandler.prototype, "listTasks", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerHandler.prototype, "getHistory", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SchedulerHandler.prototype, "runTask", null);
+SchedulerHandler = __decorate([
+    (0, index_js_1.Controller)('scheduler')
+], SchedulerHandler);
+exports.default = SchedulerHandler;

package/lib/cjs/scheduler/index.d.ts

@@ -0,0 +1,24 @@
+import { ClassType } from "../interfaces/system.js";
+export * from "./decorators/index.js";
+export interface RegisteredTask {
+    name: string;
+    interval: number;
+    propertyKey: string;
+    target: any;
+    instance: any;
+    timer?: NodeJS.Timeout;
+}
+export declare class Scheduler {
+    private tasks;
+    private get db();
+    initialize(customSchedules?: string | ClassType<unknown>[]): Promise<void>;
+    start(): void;
+    runTask(name: string, data?: any): Promise<any>;
+    getTasks(): {
+        name: string;
+        interval: number;
+        enabled: boolean;
+    }[];
+}
+declare const _default: Scheduler;
+export default _default;

package/lib/cjs/scheduler/index.js

@@ -0,0 +1,110 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+const index_js_1 = __importDefault(require("../system/index.js"));
+const index_js_2 = require("./decorators/index.js");
+const history_js_1 = __importDefault(require("./models/history.js"));
+const crypto_1 = require("crypto");
+const index_js_3 = __importDefault(require("../server/context/index.js"));
+__exportStar(require("./decorators/index.js"), exports);
+class Scheduler {
+    constructor() {
+        this.tasks = new Map();
+    }
+    get db() {
+        return index_js_3.default.get("db");
+    }
+    async initialize(customSchedules) {
+        const schedules = await index_js_1.default.getAllSchedules(customSchedules);
+        for (const TargetClass of schedules) {
+            if (TargetClass && typeof TargetClass === "function") {
+                const metadata = (0, index_js_2.getScheduleMetadata)(TargetClass);
+                if (metadata.length > 0) {
+                    const instance = new TargetClass();
+                    for (const taskOptions of metadata) {
+                        if (taskOptions.enabled) {
+                            this.tasks.set(taskOptions.name, {
+                                ...taskOptions,
+                                target: TargetClass,
+                                instance,
+                            });
+                            console.log(`[scheduler] Registered task: ${taskOptions.name} (${taskOptions.interval}ms)`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    start() {
+        for (const [name, task] of this.tasks.entries()) {
+            task.timer = setInterval(() => {
+                this.runTask(name).catch((err) => console.error(`[scheduler] Error in task ${name}:`, err));
+            }, task.interval);
+        }
+        console.log("[scheduler] All tasks started.");
+    }
+    async runTask(name, data) {
+        const task = this.tasks.get(name);
+        if (!task) {
+            throw new Error(`Task ${name} not found.`);
+        }
+        const historyRepo = this.db.getRepository(history_js_1.default);
+        const startTime = new Date();
+        const historyId = (0, crypto_1.randomUUID)();
+        // Create initial history record
+        await historyRepo.insert({
+            id: historyId,
+            nm: name,
+            st: startTime,
+            sc: false,
+        });
+        try {
+            const result = await task.instance[task.propertyKey](data);
+            const endTime = new Date();
+            const duration = endTime.getTime() - startTime.getTime();
+            await historyRepo.update({ id: historyId }, {
+                ft: endTime,
+                sc: true,
+                du: duration,
+            });
+            return result;
+        }
+        catch (error) {
+            const endTime = new Date();
+            const duration = endTime.getTime() - startTime.getTime();
+            await historyRepo.update({ id: historyId }, {
+                ft: endTime,
+                sc: false,
+                er: error.message || String(error),
+                du: duration,
+            });
+            throw error;
+        }
+    }
+    getTasks() {
+        return Array.from(this.tasks.values()).map((t) => ({
+            name: t.name,
+            interval: t.interval,
+            enabled: true,
+        }));
+    }
+}
+exports.Scheduler = Scheduler;
+exports.default = new Scheduler();

package/lib/cjs/scheduler/models/history.d.ts

@@ -0,0 +1,10 @@
+export default class ScheduleHistory {
+    id: string;
+    nm: string;
+    st: Date;
+    ft?: Date;
+    sc: boolean;
+    er?: string;
+    du?: number;
+    ct: Date;
+}

package/lib/cjs/scheduler/models/history.js

@@ -0,0 +1,50 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../orm/index.js");
+let ScheduleHistory = class ScheduleHistory {
+};
+__decorate([
+    (0, index_js_1.PrimaryColumn)({ type: "uuid" }),
+    __metadata("design:type", String)
+], ScheduleHistory.prototype, "id", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().string("name is string.").required("name is required.")),
+    __metadata("design:type", String)
+], ScheduleHistory.prototype, "nm", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().date("started at is date.").required("started at is required.")),
+    __metadata("design:type", Date)
+], ScheduleHistory.prototype, "st", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().date("finished at is date.")),
+    __metadata("design:type", Date)
+], ScheduleHistory.prototype, "ft", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().boolean("success is boolean.")),
+    __metadata("design:type", Boolean)
+], ScheduleHistory.prototype, "sc", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().string("error is string.")),
+    __metadata("design:type", String)
+], ScheduleHistory.prototype, "er", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().number("duration is number.")),
+    __metadata("design:type", Number)
+], ScheduleHistory.prototype, "du", void 0);
+__decorate([
+    (0, index_js_1.CreateDateColumn)(),
+    __metadata("design:type", Date)
+], ScheduleHistory.prototype, "ct", void 0);
+ScheduleHistory = __decorate([
+    (0, index_js_1.Entity)("sh")
+], ScheduleHistory);
+exports.default = ScheduleHistory;

package/lib/cjs/server/constants/index.d.ts

@@ -0,0 +1,78 @@
+export declare enum HttpStatusCode {
+    Continue = 100,
+    SwitchingProtocols = 101,
+    Processing = 102,
+    EarlyHints = 103,
+    OK = 200,
+    Created = 201,
+    Accepted = 202,
+    NonAuthoritativeInformation = 203,
+    NoContent = 204,
+    ResetContent = 205,
+    PartialContent = 206,
+    MultiStatus = 207,
+    AlreadyReported = 208,
+    IMUsed = 226,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    PayloadTooLarge = 413,
+    URITooLong = 414,
+    UnsupportedMediaType = 415,
+    RangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    ImATeapot = 418,
+    MisdirectedRequest = 421,
+    UnprocessableEntity = 422,
+    Locked = 423,
+    FailedDependency = 424,
+    TooEarly = 425,
+    UpgradeRequired = 426,
+    PreconditionRequired = 428,
+    TooManyRequests = 429,
+    RequestHeaderFieldsTooLarge = 431,
+    UnavailableForLegalReasons = 451,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HTTPVersionNotSupported = 505,
+    VariantAlsoNegotiates = 506,
+    InsufficientStorage = 507,
+    LoopDetected = 508,
+    NotExtended = 510,
+    NetworkAuthenticationRequired = 511
+}
+export declare const HttpStatus: Record<HttpStatusCode, {
+    code: number;
+    name: string;
+    category: string;
+}>;
+export declare enum Type {
+    string = "string",
+    number = "number",
+    jsonb = "jsonb",
+    boolean = "boolean",
+    array = "array",
+    date = "date",
+    relation = "relation"
+}