@nano-app/backend 0.2.0 → 0.3.0

package/dist/app.d.ts

@@ -1,13 +1,9 @@
-import { Endpoint } from "@all";
-type NanoAppConfig = {
-    port?: number;
-    endpoints: Endpoint[];
-};
+import { type NanoAppConfig } from "./index";
 export declare class NanoApp {
     private app;
     private router;
     private config;
     constructor(config: NanoAppConfig);
+    getApp(): import("express-serve-static-core").Express;
     start(listener?: () => void): Promise<void>;
 }
-export {};

package/dist/app.js

@@ -5,31 +5,83 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NanoApp = void 0;
 const express_1 = __importDefault(require("express"));
-const dotenv_1 = __importDefault(require("dotenv"));
-const _all_1 = require("@all");
-dotenv_1.default.config();
+const cors_1 = __importDefault(require("cors"));
+const helmet_1 = __importDefault(require("helmet"));
+const compression_1 = __importDefault(require("compression"));
+const morgan_1 = __importDefault(require("morgan"));
+const express_rate_limit_1 = __importDefault(require("express-rate-limit"));
+const index_1 = require("./index");
 class NanoApp {
     app = (0, express_1.default)();
     router;
     config = {
-        port: 3000,
         endpoints: [],
+        enableEntities: true,
+        port: 3000,
+        rateLimit: {
+            windowMs: 15 * 60 * 1000, // 15 minutos
+            max: 1000, // Máximo 1000 peticiones por IP
+            message: 'Too many requests, please try again later.'
+        },
+        morgan: {
+            tokens: {},
+            format: 'combined',
+        },
+        expressConfig: {
+            limit: '10kb',
+        },
     };
     constructor(config) {
-        // Inicializar el router
-        this.router = new _all_1.Router(config.endpoints);
         // Inicializar la configuración
         this.config = {
             ...this.config,
             ...config,
         };
+        // Inicializar el router
+        this.router = new index_1.Router(this.config.endpoints.concat(this.config.enableEntities ? [new index_1.Entities('/:endpoint{/:id}')] : []));
+        // Inicializar setters
+        if (this.config.setters) {
+            Object.entries(this.config.setters).forEach(([key, value]) => {
+                this.app.set(key, value);
+            });
+        }
+        // Inicializar morgan
+        Object.entries(this.config.morgan?.tokens || {}).forEach(([key, value]) => {
+            morgan_1.default.token(key, value);
+        });
+        this.app.use((0, morgan_1.default)(this.config.morgan?.format ?? 'combined'));
+        // Inicializar seguridad y optimizacion
+        this.app.use((0, cors_1.default)());
+        this.app.use((0, helmet_1.default)());
+        this.app.use((0, compression_1.default)());
+        // Inicializar proteccion contra ataques
+        this.app.use((0, express_rate_limit_1.default)(this.config.rateLimit));
+        // Inicializar limite de tamaño del body
+        this.app.use(express_1.default.json(this.config.expressConfig));
     }
+    getApp() { return this.app; }
     async start(listener) {
-        this.app.use(express_1.default.json());
+        // Middlewares
+        (this.config.middlewares || []).forEach(middleware => this.app.use(middleware));
         // Registrar las rutas
         this.app.use('/', this.router.getRoutes());
+        // Middleware de error (debe ir al final)
+        if (this.config.errorMiddleware) {
+            this.app.use(this.config.errorMiddleware);
+        }
+        else {
+            this.app.use((err, _, res, __) => {
+                res.status(err.status || 500).json({
+                    success: false,
+                    message: err.message || 'Error interno del servidor'
+                });
+            });
+        }
         // Iniciar el servidor
-        this.app.listen(Number(this.config.port), listener || (() => console.log(`Servidor corriendo en el puerto ${this.config.port}`)));
+        this.app.listen(Number(this.config.port), () => {
+            console.log(`Server running on port ${this.config.port}`);
+            listener?.(); // Ejecutar el listener si se proporciona
+        });
     }
 }
 exports.NanoApp = NanoApp;

package/dist/http/Endpoint.d.ts

@@ -1,9 +1,10 @@
-import { ApiResponse } from "@nano-app/core";
 import { Request, Response } from "express";
+import { PrismaClient, type ApiResponse } from "../index";
 export declare abstract class Endpoint<BeforeResult = any> {
+    protected prismaClient: PrismaClient;
     private methodMap;
-    endpointName: string;
-    constructor(endpointName?: string);
+    path: string;
+    constructor(path?: string);
     /** Metodos envoltorios */
     protected BEFORE(_req: Request): Promise<BeforeResult>;
     protected AFTER(_result: ApiResponse): Promise<ApiResponse>;

package/dist/http/Endpoint.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Endpoint = void 0;
+const index_1 = require("../index");
 class Endpoint {
-    // protected prismaClient = new PrismaClient();
+    prismaClient = new index_1.PrismaClient();
     methodMap = {};
-    endpointName = '';
-    constructor(endpointName) {
-        this.endpointName = endpointName || 'default';
+    path = '';
+    constructor(path) {
+        this.path = path || 'default';
         this.methodMap = {
             'GET': this.GET.bind(this),
             'POST': this.POST.bind(this),
@@ -26,16 +27,16 @@ class Endpoint {
      * Si no se implementan, se lanza un error por defecto
      */
     async GET(_req, _res, _beforeParams) {
-        throw { message: `Método GET no implementado para ${this.endpointName}` };
+        throw { message: `Método GET no implementado para ${this.path}` };
     }
     async POST(_req, _res, _beforeParams) {
-        throw { message: `Método POST no implementado para ${this.endpointName}` };
+        throw { message: `Método POST no implementado para ${this.path}` };
     }
     async PUT(_req, _res, _beforeParams) {
-        throw { message: `Método PUT no implementado para ${this.endpointName}` };
+        throw { message: `Método PUT no implementado para ${this.path}` };
     }
     async DELETE(_req, _res, _beforeParams) {
-        throw { message: `Método DELETE no implementado para ${this.endpointName}` };
+        throw { message: `Método DELETE no implementado para ${this.path}` };
     }
     /**
      * Ejecuta la lógica específica del endpoint
@@ -50,7 +51,10 @@ class Endpoint {
             this.BEFORE(req)
                 .then((beforeParams) => handler(req, res, beforeParams))
                 .then(result => this.AFTER(result))
-                .then(result => res.json(result));
+                .then(result => res.json({
+                success: true,
+                ...result
+            }));
         }
         catch (error) {
             res.status(500).json({

package/dist/http/Router.d.ts

@@ -1,4 +1,4 @@
-import { Endpoint } from '@all';
+import { Endpoint } from './Endpoint';
 export declare class Router {
     private router;
     constructor(endpoints: Endpoint[]);

package/dist/http/Router.js

@@ -9,8 +9,10 @@ class Router {
     router = express_1.default.Router();
     constructor(endpoints) {
         // Registrar todos los endpoints
+        console.log(`Endpoints registered:`);
         endpoints.forEach(endpoint => {
-            this.router.all(`${endpoint.endpointName}`, endpoint.execute.bind(endpoint));
+            console.log(`  - ${endpoint.path}`);
+            this.router.all(`${endpoint.path}`, endpoint.execute.bind(endpoint));
         });
     }
     getRoutes() {

package/dist/index.d.ts

@@ -1,3 +1,10 @@
 export * from "./http/Endpoint";
 export * from "./http/Router";
+export * from "./odata/Entities";
+export * from "./odata/QueryBuilder";
+export * from "./prisma/Client";
+export * from "./types/api";
+export * from "./types/app";
+export * from "./types/odata";
+export * from "./utils/Formatter";
 export * from "./app";

package/dist/index.js

@@ -16,4 +16,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./http/Endpoint"), exports);
 __exportStar(require("./http/Router"), exports);
+__exportStar(require("./odata/Entities"), exports);
+__exportStar(require("./odata/QueryBuilder"), exports);
+__exportStar(require("./prisma/Client"), exports);
+__exportStar(require("./types/api"), exports);
+__exportStar(require("./types/app"), exports);
+__exportStar(require("./types/odata"), exports);
+__exportStar(require("./utils/Formatter"), exports);
 __exportStar(require("./app"), exports);

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@nano-app/backend",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Backend for nano-app architecture",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist",
-    "bin"
+    "*.js",
+    "*.d.ts",
+    "http"
   ],
   "scripts": {
-    "dev": "tsx watch src/test.ts",
     "build": "tsc",
     "prepublishOnly": "npm run build"
   },
@@ -22,16 +22,23 @@
   "author": "Cristian Serrano",
   "license": "MIT",
   "dependencies": {
-    "@nano-app/core": "^0.1.0",
     "@prisma/adapter-pg": "^7.4.0",
     "@prisma/client": "^7.4.0",
-    "express": "^5.2.1"
+    "compression": "^1.8.1",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.2.1",
+    "helmet": "^8.1.0",
+    "morgan": "^1.10.1"
   },
   "devDependencies": {
-    "@types/dotenv": "^8.2.3",
+    "@types/compression": "^1.8.1",
+    "@types/cors": "^2.8.19",
     "@types/express": "^5.0.0",
+    "@types/morgan": "^1.9.10",
     "@types/node": "^20.0.0",
-    "typescript": "^5.3.0",
-    "tsx": "^4.7.0"
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
   }
 }

package/dist/test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const _all_1 = require("@all");
-class HealthEndpoint extends _all_1.Endpoint {
-    async GET(_ctx) {
-        return { success: true, message: "Health!" };
-    }
-}
-const app = new _all_1.NanoApp({
-    endpoints: [
-        new HealthEndpoint("/service/health"),
-        new HealthEndpoint("/:entity{/:id}"),
-    ]
-});
-app.start();