@xenterprises/fastify-xconfig 1.1.9 → 2.0.1

package/xConfigWorkingList.js

@@ -1,720 +0,0 @@
-import fp from "fastify-plugin";
-import jwt from "@fastify/jwt";
-import bcrypt from "bcrypt";
-const isProduction = process.env.NODE_ENV === 'production';
-import Stripe from 'stripe';
-/*
-  ===== SET VARS =====
-  Setting variables for the config
-*/
-
-
-/*
-  ===== SET MAIN FUNCTION AND OPTIONS =====
-  Setting variables for the config
-*/
-async function xConfig(fastify, options) {
-  const {
-    professional = false,
-    fancyErrors = true,
-    prisma: prismaOptions = {},
-    bugsnag: bugsnagOptions = {},
-    stripe: stripeOptions = {},
-    sendGrid: sendGridOptions = {},
-    twilio: twilioOptions = {},
-    cloudinary: cloudinaryOptions = {},
-    auth: authOptions = {},
-    cors: corsOptions = {},
-    underPressure: underPressureOptions = {},
-    multipart: multipartOptions = {},
-    rateLimit: rateLimitOptions = {},
-    geocode: geocodeOptions = {},
-  } = options;
-
-
-
-
-
-  // /*
-  //   ===== STRIPE =====
-  // */
-  // if (stripeOptions.active === true) {
-  //   if (!stripeOptions.apiKey) throw new Error("Stripe API key must be provided.");
-
-
-
-  //   const stripeClient = new Stripe(process.env.STRIPE_SECRET_KEY, {
-  //     apiVersion: '2022-11-15',
-  //   });
-
-  //   const stripePlugin = async function (fastify, options) {
-  //     fastify.decorate('stripe', {
-  //       // Create a Payment Intent (for processing payments)
-  //       createPaymentIntent: async (amount, currency = 'usd', customerId) => {
-  //         try {
-  //           const paymentIntent = await stripeClient.paymentIntents.create({
-  //             amount,
-  //             currency,
-  //             customer: customerId,
-  //           });
-  //           return paymentIntent;
-  //         } catch (error) {
-  //           fastify.log.error('Failed to create payment intent:', error);
-  //           throw new Error('Failed to create payment intent.');
-  //         }
-  //       },
-
-  //       // Create a Customer
-  //       createCustomer: async (email, name, paymentMethodId) => {
-  //         try {
-  //           const customer = await stripeClient.customers.create({
-  //             email,
-  //             name,
-  //             payment_method: paymentMethodId,
-  //             invoice_settings: {
-  //               default_payment_method: paymentMethodId,
-  //             },
-  //           });
-  //           return customer;
-  //         } catch (error) {
-  //           fastify.log.error('Failed to create customer:', error);
-  //           throw new Error('Failed to create customer.');
-  //         }
-  //       },
-
-  //       // Create a Subscription (recurring payments)
-  //       createSubscription: async (customerId, priceId) => {
-  //         try {
-  //           const subscription = await stripeClient.subscriptions.create({
-  //             customer: customerId,
-  //             items: [{ price: priceId }],
-  //             expand: ['latest_invoice.payment_intent'],
-  //           });
-  //           return subscription;
-  //         } catch (error) {
-  //           fastify.log.error('Failed to create subscription:', error);
-  //           throw new Error('Failed to create subscription.');
-  //         }
-  //       },
-
-  //       // Retrieve Payment Details
-  //       retrievePayment: async (paymentIntentId) => {
-  //         try {
-  //           const paymentIntent = await stripeClient.paymentIntents.retrieve(paymentIntentId);
-  //           return paymentIntent;
-  //         } catch (error) {
-  //           fastify.log.error('Failed to retrieve payment intent:', error);
-  //           throw new Error('Failed to retrieve payment intent.');
-  //         }
-  //       },
-
-  //       // Create an Invoice
-  //       createInvoice: async (customerId, items) => {
-  //         try {
-  //           const invoiceItemPromises = items.map(async item => {
-  //             return stripeClient.invoiceItems.create({
-  //               customer: customerId,
-  //               price: item.priceId,  // Assuming you have the price ID
-  //             });
-  //           });
-  //           await Promise.all(invoiceItemPromises);
-
-  //           const invoice = await stripeClient.invoices.create({
-  //             customer: customerId,
-  //             auto_advance: true,  // Automatically finalize the invoice
-  //           });
-  //           return invoice;
-  //         } catch (error) {
-  //           fastify.log.error('Failed to create invoice:', error);
-  //           throw new Error('Failed to create invoice.');
-  //         }
-  //       },
-
-  //       // Handle Webhooks (e.g., payment success, failed, etc.)
-  //       handleWebhook: async (req, res, signature, endpointSecret) => {
-  //         let event;
-  //         try {
-  //           event = stripeClient.webhooks.constructEvent(
-  //             req.rawBody,  // Stripe requires the raw body for webhooks
-  //             signature,
-  //             endpointSecret
-  //           );
-  //         } catch (error) {
-  //           fastify.log.error('Failed to verify webhook signature:', error);
-  //           throw new Error('Webhook signature verification failed.');
-  //         }
-
-  //         // Process the event (e.g., payment success, subscription created)
-  //         return event;
-  //       },
-  //     });
-
-  //     console.info("   ✅ Stripe Enabled");
-  //   }
-  // }
-
-
-  /*
-    ===== AUTHENTICATION =====
-    Admin and User authentication are handled separately and redundantly,
-    sharing no code between them.
-  */
-
-  /*
-    ===== Admin Authentication =====
-  */
-  /*
-  ===== Admin Authentication =====
-*/
-  if (authOptions.admin?.active !== false) {
-
-    // Ensure the admin JWT secret is provided
-    if (!authOptions.admin.secret) {
-      throw new Error("Admin JWT secret must be provided.");
-    }
-
-    const adminAuthOptions = authOptions.admin;
-    const adminCookieName =
-      adminAuthOptions.cookieOptions?.name || "adminToken";
-    const adminRefreshCookieName =
-      adminAuthOptions.cookieOptions?.refreshTokenName || "adminRefreshToken";
-    const adminCookieOptions = {
-      httpOnly: true,  // Ensures the cookie is not accessible via JavaScript
-      secure: isProduction,  // true in production (HTTPS), false in development (HTTP)
-      sameSite: isProduction ? 'None' : 'Lax',  // 'None' for cross-origin, 'Lax' for development
-      path: '/',  // Ensure cookies are valid for the entire site
-    };
-    const adminExcludedPaths = adminAuthOptions.excludedPaths || [
-      "/admin/auth/login",
-      "/admin/auth/logout",
-    ];
-
-    // Decorator to hash admin passwords
-    async function hashAdminPassword(password) {
-      const saltRounds = 10;  // Number of salt rounds for bcrypt (10 is generally a good default)
-      try {
-        const hashedPassword = await bcrypt.hash(password, saltRounds);
-        return hashedPassword;
-      } catch (error) {
-        throw new Error("Failed to hash password: " + error.message);
-      }
-    }
-
-    fastify.decorate("hashAdminPassword", hashAdminPassword);
-
-    // Register JWT for admin
-    await fastify.register(jwt, {
-      secret: adminAuthOptions.secret,
-      sign: { algorithm: 'HS256', expiresIn: adminAuthOptions.expiresIn || "15m" },
-      cookie: {
-        cookieName: adminCookieName,
-        signed: false,
-      },
-      namespace: "adminJwt",
-      jwtVerify: "adminJwtVerify",
-      jwtSign: "adminJwtSign",
-    });
-
-    // Common function to set tokens as cookies
-    const setAdminAuthCookies = (reply, accessToken, refreshToken) => {
-      reply.setCookie(adminCookieName, accessToken, adminCookieOptions);
-      reply.setCookie(adminRefreshCookieName, refreshToken, {
-        // ...adminCookieOptions,
-        httpOnly: true,  // Ensures the cookie is not accessible via JavaScript
-        secure: isProduction,  // true in production (HTTPS), false in development (HTTP)
-        sameSite: isProduction ? 'None' : 'Lax',  // 'None' for cross-origin, 'Lax' for development
-        path: '/',  // Ensure cookies are valid for the entire site
-      });
-    };
-
-    // Admin authentication hook
-    fastify.addHook("onRequest", async (request, reply) => {
-      const url = request.url;
-
-      // Skip authentication for excluded paths
-      if (adminExcludedPaths.some((path) => url.startsWith(path))) {
-        return;
-      }
-
-      if (url.startsWith("/admin")) {
-        try {
-          // Extract token from cookie or Authorization header
-          const authHeader = request.headers.authorization;
-          const authToken =
-            authHeader && authHeader.startsWith("Bearer ")
-              ? authHeader.slice(7)
-              : null;
-          const token = request.cookies[adminCookieName] || authToken;
-
-          if (!token) {
-            throw fastify.httpErrors.unauthorized(
-              "Admin access token not provided"
-            );
-          }
-
-          // Verify access token
-          const decoded = await request.adminJwtVerify(token);
-          request.adminAuth = decoded; // Attach admin auth context
-        } catch (err) {
-          // Use built-in HTTP error handling
-          reply.send(
-            fastify.httpErrors.unauthorized("Invalid or expired access token")
-          );
-        }
-      }
-    });
-
-    // Admin login route
-    fastify.post("/admin/auth/login", async (req, reply) => {
-      try {
-        const { email, password } = req.body;
-
-        // Validate input
-        if (!email || !password) {
-          throw fastify.httpErrors.badRequest(
-            "Email and password are required"
-          );
-        }
-
-        // Fetch admin from the database
-        const admin = await fastify.prisma.admins.findUnique({
-          where: { email },
-        });
-        if (!admin) {
-          throw fastify.httpErrors.unauthorized("Invalid credentials");
-        }
-
-        // Compare passwords using bcrypt
-        const isValidPassword = await bcrypt.compare(password, admin.password);
-        if (!isValidPassword) {
-          throw fastify.httpErrors.unauthorized("Invalid credentials");
-        }
-
-        // Issue access token
-        const accessToken = await reply.adminJwtSign({ id: admin.id });
-
-        // Generate refresh token
-        const refreshToken = randomUUID();
-        const hashedRefreshToken = await bcrypt.hash(refreshToken, 10);
-
-        // Store hashed refresh token in the database
-        await fastify.prisma.admins.update({
-          where: { id: admin.id },
-          data: { refreshToken: hashedRefreshToken },
-        });
-
-        // Set tokens as cookies
-        setAdminAuthCookies(reply, accessToken, refreshToken);
-
-        reply.send({ accessToken });
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    // Admin refresh token route
-    fastify.post("/admin/auth/refresh", async (req, reply) => {
-      try {
-        const adminAuth = req.adminAuth;
-        const refreshToken = req.cookies[adminRefreshCookieName];
-        if (!refreshToken) {
-          throw fastify.httpErrors.unauthorized("Refresh token not provided");
-        }
-
-        // Fetch admin from the database using the refresh token
-        const admin = await fastify.prisma.admins.findFirst({
-          where: { id: adminAuth.id, refreshToken: { not: null } },
-        });
-        if (!admin) {
-          throw fastify.httpErrors.unauthorized("Invalid refresh token");
-        }
-
-        // Verify the refresh token
-        const isValid = await bcrypt.compare(refreshToken, admin.refreshToken);
-        if (!isValid) {
-          throw fastify.httpErrors.unauthorized("Invalid refresh token");
-        }
-
-        // Issue new access token
-        const accessToken = await reply.adminJwtSign({ id: admin.id });
-
-        // Generate new refresh token
-        const newRefreshToken = randomUUID();
-        const hashedNewRefreshToken = await bcrypt.hash(newRefreshToken, 10);
-
-        // Update refresh token in the database
-        await fastify.prisma.admins.update({
-          where: { id: admin.id },
-          data: { refreshToken: hashedNewRefreshToken },
-        });
-
-        // Set new tokens as cookies
-        setAdminAuthCookies(reply, accessToken, newRefreshToken);
-
-        reply.send({ accessToken });
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    // Admin logout route
-    fastify.post("/admin/auth/logout", async (req, reply) => {
-      try {
-        const adminAuth = req.adminAuth;
-        if (adminAuth) {
-          // Delete refresh token from the database
-          await fastify.prisma.admins.update({
-            where: { id: adminAuth.id },
-            data: { refreshToken: null },
-          });
-        }
-
-        // Clear cookies
-        reply.clearCookie(adminCookieName, { path: "/" });
-        reply.clearCookie(adminRefreshCookieName, { path: "/" });
-
-        reply.send({ message: "Logged out successfully" });
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    // Admin authentication status route
-    fastify.get("/admin/auth/me", async (req, reply) => {
-      try {
-        const adminAuth = req.adminAuth;
-
-        // Fetch admin details from database
-        const admin = await fastify.prisma.admins.findUnique({
-          where: { id: adminAuth.id },
-          select: { id: true, firstName: true, lastName: true, email: true },
-        });
-
-        if (!admin) {
-          throw fastify.httpErrors.notFound("Admin not found");
-        }
-
-        reply.send(admin);
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    console.info("   ✅ Auth Admin Enabled");
-  }
-
-  /*
-  ===== User Authentication =====
-*/
-  if (authOptions.user?.active !== false) {
-    // Ensure the user JWT secret is provided
-    if (!authOptions.user.secret) {
-      throw new Error("User JWT secret must be provided.");
-    }
-
-    const userAuthOptions = authOptions.user;
-    const userCookieName = userAuthOptions.cookieOptions?.name || "userToken";
-    const userRefreshCookieName =
-      userAuthOptions.cookieOptions?.refreshTokenName || "userRefreshToken";
-    const userCookieOptions = {
-      httpOnly: true,  // Ensures the cookie is not accessible via JavaScript
-      secure: isProduction,  // true in production (HTTPS), false in development (HTTP)
-      sameSite: isProduction ? 'None' : 'Lax',  // 'None' for cross-origin, 'Lax' for development
-      path: '/',  // Ensure cookies are valid for the entire site
-    };
-    const userExcludedPaths = userAuthOptions.excludedPaths || [
-      "/portal/auth/login",
-      "/portal/auth/logout",
-      "/portal/auth/register",
-    ];
-
-    // Register JWT for user
-    await fastify.register(jwt, {
-      secret: userAuthOptions.secret,
-      sign: { algorithm: 'HS256', expiresIn: userAuthOptions.expiresIn || "15m" },
-      cookie: { cookieName: userCookieName, signed: false },
-      namespace: "userJwt",
-      jwtVerify: "userJwtVerify",
-      jwtSign: "userJwtSign",
-    });
-
-    // Common function to set tokens as cookies
-    const setAuthCookies = (reply, accessToken, refreshToken) => {
-      reply.setCookie(userCookieName, accessToken, userCookieOptions);
-      reply.setCookie(userRefreshCookieName, refreshToken, {
-        // ...userCookieOptions,
-        httpOnly: true,  // Ensures the cookie is not accessible via JavaScript
-        secure: isProduction,  // true in production (HTTPS), false in development (HTTP)
-        sameSite: isProduction ? 'None' : 'Lax',  // 'None' for cross-origin, 'Lax' for development
-        path: '/',  // Ensure cookies are valid for the entire site
-      });
-    };
-
-    // User authentication hook
-    fastify.addHook("onRequest", async (request, reply) => {
-      const url = request.url;
-
-      // Skip authentication for excluded paths
-      if (userExcludedPaths.some((path) => url.startsWith(path))) {
-        return;
-      }
-
-      if (url.startsWith("/portal")) {
-        try {
-          // Extract token from cookie or Authorization header
-          const authHeader = request.headers.authorization;
-          const authToken =
-            authHeader && authHeader.startsWith("Bearer ")
-              ? authHeader.slice(7)
-              : null;
-          const token = request.cookies[userCookieName] || authToken;
-
-          if (!token) {
-            throw fastify.httpErrors.unauthorized(
-              "User access token not provided"
-            );
-          }
-
-          // Verify access token using the namespaced verify method
-          const decoded = await request.userJwtVerify(token);
-          request.userAuth = decoded; // Attach user auth context
-        } catch (err) {
-          // Use built-in HTTP error handling
-          reply.send(
-            fastify.httpErrors.unauthorized("Invalid or expired access token")
-          );
-        }
-      }
-    });
-
-    // User registration route
-    fastify.post("/portal/auth/register", async (req, reply) => {
-      try {
-        const { email, password, firstName, lastName } = req.body;
-
-        // Validate input
-        if (!email || !password || !firstName || !lastName) {
-          throw fastify.httpErrors.badRequest("Missing required fields");
-        }
-
-        // Check if user already exists
-        const existingUser = await fastify.prisma.users.findUnique({
-          where: { email },
-        });
-        if (existingUser) {
-          throw fastify.httpErrors.conflict("Email already in use");
-        }
-
-        // Hash the password
-        const hashedPassword = await bcrypt.hash(password, 10);
-
-        // Create the user
-        const user = await fastify.prisma.users.create({
-          data: {
-            email,
-            password: hashedPassword,
-            firstName,
-            lastName,
-          },
-        });
-
-        // Send welcome email
-        await fastify.sendGrid.sendEmail(email, auth?.user?.registerEmail?.subject, auth?.user?.registerEmail?.templateId, { name: firstName, email });
-
-        // Issue access token
-        const accessToken = await reply.userJwtSign({ id: user.id });
-
-        // Generate refresh token
-        const refreshToken = randomUUID();
-        const hashedRefreshToken = await bcrypt.hash(refreshToken, 10);
-
-        // Store hashed refresh token in the database
-        await fastify.prisma.users.update({
-          where: { id: user.id },
-          data: { refreshToken: hashedRefreshToken },
-        });
-
-        // Set tokens as cookies
-        setAuthCookies(reply, accessToken, refreshToken);
-
-        reply.send({ accessToken });
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    // User login route
-    fastify.post("/portal/auth/login", async (req, reply) => {
-      try {
-        const { email, password } = req.body;
-
-        if (!email || !password) {
-          throw fastify.httpErrors.badRequest(
-            "Email and password are required"
-          );
-        }
-
-        // Fetch user from the database
-        const user = await fastify.prisma.users.findUnique({
-          where: { email },
-        });
-        if (!user) {
-          throw fastify.httpErrors.unauthorized("Invalid credentials");
-        }
-
-        // Compare passwords using bcrypt
-        const isValidPassword = await bcrypt.compare(password, user.password);
-        if (!isValidPassword) {
-          throw fastify.httpErrors.unauthorized("Invalid credentials");
-        }
-
-        // Issue access token
-        const accessToken = await reply.userJwtSign({ id: user.id });
-
-        // Generate refresh token
-        const refreshToken = randomUUID();
-        const hashedRefreshToken = await bcrypt.hash(refreshToken, 10);
-
-        // Store hashed refresh token in the database
-        await fastify.prisma.users.update({
-          where: { id: user.id },
-          data: { refreshToken: hashedRefreshToken },
-        });
-
-        // Set tokens as cookies
-        setAuthCookies(reply, accessToken, refreshToken);
-
-        reply.send({ accessToken });
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    // User refresh token route
-    fastify.post("/portal/auth/refresh", async (req, reply) => {
-      try {
-        const userAuth = req.userAuth;
-        const refreshToken = req.cookies[userRefreshCookieName];
-        if (!refreshToken) {
-          throw fastify.httpErrors.unauthorized("Refresh token not provided");
-        }
-
-        // Fetch user from the database using the refresh token
-        const user = await fastify.prisma.users.findFirst({
-          where: { id: userAuth?.id, refreshToken: { not: null } },
-        });
-
-        if (!user) {
-          throw fastify.httpErrors.unauthorized("Invalid refresh token");
-        }
-
-        // Verify the refresh token
-        const isValid = await bcrypt.compare(refreshToken, user.refreshToken);
-        if (!isValid) {
-          throw fastify.httpErrors.unauthorized("Invalid refresh token");
-        }
-
-        // Issue new access token
-        const accessToken = await reply.userJwtSign({ id: user.id });
-
-        // Generate new refresh token
-        const newRefreshToken = randomUUID();
-        const hashedNewRefreshToken = await bcrypt.hash(newRefreshToken, 10);
-
-        // Update refresh token in the database
-        await fastify.prisma.users.update({
-          where: { id: user.id },
-          data: { refreshToken: hashedNewRefreshToken },
-        });
-
-        // Set new tokens as cookies
-        setAuthCookies(reply, accessToken, newRefreshToken);
-
-        reply.send({ accessToken });
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    // User logout route
-    fastify.post("/portal/auth/logout", async (req, reply) => {
-      try {
-        const userAuth = req.userAuth;
-        if (userAuth) {
-          // Delete refresh token from the database
-          await fastify.prisma.users.update({
-            where: { id: userAuth.id },
-            data: { refreshToken: null },
-          });
-        }
-
-        // Clear cookies
-        reply.clearCookie(userCookieName, { path: "/" });
-        reply.clearCookie(userRefreshCookieName, { path: "/" });
-
-        reply.send({ message: "Logged out successfully" });
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    // User authentication status route
-    fastify.get("/portal/auth/me", async (req, reply) => {
-      try {
-        const userAuth = req.userAuth;
-
-        // Fetch user details from database
-        const user = await fastify.prisma.users.findUnique({
-          where: { id: userAuth.id },
-          select: { id: true, email: true, firstName: true, lastName: true, ...authOptions.user.me },
-        });
-
-        if (!user) {
-          throw fastify.httpErrors.notFound("User not found");
-        }
-
-        reply.send(user);
-      } catch (err) {
-        reply.send(err);
-      }
-    });
-
-    console.info("   ✅ Auth User Enabled");
-  }
-
-  /*
-    ===== GEOCODE =====
-  */
-
-
-
-
-  /*
-     ===== LIST ROUTES AFTER ALL PLUGINS =====
-     Use the after() method to ensure this runs after all plugins are registered.
-   */
-  fastify.after(() => {
-    if (professional !== true) {
-      console.info("   ✅ Listing Routes:");
-      fastify.ready(() => {
-        printRoutes(routes, options.colors !== false);
-        // Add rocket emoji
-        console.info(
-          `🚀 Server is ready on port ${process.env.PORT || 3000}\n\n`
-        );
-        // Add goodbye emoji for server shutting down
-        fastify.addHook("onClose", () =>
-          console.info("Server shutting down... Goodbye 👋")
-        );
-      });
-    }
-  });
-
-
-
-
-}
-
-export default fp(xConfig, {
-  name: "xConfig",
-});