@ug.software/opposer 3.0.10

package/lib/esm/playground/index.js

@@ -0,0 +1,129 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import system from '../system/index.js';
+import { getMethodMetadata, getPayloadMetadata, getFieldsMetadata, getControllerMetadata } from '../server/decorators/index.js';
+import { MetadataStore } from '../orm/index.js';
+import { Context } from '../server/index.js';
+// @ts-ignore
+const _dirname = typeof __dirname !== 'undefined'
+    ? __dirname
+    : // @ts-ignore
+        path.dirname(fileURLToPath(import.meta.url));
+async function generateMap(server, models, controllers) {
+    var map = {
+        models: {},
+        controllers: {},
+    };
+    var allModels = await system.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 = getFieldsMetadata(m.entity);
+            const meta = 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 system.getAllControllers(controllers);
+    if (Array.isArray(allControllers)) {
+        var controllersMap = allControllers.reduce((__controllers, controller) => {
+            var controllerMetadata = getControllerMetadata(controller);
+            var allMethods = getMethodMetadata(controller);
+            var allPayloads = 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 = 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.resolve(process.cwd(), 'opposer-map.json');
+        fs.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',
+};
+export default async function Playground(req, res, next) {
+    const server = req.server;
+    const models = Context.get('models');
+    const controllers = 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.resolve(_dirname, 'build', 'client');
+        let relativePath = req.url.replace('/playground', '');
+        if (relativePath === '' || relativePath === '/') {
+            relativePath = '/index.html';
+        }
+        let filePath = path.join(_buildPath, relativePath);
+        // If file doesn't exist, fallback to index.html only if it's a likely page request
+        if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+            const isAsset = /\.(js|css|png|jpg|gif|svg|ico|json|map)$/.test(relativePath);
+            if (!isAsset) {
+                filePath = path.join(_buildPath, 'index.html');
+            }
+            else {
+                res.status(404).json({ message: `Asset ${relativePath} not found.` });
+                return;
+            }
+        }
+        const ext = path.extname(filePath).toLowerCase();
+        const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+        try {
+            console.log('filePath', filePath);
+            const content = fs.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/esm/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/esm/scheduler/controllers/index.js

@@ -0,0 +1,57 @@
+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);
+};
+import { Controller, Method } from '../../server/decorators/index.js';
+import { Success } from '../../server/helpers/index.js';
+import scheduler from '../index.js';
+import ScheduleHistory from '../models/history.js';
+import { Context } from '../../server/index.js';
+let SchedulerController = class SchedulerController {
+    get db() {
+        return Context.get('db');
+    }
+    async listTasks() {
+        return Success(scheduler.getTasks());
+    }
+    async getHistory() {
+        const historyRepo = this.db.getRepository(ScheduleHistory);
+        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 Success(sortedHistory);
+    }
+    async runTask(payload) {
+        const { name, data } = payload.data;
+        const result = await scheduler.runTask(name, data);
+        return Success(result);
+    }
+};
+__decorate([
+    Method(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerController.prototype, "listTasks", null);
+__decorate([
+    Method(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerController.prototype, "getHistory", null);
+__decorate([
+    Method(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SchedulerController.prototype, "runTask", null);
+SchedulerController = __decorate([
+    Controller('scheduler')
+], SchedulerController);
+export default SchedulerController;

package/lib/esm/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/esm/scheduler/decorators/index.js

@@ -0,0 +1,16 @@
+import "reflect-metadata";
+export const SCHEDULE_METADATA_KEY = Symbol("opposer:schedule");
+export function Schedule(options) {
+    return (target, propertyKey, descriptor) => {
+        const schedules = Reflect.getMetadata(SCHEDULE_METADATA_KEY, target.constructor) || [];
+        schedules.push({
+            ...options,
+            propertyKey,
+            enabled: options.enabled !== false,
+        });
+        Reflect.defineMetadata(SCHEDULE_METADATA_KEY, schedules, target.constructor);
+    };
+}
+export function getScheduleMetadata(target) {
+    return Reflect.getMetadata(SCHEDULE_METADATA_KEY, target) || [];
+}

package/lib/esm/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/esm/scheduler/handlers/index.js

@@ -0,0 +1,57 @@
+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);
+};
+import { Controller, Method } from '../../server/decorators/index.js';
+import { Success } from '../../server/helpers/index.js';
+import scheduler from '../index.js';
+import ScheduleHistory from '../models/history.js';
+import { Context } from '../../server/index.js';
+let SchedulerHandler = class SchedulerHandler {
+    get db() {
+        return Context.get('db');
+    }
+    async listTasks() {
+        return Success(scheduler.getTasks());
+    }
+    async getHistory() {
+        const historyRepo = this.db.getRepository(ScheduleHistory);
+        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 Success(sortedHistory);
+    }
+    async runTask(payload) {
+        const { name, data } = payload.data;
+        const result = await scheduler.runTask(name, data);
+        return Success(result);
+    }
+};
+__decorate([
+    Method(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerHandler.prototype, "listTasks", null);
+__decorate([
+    Method(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerHandler.prototype, "getHistory", null);
+__decorate([
+    Method(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SchedulerHandler.prototype, "runTask", null);
+SchedulerHandler = __decorate([
+    Controller('scheduler')
+], SchedulerHandler);
+export default SchedulerHandler;

package/lib/esm/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/esm/scheduler/index.js

@@ -0,0 +1,89 @@
+import system from "../system/index.js";
+import { getScheduleMetadata } from "./decorators/index.js";
+import ScheduleHistory from "./models/history.js";
+import { randomUUID } from "crypto";
+import Context from "../server/context/index.js";
+export * from "./decorators/index.js";
+export class Scheduler {
+    constructor() {
+        this.tasks = new Map();
+    }
+    get db() {
+        return Context.get("db");
+    }
+    async initialize(customSchedules) {
+        const schedules = await system.getAllSchedules(customSchedules);
+        for (const TargetClass of schedules) {
+            if (TargetClass && typeof TargetClass === "function") {
+                const metadata = 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(ScheduleHistory);
+        const startTime = new Date();
+        const historyId = 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,
+        }));
+    }
+}
+export default new Scheduler();

package/lib/esm/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/esm/scheduler/models/history.js

@@ -0,0 +1,48 @@
+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);
+};
+import { Entity, Field, PrimaryColumn, CreateDateColumn, f, } from "../../orm/index.js";
+let ScheduleHistory = class ScheduleHistory {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], ScheduleHistory.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("name is string.").required("name is required.")),
+    __metadata("design:type", String)
+], ScheduleHistory.prototype, "nm", void 0);
+__decorate([
+    Field(() => f().date("started at is date.").required("started at is required.")),
+    __metadata("design:type", Date)
+], ScheduleHistory.prototype, "st", void 0);
+__decorate([
+    Field(() => f().date("finished at is date.")),
+    __metadata("design:type", Date)
+], ScheduleHistory.prototype, "ft", void 0);
+__decorate([
+    Field(() => f().boolean("success is boolean.")),
+    __metadata("design:type", Boolean)
+], ScheduleHistory.prototype, "sc", void 0);
+__decorate([
+    Field(() => f().string("error is string.")),
+    __metadata("design:type", String)
+], ScheduleHistory.prototype, "er", void 0);
+__decorate([
+    Field(() => f().number("duration is number.")),
+    __metadata("design:type", Number)
+], ScheduleHistory.prototype, "du", void 0);
+__decorate([
+    CreateDateColumn(),
+    __metadata("design:type", Date)
+], ScheduleHistory.prototype, "ct", void 0);
+ScheduleHistory = __decorate([
+    Entity("sh")
+], ScheduleHistory);
+export default ScheduleHistory;

package/lib/esm/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"
+}