@ug.software/opposer 3.0.10

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

@@ -0,0 +1,72 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKebabCase = toKebabCase;
+exports.toCamelCase = toCamelCase;
+exports.loadControllers = loadControllers;
+const index_js_1 = __importDefault(require("../../system/index.js"));
+const decorator = __importStar(require("../decorators/index.js"));
+const controllers = {};
+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();
+}
+function toCamelCase(str) {
+    return str
+        .toLowerCase()
+        .replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+// function responsible per cache controllers in project;
+async function loadControllers(customControllers) {
+    var __allControllers = await index_js_1.default.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/cjs/server/core/index.d.ts

@@ -0,0 +1,16 @@
+import http from 'http';
+import { type Request, type Response, type NextFunction, OpposerServer as IOpposerServer } from '../../interfaces/server.js';
+export { Request, Response, NextFunction };
+export type Middleware = (req: Request, res: Response, next: NextFunction) => Promise<void> | void;
+export declare class OpposerServer implements IOpposerServer {
+    private middlewares;
+    private settings;
+    constructor();
+    use(middleware: Middleware): this;
+    private runMiddlewares;
+    handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+    private parseCookies;
+    listen(port: number, callback?: () => void): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+}
+declare const instance: OpposerServer;
+export default instance;

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

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpposerServer = void 0;
+const http_1 = __importDefault(require("http"));
+const index_js_1 = __importDefault(require("../../system/index.js"));
+const index_js_2 = __importDefault(require("../../persistent/context/index.js"));
+class OpposerServer {
+    constructor() {
+        this.middlewares = [];
+        this.settings = index_js_1.default.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 index_js_2.default.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_1.default.createServer((req, res) => this.handleRequest(req, res));
+        server.listen(port, callback);
+        return server;
+    }
+}
+exports.OpposerServer = OpposerServer;
+const instance = new OpposerServer();
+exports.default = instance;

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = bodyParser;
+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/cjs/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/cjs/server/core/middleware/cors.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = cors;
+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/cjs/server/core/middleware/logger.d.ts

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logger;
+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/cjs/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/cjs/server/decorators/controller.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Controller;
+exports.getControllerMetadata = getControllerMetadata;
+require("reflect-metadata");
+const CONTROLLER_KEY = Symbol("controller");
+function Controller(name) {
+    return function (constructor) {
+        Reflect.defineMetadata(CONTROLLER_KEY, { name }, constructor);
+    };
+}
+function getControllerMetadata(target) {
+    return Reflect.getMetadata(CONTROLLER_KEY, target) || [];
+}

package/lib/cjs/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/cjs/server/decorators/field.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Field;
+exports.getFieldsMetadata = getFieldsMetadata;
+const index_js_1 = require("../../orm/index.js");
+const FIELD_KEY = Symbol("field");
+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 = (0, index_js_1.Field)(typeof model === 'function' ? { validation: model } : model);
+        return ormDecorator(target, name);
+    };
+}
+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 = index_js_1.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/cjs/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/cjs/server/decorators/handler.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Controller;
+exports.getControllerMetadata = getControllerMetadata;
+require("reflect-metadata");
+const CONTROLLER_KEY = Symbol("controller");
+function Controller(name) {
+    return function (constructor) {
+        Reflect.defineMetadata(CONTROLLER_KEY, { name }, constructor);
+    };
+}
+function getControllerMetadata(target) {
+    return Reflect.getMetadata(CONTROLLER_KEY, target) || [];
+}

package/lib/cjs/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/cjs/server/decorators/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.f = exports.getFieldsMetadata = exports.Field = exports.getIsPublicMethodMetadata = exports.IsPublicMethod = exports.getIsPublicMetadata = exports.IsPublic = exports.getPayloadMetadata = exports.Payload = exports.getControllerMetadata = exports.Controller = exports.getMethodMetadata = exports.Method = void 0;
+var method_js_1 = require("./method.js");
+Object.defineProperty(exports, "Method", { enumerable: true, get: function () { return __importDefault(method_js_1).default; } });
+Object.defineProperty(exports, "getMethodMetadata", { enumerable: true, get: function () { return method_js_1.getMethodMetadata; } });
+var controller_js_1 = require("./controller.js");
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return __importDefault(controller_js_1).default; } });
+Object.defineProperty(exports, "getControllerMetadata", { enumerable: true, get: function () { return controller_js_1.getControllerMetadata; } });
+var payload_js_1 = require("./payload.js");
+Object.defineProperty(exports, "Payload", { enumerable: true, get: function () { return __importDefault(payload_js_1).default; } });
+Object.defineProperty(exports, "getPayloadMetadata", { enumerable: true, get: function () { return payload_js_1.getPayloadMetadata; } });
+var is_public_js_1 = require("./is-public.js");
+Object.defineProperty(exports, "IsPublic", { enumerable: true, get: function () { return __importDefault(is_public_js_1).default; } });
+Object.defineProperty(exports, "getIsPublicMetadata", { enumerable: true, get: function () { return is_public_js_1.getIsPublicMetadata; } });
+var is_public_method_js_1 = require("./is-public-method.js");
+Object.defineProperty(exports, "IsPublicMethod", { enumerable: true, get: function () { return __importDefault(is_public_method_js_1).default; } });
+Object.defineProperty(exports, "getIsPublicMethodMetadata", { enumerable: true, get: function () { return is_public_method_js_1.getIsPublicMethodMetadata; } });
+var field_js_1 = require("./field.js");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return __importDefault(field_js_1).default; } });
+Object.defineProperty(exports, "getFieldsMetadata", { enumerable: true, get: function () { return field_js_1.getFieldsMetadata; } });
+var index_js_1 = require("../../orm/index.js");
+Object.defineProperty(exports, "f", { enumerable: true, get: function () { return index_js_1.f; } });

package/lib/cjs/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/cjs/server/decorators/is-public-method.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = IsPublicMethod;
+exports.getIsPublicMethodMetadata = getIsPublicMethodMetadata;
+require("reflect-metadata");
+const PUBLIC_METHOD_KEY = Symbol("method");
+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);
+    };
+}
+function getIsPublicMethodMetadata(target) {
+    return Reflect.getMetadata(PUBLIC_METHOD_KEY, target) || [];
+}

package/lib/cjs/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/cjs/server/decorators/is-public.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = IsPublic;
+exports.getIsPublicMetadata = getIsPublicMetadata;
+require("reflect-metadata");
+const PUBLIC_KEY = Symbol("is-public");
+function IsPublic() {
+    return (target) => {
+        Reflect.defineMetadata(PUBLIC_KEY, true, target);
+    };
+}
+function getIsPublicMetadata(target) {
+    return Reflect.getMetadata(PUBLIC_KEY, target) === true;
+}

package/lib/cjs/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/cjs/server/decorators/method.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Method;
+exports.getMethodMetadata = getMethodMetadata;
+require("reflect-metadata");
+const METHOD_KEY = Symbol("method");
+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);
+    };
+}
+function getMethodMetadata(target) {
+    return Reflect.getMetadata(METHOD_KEY, target) || [];
+}

package/lib/cjs/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/cjs/server/decorators/payload.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Payload;
+exports.getPayloadMetadata = getPayloadMetadata;
+const PAYLOAD_KEY = Symbol("method");
+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);
+    };
+}
+function getPayloadMetadata(target) {
+    return Reflect.getMetadata(PAYLOAD_KEY, target) || [];
+}

package/lib/cjs/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/cjs/server/handlers/index.js

@@ -0,0 +1,72 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKebabCase = toKebabCase;
+exports.toCamelCase = toCamelCase;
+exports.loadControllers = loadControllers;
+const index_js_1 = __importDefault(require("../../system/index.js"));
+const decorator = __importStar(require("../decorators/index.js"));
+const controllers = {};
+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();
+}
+function toCamelCase(str) {
+    return str
+        .toLowerCase()
+        .replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+// function responsible per cache controllers in project;
+async function loadControllers(customControllers) {
+    var __allControllers = await index_js_1.default.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/cjs/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/cjs/server/helpers/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Success = Success;
+exports.Exception = Exception;
+exports.validateData = validateData;
+const index_js_1 = require("../../orm/index.js");
+function Success(data) {
+    return {
+        success: true,
+        data,
+    };
+}
+function Exception(error) {
+    return {
+        success: false,
+        error: error,
+    };
+}
+/**
+ * Validates data against a model (Entity or DTO) decorated with @Field
+ */
+function validateData(model, values) {
+    const errors = {};
+    // Get fields from MetadataStore (supports both legacy and new ORM decorators)
+    const fields = index_js_1.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/cjs/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';