shuttlepro-shared 1.1.54 → 1.1.56

package/config/bull.js

@@ -0,0 +1,78 @@
+const Queue = require("bull");
+const config = require("./config");
+
+/**
+ * Create a new queue.
+ * @param {string} queueName - The name of the queue.
+ * @param {Object} [redisConfig=config.redis] - Redis configuration.
+ * @returns {Object} - A collection of queue-related functions.
+ */
+const createQueue = (queueName, redisConfig = config.redis) => {
+  const queue = new Queue(queueName, { redis: redisConfig });
+
+  // Attach event listeners for logging
+  queue.on("completed", (job) => console.log(`Job ${job.id} completed.`));
+  queue.on("failed", (job, err) => console.error(`Job ${job.id} failed:`, err));
+
+  /**
+   * Add a job to the queue.
+   * @param {Object} data - Data to be processed by the job.
+   * @param {Object} [options] - Bull job options (e.g., delay, attempts).
+   * @returns {Promise<Job>} - The created job.
+   */
+  const addJob = async (
+    data,
+    options = {
+      attempts: 3,
+      removeOnComplete: true,
+    }
+  ) => {
+    return await queue.add(data, options);
+  };
+
+  /**
+   * Process jobs in the queue.
+   * @param {Function} processor - The function to process each job.
+   */
+  const processJobs = (processor) => {
+    queue.process(processor);
+  };
+
+  /**
+   * Close the queue connection.
+   * @returns {Promise<void>}
+   */
+  const closeConnection = async () => {
+    await queue.close();
+    console.log(`Queue "${queue.name}" connection closed.`);
+  };
+
+  /**
+   * Pause the queue.
+   * @returns {Promise<void>}
+   */
+  const pauseQueue = async () => {
+    await queue.pause();
+    console.log(`Queue "${queue.name}" paused.`);
+  };
+
+  /**
+   * Resume the queue.
+   * @returns {Promise<void>}
+   */
+  const resumeQueue = async () => {
+    await queue.resume();
+    console.log(`Queue "${queue.name}" resumed.`);
+  };
+
+  // Return the functional interface
+  return {
+    addJob,
+    processJobs,
+    closeConnection,
+    pauseQueue,
+    resumeQueue,
+  };
+};
+
+module.exports = { createQueue };

package/config/config.js

@@ -0,0 +1,14 @@
+const ALLOWED_URLS = process.env.ALLOWED_ORIGIN.split(",");
+const WEBHOOK_API_KEY = process.env.API_KEY;
+const mode = process.env.MODE || "production";
+
+const redis = {
+  url: process.env.REDIS_URI,
+};
+
+module.exports = {
+  WEBHOOK_API_KEY,
+  ALLOWED_URLS,
+  mode,
+  redis,
+};

package/config/database.js

@@ -0,0 +1,7 @@
+/* eslint-disable no-undef */
+module.exports = {
+  url:
+    process.env.NODE_ENV === "test"
+      ? process.env.TEST_DB_URL
+      : process.env.DB_URL,
+};

package/config/redis.js

@@ -0,0 +1,78 @@
+const { createClient } = require("redis");
+const { redis } = require("../config/config");
+
+const client = createClient({
+  url: redis.url,
+});
+client.on("error", (err) => console.log("Redis Client Error", err));
+
+const connectRedis = async () => {
+  if (!client.isOpen) {
+    await client.connect();
+  }
+};
+
+exports.setRedisData = async (
+  key,
+  value,
+  field = null,
+  expiryInSeconds = 3600
+) => {
+  try {
+    await connectRedis();
+    let resp;
+    if (field) {
+      resp = await client.hSet(key, field, JSON.stringify(value));
+    } else {
+      resp = await client.set(key, JSON.stringify(value));
+    }
+    await client.expire(key, expiryInSeconds); // Set expiry for the key
+    return resp;
+  } catch (err) {
+    console.error("Error setting Redis data:", err);
+    throw err;
+  }
+};
+
+exports.getRedisData = async (key, field = null) => {
+  try {
+    await connectRedis();
+    let resp;
+    if (field) {
+      resp = await client.hGet(key, field);
+    } else {
+      resp = await client.get(key);
+    }
+    return resp ? JSON.parse(resp) : null;
+  } catch (err) {
+    console.error("Error getting Redis data:", err);
+    throw err;
+  }
+};
+
+exports.deleteRedisData = async (key) => {
+  try {
+    await connectRedis();
+    return await client.del(key);
+  } catch (err) {
+    console.error("Error deleting Redis data:", err);
+    throw err;
+  }
+};
+
+// Ensure the Redis client is closed when the application exits
+const closeClient = () => {
+  if (client.isOpen) {
+    client.quit();
+  }
+};
+
+process.on("exit", closeClient);
+process.on("SIGINT", () => {
+  closeClient();
+  process.exit();
+});
+process.on("SIGTERM", () => {
+  closeClient();
+  process.exit();
+});

package/index.js

@@ -1,7 +1,11 @@
 const sharedModels = require("./models");
 const sharedFunctions = require("./functions");
+const logger = require("./utils/logger");
+const shuttlePro = require("./utils/decorator-factory");
 
 module.exports = {
   sharedModels,
   sharedFunctions,
+  logger,
+  shuttlePro,
 };

package/models/UserRole.js

@@ -1,10 +1,6 @@
 const mongoose = require("mongoose");
 
 const daySchema = new mongoose.Schema({
-  _id: {
-    type: mongoose.Schema.Types.ObjectId,
-    default: mongoose.Types.ObjectId,
-  },
   day: { type: String, required: true },
   startTime: { type: String, required: false },
   endTime: { type: String, required: false },
@@ -31,10 +27,6 @@ const userRoleSchema = new mongoose.Schema(
     },
     isOwner: { type: Boolean, default: false },
     userShift: {
-      _id: {
-        type: mongoose.Schema.Types.ObjectId,
-        default: mongoose.Types.ObjectId,
-      },
       shiftName: { type: String, required: false },
       days: { type: [daySchema], required: false },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shuttlepro-shared",
-  "version": "1.1.54",
+  "version": "1.1.56",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -11,7 +11,17 @@
   "license": "ISC",
   "access": "restricted",
   "dependencies": {
+    "@babel/core": "^7.22.5",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.22.5",
+    "@babel/preset-env": "^7.22.5",
+    "@babel/register": "^7.22.5",
+    "redis": "^4.6.14",
+    "express": "^4.17.1",
     "jsonwebtoken": "^9.0.2",
-    "mongoose": "^8.7.1"
+    "mongoose": "^8.7.1",
+    "cors": "^2.8.5",
+    "helmet": "^8.0.0",
+    "bull": "^4.10.4"
   }
 }

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;