@ug.software/opposer 3.0.10

package/lib/esm/server/core/index.js

@@ -0,0 +1,103 @@
+import http from 'http';
+import system from '../../system/index.js';
+import Context from '../../persistent/context/index.js';
+export class OpposerServer {
+    constructor() {
+        this.middlewares = [];
+        this.settings = system.getSettingsFile();
+    }
+    use(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+    async runMiddlewares(req, res) {
+        let index = 0;
+        const next = async () => {
+            if (index < this.middlewares.length) {
+                const middleware = this.middlewares[index++];
+                await middleware(req, res, next);
+            }
+        };
+        await next();
+    }
+    async handleRequest(req, res) {
+        const extendedReq = req;
+        const extendedRes = res;
+        await Context.run({ server: this, req: extendedReq, res: extendedRes }, async () => {
+            // Inject server instance into request for easy access
+            extendedReq.server = this;
+            // Request properties
+            extendedReq.ip = req.socket.remoteAddress;
+            extendedReq.cookies = this.parseCookies(req.headers.cookie || '');
+            // Response helpers
+            extendedRes.status = (code) => {
+                extendedRes.statusCode = code;
+                return extendedRes;
+            };
+            extendedRes.json = (data) => {
+                if (!res.writableEnded) {
+                    extendedRes.setHeader('Content-Type', 'application/json');
+                    extendedRes.end(JSON.stringify(data));
+                }
+            };
+            extendedRes.send = (data) => {
+                if (!res.writableEnded) {
+                    if (typeof data === 'object')
+                        return extendedRes.json(data);
+                    extendedRes.end(data);
+                }
+            };
+            extendedRes.cookie = (name, value, options = {}) => {
+                let cookieStr = `${name}=${value}`;
+                if (options.httpOnly)
+                    cookieStr += '; HttpOnly';
+                if (options.secure)
+                    cookieStr += '; Secure';
+                if (options.path)
+                    cookieStr += `; Path=${options.path}`;
+                if (options.expires)
+                    cookieStr += `; Expires=${options.expires.toUTCString()}`;
+                if (options.sameSite)
+                    cookieStr += `; SameSite=${options.sameSite}`;
+                const existing = res.getHeader('Set-Cookie');
+                if (!existing) {
+                    res.setHeader('Set-Cookie', [cookieStr]);
+                }
+                else {
+                    const cookies = Array.isArray(existing) ? existing : [String(existing)];
+                    cookies.push(cookieStr);
+                    res.setHeader('Set-Cookie', cookies);
+                }
+            };
+            extendedRes.clearCookie = (name, options = {}) => {
+                extendedRes.cookie(name, '', { ...options, expires: new Date(0) });
+            };
+            try {
+                await this.runMiddlewares(extendedReq, extendedRes);
+            }
+            catch (error) {
+                console.error('[core] Server error:', error);
+                if (!res.writableEnded) {
+                    extendedRes.status(500).json({ message: error.message || 'Internal Server Error' });
+                }
+            }
+        });
+    }
+    parseCookies(cookieHeader) {
+        const cookies = {};
+        cookieHeader.split(';').forEach((cookie) => {
+            const parts = cookie.split('=');
+            if (parts.length === 2) {
+                cookies[parts[0].trim()] = parts[1].trim();
+            }
+        });
+        return cookies;
+    }
+    listen(port, callback) {
+        const server = http.createServer((req, res) => this.handleRequest(req, res));
+        server.listen(port, callback);
+        return server;
+    }
+}
+const instance = new OpposerServer();
+export default instance;

package/lib/esm/server/core/middleware/body-parser.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from "../index.js";
+export default function bodyParser(): Middleware;

package/lib/esm/server/core/middleware/body-parser.js

@@ -0,0 +1,24 @@
+export default function bodyParser() {
+    return async (req, res, next) => {
+        if (req.method === "POST" || req.method === "PUT") {
+            const chunks = [];
+            req.on("data", (chunk) => chunks.push(chunk));
+            req.on("end", () => {
+                const bodyStr = Buffer.concat(chunks).toString();
+                try {
+                    if (bodyStr) {
+                        req.body = JSON.parse(bodyStr);
+                    }
+                }
+                catch (e) {
+                    console.error("[core] JSON parsing error:", e);
+                    req.body = {};
+                }
+                next();
+            });
+        }
+        else {
+            next();
+        }
+    };
+}

package/lib/esm/server/core/middleware/cors.d.ts

@@ -0,0 +1,4 @@
+import { Middleware } from "../index.js";
+export default function cors(options?: {
+    origin: string | string[];
+}): Middleware;

package/lib/esm/server/core/middleware/cors.js

@@ -0,0 +1,29 @@
+export default function cors(options) {
+    return (req, res, next) => {
+        const originHeader = req.headers.origin;
+        let allowedOrigin = "*";
+        if (options?.origin) {
+            if (Array.isArray(options.origin)) {
+                if (originHeader && options.origin.includes(originHeader)) {
+                    allowedOrigin = originHeader;
+                }
+                else {
+                    allowedOrigin = options.origin[0]; // Fallback to first one
+                }
+            }
+            else {
+                allowedOrigin = options.origin;
+            }
+        }
+        res.setHeader("Access-Control-Allow-Origin", allowedOrigin);
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, opposer-key");
+        res.setHeader("Access-Control-Allow-Credentials", "true");
+        if (req.method === "OPTIONS") {
+            res.statusCode = 204;
+            res.end();
+            return;
+        }
+        next();
+    };
+}

package/lib/esm/server/core/middleware/logger.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from "../index.js";
+export default function logger(): Middleware;

package/lib/esm/server/core/middleware/logger.js

@@ -0,0 +1,12 @@
+export default function logger() {
+    return (req, res, next) => {
+        const start = Date.now();
+        const { method, url } = req;
+        res.on("finish", () => {
+            const duration = Date.now() - start;
+            const status = res.statusCode;
+            console.log(`[${new Date().toISOString()}] ${method} ${url} - ${status} (${duration}ms)`);
+        });
+        next();
+    };
+}

package/lib/esm/server/decorators/controller.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export default function Controller(name: string): (constructor: Object) => void;
+export declare function getControllerMetadata(target: Object): any;

package/lib/esm/server/decorators/controller.js

@@ -0,0 +1,10 @@
+import "reflect-metadata";
+const CONTROLLER_KEY = Symbol("controller");
+export default function Controller(name) {
+    return function (constructor) {
+        Reflect.defineMetadata(CONTROLLER_KEY, { name }, constructor);
+    };
+}
+export function getControllerMetadata(target) {
+    return Reflect.getMetadata(CONTROLLER_KEY, target) || [];
+}

package/lib/esm/server/decorators/field.d.ts

@@ -0,0 +1,2 @@
+export default function Field(model: any): (target: Object, name: string, context?: any) => void;
+export declare function getFieldsMetadata(target: Object): any[];

package/lib/esm/server/decorators/field.js

@@ -0,0 +1,32 @@
+import { Field as OrmField, MetadataStore } from "../../orm/index.js";
+const FIELD_KEY = Symbol("field");
+export default function Field(model) {
+    return (target, name, context) => {
+        // 1. Legacy server metadata (for existing code that uses getFieldsMetadata)
+        const fields = Reflect.getMetadata(FIELD_KEY, target.constructor) || [];
+        fields.push({ name, model: typeof model === 'function' ? model() : model });
+        Reflect.defineMetadata(FIELD_KEY, fields, target.constructor);
+        // 2. ORM metadata (calling the ORM decorator logic)
+        const ormDecorator = OrmField(typeof model === 'function' ? { validation: model } : model);
+        return ormDecorator(target, name);
+    };
+}
+export function getFieldsMetadata(target) {
+    // Try to get from the constructor if target is an instance
+    const constructor = typeof target === 'function' ? target : target.constructor;
+    // 1. Get from legacy metadata
+    const legacyFields = Reflect.getMetadata(FIELD_KEY, constructor) || [];
+    // 2. Get from ORM MetadataStore
+    const ormFields = MetadataStore.getFields(constructor).map(f => ({
+        name: f.name,
+        model: { type: f.type }
+    }));
+    // Combine and remove duplicates (by name)
+    const allFields = [...legacyFields];
+    ormFields.forEach(of => {
+        if (!allFields.find(lf => lf.name === of.name)) {
+            allFields.push(of);
+        }
+    });
+    return allFields;
+}

package/lib/esm/server/decorators/handler.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export default function Controller(name: string): (constructor: Object) => void;
+export declare function getControllerMetadata(target: Object): any;

package/lib/esm/server/decorators/handler.js

@@ -0,0 +1,10 @@
+import "reflect-metadata";
+const CONTROLLER_KEY = Symbol("controller");
+export default function Controller(name) {
+    return function (constructor) {
+        Reflect.defineMetadata(CONTROLLER_KEY, { name }, constructor);
+    };
+}
+export function getControllerMetadata(target) {
+    return Reflect.getMetadata(CONTROLLER_KEY, target) || [];
+}

package/lib/esm/server/decorators/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Method, getMethodMetadata } from "./method.js";
+export { default as Controller, getControllerMetadata } from "./controller.js";
+export { default as Payload, getPayloadMetadata } from "./payload.js";
+export { default as IsPublic, getIsPublicMetadata } from "./is-public.js";
+export { default as IsPublicMethod, getIsPublicMethodMetadata, } from "./is-public-method.js";
+export { default as Field, getFieldsMetadata } from "./field.js";
+export { f } from "../../orm/index.js";

package/lib/esm/server/decorators/index.js

@@ -0,0 +1,7 @@
+export { default as Method, getMethodMetadata } from "./method.js";
+export { default as Controller, getControllerMetadata } from "./controller.js";
+export { default as Payload, getPayloadMetadata } from "./payload.js";
+export { default as IsPublic, getIsPublicMetadata } from "./is-public.js";
+export { default as IsPublicMethod, getIsPublicMethodMetadata, } from "./is-public-method.js";
+export { default as Field, getFieldsMetadata } from "./field.js";
+export { f } from "../../orm/index.js";

package/lib/esm/server/decorators/is-public-method.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export default function IsPublicMethod(): (target: Object, name: string, context: any) => void;
+export declare function getIsPublicMethodMetadata(target: Object): any;

package/lib/esm/server/decorators/is-public-method.js

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+const PUBLIC_METHOD_KEY = Symbol("method");
+export default function IsPublicMethod() {
+    return function (target, name, context) {
+        const methods = Reflect.getMetadata(PUBLIC_METHOD_KEY, target.constructor) || [];
+        methods.push({ name });
+        Reflect.defineMetadata(PUBLIC_METHOD_KEY, methods, target.constructor);
+    };
+}
+export function getIsPublicMethodMetadata(target) {
+    return Reflect.getMetadata(PUBLIC_METHOD_KEY, target) || [];
+}

package/lib/esm/server/decorators/is-public.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export default function IsPublic(): ClassDecorator;
+export declare function getIsPublicMetadata(target: Object): boolean;

package/lib/esm/server/decorators/is-public.js

@@ -0,0 +1,10 @@
+import "reflect-metadata";
+const PUBLIC_KEY = Symbol("is-public");
+export default function IsPublic() {
+    return (target) => {
+        Reflect.defineMetadata(PUBLIC_KEY, true, target);
+    };
+}
+export function getIsPublicMetadata(target) {
+    return Reflect.getMetadata(PUBLIC_KEY, target) === true;
+}

package/lib/esm/server/decorators/method.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export default function Method(): (target: Object, name: string, context: any) => void;
+export declare function getMethodMetadata(target: Object): any;

package/lib/esm/server/decorators/method.js

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+const METHOD_KEY = Symbol("method");
+export default function Method() {
+    return function (target, name, context) {
+        const methods = Reflect.getMetadata(METHOD_KEY, target.constructor) || [];
+        methods.push({ name });
+        Reflect.defineMetadata(METHOD_KEY, methods, target.constructor);
+    };
+}
+export function getMethodMetadata(target) {
+    return Reflect.getMetadata(METHOD_KEY, target) || [];
+}

package/lib/esm/server/decorators/payload.d.ts

@@ -0,0 +1,3 @@
+import { ClassType } from "../../interfaces/system";
+export default function Payload<T>(dto: ClassType<T>): (target: Object, name: string, context: any) => void;
+export declare function getPayloadMetadata(target: Object): any;

package/lib/esm/server/decorators/payload.js

@@ -0,0 +1,11 @@
+const PAYLOAD_KEY = Symbol("method");
+export default function Payload(dto) {
+    return function (target, name, context) {
+        const payloads = Reflect.getMetadata(PAYLOAD_KEY, target.constructor) || [];
+        payloads.push({ name, dto });
+        Reflect.defineMetadata(PAYLOAD_KEY, payloads, target.constructor);
+    };
+}
+export function getPayloadMetadata(target) {
+    return Reflect.getMetadata(PAYLOAD_KEY, target) || [];
+}

package/lib/esm/server/handlers/index.d.ts

@@ -0,0 +1,5 @@
+import { ResultGetAllControllers } from "../../interfaces/controller.js";
+import { ClassType } from "../../interfaces/system.js";
+export declare function toKebabCase(str: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function loadControllers(customControllers?: string | ClassType<unknown>[]): Promise<ResultGetAllControllers>;

package/lib/esm/server/handlers/index.js

@@ -0,0 +1,31 @@
+import system from "../../system/index.js";
+import * as decorator from "../decorators/index.js";
+const controllers = {};
+export function toKebabCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2") // adiciona hífen antes de maiúsculas
+        .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2") // caso AAAa
+        .toLowerCase();
+}
+export function toCamelCase(str) {
+    return str
+        .toLowerCase()
+        .replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+// function responsible per cache controllers in project;
+export async function loadControllers(customControllers) {
+    var __allControllers = await system.getAllControllers(customControllers);
+    if (Array.isArray(__allControllers) && Object.keys(controllers).length === 0) {
+        return __allControllers.reduce((controllers, controller) => {
+            var controllerMetadata = decorator.getControllerMetadata(controller);
+            var methodsMetadata = decorator.getMethodMetadata(controller);
+            controllers[controllerMetadata.name] = {
+                metadata: controllerMetadata,
+                methods: Array.isArray(methodsMetadata) ? methodsMetadata : [],
+                controller: controller,
+            };
+            return controllers;
+        }, controllers);
+    }
+    return controllers;
+}

package/lib/esm/server/helpers/index.d.ts

@@ -0,0 +1,17 @@
+import { HandleRequestResultError } from "../../interfaces/request.js";
+export declare function Success(data: any): {
+    readonly success: true;
+    readonly data: any;
+};
+export declare function Exception(error: HandleRequestResultError["error"]): {
+    readonly success: false;
+    readonly error: {
+        name: string;
+        code: number;
+        message: any;
+    };
+};
+/**
+ * Validates data against a model (Entity or DTO) decorated with @Field
+ */
+export declare function validateData(model: any, values: Record<string, any>): Record<string, string[]>;

package/lib/esm/server/helpers/index.js

@@ -0,0 +1,34 @@
+import { MetadataStore } from "../../orm/index.js";
+export function Success(data) {
+    return {
+        success: true,
+        data,
+    };
+}
+export function Exception(error) {
+    return {
+        success: false,
+        error: error,
+    };
+}
+/**
+ * Validates data against a model (Entity or DTO) decorated with @Field
+ */
+export function validateData(model, values) {
+    const errors = {};
+    // Get fields from MetadataStore (supports both legacy and new ORM decorators)
+    const fields = MetadataStore.getFields(model);
+    for (const field of fields) {
+        const value = values[field.name || field.propertyKey];
+        if (field.validation) {
+            const validator = typeof field.validation === 'function' ? field.validation() : field.validation;
+            if (validator && typeof validator.validate === 'function') {
+                const fieldErrors = validator.validate(value, values);
+                if (fieldErrors && fieldErrors.length > 0) {
+                    errors[field.name || field.propertyKey] = fieldErrors;
+                }
+            }
+        }
+    }
+    return errors;
+}

package/lib/esm/server/index.d.ts

@@ -0,0 +1,12 @@
+import { CreateServerProps, ServerInstance } from '../interfaces/server.js';
+import Auth from './security/controller/auth.js';
+export default function Server(props: CreateServerProps): Promise<ServerInstance>;
+export declare const auth: {
+    social: typeof Auth.social;
+};
+export * from './constants/index.js';
+export * from './helpers/index.js';
+export type { ModelResult } from '../interfaces/model.js';
+export { Method, Controller, Field, Payload, IsPublic, IsPublicMethod, f } from './decorators/index.js';
+export type { PayloadRequest } from '../interfaces/controller.js';
+export { default as Context } from './context/index.js';

package/lib/esm/server/index.js

@@ -0,0 +1,147 @@
+import Controller from './controller/index.js';
+import system from '../system/index.js';
+import permission from './security/middleware/permission.js';
+import autorization from './security/middleware/autorization.js';
+import Auth from './security/controller/auth.js';
+import scheduler from '../scheduler/index.js';
+import { OpposerDatabase, PostgresDriver, SQLiteDriver, MySQLDriver } from '../orm/index.js';
+// Core
+import opposerServer from './core/index.js';
+import corsMiddleware from './core/middleware/cors.js';
+import bodyParser from './core/middleware/body-parser.js';
+import loggerMiddleware from './core/middleware/logger.js';
+import Context from './context/index.js';
+// Playground
+import Playground from '../playground/index.js';
+async function initializeDatabase(props, models) {
+    const settings = system.getSettingsFile();
+    const allModels = await system.getAllModels(models);
+    const entities = allModels.map((x) => x.entity);
+    let driver;
+    const type = props.type || settings.database?.type;
+    switch (type) {
+        case 'postgres':
+            driver = new PostgresDriver(props);
+            break;
+        case 'sqlite':
+            driver = new SQLiteDriver(props);
+            break;
+        case 'mysql':
+            driver = new MySQLDriver(props);
+            break;
+        default:
+            throw new Error(`[database] Unsupported database type: ${type}`);
+    }
+    const db = new OpposerDatabase(driver, entities);
+    await db.connect();
+    return db;
+}
+async function ensureManager(db, settings, models) {
+    if (!settings.auth)
+        return;
+    try {
+        const allModels = await system.getAllModels(models);
+        const userEntity = allModels.find((x) => x.name === 'User' || x.name === 'usr');
+        const roleEntity = allModels.find((x) => x.name === 'Role' || x.name === 'rl');
+        if (userEntity && roleEntity) {
+            const userRepository = db.getRepository(userEntity.entity);
+            const roleRepository = db.getRepository(roleEntity.entity);
+            let login = process.env.MANAGER_LOGIN || settings.manager?.login;
+            let firstName = process.env.MANAGER_FIRST_NAME || settings.manager?.firstName;
+            let lastName = process.env.MANAGER_LAST_NAME || settings.manager?.lastName;
+            let password = process.env.MANAGER_PASSWORD || settings.manager?.password;
+            let manager = await userRepository.findOne({
+                where: { lg: login },
+            });
+            if (!manager) {
+                console.log('-> Creating manager account.');
+                manager = await userRepository.insert({
+                    fn: firstName,
+                    ln: lastName,
+                    lg: login,
+                    ps: password,
+                    ac: true,
+                });
+            }
+            const hasAllRole = await roleRepository.findOne({
+                where: { usr: manager.id, sm: 'all', mt: 'all' },
+            });
+            if (!hasAllRole) {
+                console.log('-> Creating all-access role for manager.');
+                await roleRepository.insert({
+                    usr: manager.id,
+                    sm: 'all',
+                    mt: 'all',
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error('[database] Manager creation failed:', error);
+    }
+}
+export default async function Server(props) {
+    console.log('-> Initializing database connection.');
+    const settings = system.getSettingsFile();
+    if (!settings.database) {
+        throw new Error('-> It is necessary to inform database properties.');
+    }
+    const db = await initializeDatabase(settings.database, props.models);
+    await ensureManager(db, settings, props.models);
+    // Store database in server context
+    Context.set('db', db);
+    Context.set('models', props.models);
+    Context.set('controllers', props.controllers);
+    console.log('-> Initializing scheduler.');
+    await scheduler.initialize(props.schedules);
+    scheduler.start();
+    console.log('-> Initializing core server.');
+    let url = '/opposer';
+    if (settings.url) {
+        url = settings.url;
+    }
+    // 1. Logger
+    if (settings.logger) {
+        opposerServer.use(loggerMiddleware());
+    }
+    // 2. CORS (Global)
+    if (props.cors || settings.cors) {
+        opposerServer.use(corsMiddleware(props.cors || settings.cors));
+    }
+    // 3. Body Parser
+    opposerServer.use(bodyParser());
+    // 4. Playground
+    opposerServer.use(Playground);
+    // 5. Auth/Security Middlewares
+    if (settings.auth) {
+        opposerServer.use(autorization);
+        opposerServer.use(permission);
+    }
+    // 6. Main Route Handler
+    opposerServer.use(async (req, res, next) => {
+        if (req.url === url && req.method === 'POST') {
+            await Controller(req, res);
+        }
+        else {
+            next();
+        }
+    });
+    // 7. 404 Handler
+    opposerServer.use((req, res) => {
+        res.status(404).json({ message: `Route ${req.method} ${req.url} not found` });
+    });
+    function initialize() {
+        opposerServer.listen(settings.port, () => {
+            console.log(`⚡Opposer Core is running in port ${settings.port}`);
+        });
+    }
+    return {
+        opposer: opposerServer,
+        initialize,
+    };
+}
+export const auth = { social: Auth.social };
+export * from './constants/index.js';
+export * from './helpers/index.js';
+export { Method, Controller, Field, Payload, IsPublic, IsPublicMethod, f } from './decorators/index.js';
+export { default as Context } from './context/index.js';