@cristianrg/fastpress 1.0.1

package/dist/shared/middlewares/Sanitizer.js

@@ -0,0 +1,45 @@
+import { Middleware } from "../models/Middleware.js";
+class Sanitizer extends Middleware {
+    handle(ctx) {
+        const url = ctx.req.url;
+        ctx.req.url = this.sanitizeUrl(url);
+        ctx.query = this.santitizeQuery(ctx.query);
+        ctx.next();
+    }
+    sanitizeUrl(url) {
+        if (!url)
+            return url;
+        let sanitizedUrl = url.replace(/\0/g, '');
+        sanitizedUrl = decodeURIComponent(sanitizedUrl);
+        while (this.detectTraversal(sanitizedUrl)) {
+            sanitizedUrl = sanitizedUrl.replace(/(\.\.\/|%2e%2e%2f|\.{2}\\|%2e%2e%5c)/gi, '');
+        }
+        return sanitizedUrl;
+    }
+    santitizeQuery(query) {
+        if (!query)
+            return query;
+        const formatedQuery = Object.entries(query).map(([key, value]) => ({ key, value }));
+        let sanitizedQuery = new Map();
+        for (const { key, value } of formatedQuery) {
+            const sanitizedKey = key.replace(/\0/g, '');
+            const sanitizedValue = typeof value === 'string' ? value.replace(/\0/g, '') : value;
+            sanitizedQuery.set(sanitizedKey, sanitizedValue);
+            const decodedKey = decodeURIComponent(sanitizedKey);
+            const decodedValue = typeof sanitizedValue === 'string' ? decodeURIComponent(sanitizedValue) : sanitizedValue;
+            sanitizedQuery.set(decodedKey, decodedValue);
+            if (this.detectTraversal(decodedKey)) {
+                sanitizedQuery.delete(decodedKey);
+            }
+            if (this.detectTraversal(decodedValue)) {
+                sanitizedQuery.delete(decodedKey);
+            }
+        }
+        return sanitizedQuery;
+    }
+    detectTraversal(url) {
+        const traversalPatterns = [/(\.\.\/)/, /(%2e%2e%2f)/i, /(\.\.\\)/, /(%2e%2e%5c)/i];
+        return traversalPatterns.some(pattern => pattern.test(url));
+    }
+}
+export { Sanitizer };

package/dist/shared/models/Context.js

@@ -0,0 +1,22 @@
+/**
+ * A class representing the context of an Express request, encapsulating the request, response, and next function.
+ * It also provides typed access to query parameters, route parameters, and the request body.
+ */
+export class Context {
+    req;
+    res;
+    next;
+    query;
+    params;
+    body;
+    user;
+    constructor(req, res, next) {
+        this.req = req;
+        this.res = res;
+        this.next = next;
+        this.query = req.query;
+        this.params = req.params;
+        this.body = req.body;
+        this.user = req.user; // Assuming authentication middleware attaches user to req
+    }
+}

package/dist/shared/models/Guard.js

@@ -0,0 +1,5 @@
+/**
+ * Guard is an abstract class that defines the structure for creating guards in the application. Guards are used to protect routes by determining whether a request is allowed to proceed based on custom logic. The canActivate method must be implemented by any class that extends Guard, and it should return either a boolean or a GuardResponse object indicating whether the request is allowed or not.
+ */
+export class Guard {
+}

package/dist/shared/models/Hook.js

@@ -0,0 +1,7 @@
+/**
+ * Base class for hooks that can be used with the `@UseHooks` decorator. Hooks allow you to run custom logic before and after a route handler is executed.
+ * They can be used for tasks like logging, modifying the request/response, or implementing custom behavior that should run around the execution of a route handler.
+ */
+class Hook {
+}
+export { Hook };

package/dist/shared/models/Logger.js

@@ -0,0 +1,6 @@
+/**
+ * Logger is an abstract class that defines the structure for creating loggers in the application. It implements the ILogger interface, which specifies methods for logging messages at different levels (log, info, error, warn, debug). Any class that extends Logger must implement these methods to provide the actual logging functionality, such as writing to the console, a file, or an external logging service.
+ */
+class Logger {
+}
+export { Logger };

package/dist/shared/models/Middleware.js

@@ -0,0 +1,5 @@
+/**
+ * Abstract class representing a middleware component.
+ */
+export class Middleware {
+}

package/dist/shared/models/ServerResponse.js

@@ -0,0 +1,14 @@
+/**
+ * Class representing a server response.
+ * It includes a status code, an optional message, and optional data.
+ */
+export class ServerResponse {
+    statusCode;
+    message;
+    data;
+    constructor(statusCode, message, data) {
+        this.statusCode = statusCode;
+        this.message = message;
+        this.data = data;
+    }
+}

package/dist/shared/repository/BaseController.js

@@ -0,0 +1,107 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Delete, Get, Post, Put } from "../../core/decorators/Methods.js";
+import { Service } from "./Service.js";
+import { Body } from "../../common/decorators/Body.js";
+import { Query } from "../../common/decorators/Query.js";
+import { ServerResponse } from "../../shared/models/ServerResponse.js";
+import { ParseIntPipe } from "../../common/pipes/ParseIntPipe.js";
+import { UseMiddleware } from "../../core/decorators/UseMiddleware.js";
+import { Auth } from "../../shared/middlewares/Auth.js";
+let BaseController = class BaseController {
+    service;
+    modelName;
+    constructor(modelName, service) {
+        this.modelName = modelName;
+        this.service = service || new Service(modelName);
+    }
+    async get(skip, take) {
+        const items = await this.service.findAll({
+            skip,
+            take
+        });
+        return new ServerResponse(200, `Found ${items.length} items in ${String(this.service.getModelName())} table`, items);
+    }
+    async getById(id) {
+        const item = await this.service.findById(id);
+        if (!item) {
+            return new ServerResponse(404, "Item not found");
+        }
+        return new ServerResponse(200, `Item retrieved successfully from ${String(this.service.getModelName())} table`, item);
+    }
+    async create(data) {
+        if (!data)
+            return new ServerResponse(400, `Item data is required to create a new ${String(this.service.getModelName())}`);
+        const createdItem = await this.service.create(data);
+        return new ServerResponse(201, `Item created successfully in ${String(this.service.getModelName())} table`, createdItem);
+    }
+    async update(id, data) {
+        if (!data)
+            return new ServerResponse(400, `Item data is required to update a ${String(this.service.getModelName())}`);
+        const updatedItem = await this.service.update({ id }, data);
+        return new ServerResponse(200, `Item updated successfully in ${String(this.service.getModelName())} table`, updatedItem);
+    }
+    async delete(id) {
+        const item = await this.service.findById(id);
+        if (!item)
+            return new ServerResponse(404, "Item not found");
+        await this.service.delete({ id });
+        return new ServerResponse(200, `Item deleted successfully from ${String(this.service.getModelName())} table`);
+    }
+};
+__decorate([
+    Get("/"),
+    __param(0, Query("skip", ParseIntPipe)),
+    __param(1, Query("take", ParseIntPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", Promise)
+], BaseController.prototype, "get", null);
+__decorate([
+    Get("/:id"),
+    __param(0, Query("id", ParseIntPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], BaseController.prototype, "getById", null);
+__decorate([
+    Post("/"),
+    __param(0, Body(undefined)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], BaseController.prototype, "create", null);
+__decorate([
+    Put("/:id"),
+    __param(0, Query("id", ParseIntPipe)),
+    __param(1, Body(undefined)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Object]),
+    __metadata("design:returntype", Promise)
+], BaseController.prototype, "update", null);
+__decorate([
+    Delete("/:id"),
+    __param(0, Query("id", ParseIntPipe)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], BaseController.prototype, "delete", null);
+BaseController = __decorate([
+    UseMiddleware(Auth)
+    /**
+     * BaseController is a generic controller class that provides basic CRUD operations for any Prisma model. It uses the Service class to interact with the database and defines route handlers for getting all items, getting an item by ID, creating a new item, updating an existing item, and deleting an item. The routes are decorated with the appropriate HTTP method decorators (Get, Post, Put, Delete) and use parameter decorators (Query, Body) to extract data from the request. The controller also returns standardized ServerResponse objects for consistent API responses.
+     */
+    ,
+    __metadata("design:paramtypes", [Object, Object])
+], BaseController);
+export { BaseController };

package/dist/shared/repository/Logger.js

@@ -0,0 +1,65 @@
+import conf from "../../conf/index.js";
+import { Logger as LoggerModel } from "../models/Logger.js";
+class DefaultLogger extends LoggerModel {
+    log(message) {
+        console.log(this.formatMessage("log", message));
+    }
+    info(message) {
+        console.info(this.formatMessage("info", message));
+    }
+    error(message) {
+        console.error(this.formatMessage("error", message));
+    }
+    warn(message) {
+        console.warn(this.formatMessage("warn", message));
+    }
+    debug(message) {
+        console.debug(this.formatMessage("debug", message));
+    }
+    formatMessage(level, message) {
+        const timestamp = new Date().toISOString();
+        return `${timestamp} - [${level.toUpperCase()}]: ${message}`;
+    }
+}
+/**
+ * A simple Logger class that can be extended or replaced with different logging implementations.
+ * It uses the abstract Logger class as a base and delegates logging to an instance of ILogger, which can be customized.
+ * By default, it uses the DefaultLogger implementation that logs to the console with timestamps and log levels.
+ */
+class Logger extends LoggerModel {
+    logger = new DefaultLogger();
+    static instance;
+    constructor() {
+        super();
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    getLogger() {
+        return this.logger;
+    }
+    log(message) {
+        this.logger.log(message);
+    }
+    info(message) {
+        this.logger.info(message);
+    }
+    error(message) {
+        this.logger.error(message);
+    }
+    warn(message) {
+        this.logger.warn(message);
+    }
+    debug(message) {
+        this.logger.debug(message);
+    }
+}
+const logger = Logger.getInstance();
+logger.setLogger(conf.LOGGER_INSTANCE ? new DefaultLogger() : conf.LOGGER_INSTANCE);
+export default logger;

package/dist/shared/repository/Service.js

@@ -0,0 +1,67 @@
+import conf from "../../conf/index.js";
+import { PrismaClient } from "@prisma/client";
+/**
+ * BaseService is an abstract class that provides common database operations for any Prisma model. It defines methods for finding all records, finding a single record by criteria, finding a record by ID, creating a new record, updating an existing record, deleting a record, paginating results, counting records, and checking for the existence of records. The Service class extends BaseService and provides a concrete implementation that requires specifying the model name. This structure allows for easy creation of services for different models by simply extending the Service class and providing the appropriate model name.
+ */
+export class BaseService {
+    prisma;
+    constructor(prisma) {
+        this.prisma = prisma || new PrismaClient({ adapter: conf.PRISMA_ADAPTER });
+    }
+    get model() {
+        return this.prisma[this.modelName];
+    }
+    async findAll(options) {
+        return this.model.findMany({
+            skip: options?.skip,
+            take: options?.take,
+            orderBy: options?.orderBy,
+        });
+    }
+    async findOne(where) {
+        return this.model.findFirst({ where });
+    }
+    async findById(id) {
+        return this.model.findUnique({ where: { id } });
+    }
+    async create(data) {
+        return this.model.create({ data });
+    }
+    async update(where, data) {
+        return this.model.update({ where, data });
+    }
+    async delete(where) {
+        return this.model.delete({ where });
+    }
+    async paginate(where = {}, page = 1, pageSize = 10, orderBy) {
+        const skip = (page - 1) * pageSize;
+        const [data, total] = await Promise.all([
+            this.model.findMany({ where, skip, take: pageSize, orderBy }),
+            this.model.count({ where })
+        ]);
+        return {
+            data,
+            total,
+            page,
+            pageSize,
+            hasNext: skip + pageSize < total
+        };
+    }
+    async count(where = {}) {
+        return this.model.count({ where });
+    }
+    async exists(where) {
+        const count = await this.model.count({ where });
+        return count > 0;
+    }
+}
+export class Service extends BaseService {
+    modelName;
+    constructor(modelName, prisma) {
+        super(prisma);
+        this.modelName = modelName;
+    }
+    getModelName() {
+        return this.modelName;
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@cristianrg/fastpress",
+  "version": "1.0.1",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CristianRG/fastpress.git"
+  },
+  "files": [
+    "dist/**/*",
+    "prisma/schema.prisma"
+  ],
+  "author": "Cristian Alexander Rizo Gómez",
+  "description": "A fast and minimalistic web framework for Node.js, inspired by Express and built with TypeScript.",
+  "license": "MIT",
+  "type": "module",
+  "devDependencies": {
+    "@types/bcrypt": "6.0.0",
+    "@types/cors": "2.8.19",
+    "@types/express": "5.0.6",
+    "@types/jsonwebtoken": "9.0.10",
+    "nodemon": "3.1.11",
+    "reflect-metadata": "0.2.2",
+    "tsc-alias": "1.8.16",
+    "tsx": "4.19.2",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "@prisma/adapter-better-sqlite3": "^7.4.0",
+    "@prisma/client": "7.4.0",
+    "bcrypt": "6.0.0",
+    "cors": "2.8.6",
+    "dotenv": "17.2.4",
+    "express": "5.2.1",
+    "glob": "13.0.1",
+    "install": "0.13.0",
+    "jiti": "2.6.1",
+    "jsonwebtoken": "9.0.3",
+    "prisma": "7.4.0",
+    "redis": "5.11.0",
+    "winston": "3.19.0",
+    "zod": "4.3.6"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "postinstall": "prisma generate"
+  }
+}

package/prisma/schema.prisma

@@ -0,0 +1,41 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite" // Set your database provider (e.g., "postgresql", "mysql", "sqlite", etc.)
+}
+
+
+// ============================= WARNING =====================================
+// This is the base schema for the authentication system. 
+// You can customize it as needed, but make sure to keep the relationships and 
+// fields that are essential for user authentication and session management.
+// ============================================================================
+
+// Model generated by system
+model User {
+  id    String  @id @default(uuid())
+  name  String
+  email String  @unique
+  password String
+
+  sessions Session[]
+}
+
+// Model generated by system
+model Session {
+  id        String  @id @default(uuid())
+  userId    String
+  token     String   @unique
+  createdAt DateTime @default(now())
+  expiresAt DateTime
+
+  user User @relation(fields: [userId], references: [id])
+}