@nano-app/backend 0.4.0 → 0.6.0

package/dist/odata/Entities.d.ts

@@ -0,0 +1,9 @@
+import { Endpoint, type ApiResponse, type BeforeResult } from "../index";
+import type { Request, Response } from 'express';
+export declare class Entities extends Endpoint<BeforeResult> {
+    protected BEFORE({ params: { endpoint, id }, path }: Request): Promise<BeforeResult>;
+    protected GET(req: Request, _res: Response, { entity, id }: BeforeResult): Promise<ApiResponse>;
+    protected POST({ body }: Request, _res: Response, { entity }: BeforeResult): Promise<ApiResponse>;
+    protected PUT({ body }: Request, _res: Response, { entity, id }: BeforeResult): Promise<ApiResponse>;
+    protected DELETE(_req: Request, _res: Response, { entity, id }: BeforeResult): Promise<ApiResponse>;
+}

package/dist/odata/Entities.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entities = void 0;
+const index_1 = require("../index");
+class Entities extends index_1.Endpoint {
+    BEFORE({ params: { endpoint, id }, path }) {
+        // Valida que la entidad exista
+        const entity = this.prismaClient.getModel(endpoint);
+        if (!entity) {
+            throw { message: `Endpoint ${path} no encontrado` };
+        }
+        return Promise.resolve({ entity, id: Number(id) });
+    }
+    async GET(req, _res, { entity, id }) {
+        const query = req.query;
+        let result;
+        // Si se proporciona un ID, se busca un registro único
+        if (id) {
+            query.id = id.toString();
+            result = await entity.findUnique(index_1.QueryBuilder.build(query));
+        }
+        else {
+            result = await entity.findMany(index_1.QueryBuilder.build(query));
+        }
+        return { result };
+    }
+    async POST({ body }, _res, { entity }) {
+        const result = await entity.create({ data: body });
+        return { result, message: `Registro creado correctamente` };
+    }
+    async PUT({ body }, _res, { entity, id }) {
+        if (!id) {
+            throw { message: "ID es requerido para actualizar" };
+        }
+        const result = await entity.update({
+            where: { id },
+            data: body
+        });
+        return { result, message: `Registro actualizado correctamente` };
+    }
+    async DELETE(_req, _res, { entity, id }) {
+        let result;
+        if (!id) {
+            throw { message: "ID es requerido para eliminar" };
+        }
+        result = await entity.delete({ where: { id } });
+        return { result, message: `Registro eliminado correctamente` };
+    }
+}
+exports.Entities = Entities;

package/dist/odata/QueryBuilder.d.ts

@@ -0,0 +1,33 @@
+import type { QueryParams } from "../index";
+export declare class QueryBuilder {
+    private static readonly OPERATORS;
+    private static parseValue;
+    /**
+     * Construye el objeto expand
+     */
+    private static buildExpand;
+    /**
+     * Parsea una expresión de filtro individual
+     */
+    private static parseExpression;
+    /**
+     * Construye el objeto filter
+     */
+    private static buildFilter;
+    /**
+     * Construye un objeto de ordenamiento
+     * Soporta propiedades encadenadas como "subscription.description"
+     */
+    private static buildOrderBy;
+    /**
+     * Construye el objeto query
+     */
+    static build(query: QueryParams): {
+        where: {
+            [x: string]: any;
+        };
+        include: Record<string, boolean> | undefined;
+        take: number;
+        orderBy: any;
+    };
+}

package/dist/odata/QueryBuilder.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+class QueryBuilder {
+    static OPERATORS = {
+        eq: (f, v) => ({ [f]: v }),
+        ne: (f, v) => ({ [f]: { not: v } }),
+        ge: (f, v) => ({ [f]: { gte: v } }),
+        le: (f, v) => ({ [f]: { lte: v } }),
+        contains: (f, v) => ({
+            [f]: { contains: v, mode: 'insensitive' }
+        }),
+        startswith: (f, v) => ({
+            [f]: { startsWith: v, mode: 'insensitive' }
+        }),
+        endswith: (f, v) => ({
+            [f]: { endsWith: v, mode: 'insensitive' }
+        }),
+    };
+    static parseValue(value) {
+        if (value === undefined)
+            return value;
+        if (!isNaN(Number(value)))
+            return Number(value);
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        return value;
+    }
+    /**
+     * Construye el objeto expand
+     */
+    static buildExpand(expand) {
+        return expand?.split(',').reduce((acc, path) => {
+            acc[path] = true;
+            return acc;
+        }, {});
+    }
+    /**
+     * Parsea una expresión de filtro individual
+     */
+    static parseExpression(expr) {
+        const [field, op, ...rest] = expr.trim().split(' ');
+        if (!this.OPERATORS[op])
+            throw { message: `Operador '${op}' no soportado` };
+        const value = this.parseValue(rest.join(' '));
+        return this.OPERATORS[op](field, value);
+    }
+    /**
+     * Construye el objeto filter
+     */
+    static buildFilter(filter) {
+        if (!filter)
+            return {};
+        if (filter.includes(' or ')) {
+            return {
+                OR: filter.split(' or ').map(this.parseExpression.bind(this))
+            };
+        }
+        if (filter.includes(' and ')) {
+            return {
+                AND: filter.split(' and ').map(this.parseExpression.bind(this))
+            };
+        }
+        return this.parseExpression.bind(this)(filter);
+    }
+    /**
+     * Construye un objeto de ordenamiento
+     * Soporta propiedades encadenadas como "subscription.description"
+     */
+    static buildOrderBy(orderby) {
+        if (!orderby)
+            return undefined;
+        // Obtiene el campo y la dirección
+        const [field, direction] = orderby.split(' ');
+        // Solo acepta asc o desc
+        if (direction !== 'asc' && direction !== 'desc')
+            return undefined;
+        // Construye el objeto de ordenamiento
+        const parts = field.split(".");
+        let result = {};
+        let current = result;
+        for (let i = 0; i < parts.length; i++) {
+            if (i === parts.length - 1) {
+                current[parts[i]] = direction;
+            }
+            else {
+                current[parts[i]] = {};
+                current = current[parts[i]];
+            }
+        }
+        return result;
+    }
+    /**
+     * Construye el objeto query
+     */
+    static build(query) {
+        return {
+            where: {
+                ...this.buildFilter(query.filter)
+            },
+            include: this.buildExpand(query.expand),
+            take: Number(query.top || 10) + Number(query.skip || 0),
+            orderBy: this.buildOrderBy(query.orderby),
+        };
+    }
+}
+exports.QueryBuilder = QueryBuilder;

package/dist/prisma/Client.d.ts

@@ -0,0 +1,12 @@
+import "dotenv/config";
+declare const Prisma: any;
+type GeneratedPrismaClient = typeof Prisma;
+export type AppModels = Omit<GeneratedPrismaClient, `$${string}` | symbol>;
+/** Cliente Prisma. getModel retorna el tipo correcto según el nombre del modelo. */
+export declare class PrismaClient {
+    private prisma;
+    getModel<K extends keyof AppModels>(entityName: K): AppModels[K];
+    /** Para consultas que comparan columnas u otras condiciones no soportadas en findMany */
+    queryRaw<T = unknown>(strings: TemplateStringsArray, ...values: any[]): Promise<T>;
+}
+export {};

package/dist/prisma/Client.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaClient = void 0;
+require("dotenv/config");
+const path_1 = __importDefault(require("path"));
+const adapter_pg_1 = require("@prisma/adapter-pg");
+// Crea el adaptador a la base de datos
+if (!process.env.DATABASE_URL) {
+    throw { message: 'DATABASE_URL no está configurada' };
+}
+const adapter = new adapter_pg_1.PrismaPg({
+    connectionString: process.env.DATABASE_URL
+});
+// Carga el cliente generado por el binario
+const clientPath = path_1.default.join(process.cwd(), "node_modules/.prisma/prisma-client/client");
+const client = require(clientPath);
+const Prisma = client.PrismaClient ?? client.default?.PrismaClient ?? client;
+// Crea una instancia de Prisma
+const prismaInstance = new Prisma({ adapter });
+/** Cliente Prisma. getModel retorna el tipo correcto según el nombre del modelo. */
+class PrismaClient {
+    prisma = prismaInstance;
+    getModel(entityName) {
+        return this.prisma[entityName];
+    }
+    /** Para consultas que comparan columnas u otras condiciones no soportadas en findMany */
+    async queryRaw(strings, ...values) {
+        return this.prisma.$queryRaw(strings, ...values);
+    }
+}
+exports.PrismaClient = PrismaClient;

package/dist/types/api.d.ts

@@ -0,0 +1,6 @@
+export type ApiResponse<T = any> = {
+    success?: boolean;
+    result?: T;
+    message?: string;
+    warning?: boolean;
+};

package/dist/types/api.js

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

package/dist/types/app.d.ts

@@ -0,0 +1,17 @@
+import type { Endpoint } from "../http/Endpoint";
+import type { ErrorRequestHandler, RequestHandler } from "express";
+import type { Options } from "express-rate-limit";
+export type NanoAppConfig = {
+    endpoints: Endpoint[];
+    enableEntities?: boolean;
+    errorMiddleware?: ErrorRequestHandler;
+    middlewares?: RequestHandler[];
+    port?: number;
+    rateLimit?: Partial<Options>;
+    expressConfig?: Partial<Express.Application>;
+    setters?: Record<string, any>;
+    morgan?: {
+        tokens?: Record<string, any>;
+        format?: string;
+    };
+};

package/dist/types/app.js

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

package/dist/types/odata.d.ts

@@ -0,0 +1,12 @@
+export type QueryParams = {
+    id?: string;
+    filter?: string;
+    expand?: string;
+    top?: string;
+    skip?: string;
+    orderby?: string;
+};
+export type BeforeResult = {
+    entity: any;
+    id: number;
+};

package/dist/types/odata.js

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

package/dist/utils/Formatter.d.ts

@@ -0,0 +1,4 @@
+export declare class Formatter {
+    static price(value: number): string;
+    static logDate(date?: Date): string;
+}

package/dist/utils/Formatter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formatter = void 0;
+class Formatter {
+    static price(value) {
+        return `$${new Intl.NumberFormat("de-DE", { maximumFractionDigits: 0 }).format(value || 0)}`;
+    }
+    static logDate(date = new Date()) {
+        return new Intl.DateTimeFormat("es-ES", {
+            year: "2-digit",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+        }).format(date);
+    }
+}
+exports.Formatter = Formatter;

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "@nano-app/backend",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Backend for nano-app architecture",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "*.js",
-    "*.d.ts",
-    "http"
+    "dist"
   ],
   "scripts": {
     "build": "tsc",