shuttlepro-shared 1.3.19 → 1.3.20

package/utils/decorator-factory.js

@@ -0,0 +1,264 @@
+const express = require("express");
+const logger = require("./logger");
+const cors = require("cors");
+const helmet = require("helmet");
+
+// Controller Decorator
+function Controller(basePath) {
+  return function (target) {
+    target.prototype.basePath = basePath;
+  };
+}
+
+// Modified method decorator factory to handle pending middlewares
+function createMethodDecorator(method) {
+  return function (path = "") {
+    return function (target, key, descriptor) {
+      if (!target.constructor.prototype.routes) {
+        target.constructor.prototype.routes = [];
+      }
+
+      // Create route object
+      const route = {
+        method,
+        path,
+        handlerName: key,
+        handler: descriptor.value,
+        middlewares: [],
+        guards: [],
+        interceptors: [],
+        pipes: [],
+        auth: null,
+      };
+
+      // Check if there are any pending middlewares for this route
+      if (
+        target.constructor.prototype._pendingMiddlewares &&
+        target.constructor.prototype._pendingMiddlewares[key]
+      ) {
+        route.middlewares.push(
+          ...target.constructor.prototype._pendingMiddlewares[key]
+        );
+        // Clear the pending middlewares
+        delete target.constructor.prototype._pendingMiddlewares[key];
+      }
+
+      target.constructor.prototype.routes.push(route);
+
+      return descriptor;
+    };
+  };
+}
+
+// HTTP Method Decorators
+const Get = createMethodDecorator("get");
+const Post = createMethodDecorator("post");
+const Put = createMethodDecorator("put");
+const Delete = createMethodDecorator("delete");
+const Patch = createMethodDecorator("patch");
+
+function formatResponse(data, code = 200, message = "Success") {
+  return { code, message, data };
+}
+
+function Middleware(middlewares = []) {
+  return function (target) {
+    if (!target.prototype.middlewares) {
+      target.prototype.middlewares = [];
+    }
+    target.prototype.middlewares = [
+      ...target.prototype.middlewares,
+      ...middlewares,
+    ]; // Append instead of overwrite
+  };
+}
+
+function UseMiddleware(...middlewares) {
+  return function (target, key, descriptor) {
+    // Initialize routes array if it doesn't exist
+    if (!target.constructor.prototype.routes) {
+      target.constructor.prototype.routes = [];
+    }
+
+    // Find the route by handlerName
+    const route = target.constructor.prototype.routes.find(
+      (r) => r.handlerName === key
+    );
+
+    if (route) {
+      // Ensure route.middlewares is initialized
+      if (!route.middlewares) {
+        route.middlewares = [];
+      }
+      // Add the middlewares to the route
+      route.middlewares.push(...middlewares);
+    } else {
+      // If the route doesn't exist yet (decorator order issue),
+      // we need to create a route object that will be used later
+      target.constructor.prototype._pendingMiddlewares =
+        target.constructor.prototype._pendingMiddlewares || {};
+
+      if (!target.constructor.prototype._pendingMiddlewares[key]) {
+        target.constructor.prototype._pendingMiddlewares[key] = [];
+      }
+
+      target.constructor.prototype._pendingMiddlewares[key].push(
+        ...middlewares
+      );
+    }
+
+    return descriptor;
+  };
+}
+
+// Guard Decorator
+function Guard(...guards) {
+  return function (target, key, descriptor) {
+    const route = target.constructor.prototype.routes.find(
+      (r) => r.handlerName === key
+    );
+    if (route) {
+      route.guards = [...(route.guards || []), ...guards];
+    }
+    return descriptor;
+  };
+}
+
+// Auth Decorator
+function Auth(authConfig) {
+  return function (target, key, descriptor) {
+    const route = target.constructor.prototype.routes.find(
+      (r) => r.handlerName === key
+    );
+    if (route) {
+      route.auth = authConfig;
+    }
+    return descriptor;
+  };
+}
+
+// Pipe Decorator
+function Pipe(...pipes) {
+  return function (target, key, descriptor) {
+    const route = target.constructor.prototype.routes.find(
+      (r) => r.handlerName === key
+    );
+    if (route) {
+      route.pipes = [...(route.pipes || []), ...pipes];
+    }
+    return descriptor;
+  };
+}
+
+// Error Handling Middleware
+function asyncHandler(fn) {
+  return async (req, res, next) => {
+    try {
+      const result = await fn(req, res, next);
+      res.status(result.code || 200).json(result);
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+function createRouterFromController(ControllerClass) {
+  const controller = new ControllerClass();
+  const router = express.Router();
+  const basePath = controller.constructor.prototype.basePath || "";
+  const globalMiddlewares = controller.constructor.prototype.middlewares || []; // Retrieve global middlewares
+
+  if (controller.constructor.prototype.routes) {
+    controller.constructor.prototype.routes.forEach((route) => {
+      const { method, path, handler, middlewares, guards, pipes, auth } = route;
+
+      const middlewareChain = [
+        ...(auth ? [createAuthMiddleware(auth)] : []),
+        ...globalMiddlewares, // Apply global middlewares first
+        ...guards.map((guard) => createGuardMiddleware(guard)),
+        ...middlewares, // Then apply route-specific middlewares
+        asyncHandler(async (req) => {
+          if (pipes.length > 0) {
+            req.body = pipes.reduce(
+              (data, pipe) => pipe.transform(data),
+              req.body
+            );
+          }
+          return await handler.call(controller, req);
+        }),
+      ];
+
+      router[method](path, ...middlewareChain);
+    });
+  }
+
+  router.use((error, req, res, next) => {
+    console.error("Route error:", error);
+    res
+      .status(500)
+      .json({ code: 500, message: error.message || "Internal Server Error" });
+  });
+
+  return { basePath, router };
+}
+
+/**
+ * Configure Express middleware and settings
+ * @param {Express.Application} app - Express application instance
+ */
+
+function configureMiddleware(app, config) {
+  // Request parsing middleware
+  app.use(express.json({ limit: config?.limit || "10mb" }));
+  app.use(
+    express.urlencoded({ limit: config?.limit || "10mb", extended: true })
+  );
+
+  // Security middleware
+  app.use(
+    cors({
+      origin: config?.ALLOWED_URLS,
+      credentials: true,
+    })
+  );
+  app.use(helmet());
+
+  // Request logging
+  app.use((req, res, next) => {
+    logger.info(`${req.method} ${req.originalUrl}`);
+    if (req.method !== "GET") {
+      logger.debug("Request Body:", req.body);
+    }
+    next();
+  });
+}
+
+// App Initialization
+function createApp(controllers, config) {
+  const app = express(); // Ensure express is initialized
+  configureMiddleware(app, config);
+
+  controllers.forEach((ControllerClass) => {
+    const { basePath, router } = createRouterFromController(ControllerClass);
+    app.use(`${config?.globalPrefix}${basePath}`, router); // Apply global prefix
+  });
+
+  return app; // Return a properly configured express app
+}
+
+module.exports = {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Patch,
+  UseMiddleware,
+  Guard,
+  Auth,
+  Pipe,
+  createRouterFromController,
+  createApp,
+  formatResponse,
+  Middleware,
+};

package/utils/logger.js

@@ -0,0 +1,41 @@
+/**
+ * Simple logger utility for consistent logging
+ * Can be replaced with a more robust solution like Winston or Pino
+ */
+const logger = {
+  /**
+   * Log info level messages
+   * @param  {...any} args - Arguments to log
+   */
+  info: (...args) => {
+    console.log(`[${new Date().toISOString()}] [INFO]`, ...args);
+  },
+
+  /**
+   * Log debug level messages
+   * @param  {...any} args - Arguments to log
+   */
+  debug: (...args) => {
+    if (process.env.NODE_ENV !== "production") {
+      console.log(`[${new Date().toISOString()}] [DEBUG]`, ...args);
+    }
+  },
+
+  /**
+   * Log error level messages
+   * @param  {...any} args - Arguments to log
+   */
+  error: (...args) => {
+    console.error(`[${new Date().toISOString()}] [ERROR]`, ...args);
+  },
+
+  /**
+   * Log warning level messages
+   * @param  {...any} args - Arguments to log
+   */
+  warn: (...args) => {
+    console.warn(`[${new Date().toISOString()}] [WARN]`, ...args);
+  },
+};
+
+module.exports = logger;