@nano-app/backend 0.1.0

package/dist/app.d.ts

@@ -0,0 +1,13 @@
+import { Endpoint } from "@all";
+type NanoAppConfig = {
+    port?: number;
+    endpoints: Endpoint[];
+};
+export declare class NanoApp {
+    private app;
+    private router;
+    private config;
+    constructor(config: NanoAppConfig);
+    start(listener?: () => void): Promise<void>;
+}
+export {};

package/dist/app.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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();
+class NanoApp {
+    app = (0, express_1.default)();
+    router;
+    config = {
+        port: 3000,
+        endpoints: [],
+    };
+    constructor(config) {
+        // Inicializar el router
+        this.router = new _all_1.Router(config.endpoints);
+        // Inicializar la configuración
+        this.config = {
+            ...this.config,
+            ...config,
+        };
+    }
+    async start(listener) {
+        this.app.use(express_1.default.json());
+        // Registrar las rutas
+        this.app.use('/', this.router.getRoutes());
+        // Iniciar el servidor
+        this.app.listen(Number(this.config.port), listener || (() => console.log(`Servidor corriendo en el puerto ${this.config.port}`)));
+    }
+}
+exports.NanoApp = NanoApp;

package/dist/http/Endpoint.d.ts

@@ -0,0 +1,22 @@
+import { ApiResponse } from "@nano-app/core";
+import { Request, Response } from "express";
+export declare abstract class Endpoint<BeforeResult = any> {
+    private methodMap;
+    endpointName: string;
+    constructor(endpointName?: string);
+    /** Metodos envoltorios */
+    protected BEFORE(_req: Request): Promise<BeforeResult>;
+    protected AFTER(_result: ApiResponse): Promise<ApiResponse>;
+    /**
+     * Métodos HTTP opcionales - las clases hijas solo implementan los que necesiten
+     * Si no se implementan, se lanza un error por defecto
+     */
+    protected GET(_req: Request, _res: Response, _beforeParams: BeforeResult): Promise<ApiResponse>;
+    protected POST(_req: Request, _res: Response, _beforeParams: BeforeResult): Promise<ApiResponse>;
+    protected PUT(_req: Request, _res: Response, _beforeParams: BeforeResult): Promise<ApiResponse>;
+    protected DELETE(_req: Request, _res: Response, _beforeParams: BeforeResult): Promise<ApiResponse>;
+    /**
+     * Ejecuta la lógica específica del endpoint
+     */
+    execute(req: Request, res: Response): void;
+}

package/dist/http/Endpoint.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endpoint = void 0;
+class Endpoint {
+    // protected prismaClient = new PrismaClient();
+    methodMap = {};
+    endpointName = '';
+    constructor(endpointName) {
+        this.endpointName = endpointName || 'default';
+        this.methodMap = {
+            'GET': this.GET.bind(this),
+            'POST': this.POST.bind(this),
+            'PUT': this.PUT.bind(this),
+            'DELETE': this.DELETE.bind(this),
+        };
+    }
+    /** Metodos envoltorios */
+    BEFORE(_req) {
+        return Promise.resolve({});
+    }
+    AFTER(_result) {
+        return Promise.resolve(_result);
+    }
+    /**
+     * Métodos HTTP opcionales - las clases hijas solo implementan los que necesiten
+     * 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}` };
+    }
+    async POST(_req, _res, _beforeParams) {
+        throw { message: `Método POST no implementado para ${this.endpointName}` };
+    }
+    async PUT(_req, _res, _beforeParams) {
+        throw { message: `Método PUT no implementado para ${this.endpointName}` };
+    }
+    async DELETE(_req, _res, _beforeParams) {
+        throw { message: `Método DELETE no implementado para ${this.endpointName}` };
+    }
+    /**
+     * Ejecuta la lógica específica del endpoint
+     */
+    execute(req, res) {
+        try {
+            const method = req.method;
+            const handler = this.methodMap[method];
+            if (!handler) {
+                throw { message: `Método ${method} no soportado` };
+            }
+            this.BEFORE(req)
+                .then((beforeParams) => handler(req, res, beforeParams))
+                .then(result => this.AFTER(result))
+                .then(result => res.json(result));
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: error.message ? error.message : error
+            });
+        }
+    }
+}
+exports.Endpoint = Endpoint;

package/dist/http/Handler.d.ts

@@ -0,0 +1,10 @@
+import { Endpoint } from "@all";
+import { Request, Response } from "express";
+export declare class Handler {
+    private endpoints;
+    basePath: string;
+    /** Agrega los endpoints al handler */
+    constructor(basePath: string, dinamicPath: string, endpoints: Endpoint[]);
+    /** Maneja la petición HTTP */
+    handlerRequest(req: Request, res: Response): Promise<Response>;
+}

package/dist/http/Handler.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Handler = void 0;
+class Handler {
+    endpoints = {};
+    basePath;
+    /** Agrega los endpoints al handler */
+    constructor(basePath, dinamicPath, endpoints) {
+        this.basePath = basePath;
+        endpoints.forEach(endpoint => {
+            this.endpoints[endpoint.endpointName] = endpoint;
+        });
+    }
+    /** Maneja la petición HTTP */
+    async handlerRequest(req, res) {
+        try {
+            // Obtiene el path del endpoint
+            const path = (typeof req.params.path === "string" ? req.params.path : req.params.path[0]).slice(1);
+            // Obtiene el endpoint correspondiente al path
+            const endpoint = this.endpoints[path] || this.endpoints['default'];
+            // Lanza error si el endpoint no existe
+            if (!endpoint) {
+                throw { message: `Endpoint ${path} no encontrado` };
+            }
+            // Ejecuta el handler específico
+            return await endpoint.execute(req, res)
+                .then(result => res.json(result)).catch(error => res.status(500).json({
+                success: false,
+                message: error.message ? error.message : error
+            }));
+        }
+        catch (error) {
+            return res.status(500).json({
+                success: false,
+                message: error.message ? error.message : error
+            });
+        }
+    }
+}
+exports.Handler = Handler;

package/dist/http/Router.d.ts

@@ -0,0 +1,6 @@
+import { Endpoint } from '@all';
+export declare class Router {
+    private router;
+    constructor(endpoints: Endpoint[]);
+    getRoutes(): import("express-serve-static-core").Router;
+}

package/dist/http/Router.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const express_1 = __importDefault(require("express"));
+class Router {
+    router = express_1.default.Router();
+    constructor(endpoints) {
+        // Registrar todos los endpoints
+        endpoints.forEach(endpoint => {
+            this.router.all(`${endpoint.endpointName}`, endpoint.execute.bind(endpoint));
+        });
+    }
+    getRoutes() {
+        return this.router;
+    }
+}
+exports.Router = Router;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./http/Endpoint";
+export * from "./http/Router";
+export * from "./app";

package/dist/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http/Endpoint"), exports);
+__exportStar(require("./http/Router"), exports);
+__exportStar(require("./app"), exports);

package/dist/loader/app-loader.d.ts

@@ -0,0 +1,6 @@
+export interface LoadedEndpoint<T = any> {
+    path: string;
+    EndpointClass: new (...args: any[]) => T;
+    endpointName: string;
+}
+export declare function loadEndpoints<T = any>(endpointsDir: string): Promise<LoadedEndpoint<T>[]>;

package/dist/loader/app-loader.js

@@ -0,0 +1,85 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEndpoints = loadEndpoints;
+const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const url_1 = require("url");
+const EXT = [".js", ".ts"];
+function slugFromClass(name) {
+    const base = name.replace(/Endpoint$/i, "") || "endpoint";
+    return base.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+async function* listFiles(dir) {
+    for (const e of await (0, promises_1.readdir)(dir, { withFileTypes: true })) {
+        const full = (0, path_1.join)(dir, e.name);
+        if (e.isDirectory())
+            yield* listFiles(full);
+        else if (e.isFile() && EXT.some((x) => e.name.endsWith(x)))
+            yield full;
+    }
+}
+function getEndpointClass(mod) {
+    const C = mod?.default ?? Object.values(mod).find((v) => typeof v === "function");
+    return typeof C === "function" ? C : null;
+}
+async function loadEndpoints(endpointsDir) {
+    const results = [];
+    const baseDir = (0, path_1.resolve)(process.cwd(), endpointsDir);
+    if (!(0, fs_1.existsSync)(baseDir)) {
+        throw new Error(`Carpeta de endpoints no encontrada: ${baseDir} (cwd: ${process.cwd()})`);
+    }
+    for await (const file of listFiles(baseDir)) {
+        const rel = (0, path_1.relative)(baseDir, file);
+        const dirs = (0, path_1.dirname)(rel).split(path_1.sep).filter((s) => s && s !== ".");
+        try {
+            const fileUrl = (0, url_1.pathToFileURL)(file).href;
+            const mod = await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s)));
+            const EndpointClass = getEndpointClass(mod);
+            if (!EndpointClass)
+                continue;
+            const endpointName = slugFromClass(EndpointClass.name ?? "endpoint");
+            const path = "/" + [...dirs, endpointName].join("/");
+            results.push({ path, EndpointClass: EndpointClass, endpointName });
+        }
+        catch (err) {
+            if (process.env.NODE_ENV !== "production") {
+                console.warn(`[nano-app] No se pudo cargar ${rel}:`, err?.message ?? err);
+            }
+        }
+    }
+    return results;
+}

package/dist/paths/Paths.d.ts

@@ -0,0 +1,44 @@
+import { DiscoveredEndpoint } from "./discover-endpoints";
+/**
+ * Clase que expone los paths de los endpoints descubiertos a partir de la
+ * estructura de carpetas del proyecto donde está instalado el backend.
+ *
+ * Se inicializa con Paths.init(projectRoot, endpointsDir) antes de usar
+ * (normalmente lo hace NanoApp al arrancar). Luego se puede usar
+ * Paths.health, Paths.greetingHello, etc., según los archivos en src/endpoints.
+ */
+export declare class Paths {
+    private static _map;
+    private static _endpoints;
+    private static _instances;
+    private static _initialized;
+    /**
+     * Inicializa Paths leyendo la estructura de carpetas del proyecto y
+     * cargando las instancias de las clases Endpoint.
+     * Debe llamarse con la raíz del proyecto (p. ej. process.cwd()) y el
+     * directorio de endpoints (p. ej. "src/endpoints").
+     */
+    static init(projectRoot: string, endpointsDir: string): Promise<void>;
+    /**
+     * Obtiene el path HTTP por clave (camelCase). Ej: Paths.get("greetingHello") => "/greeting/hello"
+     */
+    static get(key: string): string;
+    /**
+     * Devuelve todos los paths descubiertos (clave -> path).
+     */
+    static getAll(): Record<string, string>;
+    /**
+     * Lista completa de endpoints descubiertos (path, key, filePath).
+     */
+    static getEndpoints(): DiscoveredEndpoint[];
+    /**
+     * Obtiene la instancia de Endpoint por clave (camelCase).
+     * Ej: Paths.getInstance("greetingHello") => instancia de HelloEndpoint
+     */
+    static getInstance(key: string): any;
+    /**
+     * Devuelve todas las instancias de Endpoint cargadas (clave -> instancia).
+     */
+    static getAllInstances(): Record<string, any>;
+    static get initialized(): boolean;
+}

package/dist/paths/Paths.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Paths = void 0;
+const discover_endpoints_1 = require("./discover-endpoints");
+/**
+ * Clase que expone los paths de los endpoints descubiertos a partir de la
+ * estructura de carpetas del proyecto donde está instalado el backend.
+ *
+ * Se inicializa con Paths.init(projectRoot, endpointsDir) antes de usar
+ * (normalmente lo hace NanoApp al arrancar). Luego se puede usar
+ * Paths.health, Paths.greetingHello, etc., según los archivos en src/endpoints.
+ */
+class Paths {
+    static _map = {};
+    static _endpoints = [];
+    static _instances = {};
+    static _initialized = false;
+    /**
+     * Inicializa Paths leyendo la estructura de carpetas del proyecto y
+     * cargando las instancias de las clases Endpoint.
+     * Debe llamarse con la raíz del proyecto (p. ej. process.cwd()) y el
+     * directorio de endpoints (p. ej. "src/endpoints").
+     */
+    static async init(projectRoot, endpointsDir) {
+        this._endpoints = (0, discover_endpoints_1.discoverEndpoints)(projectRoot, endpointsDir);
+        this._map = (0, discover_endpoints_1.discoverPathsMap)(projectRoot, endpointsDir);
+        // Cargar instancias de las clases Endpoint
+        this._instances = await (0, discover_endpoints_1.loadEndpointInstances)(this._endpoints, projectRoot, endpointsDir);
+        // Exponer cada path como propiedad estática en la clase
+        for (const [key, value] of Object.entries(this._map)) {
+            this[key] = value;
+        }
+        // Exponer cada instancia como propiedad estática (ej: Paths.healthInstance)
+        for (const [key, instance] of Object.entries(this._instances)) {
+            this[`${key}Instance`] = instance;
+        }
+        this._initialized = true;
+    }
+    /**
+     * Obtiene el path HTTP por clave (camelCase). Ej: Paths.get("greetingHello") => "/greeting/hello"
+     */
+    static get(key) {
+        return this._map[key] ?? "";
+    }
+    /**
+     * Devuelve todos los paths descubiertos (clave -> path).
+     */
+    static getAll() {
+        return { ...this._map };
+    }
+    /**
+     * Lista completa de endpoints descubiertos (path, key, filePath).
+     */
+    static getEndpoints() {
+        return [...this._endpoints];
+    }
+    /**
+     * Obtiene la instancia de Endpoint por clave (camelCase).
+     * Ej: Paths.getInstance("greetingHello") => instancia de HelloEndpoint
+     */
+    static getInstance(key) {
+        return this._instances[key] ?? null;
+    }
+    /**
+     * Devuelve todas las instancias de Endpoint cargadas (clave -> instancia).
+     */
+    static getAllInstances() {
+        return { ...this._instances };
+    }
+    static get initialized() {
+        return this._initialized;
+    }
+}
+exports.Paths = Paths;

package/dist/paths/discover-endpoints.d.ts

@@ -0,0 +1,33 @@
+export interface DiscoveredEndpoint {
+    /** Ruta HTTP del endpoint, ej: "/health", "/greeting/hello" */
+    path: string;
+    /** Nombre en camelCase para usar como propiedad, ej: "health", "greetingHello" */
+    key: string;
+    /** Ruta del archivo relativa al directorio de endpoints */
+    filePath: string;
+    /** Ruta absoluta completa del archivo */
+    absolutePath: string;
+}
+/**
+ * Lee la estructura de la carpeta de endpoints del proyecto y devuelve
+ * la lista de endpoints con su path HTTP y clave para la clase Paths.
+ *
+ * Reglas:
+ * - Carpetas cuyo nombre empieza con _ no forman parte del path (ej: _invisible_path).
+ * - El path es: /carpeta/subcarpeta/nombrearchivo en minúsculas.
+ */
+export declare function discoverEndpoints(projectRoot: string, endpointsDir: string): DiscoveredEndpoint[];
+/**
+ * Devuelve un objeto con las claves en camelCase y los paths como valores.
+ * Ej: { health: "/health", greetingHello: "/greeting/hello" }
+ */
+export declare function discoverPathsMap(projectRoot: string, endpointsDir: string): Record<string, string>;
+/**
+ * Tipo para representar una clase Endpoint (clase abstracta de @nano-app/core)
+ */
+export type EndpointClass = new (...args: any[]) => any;
+/**
+ * Carga todas las instancias de Endpoint desde los archivos descubiertos.
+ * Retorna un mapa de clave (camelCase) -> instancia de Endpoint.
+ */
+export declare function loadEndpointInstances(endpoints: DiscoveredEndpoint[], projectRoot: string, endpointsDir: string): Promise<Record<string, any>>;

package/dist/paths/discover-endpoints.js

@@ -0,0 +1,203 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverEndpoints = discoverEndpoints;
+exports.discoverPathsMap = discoverPathsMap;
+exports.loadEndpointInstances = loadEndpointInstances;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+/**
+ * Convierte un path de endpoint a nombre en camelCase para usar como propiedad.
+ * Ej: "greeting/hello" -> "greetingHello", "health" -> "health"
+ */
+function pathToCamelCase(routePath) {
+    const segments = routePath
+        .split("/")
+        .filter(Boolean)
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase());
+    if (segments.length === 0)
+        return "";
+    const first = segments[0].toLowerCase();
+    const rest = segments.slice(1).join("");
+    return first + rest;
+}
+/**
+ * Recorre recursivamente un directorio y devuelve rutas relativas de archivos .ts
+ */
+function walkDir(dir, baseDir, relativePrefix, result) {
+    if (!fs.existsSync(dir))
+        return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativeFromBase = path.relative(baseDir, fullPath);
+        if (entry.isDirectory()) {
+            // Carpetas que empiezan con _ no forman parte del path HTTP
+            const segment = entry.name.startsWith("_") ? [] : [entry.name];
+            walkDir(fullPath, baseDir, [...relativePrefix, ...segment], result);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+            const nameWithoutExt = path.basename(entry.name, ".ts");
+            const pathSegments = [...relativePrefix, nameWithoutExt];
+            const routePath = "/" + pathSegments.map((s) => s.toLowerCase()).join("/");
+            result.push({ relativePath: routePath, fullPath: relativeFromBase });
+        }
+    }
+}
+/**
+ * Lee la estructura de la carpeta de endpoints del proyecto y devuelve
+ * la lista de endpoints con su path HTTP y clave para la clase Paths.
+ *
+ * Reglas:
+ * - Carpetas cuyo nombre empieza con _ no forman parte del path (ej: _invisible_path).
+ * - El path es: /carpeta/subcarpeta/nombrearchivo en minúsculas.
+ */
+function discoverEndpoints(projectRoot, endpointsDir) {
+    const absoluteDir = path.resolve(projectRoot, endpointsDir);
+    const collected = [];
+    walkDir(absoluteDir, absoluteDir, [], collected);
+    const seen = new Set();
+    return collected.map(({ relativePath, fullPath }) => {
+        const key = pathToCamelCase(relativePath);
+        const uniqueKey = key || "index";
+        let finalKey = uniqueKey;
+        let n = 1;
+        while (seen.has(finalKey)) {
+            finalKey = uniqueKey + n++;
+        }
+        seen.add(finalKey);
+        const absolutePath = path.resolve(absoluteDir, fullPath);
+        return {
+            path: relativePath,
+            key: finalKey,
+            filePath: fullPath,
+            absolutePath,
+        };
+    });
+}
+/**
+ * Devuelve un objeto con las claves en camelCase y los paths como valores.
+ * Ej: { health: "/health", greetingHello: "/greeting/hello" }
+ */
+function discoverPathsMap(projectRoot, endpointsDir) {
+    const endpoints = discoverEndpoints(projectRoot, endpointsDir);
+    const map = {};
+    for (const ep of endpoints) {
+        map[ep.key] = ep.path;
+    }
+    return map;
+}
+/**
+ * Carga dinámicamente un módulo y busca la clase Endpoint exportada.
+ * Busca tanto exportaciones por defecto como exportaciones nombradas.
+ * Intenta cargar primero archivos .js compilados, luego .ts si están disponibles.
+ */
+async function loadEndpointClass(filePath, projectRoot, endpointsDir) {
+    // Construir rutas posibles:
+    // 1. Archivo .js compilado en la misma ubicación
+    const jsPath = filePath.replace(/\.ts$/, ".js");
+    // 2. Archivo .js en dist/ manteniendo la estructura relativa
+    const relativeFromEndpoints = path.relative(path.resolve(projectRoot, endpointsDir), filePath);
+    const distPath = path.resolve(projectRoot, "dist", endpointsDir.replace(/^src\//, ""), relativeFromEndpoints.replace(/\.ts$/, ".js"));
+    const pathsToTry = [jsPath, distPath, filePath];
+    for (const tryPath of pathsToTry) {
+        if (!fs.existsSync(tryPath) && tryPath.endsWith(".js")) {
+            continue; // Saltar .js si no existe
+        }
+        try {
+            // Convertir ruta absoluta a URL para import dinámico
+            const fileUrl = (0, url_1.pathToFileURL)(tryPath).href;
+            // Intentar importar el módulo
+            const module = await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s)));
+            // Buscar la clase Endpoint en las exportaciones
+            // 1. Primero buscar exportación por defecto
+            if (module.default) {
+                const DefaultClass = module.default;
+                if (typeof DefaultClass === "function" && DefaultClass.prototype) {
+                    return DefaultClass;
+                }
+            }
+            // 2. Buscar en exportaciones nombradas (buscar clases que tengan "Endpoint" en el nombre)
+            for (const [key, value] of Object.entries(module)) {
+                if (typeof value === "function" &&
+                    value.prototype &&
+                    (key.includes("Endpoint") || key.match(/^[A-Z]/))) {
+                    return value;
+                }
+            }
+            // 3. Si no encontramos nada específico, buscar cualquier clase exportada
+            for (const [key, value] of Object.entries(module)) {
+                if (typeof value === "function" && value.prototype) {
+                    // Verificar que no sea una función helper (empieza con minúscula generalmente)
+                    if (key.charAt(0) === key.charAt(0).toUpperCase()) {
+                        return value;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Continuar al siguiente path si este falla
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Carga todas las instancias de Endpoint desde los archivos descubiertos.
+ * Retorna un mapa de clave (camelCase) -> instancia de Endpoint.
+ */
+async function loadEndpointInstances(endpoints, projectRoot, endpointsDir) {
+    const instances = {};
+    for (const endpoint of endpoints) {
+        const EndpointClass = await loadEndpointClass(endpoint.absolutePath, projectRoot, endpointsDir);
+        if (EndpointClass) {
+            try {
+                // Crear instancia de la clase (sin argumentos por ahora)
+                const instance = new EndpointClass();
+                instances[endpoint.key] = instance;
+            }
+            catch (error) {
+                console.error(`Error al crear instancia de ${endpoint.key} desde ${endpoint.filePath}:`, error);
+            }
+        }
+        else {
+            console.warn(`No se encontró clase Endpoint exportada en ${endpoint.filePath}. ` +
+                `Asegúrate de que el archivo exporte una clase que extienda Endpoint ` +
+                `o que los archivos estén compilados a JavaScript en dist/`);
+        }
+    }
+    return instances;
+}

package/dist/prisma/PrismaClient.d.ts

@@ -0,0 +1,7 @@
+import "dotenv/config";
+export default class PrismaClient {
+    private prisma;
+    getModel(entityName: string): any;
+    /** Para consultas que comparan columnas u otras condiciones no soportadas en findMany */
+    queryRaw<T = unknown>(strings: TemplateStringsArray, ...values: any[]): Promise<T>;
+}

package/dist/prisma/PrismaClient.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const adapter_pg_1 = require("@prisma/adapter-pg");
+const client_1 = require("@prisma-client/client");
+if (!process.env.DATABASE_URL) {
+    throw { message: 'DATABASE_URL no está configurada' };
+}
+const adapter = new adapter_pg_1.PrismaPg({
+    connectionString: process.env.DATABASE_URL
+});
+class PrismaClient {
+    prisma = new client_1.PrismaClient({ adapter });
+    getModel(entityName) {
+        return this.prisma[entityName.toLowerCase()];
+    }
+    /** Para consultas que comparan columnas u otras condiciones no soportadas en findMany */
+    async queryRaw(strings, ...values) {
+        return this.prisma.$queryRaw(strings, ...values);
+    }
+}
+exports.default = PrismaClient;

package/dist/test.d.ts

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

package/dist/test.js

@@ -0,0 +1,15 @@
+"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();

package/dist/types/app.d.ts

@@ -0,0 +1,5 @@
+import { Handler } from "@all";
+export type NanoAppConfig = {
+    handlers: Handler[];
+    port?: number;
+};

package/dist/types/app.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@nano-app/backend",
+  "version": "0.1.0",
+  "description": "Backend for nano-app architecture",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "architecture",
+    "typescript",
+    "framework",
+    "core"
+  ],
+  "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"
+  },
+  "devDependencies": {
+    "@types/dotenv": "^8.2.3",
+    "@types/express": "^5.0.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}