@syntay/fastay 0.1.5 → 0.1.7

package/dist/app.js

@@ -4,6 +4,7 @@ import { loadApiRoutes } from './router.js';
 import { loadFastayMiddlewares, createMiddleware, } from './middleware.js';
 import { logger } from './logger.js';
 import { printBanner } from './banner.js';
+import { RequestCookies } from './utils/cookies.js';
 /**
  * Bootstraps and configures a Fastay application.
  *
@@ -91,8 +92,9 @@ export async function createApp(opts) {
     const isMiddleware = await loadFastayMiddlewares(app);
     // health check
     app.get('/_health', (_, res) => res.json({ ok: true }));
-    app.use((_req, res, next) => {
+    app.use((req, res, next) => {
         res.setHeader('X-Powered-By', 'Syntay Engine');
+        req.cookies = new RequestCookies(req.headers.cookie);
         next();
     });
     // load routes

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { createApp } from './app.js';
 export { createMiddleware } from './middleware.js';
 export type { CreateAppOptions } from './app.js';
-export { Request, Response, Next } from './types';
+export type { Request, Response, Next } from './types';

package/dist/router.js

@@ -42,6 +42,61 @@ function wrapHandler(fn, routePath, filePath) {
                 return;
             if (result === undefined)
                 return;
+            // Suporte a status e cookies customizado
+            // if (
+            //   typeof result === 'object' &&
+            //   'status' in result &&
+            //   'body' in result &&
+            //   typeof result.status === 'number'
+            // ) {
+            //   return res.status(result.status).json(result.body);
+            // }
+            if (typeof result === 'object' && result !== null) {
+                const typedResult = result;
+                // redirect
+                if (typedResult.redirect) {
+                    return res.redirect(typedResult.status ?? 302, typedResult.redirect);
+                }
+                //headers
+                if (typedResult.headers) {
+                    for (const [h, v] of Object.entries(typedResult.headers)) {
+                        res.setHeader(h, v);
+                    }
+                }
+                //file
+                if (typedResult.file) {
+                    const { path, filename, options } = typedResult.file;
+                    if (filename) {
+                        return res.download(path, filename, options);
+                    }
+                    return res.download(path, options);
+                }
+                // stream
+                if (typedResult.stream) {
+                    if (typedResult.headers) {
+                        for (const [h, v] of Object.entries(typedResult.headers))
+                            res.setHeader(h, v);
+                    }
+                    return typedResult.stream.pipe(res);
+                }
+                // raw
+                if (typedResult.raw) {
+                    if (typedResult.headers) {
+                        for (const [h, v] of Object.entries(typedResult.headers))
+                            res.setHeader(h, v);
+                    }
+                    return res.status(typedResult.status ?? 200).send(typedResult.raw);
+                }
+                if (typedResult.cookies) {
+                    for (const [name, data] of Object.entries(typedResult.cookies)) {
+                        res.cookie(name, data.value, data.options || {});
+                    }
+                }
+                const statusCode = typeof result.status === 'number' ? result.status : 200;
+                const body = result.body ?? result; // se não existir body, retorna o objeto inteiro
+                return res.status(statusCode).json(body);
+            }
+            // Suporte a retorno simples
             if (typeof result === 'string')
                 return res.send(result);
             if (typeof result === 'number')
@@ -50,31 +105,7 @@ function wrapHandler(fn, routePath, filePath) {
         }
         catch (err) {
             const stack = err?.stack?.split('\n').slice(0, 3).join('\n') || '';
-            // logger.error(
-            //   `✗ Runtime Error in route [${req.method} ${routePath}]\n` +
-            //     `  File: ${filePath}\n` +
-            //     `  ${err.name}: ${err.message || 'Unknown error'}\n` +
-            //     `  Stack: ${stack}`
-            // );
-            let fileInfo = '';
-            if (err.stack) {
-                const stackLine = err.stack.split('\n')[1]; // pega primeira linha depois do erro
-                const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
-                if (match) {
-                    const [_, file, line, col] = match;
-                    fileInfo = `${file}:${line}:${col}`;
-                    // Tenta mostrar o trecho da linha que deu erro
-                    if (fs.existsSync(file)) {
-                        const codeLines = fs.readFileSync(file, 'utf-8').split('\n');
-                        const codeSnippet = codeLines[parseInt(line) - 1].trim();
-                        fileInfo += ` → ${codeSnippet}`;
-                    }
-                }
-            }
-            // logger.group(`✗ Runtime Error in route  [${req.method} ${routePath}]`);
             logger.error(`${err.name}: ${err.message}`);
-            if (fileInfo)
-                logger.error(`Location: ${fileInfo}`);
             next(err);
         }
     };

package/dist/types/index.d.ts

@@ -1,8 +1,59 @@
 import { Request as ExpressRequest, Response as ExpressResponse, NextFunction } from 'express';
-/**
- * Request e Response do Express
- * Podem ser usados nos handlers do usuário
- */
-export type Request = ExpressRequest;
+export interface CookieItem {
+    value: string;
+}
+export interface RequestCookies {
+    /**
+     * Retrieves a cookie by its name.
+     * @param name - The name of the cookie to retrieve.
+     * @returns An object containing the cookie's value, or undefined if not found.
+     */
+    get(name: string): CookieItem | undefined;
+    /**
+     * Checks if a cookie with the given name exists.
+     * @param name - The name of the cookie to check.
+     * @returns True if the cookie exists, false otherwise.
+     */
+    has(name: string): boolean;
+    /**
+     * Returns all cookies as a key-value object.
+     * @returns An object where keys are cookie names and values are cookie values.
+     */
+    all(): Record<string, string>;
+}
+export interface Request extends ExpressRequest {
+    /**
+     * Represents the cookies sent in a request.
+     */
+    cookies: RequestCookies;
+}
 export type Response = ExpressResponse;
 export type Next = NextFunction;
+declare global {
+    type FastayResponse = {
+        status?: number;
+        body?: any;
+        cookies?: Record<string, {
+            value: string;
+            options?: any;
+        }>;
+        headers?: Record<string, string>;
+        redirect?: string;
+        file?: {
+            path: string;
+            filename?: string;
+            options?: any;
+        };
+        stream?: NodeJS.ReadableStream;
+        raw?: Buffer | string;
+    };
+}
+export type RouteHandler = (() => FastayResponse | any) | ((req: Request) => FastayResponse | any) | ((req: Request, res: Response) => FastayResponse | any);
+export interface CookieItem {
+    value: string;
+}
+declare module 'express-serve-static-core' {
+    interface Request {
+        typedCookies: RequestCookies | any;
+    }
+}

package/dist/utils/cookies.d.ts

@@ -0,0 +1,9 @@
+export declare class RequestCookies {
+    private cookies;
+    constructor(cookieHeader: string | undefined);
+    get(name: string): {
+        value: string;
+    } | undefined;
+    has(name: string): boolean;
+    all(): Record<string, string>;
+}

package/dist/utils/cookies.js

@@ -0,0 +1,27 @@
+export class RequestCookies {
+    constructor(cookieHeader) {
+        this.cookies = new Map();
+        if (!cookieHeader)
+            return;
+        cookieHeader.split(';').forEach((cookie) => {
+            const [name, ...rest] = cookie.trim().split('=');
+            if (!name)
+                return;
+            this.cookies.set(name, decodeURIComponent(rest.join('=')));
+        });
+    }
+    get(name) {
+        const value = this.cookies.get(name);
+        if (!value)
+            return undefined;
+        return { value };
+    }
+    has(name) {
+        return this.cookies.has(name);
+    }
+    all() {
+        const obj = {};
+        this.cookies.forEach((v, k) => (obj[k] = v));
+        return obj;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syntay/fastay",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Framework backend moderno baseado em Express.js, para criar APIs rapidamente",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/app.ts

@@ -10,6 +10,7 @@ import { logger } from './logger.js';
 import { printBanner } from './banner.js';
 import type { ServeStaticOptions } from 'serve-static';
 import { Next, Request, Response } from './types/index.js';
+import { RequestCookies } from './utils/cookies.js';
 
 /**
  * Express configuration options applied automatically by Fastay
@@ -214,8 +215,9 @@ export async function createApp(opts?: CreateAppOptions) {
 
   // health check
   app.get('/_health', (_, res) => res.json({ ok: true }));
-  app.use((_req: Request, res: Response, next: Next) => {
+  app.use((req: Request, res: Response, next: Next) => {
     res.setHeader('X-Powered-By', 'Syntay Engine');
+    (req as any).cookies = new RequestCookies(req.headers.cookie);
     next();
   });
 

package/src/index.ts

@@ -1,4 +1,4 @@
 export { createApp } from './app.js';
 export { createMiddleware } from './middleware.js';
 export type { CreateAppOptions } from './app.js';
-export { Request, Response, Next } from './types';
+export type { Request, Response, Next } from './types';

package/src/router.ts

@@ -47,41 +47,96 @@ function wrapHandler(fn: Function, routePath: string, filePath: string) {
   return async (req: Request, res: Response, next: NextFunction) => {
     try {
       const result = fn.length >= 2 ? await fn(req, res) : await fn(req);
+
       if (res.headersSent) return;
       if (result === undefined) return;
-      if (typeof result === 'string') return res.send(result);
-      if (typeof result === 'number') return res.send(String(result));
-      return res.json(result);
-    } catch (err: any) {
-      const stack = err?.stack?.split('\n').slice(0, 3).join('\n') || '';
-      // logger.error(
-      //   `✗ Runtime Error in route [${req.method} ${routePath}]\n` +
-      //     `  File: ${filePath}\n` +
-      //     `  ${err.name}: ${err.message || 'Unknown error'}\n` +
-      //     `  Stack: ${stack}`
-      // );
 
-      let fileInfo = '';
-      if (err.stack) {
-        const stackLine = err.stack.split('\n')[1]; // pega primeira linha depois do erro
-        const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
-        if (match) {
-          const [_, file, line, col] = match;
-          fileInfo = `${file}:${line}:${col}`;
+      // Suporte a status e cookies customizado
+      // if (
+      //   typeof result === 'object' &&
+      //   'status' in result &&
+      //   'body' in result &&
+      //   typeof result.status === 'number'
+      // ) {
+      //   return res.status(result.status).json(result.body);
+      // }
+      if (typeof result === 'object' && result !== null) {
+        const typedResult = result as {
+          status?: number;
+          body?: any;
+          cookies?: Record<string, { value: string; options?: any }>;
+          headers?: Record<string, string>;
+          redirect?: string;
+          file?: {
+            path: string;
+            filename?: string;
+            options?: any;
+          };
+          stream?: NodeJS.ReadableStream;
+          raw?: Buffer | string;
+        };
+
+        // redirect
+        if (typedResult.redirect) {
+          return res.redirect(typedResult.status ?? 302, typedResult.redirect);
+        }
 
-          // Tenta mostrar o trecho da linha que deu erro
-          if (fs.existsSync(file)) {
-            const codeLines = fs.readFileSync(file, 'utf-8').split('\n');
-            const codeSnippet = codeLines[parseInt(line) - 1].trim();
-            fileInfo += ` → ${codeSnippet}`;
+        //headers
+        if (typedResult.headers) {
+          for (const [h, v] of Object.entries(typedResult.headers)) {
+            res.setHeader(h, v);
           }
         }
+
+        //file
+        if (typedResult.file) {
+          const { path, filename, options } = typedResult.file;
+
+          if (filename) {
+            return res.download(path, filename, options);
+          }
+
+          return res.download(path, options);
+        }
+
+        // stream
+        if (typedResult.stream) {
+          if (typedResult.headers) {
+            for (const [h, v] of Object.entries(typedResult.headers))
+              res.setHeader(h, v);
+          }
+          return typedResult.stream.pipe(res);
+        }
+
+        // raw
+        if (typedResult.raw) {
+          if (typedResult.headers) {
+            for (const [h, v] of Object.entries(typedResult.headers))
+              res.setHeader(h, v);
+          }
+          return res.status(typedResult.status ?? 200).send(typedResult.raw);
+        }
+
+        if (typedResult.cookies) {
+          for (const [name, data] of Object.entries(typedResult.cookies)) {
+            res.cookie(name, data.value, data.options || {});
+          }
+        }
+
+        const statusCode =
+          typeof result.status === 'number' ? result.status : 200;
+
+        const body = result.body ?? result; // se não existir body, retorna o objeto inteiro
+        return res.status(statusCode).json(body);
       }
 
-      // logger.group(`✗ Runtime Error in route  [${req.method} ${routePath}]`);
+      // Suporte a retorno simples
+      if (typeof result === 'string') return res.send(result);
+      if (typeof result === 'number') return res.send(String(result));
+      return res.json(result);
+    } catch (err: any) {
+      const stack = err?.stack?.split('\n').slice(0, 3).join('\n') || '';
       logger.error(`${err.name}: ${err.message}`);
-      if (fileInfo) logger.error(`Location: ${fileInfo}`);
-
       next(err);
     }
   };

package/src/types/fastay-global.d.ts

@@ -0,0 +1,7 @@
+import { RequestCookies } from '../src/utils/cookies';
+
+declare module 'express-serve-static-core' {
+  interface Request {
+    cookies: RequestCookies;
+  }
+}

package/src/types/fastay.d.ts

@@ -0,0 +1,9 @@
+export interface CookieItem {
+  value: string;
+}
+
+export interface RequestCookies {
+  get(name: string): CookieItem | undefined;
+  has(name: string): boolean;
+  all(): Record<string, string>;
+}

package/src/types/index.ts

@@ -4,10 +4,68 @@ import {
   NextFunction,
 } from 'express';
 
-/**
- * Request e Response do Express
- * Podem ser usados nos handlers do usuário
- */
-export type Request = ExpressRequest;
+export interface CookieItem {
+  value: string;
+}
+
+export interface RequestCookies {
+  /**
+   * Retrieves a cookie by its name.
+   * @param name - The name of the cookie to retrieve.
+   * @returns An object containing the cookie's value, or undefined if not found.
+   */
+  get(name: string): CookieItem | undefined;
+
+  /**
+   * Checks if a cookie with the given name exists.
+   * @param name - The name of the cookie to check.
+   * @returns True if the cookie exists, false otherwise.
+   */
+  has(name: string): boolean;
+
+  /**
+   * Returns all cookies as a key-value object.
+   * @returns An object where keys are cookie names and values are cookie values.
+   */
+  all(): Record<string, string>;
+}
+
+export interface Request extends ExpressRequest {
+  /**
+   * Represents the cookies sent in a request.
+   */
+  cookies: RequestCookies;
+  // params:
+  // query:
+}
+
 export type Response = ExpressResponse;
 export type Next = NextFunction;
+
+declare global {
+  type FastayResponse = {
+    status?: number;
+    body?: any;
+    cookies?: Record<string, { value: string; options?: any }>;
+    headers?: Record<string, string>;
+    redirect?: string;
+    file?: { path: string; filename?: string; options?: any };
+    stream?: NodeJS.ReadableStream;
+    raw?: Buffer | string;
+  };
+}
+
+export type RouteHandler =
+  | (() => FastayResponse | any)
+  | ((req: Request) => FastayResponse | any)
+  | ((req: Request, res: Response) => FastayResponse | any);
+
+export interface CookieItem {
+  value: string;
+}
+
+declare module 'express-serve-static-core' {
+  interface Request {
+    typedCookies: RequestCookies | any;
+  }
+}

package/src/utils/cookies.ts

@@ -0,0 +1,32 @@
+// utils/cookies.ts
+import { IncomingMessage } from 'http';
+
+export class RequestCookies {
+  private cookies: Map<string, string> = new Map();
+
+  constructor(cookieHeader: string | undefined) {
+    if (!cookieHeader) return;
+
+    cookieHeader.split(';').forEach((cookie) => {
+      const [name, ...rest] = cookie.trim().split('=');
+      if (!name) return;
+      this.cookies.set(name, decodeURIComponent(rest.join('=')));
+    });
+  }
+
+  public get(name: string) {
+    const value = this.cookies.get(name);
+    if (!value) return undefined;
+    return { value };
+  }
+
+  public has(name: string) {
+    return this.cookies.has(name);
+  }
+
+  public all() {
+    const obj: Record<string, string> = {};
+    this.cookies.forEach((v, k) => (obj[k] = v));
+    return obj;
+  }
+}

package/tsconfig.json

@@ -4,14 +4,16 @@
     "module": "CommonJS",
     "rootDir": "src",
     "outDir": "dist",
+    "baseUrl": ".",
     "strict": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": true,
     "moduleResolution": "node",
     "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true
+    "allowSyntheticDefaultImports": true,
+    "typeRoots": ["./node_modules/@types", "./types"]
   },
-  "include": ["src"],
+  "include": ["src", "types"],
   "exclude": ["node_modules", "dist"]
 }