bootifyjs 0.0.1 → 0.0.3

package/src/application/Application.ts

@@ -1,355 +0,0 @@
-import Fastify, {
-  FastifyInstance,
-  FastifyPluginAsync,
-  FastifyPluginCallback,
-  FastifyServerOptions,
-} from 'fastify';
-import { registerControllers } from '../decorators/controller.decorator';
-import Logger from '../logger/Logger';
-import { requestContext } from '../middleware/requestcontext';
-import { httpLoggerMiddleware } from '../middleware/http';
-
-interface FastifyServerConfig {
-  port?: number;
-  host?: string;
-  route?: FastifyPluginCallback | FastifyPluginAsync;
-  enableCors?: boolean;
-  enableSwagger?: boolean;
-  enableLogging?: boolean;
-  enableErrorHandling?: boolean;
-  enableDatabase?: boolean;
-  enableRedis?: boolean;
-  corsOptions?: {
-    origin?: string | string[];
-    methods?: string[];
-    credentials?: boolean;
-  };
-  swaggerOptions?: {
-    routePrefix?: string;
-    swaggerDoc?: any;
-  };
-  enableMetrics?: boolean;
-  enableCookie?: boolean;
-  enableAuth?: boolean;
-}
-
-export class Application {
-  private server: FastifyInstance;
-  private config: FastifyServerConfig;
-
-  constructor(config: FastifyServerConfig = {}) {
-    this.config = {
-      port: 3000,
-      host: '0.0.0.0',
-      enableCors: true,
-      enableSwagger: false,
-      enableLogging: true,
-      enableErrorHandling: true,
-      enableDatabase: false,
-      enableRedis: false,
-      enableCookie: false,
-      enableAuth: false,
-      enableMetrics: false,
-      corsOptions: {
-        origin: [
-          'http://localhost:4000',
-          'http://localhost:3000',
-          'http://localhost:5173',
-        ],
-        methods: ['GET', 'PUT', 'PATCH', 'POST', 'DELETE'],
-        credentials: true,
-      },
-      swaggerOptions: {
-        routePrefix: '/docs',
-        swaggerDoc: {
-          info: {
-            title: 'API Documentation',
-            version: '1.0.0',
-          },
-        },
-      },
-      ...config,
-    };
-
-    this.server = Fastify({
-      ajv: {
-        customOptions: {
-          strict: false,
-        },
-      },
-      genReqId: (req) => {
-        const requestId = req.headers['x-request-id'];
-        return Array.isArray(requestId) ? requestId[0] : requestId || crypto.randomUUID();
-      },
-    });
-
-    this.setupServer();
-  }
-
-  private async setupServer() {
-    try {
-      // Register CORS
-      // if (this.config.enableCors) {
-      //   Logger.info('Registering CORS');
-      //   await this.server.register(require('@fastify/cors'), this.config.corsOptions);
-      // }
-
-      // Register Swagger
-      // if (this.config.enableSwagger) {
-      //   await this.server.register(require('@fastify/swagger'), this.config.swaggerOptions?.swaggerDoc);
-      //   await this.server.register(require('@fastify/swagger-ui'), {
-      //     routePrefix: this.config.swaggerOptions?.routePrefix,
-      //   });
-      // }
-
-      // Register Cookie support
-      // if (this.config.enableCookie) {
-      //   await this.server.register(require('@fastify/cookie'), {
-      //     hook: 'onRequest',
-      //     parseOptions: {},
-      //   });
-      // }
-
-      // Register Metrics
-      // if (this.config.enableMetrics) {
-      //   await this.server.register(require('fastify-metrics'), {
-      //     endpoint: '/metrics',
-      //   });
-      // }
-
-      // Register error handling
-      if (this.config.enableErrorHandling) {
-        this.server.setErrorHandler(this.globalErrorHandler);
-      }
-
-      // Add common schemas
-      this.addCommonSchemas();
-
-      // Add logging hooks
-      if (this.config.enableLogging) {
-        this.setupLogging();
-      }
-
-      // Setup route logging
-      this.setupRouteLogging();
-
-      // Register custom routes
-      if (this.config.route) {
-        await this.server.register(this.config.route);
-      }
-
-    } catch (error) {
-      Logger.error('Failed to setup server:', error as Error);
-      throw error;
-    }
-  }
-
-  private globalErrorHandler = (error: any, request: any, reply: any) => {
-    Logger.error('Global error handler:', error);
-
-    const statusCode = error.statusCode || 500;
-    const message = error.message || 'Internal Server Error';
-
-    reply.status(statusCode).send({
-      statusCode,
-      error: error.name || 'Error',
-      message,
-    });
-  };
-
-  private addCommonSchemas() {
-    this.server.addSchema({
-      $id: 'errorResponseSchema',
-      type: 'object',
-      description: 'Error Response',
-      properties: {
-        statusCode: { type: 'number' },
-        error: { type: 'string' },
-        message: { type: 'string' },
-      },
-    });
-
-    this.server.addSchema({
-      $id: 'messageResponseSchema',
-      type: 'object',
-      description: 'Message Response',
-      properties: {
-        message: { type: 'string' },
-      },
-    });
-  }
-
-  private setupLogging() {
-    // requestContext.run
-
-    this.server.addHook('preHandler', (request, reply, done) => {
-      request.raw.id = request.id
-      reply.header('x-request-id', request.id)
-      httpLoggerMiddleware(request.raw, reply.raw)
-      // console.log('Request ID:', request.id)
-      // console.log('User ID:', request.user)
-
-      requestContext.run(
-        { requestId: request.id, userId: "pxpxpx", username: "priyadarship4@gmail.com" },
-        () => {
-          done()
-        }
-      )
-    })
-
-    // this.server.addHook('onRequest', async (request, reply) => {
-    //   const startTime = Date.now();
-    //   request.raw.startTime = startTime;
-    //   reply.header('x-request-id', request.id);
-
-    //   Logger.info({
-    //     requestId: request.id,
-    //     method: request.method,
-    //     url: request.url,
-    //     userAgent: request.headers['user-agent'],
-    //     ip: request.ip,
-    //     message: 'Incoming request'
-    //   });
-    // });
-
-    // this.server.addHook('onResponse', async (request, reply) => {
-    //   const duration = Date.now() - (request.raw.startTime || Date.now());
-
-    //   Logger.info({
-    //     requestId: request.id,
-    //     method: request.method,
-    //     url: request.url,
-    //     statusCode: reply.statusCode,
-    //     duration: `${duration}ms`,
-    //     message: 'Request completed'
-    //   });
-    // });
-  }
-
-  private setupRouteLogging() {
-    const routeOptions: any[] = [];
-
-    this.server.addHook('onRoute', (routeOption) => {
-      routeOptions.push(routeOption);
-    });
-
-    this.server.addHook('onReady', (done) => {
-      this.printFastifyRoutes(routeOptions, { colors: true });
-      done();
-    });
-  }
-
-  private printFastifyRoutes(routeOptions: any[], opts: { colors: boolean }) {
-    const { colors } = opts;
-
-    if (routeOptions.length === 0) {
-      return;
-    }
-
-    routeOptions.sort((a, b) => a.url.localeCompare(b.url));
-
-    const logEntries = [];
-    logEntries.push("Available routes:");
-
-    for (const routeOption of routeOptions) {
-      const { method, url } = routeOption;
-      if (method === "HEAD") continue;
-      const formattedMethod = colors ? this.colorMethod(method) : method;
-      logEntries.push(`${formattedMethod}\t${url}`);
-    }
-
-    Logger.info(logEntries.join("\n"));
-  }
-
-  private colorMethod(method: string): string {
-    const COLORS = {
-      yellow: 33,
-      green: 32,
-      blue: 34,
-      red: 31,
-      grey: 90,
-      clear: 39,
-    };
-
-    const colorText = (color: number, string: string): string => {
-      return `\u001b[${color}m${string}\u001b[${COLORS.clear}m`;
-    };
-
-    switch (method) {
-      case "POST": return colorText(COLORS.yellow, method);
-      case "GET": return colorText(COLORS.green, method);
-      case "PUT": return colorText(COLORS.blue, method);
-      case "DELETE": return colorText(COLORS.red, method);
-      case "PATCH": return colorText(COLORS.grey, method);
-      default: return method;
-    }
-  }
-
-  public registerControllers(controllers: Function[]) {
-    registerControllers(this.server, controllers);
-  }
-
-  public async start(port?: number, host?: string) {
-    const serverPort = port || this.config.port || 3000;
-    const serverHost = host || this.config.host || '0.0.0.0';
-
-    try {
-      // Initialize Redis if enabled
-      if (this.config.enableRedis) {
-        Logger.info('Connecting to Redis...');
-        // Add Redis initialization logic here
-        Logger.info('Redis connected');
-      }
-
-      // Initialize Database if enabled
-      if (this.config.enableDatabase) {
-        Logger.info('Connecting to database...');
-        // Add Database initialization logic here
-        Logger.info('Database connected');
-      }
-
-      Logger.info(`Starting server at http://${serverHost}:${serverPort}`);
-      await this.server.listen({ port: serverPort, host: serverHost });
-      Logger.info(`Server listening on http://${serverHost}:${serverPort}`);
-
-      // Setup graceful shutdown
-      this.setupGracefulShutdown();
-
-    } catch (err) {
-      // Logger.error(err)
-      Logger.error('Failed to start server:', err as Error);
-      process.exit(1);
-    }
-  }
-
-  private setupGracefulShutdown() {
-    const signals: NodeJS.Signals[] = ['SIGINT', 'SIGTERM'];
-
-    signals.forEach((signal) => {
-      process.on(signal, async () => {
-        try {
-          await this.server.close();
-          Logger.info(`Closed application on ${signal}`);
-          process.exit(0);
-        } catch (err) {
-          Logger.error(`Error closing application on ${signal}`, err as Error);
-          process.exit(1);
-        }
-      });
-    });
-
-    process.on('unhandledRejection', (err: Error) => {
-      // Logger.error(err)
-      Logger.error('Unhandled Rejection:', err as Error);
-      process.exit(1);
-    });
-  }
-
-  public getServer(): FastifyInstance {
-    return this.server;
-  }
-
-  public updateConfig(newConfig: Partial<FastifyServerConfig>) {
-    this.config = { ...this.config, ...newConfig };
-  }
-}

package/src/container/container.ts

@@ -1,28 +0,0 @@
-import { Container, injectable } from "inversify";
-const container = new Container();
-
-interface BeanOptions {
-    scope?: 'singleton' | 'transient';
-    bindTo?: Function[];  // Array of interfaces to bind to
-}
-export function Bean(options: BeanOptions) {
-    return function (target: any) {
-        const { scope = 'singleton', bindTo = [] } = options || {};
-
-        injectable()(target);
-
-        // Bind to self (class constructor)
-        const binding = container.bind(target).toSelf();
-        scope === 'singleton' ? binding.inSingletonScope() : binding.inTransientScope();
-
-        // Bind to each specified interface
-        bindTo.forEach(intrfc => {
-            const interfaceBinding = container.bind(intrfc).to(target);
-            scope === 'singleton'
-                ? interfaceBinding.inSingletonScope()
-                : interfaceBinding.inTransientScope();
-        });
-    };
-}
-
-export default container;

package/src/decorators/cache/ICacheClient.ts

@@ -1,5 +0,0 @@
-export interface ICacheClient {
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string, ttlSeconds?: number): Promise<void>;
-    del(key: string): Promise<void>;
-}

package/src/decorators/cache/cache.decorator.ts

@@ -1,36 +0,0 @@
-import container from '../../container/container';
-import { ICacheClient } from './ICacheClient';
-
-export function Cache(ttlSeconds: number = 60, keyGenerator?: (...args: any[]) => string): MethodDecorator {
-    return (target, propertyKey, descriptor) => {
-        const originalMethod = descriptor.value as (...args: any[]) => any;
-        const className = target.constructor.name;
-        const methodName = String(propertyKey);
-
-        descriptor.value = async function (this: any, ...args: any[]) {
-            const cacheClient = container.get<ICacheClient>('CacheClient');
-            const cacheKey = keyGenerator
-                ? keyGenerator(...args)
-                : `cache:${className}:${methodName}:${JSON.stringify(args)}`;
-
-            try {
-                const cached = await cacheClient.get(cacheKey);
-                if (cached) return JSON.parse(cached);
-            } catch (err) {
-                console.error('Cache read error:', err);
-            }
-
-            const result = await originalMethod.apply(this, args);
-
-            try {
-                await cacheClient.set(cacheKey, JSON.stringify(result), ttlSeconds);
-            } catch (err) {
-                console.error('Cache write error:', err);
-            }
-
-            return result;
-        } as any;
-
-        return descriptor;
-    };
-}

package/src/decorators/controller.decorator.ts

@@ -1,119 +0,0 @@
-import 'reflect-metadata';
-import { FastifyInstance, FastifyRequest, FastifyReply, RouteOptions } from 'fastify';
-import container from '../container/container';
-import Logger from '../logger/Logger';
-
-const CONTROLLER_METADATA = 'controller:metadata';
-export const ROUTE_METADATA = 'route:metadata';
-
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-
-interface RouteDefinition {
-  path: string;
-  method: HttpMethod;
-  handlerName: string;
-  options?: Partial<RouteOptions>;
-}
-
-export function Controller(prefix: string = ''): ClassDecorator {
-  return (target: Function) => {
-    Reflect.defineMetadata(CONTROLLER_METADATA, { prefix }, target);
-  };
-}
-
-export function registerControllers(fastify: FastifyInstance, controllers: Function[]) {
-  const routeOptions: any[] = [];
-
-  const fastifyWithHooks = fastify as unknown as {
-    addHook: (hookName: string, handler: (...args: any[]) => void) => void;
-  };
-
-  fastifyWithHooks.addHook("onRoute", (routeOption) => {
-    routeOptions.push(routeOption);
-  });
-
-  fastifyWithHooks.addHook("onReady", (done) => {
-    printFastifyRoutes(routeOptions, { colors: true });
-    done();
-  });
-
-  controllers.forEach(Controller => {
-    const controllerMetadata = Reflect.getMetadata(CONTROLLER_METADATA, Controller);
-    const routes: RouteDefinition[] = Reflect.getMetadata(ROUTE_METADATA, Controller) || [];
-    const controllerInstance = container.get(Controller) as Record<string, (request: FastifyRequest, reply: FastifyReply) => Promise<any>>;
-
-    const prefix = controllerMetadata?.prefix || '';
-
-    routes.forEach(route => {
-      const fullPath = `${prefix}${route.path}`.replace(/\/\//g, '/');
-
-      const handler = async (request: FastifyRequest, reply: FastifyReply) => {
-        try {
-          const result = await controllerInstance[route.handlerName](request, reply);
-          if (result !== undefined) return result;
-        } catch (error: any) {
-          Logger.error('Controller error:', error);
-          const statusCode = error.statusCode || 500;
-          const message = error.message || 'Internal Server Error';
-          reply.status(statusCode).send({ error: message });
-        }
-      };
-
-      const routeConfig = {
-        ...route.options,
-        handler,
-        url: fullPath,
-        method: route.method
-      };
-
-      (fastify as any).route(routeConfig);
-    });
-  });
-}
-
-export function printFastifyRoutes(routeOptions: any[], opts: { colors: boolean }) {
-  const { colors } = opts;
-
-  if (routeOptions.length === 0) {
-    return;
-  }
-
-  routeOptions.sort((a, b) => a.url.localeCompare(b.url));
-
-  const logEntries = [];
-  logEntries.push("Available routes:");
-
-  for (const routeOption of routeOptions) {
-    const { method, url } = routeOption;
-    if (method === "HEAD") continue;
-    const formattedMethod = colors ? colorMethod(method) : method;
-    logEntries.push(`${formattedMethod}\t${url}`);
-  }
-
-  Logger.info(logEntries.join("\n"));
-}
-
-const COLORS = {
-  yellow: 33,
-  green: 32,
-  blue: 34,
-  red: 31,
-  grey: 90,
-  magenta: 35,
-  clear: 39,
-};
-
-function colorText(color: number, string: string): string {
-  return `\u001b[${color}m${string}\u001b[${COLORS.clear}m`;
-}
-
-function colorMethod(method: string): string {
-  switch (method) {
-    case "POST": return colorText(COLORS.yellow, method);
-    case "GET": return colorText(COLORS.green, method);
-    case "PUT": return colorText(COLORS.blue, method);
-    case "DELETE": return colorText(COLORS.red, method);
-    case "PATCH": return colorText(COLORS.grey, method);
-    default: return method;
-  }
-}

package/src/decorators/http.decorator.ts

@@ -1,25 +0,0 @@
-import { ROUTE_METADATA } from './controller.decorator';
-
-export function createMethodDecorator(method: string) {
-  return (path: string = '', options?: any): MethodDecorator => {
-    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-      const routes: any[] = Reflect.getMetadata(ROUTE_METADATA, target.constructor) || [];
-
-      routes.push({
-        path,
-        method: method.toUpperCase(),
-        handlerName: propertyKey,
-        options
-      });
-
-      Reflect.defineMetadata(ROUTE_METADATA, routes, target.constructor);
-      return descriptor;
-    };
-  };
-}
-
-export const Get = createMethodDecorator('GET');
-export const Post = createMethodDecorator('POST');
-export const Put = createMethodDecorator('PUT');
-export const Delete = createMethodDecorator('DELETE');
-export const Patch = createMethodDecorator('PATCH');

package/src/decorators/timing.decorator.ts

@@ -1,23 +0,0 @@
-export function Timed(): MethodDecorator {
-    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-        const originalMethod = descriptor.value;
-
-        descriptor.value = async function (...args: any[]) {
-            const start = process.hrtime.bigint();
-            try {
-                const result = await originalMethod.apply(this, args);
-                const end = process.hrtime.bigint();
-                const duration = Number(end - start) / 1_000_000;
-                console.log(`[TIMED] ${target.constructor.name}.${String(propertyKey)} took ${duration.toFixed(2)}ms`);
-                return result;
-            } catch (error) {
-                const end = process.hrtime.bigint();
-                const duration = Number(end - start) / 1_000_000;
-                console.error(`[TIMED-ERROR] ${target.constructor.name}.${String(propertyKey)} failed after ${duration.toFixed(2)}ms`, error);
-                throw error;
-            }
-        };
-
-        return descriptor;
-    };
-}

package/src/decorators/transaction/IDatabaseClient.ts

@@ -1,9 +0,0 @@
-export interface ITransaction {
-    transaction: any;
-    commit: () => Promise<void>;
-    rollback: () => Promise<void>;
-}
-
-export interface IDatabaseClient {
-    startTransaction(): Promise<ITransaction>;
-}

package/src/decorators/transaction/transactional.decorator.ts

@@ -1,24 +0,0 @@
-import container from '../../container/container';
-import { IDatabaseClient } from './IDatabaseClient';
-
-export function Transactional(): MethodDecorator {
-    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-        const originalMethod = descriptor.value;
-
-        descriptor.value = async function (...args: any[]) {
-            const dbClient = container.get<IDatabaseClient>('DatabaseClient');
-            const transaction = await dbClient.startTransaction();
-
-            try {
-                const result = await originalMethod.apply(this, [...args, transaction.transaction]);
-                await transaction.commit();
-                return result;
-            } catch (error) {
-                await transaction.rollback();
-                throw error;
-            }
-        };
-
-        return descriptor;
-    };
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './application/Application';
-export { default as container, Bean } from './container/container';
-export * from './decorators/controller.decorator';
-export * from './decorators/http.decorator';
-export * from './decorators/timing.decorator';
-export * from './decorators/cache/cache.decorator';
-export * from './decorators/cache/ICacheClient';
-export * from './decorators/transaction/transactional.decorator';
-export * from './decorators/transaction/IDatabaseClient';
-export { default as logger, } from './logger/Logger';