@ug.software/opposer 3.0.10

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

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = exports.HttpStatus = exports.HttpStatusCode = void 0;
+// Enum só com códigos
+var HttpStatusCode;
+(function (HttpStatusCode) {
+    HttpStatusCode[HttpStatusCode["Continue"] = 100] = "Continue";
+    HttpStatusCode[HttpStatusCode["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    HttpStatusCode[HttpStatusCode["Processing"] = 102] = "Processing";
+    HttpStatusCode[HttpStatusCode["EarlyHints"] = 103] = "EarlyHints";
+    HttpStatusCode[HttpStatusCode["OK"] = 200] = "OK";
+    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
+    HttpStatusCode[HttpStatusCode["Accepted"] = 202] = "Accepted";
+    HttpStatusCode[HttpStatusCode["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
+    HttpStatusCode[HttpStatusCode["ResetContent"] = 205] = "ResetContent";
+    HttpStatusCode[HttpStatusCode["PartialContent"] = 206] = "PartialContent";
+    HttpStatusCode[HttpStatusCode["MultiStatus"] = 207] = "MultiStatus";
+    HttpStatusCode[HttpStatusCode["AlreadyReported"] = 208] = "AlreadyReported";
+    HttpStatusCode[HttpStatusCode["IMUsed"] = 226] = "IMUsed";
+    HttpStatusCode[HttpStatusCode["MultipleChoices"] = 300] = "MultipleChoices";
+    HttpStatusCode[HttpStatusCode["MovedPermanently"] = 301] = "MovedPermanently";
+    HttpStatusCode[HttpStatusCode["Found"] = 302] = "Found";
+    HttpStatusCode[HttpStatusCode["SeeOther"] = 303] = "SeeOther";
+    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
+    HttpStatusCode[HttpStatusCode["UseProxy"] = 305] = "UseProxy";
+    HttpStatusCode[HttpStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    HttpStatusCode[HttpStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
+    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatusCode[HttpStatusCode["PaymentRequired"] = 402] = "PaymentRequired";
+    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    HttpStatusCode[HttpStatusCode["NotAcceptable"] = 406] = "NotAcceptable";
+    HttpStatusCode[HttpStatusCode["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+    HttpStatusCode[HttpStatusCode["RequestTimeout"] = 408] = "RequestTimeout";
+    HttpStatusCode[HttpStatusCode["Conflict"] = 409] = "Conflict";
+    HttpStatusCode[HttpStatusCode["Gone"] = 410] = "Gone";
+    HttpStatusCode[HttpStatusCode["LengthRequired"] = 411] = "LengthRequired";
+    HttpStatusCode[HttpStatusCode["PreconditionFailed"] = 412] = "PreconditionFailed";
+    HttpStatusCode[HttpStatusCode["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    HttpStatusCode[HttpStatusCode["URITooLong"] = 414] = "URITooLong";
+    HttpStatusCode[HttpStatusCode["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    HttpStatusCode[HttpStatusCode["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+    HttpStatusCode[HttpStatusCode["ExpectationFailed"] = 417] = "ExpectationFailed";
+    HttpStatusCode[HttpStatusCode["ImATeapot"] = 418] = "ImATeapot";
+    HttpStatusCode[HttpStatusCode["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    HttpStatusCode[HttpStatusCode["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    HttpStatusCode[HttpStatusCode["Locked"] = 423] = "Locked";
+    HttpStatusCode[HttpStatusCode["FailedDependency"] = 424] = "FailedDependency";
+    HttpStatusCode[HttpStatusCode["TooEarly"] = 425] = "TooEarly";
+    HttpStatusCode[HttpStatusCode["UpgradeRequired"] = 426] = "UpgradeRequired";
+    HttpStatusCode[HttpStatusCode["PreconditionRequired"] = 428] = "PreconditionRequired";
+    HttpStatusCode[HttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
+    HttpStatusCode[HttpStatusCode["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    HttpStatusCode[HttpStatusCode["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+    HttpStatusCode[HttpStatusCode["InternalServerError"] = 500] = "InternalServerError";
+    HttpStatusCode[HttpStatusCode["NotImplemented"] = 501] = "NotImplemented";
+    HttpStatusCode[HttpStatusCode["BadGateway"] = 502] = "BadGateway";
+    HttpStatusCode[HttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+    HttpStatusCode[HttpStatusCode["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+    HttpStatusCode[HttpStatusCode["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    HttpStatusCode[HttpStatusCode["InsufficientStorage"] = 507] = "InsufficientStorage";
+    HttpStatusCode[HttpStatusCode["LoopDetected"] = 508] = "LoopDetected";
+    HttpStatusCode[HttpStatusCode["NotExtended"] = 510] = "NotExtended";
+    HttpStatusCode[HttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(HttpStatusCode || (exports.HttpStatusCode = HttpStatusCode = {}));
+// Map auxiliar para obter name e category
+exports.HttpStatus = {
+    [HttpStatusCode.Continue]: {
+        code: 100,
+        name: "Continue",
+        category: "Informational",
+    },
+    [HttpStatusCode.SwitchingProtocols]: {
+        code: 101,
+        name: "SwitchingProtocols",
+        category: "Informational",
+    },
+    [HttpStatusCode.Processing]: {
+        code: 102,
+        name: "Processing",
+        category: "Informational",
+    },
+    [HttpStatusCode.EarlyHints]: {
+        code: 103,
+        name: "EarlyHints",
+        category: "Informational",
+    },
+    [HttpStatusCode.OK]: { code: 200, name: "OK", category: "Success" },
+    [HttpStatusCode.Created]: { code: 201, name: "Created", category: "Success" },
+    [HttpStatusCode.Accepted]: {
+        code: 202,
+        name: "Accepted",
+        category: "Success",
+    },
+    [HttpStatusCode.NonAuthoritativeInformation]: {
+        code: 203,
+        name: "NonAuthoritativeInformation",
+        category: "Success",
+    },
+    [HttpStatusCode.NoContent]: {
+        code: 204,
+        name: "NoContent",
+        category: "Success",
+    },
+    [HttpStatusCode.ResetContent]: {
+        code: 205,
+        name: "ResetContent",
+        category: "Success",
+    },
+    [HttpStatusCode.PartialContent]: {
+        code: 206,
+        name: "PartialContent",
+        category: "Success",
+    },
+    [HttpStatusCode.MultiStatus]: {
+        code: 207,
+        name: "MultiStatus",
+        category: "Success",
+    },
+    [HttpStatusCode.AlreadyReported]: {
+        code: 208,
+        name: "AlreadyReported",
+        category: "Success",
+    },
+    [HttpStatusCode.IMUsed]: { code: 226, name: "IMUsed", category: "Success" },
+    [HttpStatusCode.MultipleChoices]: {
+        code: 300,
+        name: "MultipleChoices",
+        category: "Redirection",
+    },
+    [HttpStatusCode.MovedPermanently]: {
+        code: 301,
+        name: "MovedPermanently",
+        category: "Redirection",
+    },
+    [HttpStatusCode.Found]: { code: 302, name: "Found", category: "Redirection" },
+    [HttpStatusCode.SeeOther]: {
+        code: 303,
+        name: "SeeOther",
+        category: "Redirection",
+    },
+    [HttpStatusCode.NotModified]: {
+        code: 304,
+        name: "NotModified",
+        category: "Redirection",
+    },
+    [HttpStatusCode.UseProxy]: {
+        code: 305,
+        name: "UseProxy",
+        category: "Redirection",
+    },
+    [HttpStatusCode.TemporaryRedirect]: {
+        code: 307,
+        name: "TemporaryRedirect",
+        category: "Redirection",
+    },
+    [HttpStatusCode.PermanentRedirect]: {
+        code: 308,
+        name: "PermanentRedirect",
+        category: "Redirection",
+    },
+    [HttpStatusCode.BadRequest]: {
+        code: 400,
+        name: "BadRequest",
+        category: "Client Error",
+    },
+    [HttpStatusCode.Unauthorized]: {
+        code: 401,
+        name: "Unauthorized",
+        category: "Client Error",
+    },
+    [HttpStatusCode.PaymentRequired]: {
+        code: 402,
+        name: "PaymentRequired",
+        category: "Client Error",
+    },
+    [HttpStatusCode.Forbidden]: {
+        code: 403,
+        name: "Forbidden",
+        category: "Client Error",
+    },
+    [HttpStatusCode.NotFound]: {
+        code: 404,
+        name: "NotFound",
+        category: "Client Error",
+    },
+    [HttpStatusCode.MethodNotAllowed]: {
+        code: 405,
+        name: "MethodNotAllowed",
+        category: "Client Error",
+    },
+    [HttpStatusCode.NotAcceptable]: {
+        code: 406,
+        name: "NotAcceptable",
+        category: "Client Error",
+    },
+    [HttpStatusCode.ProxyAuthenticationRequired]: {
+        code: 407,
+        name: "ProxyAuthenticationRequired",
+        category: "Client Error",
+    },
+    [HttpStatusCode.RequestTimeout]: {
+        code: 408,
+        name: "RequestTimeout",
+        category: "Client Error",
+    },
+    [HttpStatusCode.Conflict]: {
+        code: 409,
+        name: "Conflict",
+        category: "Client Error",
+    },
+    [HttpStatusCode.Gone]: { code: 410, name: "Gone", category: "Client Error" },
+    [HttpStatusCode.LengthRequired]: {
+        code: 411,
+        name: "LengthRequired",
+        category: "Client Error",
+    },
+    [HttpStatusCode.PreconditionFailed]: {
+        code: 412,
+        name: "PreconditionFailed",
+        category: "Client Error",
+    },
+    [HttpStatusCode.PayloadTooLarge]: {
+        code: 413,
+        name: "PayloadTooLarge",
+        category: "Client Error",
+    },
+    [HttpStatusCode.URITooLong]: {
+        code: 414,
+        name: "URITooLong",
+        category: "Client Error",
+    },
+    [HttpStatusCode.UnsupportedMediaType]: {
+        code: 415,
+        name: "UnsupportedMediaType",
+        category: "Client Error",
+    },
+    [HttpStatusCode.RangeNotSatisfiable]: {
+        code: 416,
+        name: "RangeNotSatisfiable",
+        category: "Client Error",
+    },
+    [HttpStatusCode.ExpectationFailed]: {
+        code: 417,
+        name: "ExpectationFailed",
+        category: "Client Error",
+    },
+    [HttpStatusCode.ImATeapot]: {
+        code: 418,
+        name: "ImATeapot",
+        category: "Client Error",
+    },
+    [HttpStatusCode.MisdirectedRequest]: {
+        code: 421,
+        name: "MisdirectedRequest",
+        category: "Client Error",
+    },
+    [HttpStatusCode.UnprocessableEntity]: {
+        code: 422,
+        name: "UnprocessableEntity",
+        category: "Client Error",
+    },
+    [HttpStatusCode.Locked]: {
+        code: 423,
+        name: "Locked",
+        category: "Client Error",
+    },
+    [HttpStatusCode.FailedDependency]: {
+        code: 424,
+        name: "FailedDependency",
+        category: "Client Error",
+    },
+    [HttpStatusCode.TooEarly]: {
+        code: 425,
+        name: "TooEarly",
+        category: "Client Error",
+    },
+    [HttpStatusCode.UpgradeRequired]: {
+        code: 426,
+        name: "UpgradeRequired",
+        category: "Client Error",
+    },
+    [HttpStatusCode.PreconditionRequired]: {
+        code: 428,
+        name: "PreconditionRequired",
+        category: "Client Error",
+    },
+    [HttpStatusCode.TooManyRequests]: {
+        code: 429,
+        name: "TooManyRequests",
+        category: "Client Error",
+    },
+    [HttpStatusCode.RequestHeaderFieldsTooLarge]: {
+        code: 431,
+        name: "RequestHeaderFieldsTooLarge",
+        category: "Client Error",
+    },
+    [HttpStatusCode.UnavailableForLegalReasons]: {
+        code: 451,
+        name: "UnavailableForLegalReasons",
+        category: "Client Error",
+    },
+    [HttpStatusCode.InternalServerError]: {
+        code: 500,
+        name: "InternalServerError",
+        category: "Server Error",
+    },
+    [HttpStatusCode.NotImplemented]: {
+        code: 501,
+        name: "NotImplemented",
+        category: "Server Error",
+    },
+    [HttpStatusCode.BadGateway]: {
+        code: 502,
+        name: "BadGateway",
+        category: "Server Error",
+    },
+    [HttpStatusCode.ServiceUnavailable]: {
+        code: 503,
+        name: "ServiceUnavailable",
+        category: "Server Error",
+    },
+    [HttpStatusCode.GatewayTimeout]: {
+        code: 504,
+        name: "GatewayTimeout",
+        category: "Server Error",
+    },
+    [HttpStatusCode.HTTPVersionNotSupported]: {
+        code: 505,
+        name: "HTTPVersionNotSupported",
+        category: "Server Error",
+    },
+    [HttpStatusCode.VariantAlsoNegotiates]: {
+        code: 506,
+        name: "VariantAlsoNegotiates",
+        category: "Server Error",
+    },
+    [HttpStatusCode.InsufficientStorage]: {
+        code: 507,
+        name: "InsufficientStorage",
+        category: "Server Error",
+    },
+    [HttpStatusCode.LoopDetected]: {
+        code: 508,
+        name: "LoopDetected",
+        category: "Server Error",
+    },
+    [HttpStatusCode.NotExtended]: {
+        code: 510,
+        name: "NotExtended",
+        category: "Server Error",
+    },
+    [HttpStatusCode.NetworkAuthenticationRequired]: {
+        code: 511,
+        name: "NetworkAuthenticationRequired",
+        category: "Server Error",
+    },
+};
+var Type;
+(function (Type) {
+    Type["string"] = "string";
+    Type["number"] = "number";
+    Type["jsonb"] = "jsonb";
+    Type["boolean"] = "boolean";
+    Type["array"] = "array";
+    Type["date"] = "date";
+    Type["relation"] = "relation";
+})(Type || (exports.Type = Type = {}));

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

@@ -0,0 +1,17 @@
+/**
+ * Specialized storage for Opposer Server Context.
+ * Manages global application state like database connections and model definitions.
+ */
+declare class ServerContext {
+    private static instance;
+    private data;
+    private constructor();
+    static getInstance(): ServerContext;
+    set<T>(key: string, value: T): void;
+    get<T>(key: string): T;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+}
+declare const _default: ServerContext;
+export default _default;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Specialized storage for Opposer Server Context.
+ * Manages global application state like database connections and model definitions.
+ */
+class ServerContext {
+    constructor() {
+        this.data = new Map();
+    }
+    static getInstance() {
+        if (!ServerContext.instance) {
+            ServerContext.instance = new ServerContext();
+        }
+        return ServerContext.instance;
+    }
+    set(key, value) {
+        this.data.set(key, value);
+    }
+    get(key) {
+        return this.data.get(key);
+    }
+    has(key) {
+        return this.data.has(key);
+    }
+    delete(key) {
+        return this.data.delete(key);
+    }
+    clear() {
+        this.data.clear();
+    }
+}
+exports.default = ServerContext.getInstance();

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

@@ -0,0 +1,3 @@
+import { Request, Response } from "../core/index.js";
+declare const _default: (req: Request, res: Response) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,217 @@
+"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 });
+const get_js_1 = __importDefault(require("../services/get.js"));
+const insert_js_1 = __importDefault(require("../services/insert.js"));
+const update_js_1 = __importDefault(require("../services/update.js"));
+const delete_js_1 = __importDefault(require("../services/delete.js"));
+const index_js_1 = require("../constants/index.js");
+const index_js_2 = __importDefault(require("../../system/index.js"));
+const helper = __importStar(require("../controllers/index.js"));
+const auth_js_1 = __importDefault(require("../security/controller/auth.js"));
+const payload_js_1 = require("../decorators/payload.js");
+const index_js_3 = require("../helpers/index.js");
+const index_js_4 = __importDefault(require("../context/index.js"));
+const settings = index_js_2.default.getSettingsFile();
+exports.default = async (req, res) => {
+    if (!req.body || typeof req.body !== 'object' || Object.keys(req.body).length === 0) {
+        return res.status(400).json({
+            ...index_js_1.HttpStatus[400],
+            message: 'Request body is empty or invalid. Please provide a valid JSON payload.',
+        });
+    }
+    var props = req.body;
+    //controller method call
+    if (props.controller) {
+        var { method, payload, controller } = props;
+        if (!controller) {
+            return res.status(400).json({
+                ...index_js_1.HttpStatus[400],
+                message: "Unable to identify controller name.",
+            });
+        }
+        const customControllers = index_js_4.default.get("controllers");
+        var controllers = await helper.loadControllers(customControllers);
+        if (settings.auth) {
+            var auth = {
+                methods: [
+                    { name: "register" },
+                    { name: "login" },
+                    { name: "refresh" },
+                    { name: "logout" },
+                    { name: "me" },
+                ],
+                controller: auth_js_1.default,
+                metadata: { name: "Auth" },
+            };
+            if (typeof settings.auth === "object" &&
+                settings.auth.exposeChangePassword) {
+                auth.methods.push(...[{ name: "changePassword" }, { name: "forgotPassword" }]);
+            }
+            Object.defineProperty(controllers, "Auth", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: auth,
+            });
+        }
+        if (!controllers[controller]) {
+            return res.status(400).json({
+                ...index_js_1.HttpStatus[400],
+                message: "Impossible to find controller.",
+            });
+        }
+        if (!method) {
+            return res.status(400).json({
+                ...index_js_1.HttpStatus[400],
+                message: "Unable to identify method name.",
+            });
+        }
+        var __meta = controllers[controller];
+        if (!__meta.methods.find((x) => x.name === method)) {
+            return res.status(400).json({
+                ...index_js_1.HttpStatus[400],
+                message: "Unable to find action method.",
+            });
+        }
+        var allDto = (0, payload_js_1.getPayloadMetadata)(__meta.controller);
+        //realize validation dto
+        if (Array.isArray(allDto) && allDto.length > 0) {
+            var payloadMetadata = allDto.find((x) => x.name === method);
+            if (payloadMetadata) {
+                var erros = (0, index_js_3.validateData)(payloadMetadata.dto, payload);
+                if (Object.keys(erros).length > 0) {
+                    res.status(400).json({
+                        erros,
+                        message: "Data not valid for method, verify erros and try again.",
+                    });
+                    return;
+                }
+            }
+        }
+        try {
+            const data = payload;
+            payload = {
+                headers: {
+                    accept: req.headers.accept,
+                    autorization: req.headers.authorization,
+                    contentType: req.headers["content-type"],
+                    origin: req.headers.origin,
+                    ip: req.ip,
+                    referer: req.headers.referer,
+                    userAgent: req.headers["user-agent"],
+                    cookies: {
+                        data: req.cookies,
+                        set: (name, value, options) => {
+                            res.cookie(name, value, options);
+                        },
+                        remove: (name, options) => {
+                            res.clearCookie(name, options);
+                        },
+                    },
+                },
+                data,
+            };
+            var resultController = await new __meta.controller()[method](payload);
+            return res.status(200).json(resultController);
+        }
+        catch (err) {
+            const error = err;
+            return res.status(400).json((0, index_js_3.Exception)({
+                ...index_js_1.HttpStatus[400],
+                message: error.message,
+            }));
+        }
+    }
+    //database request...
+    const customModels = index_js_4.default.get("models");
+    var allModels = await index_js_2.default.getAllModels(customModels);
+    var model = allModels.find((x) => x.name.toLocaleLowerCase() === props.model.toLocaleLowerCase());
+    if (!model) {
+        res.status(400).json({
+            name: index_js_1.HttpStatus[400].name,
+            code: index_js_1.HttpStatus[400].code,
+            message: "Unable to identify Model.",
+        });
+        return;
+    }
+    var result = {
+        success: false,
+        error: {
+            name: index_js_1.HttpStatus[400].name,
+            code: index_js_1.HttpStatus[400].code,
+            message: "Unable to identify Model",
+        },
+    };
+    if (!["get", "insert", "update", "delete"].includes(props.method)) {
+        result.error.message = "It was not possible to identify the method used.";
+    }
+    if (["insert", "update"].includes(props.method)) {
+        var erros = (0, index_js_3.validateData)(model.entity, props.data);
+        if (Object.keys(erros).length > 0) {
+            return res.status(400).json({
+                erros,
+                message: "Data not valid for method, verify erros and try again.",
+            });
+        }
+    }
+    switch (props.method) {
+        case "get":
+            var getBody = req.body;
+            result = await (0, get_js_1.default)(getBody);
+            break;
+        case "insert":
+            var insertBody = req.body;
+            result = await (0, insert_js_1.default)(insertBody);
+            break;
+        case "update":
+            var updateBody = req.body;
+            result = await (0, update_js_1.default)(updateBody);
+            break;
+        case "delete":
+            var deleteBody = req.body;
+            result = await (0, delete_js_1.default)(deleteBody);
+            break;
+    }
+    if (result.success) {
+        res.status(index_js_1.HttpStatus[200].code).json(result.data);
+        return;
+    }
+    res.status(result.error.code).json(result.error);
+    return;
+};

package/lib/cjs/server/controllers/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>;