@cristianrg/fastpress 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fastpress
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,180 @@
+# Fastpress
+
+Fastpress is an open-source project designed to empower developers to build backend applications easily. It features a clean, modern syntax inspired by major frameworks like SpringBoot, bringing that familiar structure to Node.js with TypeScript.
+
+## Features
+
+- **Integrated Daemon**: Includes a development mode that monitors .ts files. The server restarts automatically upon changes, eliminating the need for manual restarts.
+
+- **Automatic Controller Discovery**: No more manual registration. Your controllers (entry points) are automatically detected and registered by the system.
+
+- **Decorator-based Architecture**: Use decorators to register new controllers, define HTTP methods, apply middlewares, pipes, and more.
+
+- **Prisma Integration**: Powered by Prisma ORM for maximum flexibility and type safety. It is currently the primary database manager for the framework.
+
+- **Base Controllers**: Jumpstart your CRUD operations by extending a **Base** class. This provides out-of-the-box functionality to get all records, find by ID, create, update, and delete without writing boilerplate code.
+
+- **Hooks**: Events that are executed before and after a specific method is called. They allow data transformations, integration of elements into the request, and more.
+
+- **Centralized Configuration**: Allows you to change the behavior of certain elements in the application, such as the Prisma adapter or the logging system, through a centralized configuration file.
+
+- **Authentication**: Includes an authentication controller and middleware by default, using JWT for a token-based authentication method with refresh tokens and access tokens.
+
+
+## Usage Example
+
+Fastpress uses decorators and Zod schemas to keep your code clean and validated:
+
+```typescript
+const CreateUserSchema = z.object({
+    name: z.string().min(3).max(50),
+    email: z.string().email(),
+    age: z.number().int().min(18).optional()
+});
+
+@UseMiddleware(Auth, Sanitizer)
+@Controller("/users")
+class UserController {
+
+    @Get("/")
+    getAll(
+        @Query("page", ParseIntPipe) page: number = 1,
+        @Query("limit", ParseIntPipe) limit: number = 10
+    ) {
+        return new ServerResponse(200, "Users list", {
+            users: [], 
+            pagination: { page, limit, total: 0 }
+        });
+    }
+
+    @Post("/")
+    create(
+        @Body(undefined, new ZodValidationPipe(CreateUserSchema)) data: z.infer<typeof CreateUserSchema>,
+        @User() user: UserModel
+    ) {
+        return new ServerResponse(201, "User created", { data, createdBy: user });
+    }
+}
+```
+
+## Installation and Setup
+Follow these steps to get your environment ready:
+
+### 1) Clone the Repository
+Run the following command in your workspace to get the source code:
+
+```bash
+git clone https://github.com/CristianRG/fastpress.git
+```
+
+### 2) Install Dependencies
+Install the required packages using pnpm or npm:
+
+```bash
+pnpm install
+# or
+npm install
+```
+
+### 3) Prisma Configuration
+To start using the Prisma ORM, you need to make some configurations:
+
+Configure Prisma. You can customize the `prisma.config.ts` file and an `.env` file with your database connection URL:
+
+```ts
+// This is the default file provided by prisma
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    path: "prisma/migrations",
+  },
+  datasource: {
+    url: process.env["DATABASE_URL"],
+  },
+});
+```
+
+Create your .env file. You must create a .env file with the following variable:
+
+```bash
+DATABASE_URL=<your_database_url>
+```
+
+**Note:** Before proceeding, define your database provider in `prisma/schema.prisma` (this file is included in the repository because it contains authentication models required by the system) under the datasource block:
+
+```javascript
+datasource db {
+  provider = "sqlite" // Define your provider here
+}
+```
+
+Install the specific adapter for your chosen provider. For more details, refer to the official Prisma [documentation](https://www.prisma.io/docs/orm/overview/databases).
+
+Configure the adapter in the [Fastpress Config File](fastpress.config.ts). By default, it will be using `PrismaBetterSqlite3`, but once you've installed your provider, you can change this instance to yours and uninstall the default provider.
+
+```typescript
+server: {
+        // Some other configurations...
+        prismaAdapter: new PrismaBetterSqlite3({ url: process.env.DATABASE_URL || 'file:./dev.db' }),
+    },
+```
+
+Once configured, define your models in `prisma/schema.prisma` and generate the types:
+
+This creates a generated folder containing all the types Prisma needs to function and syncs your database with the models schema:
+
+```bash
+pnpx prisma db push
+```
+
+If the folder was not generated, you can run the following command:
+
+```bash
+pnpx prisma generate
+```
+
+### 4) Run the Project
+With everything configured, you are ready to start the server.
+
+**Development mode:**
+
+```bash
+pnpm run dev
+```
+
+**Production mode:**
+
+```bash
+pnpm run production
+```
+
+## Roadmap
+Fastpress is in its early stages. Future milestones include:
+
+- **Automated Prisma Setup**: A CLI-guided setup to install drivers automatically based on the selected database provider.
+
+- **CLI Scaffolding**: Commands like `npx fastpress generate` to automatically create controllers in the modules folder based on your database models (including flags to overwrite or skip files).
+
+- **Official CLI**: An `npx create fastpress` command to bootstrap new projects instantly.
+
+- **Dependency Abstraction**: Decouple the core to allow alternatives to Prisma or custom logging libraries.
+
+- **Testing Suite**: Built-in utilities to ensure application behavior remains consistent.
+
+## Motivation
+
+Initially, it was just a simple server using Express syntax, as it was intended to be an embedded server within a desktop application using Electron. However, with the constant implementation of new modules, the application grew to a point where it seemed unsustainable.
+
+Then Fastpress was born. Using modern syntax similar to frameworks like SpringBoot, it became possible to organize each new module in a simpler way, as they don't need to be manually imported into a file where the main instance is located along with other modules. Additionally, it features clean and easy-to-understand syntax.
+
+Although it's a small project that I maintain alone, I hope it will be useful to anyone interested, and that both you and I can learn a lot by developing this project. Even better, I would love to see what new features you can implement. 
+
+## Useful Resources
+- [Prisma Documentation](https://www.prisma.io/docs)
+- [Database Drivers Guide](https://www.prisma.io/docs/orm/overview/databases)
+
+## License
+>This project is licensed under the MIT License.
+
+## Author
+Created with 💙 by CristianRG

package/dist/common/decorators/Body.js

@@ -0,0 +1,20 @@
+import "reflect-metadata";
+import { PARAM_METADATA_KEY } from "./Param.js";
+/**
+ * Body decorator to extract data from the request body and inject it into the route handler's parameters. You can also apply pipes to transform or validate the data before it is passed to the route handler.
+ * @param propertyKey propertyKey is optional. If provided, it will extract the specific property from the request body (e.g., if you want to extract req.body.username, you would use @Body("username")). If not provided, it will inject the entire request body object into the parameter.
+ * @param pipes An array of Pipe instances or Pipe classes to be applied to the extracted data. Pipes are functions that can transform or validate the data before it is passed to the route handler. The pipes will be executed in the order they are provided in the array.
+ * @returns
+ */
+export function Body(propertyKey, ...pipes) {
+    return (target, methodName, parameterIndex) => {
+        const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, methodName) || [];
+        existingParams.push({
+            index: parameterIndex,
+            type: "body",
+            propertyKey,
+            pipes
+        });
+        Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, methodName);
+    };
+}

package/dist/common/decorators/Param.js

@@ -0,0 +1,23 @@
+import "reflect-metadata";
+const PARAM_METADATA_KEY = "custom:params";
+/**
+ * Param decorator to extract data from the route parameters and inject it into the route handler's parameters. You can also apply pipes to transform or validate the data before it is passed to the route handler.
+ * @param propertyKey propertyKey is optional. If provided, it will extract the specific property from the route parameters (e.g., if you want to extract req.params.id, you would use @Param("id")). If not provided, it will inject the entire route parameters object into the parameter.
+ * @param isOptional is optional. If set to true, it indicates that the parameter is optional. If the parameter is not present in the route parameters, it will be set to undefined instead of throwing an error.
+ * @param pipes An array of Pipe instances or Pipe classes to be applied to the extracted data. Pipes are functions that can transform or validate the data before it is passed to the route handler. The pipes will be executed in the order they are provided in the array.
+ * @returns
+ */
+export function Param(propertyKey, isOptional = false, ...pipes) {
+    return (target, methodName, parameterIndex) => {
+        const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, methodName) || [];
+        existingParams.push({
+            index: parameterIndex,
+            type: "param",
+            propertyKey,
+            isOptional,
+            pipes
+        });
+        Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, methodName);
+    };
+}
+export { PARAM_METADATA_KEY };

package/dist/common/decorators/Query.js

@@ -0,0 +1,20 @@
+import "reflect-metadata";
+import { PARAM_METADATA_KEY } from "./Param.js";
+/**
+ * Query decorator to extract data from the query parameters and inject it into the route handler's parameters. You can also apply pipes to transform or validate the data before it is passed to the route handler.
+ * @param propertyKey propertyKey is optional. If provided, it will extract the specific property from the query parameters (e.g., if you want to extract req.query.page, you would use @Query("page")). If not provided, it will inject the entire query parameters object into the parameter.
+ * @param pipes An array of Pipe instances or Pipe classes to be applied to the extracted data. Pipes are functions that can transform or validate the data before it is passed to the route handler. The pipes will be executed in the order they are provided in the array.
+ * @returns
+ */
+export function Query(propertyKey, ...pipes) {
+    return (target, methodName, parameterIndex) => {
+        const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, methodName) || [];
+        existingParams.push({
+            index: parameterIndex,
+            type: "query",
+            propertyKey,
+            pipes
+        });
+        Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, methodName);
+    };
+}

package/dist/common/decorators/Req.js

@@ -0,0 +1,32 @@
+import "reflect-metadata";
+import { PARAM_METADATA_KEY } from "./Param.js";
+/**
+ * Req decorator to inject the entire request object into the route handler's parameters. This is useful when you need access to the full request object, including headers, body, query parameters, etc.
+ * @returns
+ */
+export function Req() {
+    return (target, methodName, parameterIndex) => {
+        const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, methodName) || [];
+        existingParams.push({
+            index: parameterIndex,
+            type: "request",
+            pipes: []
+        });
+        Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, methodName);
+    };
+}
+/**
+ * Res decorator to inject the entire response object into the route handler's parameters. This is useful when you need access to the full response object to set headers, status codes, send responses, etc.
+ * @returns
+ */
+export function Res() {
+    return (target, methodName, parameterIndex) => {
+        const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, methodName) || [];
+        existingParams.push({
+            index: parameterIndex,
+            type: "response",
+            pipes: []
+        });
+        Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, methodName);
+    };
+}

package/dist/common/decorators/User.js

@@ -0,0 +1,17 @@
+import "reflect-metadata";
+import { PARAM_METADATA_KEY } from "./Param.js";
+/**
+ * User decorator to inject the authenticated user object into the route handler's parameters. This is useful when you have authentication middleware that attaches the user object to the request and you want to access it directly in your route handlers.
+ * @returns
+ */
+export function User() {
+    return (target, methodName, parameterIndex) => {
+        const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, methodName) || [];
+        existingParams.push({
+            index: parameterIndex,
+            type: "user",
+            pipes: []
+        });
+        Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, methodName);
+    };
+}

package/dist/common/loggers/Winston.js

@@ -0,0 +1,37 @@
+import conf from "../../conf/index.js";
+import { Logger } from "../../shared/models/Logger.js";
+import winston from "winston";
+const defaultFormat = winston.format.combine(winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston.format.printf(({ timestamp, level, message }) => {
+    return `${timestamp} - [${level}]: ${message}`;
+}));
+const defaultTransports = [
+    conf.ENV === 'production' ? new winston.transports.File({ filename: "logs/combined.log" }) : new winston.transports.Console(),
+    new winston.transports.File({ filename: "logs/error.log", level: "error" }),
+];
+class WinstonLogger extends Logger {
+    winstonLogger;
+    constructor(config) {
+        super();
+        this.winstonLogger = winston.createLogger({
+            level: conf.ENV === 'production' ? 'info' : 'debug',
+            format: config?.format ?? defaultFormat,
+            transports: config?.transports ?? defaultTransports,
+        });
+    }
+    log(message) {
+        this.winstonLogger.info(message);
+    }
+    info(message) {
+        this.winstonLogger.info(message);
+    }
+    error(message) {
+        this.winstonLogger.error(message);
+    }
+    warn(message) {
+        this.winstonLogger.warn(message);
+    }
+    debug(message) {
+        this.winstonLogger.debug(message);
+    }
+}
+export { WinstonLogger };

package/dist/common/pipes/ParseIntPipe.js

@@ -0,0 +1,11 @@
+import { Pipe } from "./Pipe.js";
+import { ServerResponse } from "../../shared/models/ServerResponse.js";
+export class ParseIntPipe extends Pipe {
+    transform(value, ctx) {
+        const parsed = parseInt(value, 10);
+        if (isNaN(parsed)) {
+            throw new ServerResponse(400, `Validation failed: "${value}" is not an integer`);
+        }
+        return parsed;
+    }
+}

package/dist/common/pipes/Pipe.js

@@ -0,0 +1,2 @@
+export class Pipe {
+}

package/dist/common/pipes/ZodValidationPipe.js

@@ -0,0 +1,26 @@
+import { Pipe } from "./Pipe.js";
+import { ServerResponse } from "../../shared/models/ServerResponse.js";
+import { z } from "zod";
+export class ZodValidationPipe extends Pipe {
+    schema;
+    constructor(schema) {
+        super();
+        this.schema = schema;
+    }
+    transform(value, ctx) {
+        try {
+            return this.schema.parse(value);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new ServerResponse(400, "Validation failed", {
+                    errors: error.issues.map(err => ({
+                        path: err.path.join('.'),
+                        message: err.message
+                    }))
+                });
+            }
+            throw error;
+        }
+    }
+}

package/dist/common/prisma/index.js

@@ -0,0 +1,26 @@
+import conf from "../../conf/index.js";
+import { PrismaClient } from "@prisma/client";
+let prisma = null;
+export function initializePrisma() {
+    if (!prisma) {
+        if (!conf.PRISMA_ADAPTER) {
+            throw new Error('Prisma adapter not configured. Make sure to call createServer() before using Prisma.');
+        }
+        prisma = new PrismaClient({ adapter: conf.PRISMA_ADAPTER });
+    }
+    return prisma;
+}
+export function getPrisma() {
+    if (!prisma) {
+        return initializePrisma();
+    }
+    return prisma;
+}
+const prismaProxy = new Proxy({}, {
+    get(target, prop) {
+        const instance = getPrisma();
+        const value = instance[prop];
+        return typeof value === 'function' ? value.bind(instance) : value;
+    }
+});
+export default prismaProxy;

package/dist/common/redis/index.js

@@ -0,0 +1,40 @@
+import { createClient } from "redis";
+import logger from "../../shared/repository/Logger.js";
+let client = null;
+let isConnected = false;
+async function getRedisClient() {
+    if (isConnected && client) {
+        return client;
+    }
+    if (!client) {
+        try {
+            client = createClient({
+                socket: {
+                    reconnectStrategy: false
+                }
+            });
+            client.on('error', (err) => {
+                logger.error(`Redis Client Error: ${err}`);
+                isConnected = false;
+            });
+            await client.connect();
+            isConnected = true;
+            return client;
+        }
+        catch (error) {
+            client = null;
+            isConnected = false;
+            return null;
+        }
+    }
+    return client;
+}
+async function disconnectRedis() {
+    if (client && isConnected) {
+        await client.quit();
+        client = null;
+        isConnected = false;
+    }
+}
+export { getRedisClient, disconnectRedis };
+export default getRedisClient;

package/dist/common/util/index.js

@@ -0,0 +1,13 @@
+import bycrypt from 'bcrypt';
+import z from 'zod';
+const zodText = z.string().min(1, "Text cannot be empty").max(72, "Text exceeds maximum length of 72 bytes for bcrypt");
+const encrypt = (text, options) => {
+    const parsedText = zodText.parse(text); // This will throw if the text is invalid, ensuring we only hash valid strings
+    const saltRounds = options?.saltRounds || 10;
+    const salt = bycrypt.genSaltSync(saltRounds);
+    return bycrypt.hashSync(parsedText, salt);
+};
+const compare = (text, hash) => {
+    return bycrypt.compareSync(text, hash);
+};
+export { encrypt, compare };

package/dist/conf/config.js

@@ -0,0 +1,4 @@
+function defineFastPressConfig(config) {
+    return config;
+}
+export { defineFastPressConfig };

package/dist/conf/index.js

@@ -0,0 +1,60 @@
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { pathToFileURL } from 'url';
+import createJiti from 'jiti';
+const defaultConfig = {
+    PORT: parseInt(process.env.PORT || '3000'),
+    ALLOWED_ORIGINS: process.env.ALLOWED_ORIGINS ? process.env.ALLOWED_ORIGINS.split(',') : ['http://localhost:3000'],
+    JWT_SECRET: process.env.JWT_SECRET || Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),
+    ENV: process.env.NODE_ENV || 'development',
+    ALGORITHM: 'HS256',
+    JWT_EXPIRATION: 15 * 60 * 1000, // 15 minutes
+    RJWT_EXPIRATION: 7 * 24 * 60 * 60 * 1000, // 7 days
+    LOGGER_INSTANCE: null,
+    PRISMA_ADAPTER: null,
+};
+const conf = { ...defaultConfig };
+let isConfigLoaded = false;
+function printConfigDetails() {
+    console.log(`\n================== FastPress Configuration =================`);
+    console.log(`PORT: ${conf.PORT}`);
+    console.log(`ENV: ${conf.ENV}`);
+    console.log(`============================================================`);
+}
+async function loadUserConfig() {
+    const configPath = resolve(process.cwd(), 'fastpress.config.ts');
+    const jiti = createJiti(import.meta.url);
+    if (existsSync(configPath)) {
+        try {
+            const configUrl = pathToFileURL(configPath).href;
+            const userConfigModule = await jiti.import(configUrl, { default: true });
+            return userConfigModule;
+        }
+        catch (error) {
+            console.warn('We cant load fastpress.config.ts:', error);
+            return undefined;
+        }
+    }
+    return undefined;
+}
+export async function initializeConfig() {
+    if (isConfigLoaded) {
+        return conf;
+    }
+    const userConfig = await loadUserConfig();
+    if (userConfig) {
+        conf.PORT = userConfig.server?.port ?? defaultConfig.PORT;
+        conf.ALLOWED_ORIGINS = userConfig.server?.allowedOrigins ?? defaultConfig.ALLOWED_ORIGINS;
+        conf.JWT_SECRET = userConfig.jwt?.secret ?? defaultConfig.JWT_SECRET;
+        conf.ENV = userConfig.server?.env ?? defaultConfig.ENV;
+        conf.ALGORITHM = userConfig.jwt?.algorithm ?? defaultConfig.ALGORITHM;
+        conf.JWT_EXPIRATION = userConfig.jwt?.jwt_exp ?? defaultConfig.JWT_EXPIRATION;
+        conf.RJWT_EXPIRATION = userConfig.jwt?.refresh_exp ?? defaultConfig.RJWT_EXPIRATION;
+        conf.LOGGER_INSTANCE = userConfig.server?.logger ?? defaultConfig.LOGGER_INSTANCE;
+        conf.PRISMA_ADAPTER = userConfig.server?.prismaAdapter ?? defaultConfig.PRISMA_ADAPTER;
+        printConfigDetails();
+    }
+    isConfigLoaded = true;
+    return conf;
+}
+export default conf;