@xenterprises/fastify-xconfig 1.0.2 → 1.1.1

package/src/auth/portal.js

@@ -0,0 +1,177 @@
+import * as jose from "jose";
+import fetch from "node-fetch";
+
+export async function setupAuth(fastify, options) {
+  if (options.user?.active !== false) {
+    // Get configuration
+    const projectId = options.user.portalStackProjectId || process.env.STACK_PROJECT_ID;
+    const publishableKey = options.user.publishableKey || process.env.STACK_PUBLISHABLE_CLIENT_KEY;
+    const secretKey = options.user.secretKey || process.env.STACK_SECRET_SERVER_KEY;
+
+    if (!projectId) {
+      throw new Error("Stack Auth project ID is required");
+    }
+
+    if (!publishableKey || !secretKey) {
+      throw new Error("Stack Auth publishable and secret keys are required");
+    }
+
+    const userExcludedPaths = options.user.excludedPaths || [
+      "/portal/auth/login",
+      "/portal/auth/logout",
+      "/portal/auth/register",
+      "/portal/auth/forgot-password",
+      "/portal/auth/reset-password"
+    ];
+
+    // Base URL for Stack Auth API
+    const stackAuthBaseUrl = `https://api.stack-auth.com/api/v1`;
+    const jwksUrl = `${stackAuthBaseUrl}/projects/${projectId}/.well-known/jwks.json`;
+
+    // Create JWKS for token verification
+    const jwks = jose.createRemoteJWKSet(new URL(jwksUrl));
+
+    // Helper for Stack Auth API headers
+    fastify.decorate('getStackAuthHeaders', function (accessType = "server") {
+      const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'X-Stack-Access-Type': accessType,
+        'X-Stack-Project-Id': projectId,
+      };
+
+      if (accessType === "client") {
+        headers['X-Stack-Publishable-Client-Key'] = publishableKey;
+      } else if (accessType === "server") {
+        headers['X-Stack-Secret-Server-Key'] = secretKey;
+      }
+
+      return headers;
+    });
+
+    // JWT verification helper
+    fastify.decorate('verifyStackJWT', async function (accessToken) {
+      try {
+        const { payload } = await jose.jwtVerify(accessToken, jwks);
+        return payload;
+      } catch (error) {
+        fastify.log.error(error);
+        return null;
+      }
+    });
+
+    // API URL helper
+    fastify.decorate('getStackAuthApiUrl', function () {
+      return stackAuthBaseUrl;
+    });
+
+    // Authentication middleware
+    fastify.addHook("onRequest", async (request, reply) => {
+      const url = request.url;
+
+      // Skip excluded paths
+      if (userExcludedPaths.some(path => url.startsWith(path))) {
+        return;
+      }
+
+      if (url.startsWith("/portal")) {
+        try {
+          // Get token from header
+          const authHeader = request.headers.authorization;
+          if (!authHeader || !authHeader.startsWith("Bearer ")) {
+            return reply.code(401).send({ error: "Access token required" });
+          }
+
+          // Verify token
+          const token = authHeader.slice(7);
+          const payload = await fastify.verifyStackJWT(token);
+
+          if (!payload) {
+            return reply.code(401).send({ error: "Invalid token" });
+          }
+
+          // Set user info on request
+          request.user = payload;
+          request.userAuth = { id: payload.sub };
+        } catch (err) {
+          return reply.code(401).send({ error: "Authentication failed" });
+        }
+      }
+    });
+
+    // Login endpoint
+    fastify.post("/portal/auth/login", async (req, reply) => {
+      try {
+        const { email, password } = req.body;
+
+        if (!email || !password) {
+          return reply.code(400).send({ error: "Email and password required" });
+        }
+
+        // Call Stack Auth API for password sign-in
+        const response = await fetch(
+          `${stackAuthBaseUrl}/auth/password/sign-in`,
+          {
+            method: 'POST',
+            headers: fastify.getStackAuthHeaders("server"),
+            body: JSON.stringify({ email, password })
+          }
+        );
+
+        const data = await response.json().catch(() => ({}));
+
+        if (!response.ok) {
+          return reply.code(response.status || 400).send({
+            error: data.message || "Authentication failed"
+          });
+        }
+
+        // Check if we have the expected response properties
+        if (!data.access_token || !data.refresh_token || !data.user_id) {
+          return reply.code(500).send({ error: "Invalid response from authentication service" });
+        }
+
+        // Verify token
+        const payload = await fastify.verifyStackJWT(data.access_token);
+        if (!payload) {
+          return reply.code(401).send({ error: "Invalid token received" });
+        }
+
+        reply.send({
+          accessToken: data.access_token,
+          refreshToken: data.refresh_token,
+          user: payload,
+          userId: data.user_id
+        });
+      } catch (err) {
+        fastify.log.error(err);
+        reply.code(500).send({ error: "Internal server error" });
+      }
+    });
+
+
+    // User info endpoint
+    fastify.get("/portal/auth/me", async (req, reply) => {
+      reply.send(req.user || { authenticated: false });
+    });
+
+    // Token verification endpoint
+    fastify.post("/portal/auth/verify", async (req, reply) => {
+      const { token } = req.body;
+
+      if (!token) {
+        return reply.code(400).send({ error: "Token required" });
+      }
+
+      const payload = await fastify.verifyStackJWT(token);
+
+      if (!payload) {
+        return reply.code(401).send({ valid: false });
+      }
+
+      reply.send({ valid: true, user: payload });
+    });
+
+    console.info("   ✅ Auth User Enabled");
+  }
+}

package/src/integrations/cloudinary.js

@@ -0,0 +1,98 @@
+import { v2 as Cloudinary } from "cloudinary";
+
+export async function setupCloudinary(fastify, options) {
+
+  if (options.active !== false) {
+    if (
+      !options.cloudName ||
+      !options.apiKey ||
+      !options.apiSecret
+    ) {
+      throw new Error(
+        "Cloudinary cloudName, apiKey, and apiSecret must be provided."
+      );
+    }
+
+    Cloudinary.config({
+      cloud_name: options.cloudName,
+      api_key: options.apiKey,
+      api_secret: options.apiSecret,
+    },
+    );
+
+    fastify.decorate('cloudinary', {
+      upload: async (fileStream, options = {}) => {
+        return new Promise((resolve, reject) => {
+          if (options.folder) {
+            options.folder = options.folder || options.folder;
+          }
+          options.resource_type = options.resource_type || 'auto';
+          options.timestamp = Math.floor(Date.now() / 1000);  // Add timestamp to options
+          options.use_filename = options.use_filename !== undefined ? options.use_filename : true;
+          options.unique_filename = options.unique_filename !== undefined ? options.unique_filename : true;
+
+          const uploadStream = Cloudinary.uploader.upload_stream(options, (error, result) => {
+            if (error) {
+              fastify.log.error("Cloudinary upload failed:", error);
+              reject(new Error(`Failed to upload to Cloudinary: ${JSON.stringify(error)}`));
+            } else {
+              resolve(result);  // Resolve with the result from Cloudinary
+            }
+          });
+
+          fileStream.pipe(uploadStream)
+            .on('error', (streamError) => {
+              fastify.log.error("Stream error:", streamError);
+              reject(new Error(`Stream error during Cloudinary upload: ${streamError.message}`));
+            })
+            .on('end', () => {
+              fastify.log.info("Stream ended successfully.");
+            });
+        });
+      },
+
+      uploadLarge: async (fileStream, options = {}) => {
+        return new Promise((resolve, reject) => {
+          if (options.folder) {
+            options.folder = options.folder || options.folder;
+          }
+          options.resource_type = options.resource_type || 'auto';
+          options.timestamp = Math.floor(Date.now() / 1000);
+          options.use_filename = options.use_filename !== undefined ? options.use_filename : true;
+          options.unique_filename = options.unique_filename !== undefined ? options.unique_filename : true;
+          options.overwrite = options.overwrite !== undefined ? options.overwrite : false;
+
+          const uploadStream = Cloudinary.uploader.upload_stream(options, (error, result) => {
+            if (error) {
+              fastify.log.error("Cloudinary upload failed:", error);
+              reject(new Error(`Failed to upload to Cloudinary: ${JSON.stringify(error)}`));
+            } else {
+              resolve(result);
+            }
+          });
+
+          fileStream.pipe(uploadStream)
+            .on('error', (streamError) => {
+              fastify.log.error("Stream error:", streamError);
+              reject(new Error(`Stream error during Cloudinary upload: ${streamError.message}`));
+            })
+            .on('end', () => {
+              fastify.log.info("Stream ended successfully.");
+            });
+        });
+      },
+
+      delete: async (publicId) => {
+        try {
+          const response = await Cloudinary.uploader.destroy(publicId);
+          return response;
+        } catch (error) {
+          fastify.log.error("Cloudinary delete failed:", error);
+          throw new Error("Failed to delete from Cloudinary.");
+        }
+      }
+    });
+
+    console.info("   ✅ Cloudinary Enabled");
+  }
+}

package/src/integrations/geocode.js

@@ -0,0 +1,43 @@
+export async function setupGeocode(fastify, options) {
+  if (options.active !== false) {
+    if (!options.apiKey) {
+      throw new Error("Geocode API key must be provided.");
+    }
+    const geocodioEndpoint = 'https://api.geocod.io/v1.7/geocode';
+    const geocodioApiKey = options.apiKey;
+
+    fastify.decorate('geocode', {
+      // Method to get lat/long and county from a zip code
+      async getLatLongByZip(zipCode) {
+        try {
+          const url = `${geocodioEndpoint}?q=${zipCode}&fields=cd,stateleg&api_key=${geocodioApiKey}`;
+          const response = await fetch(url);
+          const result = await response.json();
+
+          if (result.results && result.results.length > 0) {
+            const location = result.results[0].location;
+            const addressComponents = result.results[0].address_components;
+
+            return {
+              zip: zipCode,
+              lat: location.lat,
+              lng: location.lng,
+              city: addressComponents.city,
+              county: addressComponents.county,
+              country: addressComponents.country,
+              state: addressComponents.state,
+              addressComponents: addressComponents
+            };
+          } else {
+            throw new Error('No results found for the provided zip code.');
+          }
+        } catch (error) {
+          fastify.log.error('Failed to fetch geolocation data:', error);
+          throw new Error('Failed to fetch geolocation data.');
+        }
+      }
+    });
+
+    console.info('   ✅ Geocodio Enabled');
+  }
+}

package/src/integrations/prisma.js

@@ -0,0 +1,30 @@
+
+import { PrismaClient } from "@prisma/client";
+export async function setupPrisma(fastify, options) {
+  if (options.active !== false) {
+    delete options.active;
+    const prisma = new PrismaClient(options);
+
+    // Connect to the database
+    await prisma.$connect();
+
+    // Decorate Fastify instance with Prisma Client
+    fastify.decorate("prisma", prisma);
+
+    // Disconnect Prisma Client when Fastify closes
+    fastify.addHook("onClose", async () => {
+      await fastify.prisma.$disconnect();
+    });
+
+    console.info("   ✅ Prisma Enabled");
+  }
+  /*
+  ===== Ensure Proper Cleanup on Server Shutdown =====
+  */
+  fastify.addHook("onClose", async () => {
+    if (fastify.prisma) {
+      await fastify.prisma.$disconnect();
+    }
+    // Add additional cleanup for other services if necessary
+  });
+}

package/src/integrations/sendgrid.js

@@ -0,0 +1,58 @@
+import Sendgrid from '@sendgrid/mail';
+import sgClient from '@sendgrid/client';
+export async function setupSendgrid(fastify, options) {
+  if (options.active !== false) {
+    if (!options.apiKey)
+      throw new Error("SendGrid API key must be provided.");
+
+    Sendgrid.setApiKey(options.apiKey);
+    sgClient.setApiKey(options.apiKeyEmailValidation);
+    // Decorator to group SendGrid-related methods under fastify.sendGrid
+    fastify.decorate('sendgrid', {
+      sendEmail: async (to, subject, templateId, dynamicTemplateData) => {
+        try {
+
+          const msg = {
+            to: to,
+            from: options.fromEmail,
+            subject: subject,
+            templateId: templateId,
+            dynamicTemplateData: { ...dynamicTemplateData, subject: subject },
+          };
+          await Sendgrid.send(msg);
+          return true;
+        } catch (error) {
+          fastify.log.error("SendGrid send email failed:", error);
+          throw new Error("Failed to send email.");
+        }
+      },
+      validateEmail: async (email) => {
+        const data = {
+          email: email,
+          // source: 'signup',
+        };
+
+        const request = {
+          url: `/v3/validations/email`,
+          method: 'POST',
+          body: data,
+        };
+
+        try {
+          const [response, body] = await sgClient.request(request);
+          console.log(body)
+          if (response.statusCode === 200) {
+            return body?.result;  // Return the validation result
+          } else {
+            throw new Error(body.errors ? body.errors.map(err => err.message).join(', ') : 'Failed to validate email.');
+          }
+        } catch (error) {
+          fastify.log.error('SendGrid email validation failed:', error);
+          throw new Error('Failed to validate email.');
+        }
+      }
+    });
+
+    console.info("   ✅ SendGrid Enabled");
+  }
+}

package/src/integrations/twilio.js

@@ -0,0 +1,146 @@
+import Twilio from "twilio";
+export async function setupTwilio(fastify, options) {
+  if (options.active !== false) {
+    // Return if missing Twilio credentials
+    if (
+      !options.accountSid ||
+      !options.authToken ||
+      !options.phoneNumber
+    )
+      throw new Error(
+        "Twilio accountSid, authToken, and phoneNumber must be provided."
+      );
+
+    const twilioClient = Twilio(
+      options.accountSid,
+      options.authToken
+    );
+
+    // Decorator to group Twilio-related methods under fastify.twilio
+    fastify.decorate('twilio', {
+      sendSMS: async (to, body) => {
+        try {
+          const message = await twilioClient.messages.create({
+            body,
+            to,
+            from: options.phoneNumber,  // Use the Twilio phone number from options
+          });
+          return message;
+        } catch (error) {
+          fastify.log.error("Twilio send SMS failed:", error);
+          throw new Error("Failed to send SMS.");
+        }
+      },
+      sendMMS: async (to, body, mediaUrl) => {
+        try {
+          const message = await twilioClient.messages.create({
+            body,
+            to,
+            from: options.phoneNumber,
+            mediaUrl: [mediaUrl],  // Array of media URLs
+          });
+          return message;
+        } catch (error) {
+          fastify.log.error("Twilio send MMS failed:", error);
+          throw new Error("Failed to send MMS.");
+        }
+      },
+      makeVoiceCall: async (to, twimlUrl) => {
+        try {
+          const call = await twilioClient.calls.create({
+            to,
+            from: options.phoneNumber,
+            url: twimlUrl,  // URL that provides TwiML instructions
+          });
+          return call;
+        } catch (error) {
+          fastify.log.error("Twilio make voice call failed:", error);
+          throw new Error("Failed to make voice call.");
+        }
+      },
+      sendVerificationCode: async (to, channel = 'sms') => {
+        try {
+          const verification = await twilioClient.verify.services(options.verifyServiceSid)
+            .verifications
+            .create({ to, channel });  // channel can be 'sms' or 'call'
+          return verification;
+        } catch (error) {
+          fastify.log.error("Twilio send verification code failed:", error);
+          throw new Error("Failed to send verification code.");
+        }
+      },
+      verifyCode: async (to, code) => {
+        try {
+          const verificationCheck = await twilioClient.verify.services(options.verifyServiceSid)
+            .verificationChecks
+            .create({ to, code });
+          return verificationCheck;
+        } catch (error) {
+          fastify.log.error("Twilio verify code failed:", error);
+          throw new Error("Failed to verify code.");
+        }
+      },
+      fetchSMSHistory: async (fromDate, toDate) => {
+        try {
+          const messages = await twilioClient.messages.list({
+            dateSentAfter: fromDate,
+            dateSentBefore: toDate,
+            limit: 100,
+          });
+          return messages;
+        } catch (error) {
+          fastify.log.error("Twilio fetch SMS history failed:", error);
+          throw new Error("Failed to fetch SMS history.");
+        }
+      },
+      handleIncomingSMS: (req, reply) => {
+        const { Body, From } = req.body;
+
+        // Process incoming message
+        console.log(`Message received from ${From}: ${Body}`);
+
+        reply.type('text/xml');
+        reply.send('<Response><Message>Thanks for your message!</Message></Response>');
+      },
+      checkCallStatus: async (callSid) => {
+        try {
+          const call = await twilioClient.calls(callSid).fetch();
+          return call;
+        } catch (error) {
+          fastify.log.error("Twilio check call status failed:", error);
+          throw new Error("Failed to check call status.");
+        }
+      },
+      validatePhoneNumber: async (phoneNumber) => {
+        try {
+          // Perform phone number validation with Twilio
+          const validation = await twilioClient.lookups.v2
+            .phoneNumbers(phoneNumber)
+            .fetch();
+
+          // Check if the phone number is valid (Twilio may return "valid": true/false)
+          const isValid = validation.valid !== undefined ? validation.valid : true;
+
+          // Return the required structure
+          return {
+            sms: phoneNumber,                  // The phone number
+            smsValidate: validation,           // The full validation payload from Twilio
+            isSmsValidated: isValid            // Set true/false based on the validation
+          };
+        } catch (error) {
+          fastify.log.error("Twilio phone number validation failed:", error);
+
+          // Return the structure with failed validation
+          return {
+            sms: phoneNumber,                  // The phone number
+            smsValidate: {},                   // Empty object as validation failed
+            isSmsValidated: false              // Validation failed
+          };
+        }
+      }
+    });
+
+    console.info("   ✅ Twilio Enabled");
+  }
+
+}

package/src/lifecycle/xFastifyAfter.js

@@ -0,0 +1,27 @@
+// src/lifecycle/xFastifyAfter.js
+import { printRoutes } from "../utils/colorize.js";
+export async function xFastifyAfter(fastify, options) {
+
+  /*
+   ===== LIST ROUTES AFTER ALL PLUGINS =====
+   Use the after() method to ensure this runs after all plugins are registered.
+ */
+  fastify.after(() => {
+    if (options.professional !== true) {
+      console.info("   ✅ Listing Routes:");
+      fastify.ready(() => {
+        printRoutes(options.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 👋")
+        );
+      });
+    }
+  });
+
+
+}

package/src/middleware/bugsnag.js

@@ -0,0 +1,10 @@
+export async function setupBugsnag(fastify, options) {
+  if (options.active !== false) {
+    if (!options.apiKey)
+      throw new Error("Bugsnag API key must be provided.");
+    fastify.register(import("fastify-bugsnag"), {
+      apiKey: options.apiKey,
+    });
+    console.info("   ✅ BugSnag Enabled");
+  }
+}

package/src/middleware/cors.js

@@ -0,0 +1,10 @@
+export async function setupCors(fastify, options) {
+  if (options.active !== false) {
+    await fastify.register(await import("@fastify/cors"), {
+      origin: options.origin || ["https://getx.io", "http://localhost:3000"],
+      credentials: options.credentials !== undefined ? options.credentials : true,
+      methods: options.methods || ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    });
+    console.info("   ✅ CORS Enabled");
+  }
+}

package/src/middleware/fancyErrors.js

@@ -0,0 +1,26 @@
+export async function setupFancyErrors(fastify, options) {
+
+  /*
+    ===== EXTEND ERRORS =====
+  */
+  if (options.fancyErrors !== false) {
+    fastify.setErrorHandler((error, request, reply) => {
+      const statusCode = error.statusCode || 500;
+      const response = {
+        status: statusCode,
+        message: error.message || "Internal Server Error",
+        // Only show stack in development mode
+        stack: process.env.NODE_ENV === "development" ? error.stack : undefined,
+      };
+
+      // Optional Bugsnag error reporting
+      if (fastify.bugsnag) {
+        fastify.bugsnag.notify(error);
+      }
+
+      fastify.log.error(response);
+      reply.status(statusCode).send(response);
+    });
+    console.info("   ✅ Fancy Errors Enabled");
+  }
+}

package/src/middleware/multipart.js

@@ -0,0 +1,6 @@
+export async function setupMultipart(fastify, options) {
+  if (options.active !== false) {
+    fastify.register(import("@fastify/multipart"), options);
+    console.info("   ✅ Multipart Enabled");
+  }
+}

package/src/middleware/rateLimit.js

@@ -0,0 +1,6 @@
+export async function setupRateLimit(fastify, options) {
+  if (options.active !== false) {
+    fastify.register(import("@fastify/rate-limit"), options);
+    console.info("   ✅ Rate Limiting Enabled");
+  }
+}

package/src/middleware/underPressure.js

@@ -0,0 +1,6 @@
+export async function setupUnderPressure(fastify, options) {
+  if (options.active !== false) {
+    fastify.register(import("@fastify/under-pressure"), options);
+    console.info("   ✅ Under Pressure Enabled");
+  }
+}