@xenterprises/fastify-xconfig 1.0.1 → 1.1.0

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");
+  }
+}

package/src/utils/colorize.js

@@ -0,0 +1,37 @@
+// src/utils/colorize.js
+const colors = {
+  POST: 33,
+  GET: 32,
+  PUT: 34,
+  DELETE: 31,
+  PATCH: 90,
+  clear: 39,
+};
+
+
+// Function to colorize method and path names
+function colorize(method, text) {
+  const colorCode = colors[method] || colors.clear;
+  return `\u001b[${colorCode}m${text}\u001b[${colors.clear}m`;
+}
+// Function to print the collected routes
+function printRoutes(routes, colors = true) {
+  routes
+    .sort((a, b) => a.url.localeCompare(b.url))
+    .forEach(({ method, url }) => {
+      const methodsArray = Array.isArray(method) ? method : [method];
+      methodsArray
+        .filter((m) => m !== "HEAD")
+        .forEach((m) =>
+          console.info(
+            `${colors ? colorize(m, m) : m}\t${colors ? colorize(m, url) : url}`
+          )
+        );
+    });
+}
+
+export {
+  colors,
+  colorize,
+  printRoutes,
+};

package/src/utils/cookie.js

@@ -0,0 +1,5 @@
+export async function setupCookie(fastify, options) {
+  fastify.register(import("@fastify/cookie"));
+
+  console.info("   ✅ @fastify/cookie Enabled");
+}

package/src/utils/formatBytes.js

@@ -0,0 +1,16 @@
+import fp from "fastify-plugin";
+
+async function formatBytesPlugin(fastify, options) {
+  fastify.decorate("formatBytes", (bytes, decimals = 2) => {
+    if (bytes === 0) return "0 Bytes";
+
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+  });
+}
+
+export default fp(formatBytesPlugin);

package/src/utils/health.js

@@ -0,0 +1,126 @@
+// Import necessary modules
+import os from "os";
+import process from "process";
+import fs from "fs";
+import util from "util";
+
+
+// Promisify fs functions
+const statAsync = util.promisify(fs.stat);
+
+// Record the server start time
+const serverStartTime = Date.now();
+
+// Helper function to format bytes into human-readable format
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const formattedNumber = parseFloat((bytes / Math.pow(k, i)).toFixed(dm));
+  return `${formattedNumber} ${sizes[i]}`;
+}
+
+export async function setupHealth(fastify, options) {
+  fastify.get("/health", async (request, reply) => {
+    const status = {
+      status: "healthy",
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(), // Uptime in seconds
+      version: "1.0.0", // Fetch dynamically if possible
+      environment: process.env.NODE_ENV || "development",
+      dependencies: {},
+      resources: {},
+      details: {},
+    };
+
+    try {
+      // Database connectivity check
+      if (fastify.prisma) {
+        await fastify.prisma.$queryRaw`SELECT 1`;
+        status.dependencies.database = "up";
+      } else {
+        status.dependencies.database = "not configured";
+      }
+    } catch (error) {
+      status.dependencies.database = "down";
+      status.status = "degraded";
+      status.details.databaseError = error.message;
+    }
+
+    try {
+      // Redis connectivity check
+      if (fastify.redis) {
+        await fastify.redis.ping();
+        status.dependencies.redis = "up";
+      } else {
+        status.dependencies.redis = "not configured";
+      }
+    } catch (error) {
+      status.dependencies.redis = "down";
+      status.status = "degraded";
+      status.details.redisError = error.message;
+    }
+
+    // Resource usage
+    const memoryUsage = process.memoryUsage();
+    const loadAverage = os.loadavg();
+
+    status.resources.memory = {
+      rss: formatBytes(memoryUsage.rss),
+      heapTotal: formatBytes(memoryUsage.heapTotal),
+      heapUsed: formatBytes(memoryUsage.heapUsed),
+      external: formatBytes(memoryUsage.external),
+      arrayBuffers: formatBytes(memoryUsage.arrayBuffers),
+    };
+
+    status.resources.cpu = {
+      loadAverage, // 1, 5, and 15 minute load averages
+      cpus: os.cpus().length,
+    };
+
+    // Disk space availability
+    try {
+      // Implement disk space check using 'check-disk-space' package
+      // Install it via 'npm install check-disk-space'
+      const checkDiskSpace = (await import("check-disk-space")).default;
+      const diskSpace = await checkDiskSpace("/"); // Replace '/' with your drive or mount point
+      status.resources.disk = {
+        free: formatBytes(diskSpace.free),
+        size: formatBytes(diskSpace.size),
+      };
+    } catch (error) {
+      status.resources.disk = "unknown";
+      status.details.diskError = error.message;
+    }
+
+    // Application-specific checks
+    // Example: Check if a scheduled job is running
+    if (typeof isJobRunning === "function" && !isJobRunning()) {
+      status.status = "degraded";
+      status.details.jobStatus = "Scheduled job is not running";
+    }
+
+    // Configuration validation
+    const requiredEnvVars = [
+      "DATABASE_URL",
+      "ADMIN_JWT_SECRET",
+      "USER_JWT_SECRET",
+    ];
+    const missingEnvVars = requiredEnvVars.filter(
+      (varName) => !process.env[varName]
+    );
+    if (missingEnvVars.length > 0) {
+      status.status = "degraded";
+      status.details.missingEnvVars = missingEnvVars;
+    }
+
+    // Determine overall health
+    if (status.status === "healthy") {
+      reply.send(status);
+    } else {
+      reply.status(500).send(status);
+    }
+  });
+}

package/src/utils/xEcho.js

@@ -0,0 +1,12 @@
+// src/utils/xEcho.js
+import fp from "fastify-plugin";
+
+async function xEcho(fastify, options) {
+  fastify.decorate("xEcho", function () {
+    return "Hello from X Enterprises!"
+  });
+}
+
+export default fp(xEcho, {
+  name: "xEcho",
+});

package/src/utils/xSlugify.js

@@ -0,0 +1,20 @@
+// src/utils/xSlugify.js
+import fp from "fastify-plugin";
+
+async function xSlugify(fastify, options) {
+  fastify.decorate('slugify', (string) => {
+    return string
+      .toString()
+      .toLowerCase()                   // Convert to lowercase
+      .trim()                          // Trim leading and trailing spaces
+      .replace(/\s+/g, '-')            // Replace spaces with -
+      .replace(/[^\w\-]+/g, '')        // Remove all non-word characters (allow only letters, numbers, and dashes)
+      .replace(/\-\-+/g, '-')          // Replace multiple dashes with a single dash
+      .replace(/^-+/, '')              // Trim leading dashes
+      .replace(/-+$/, '');             // Trim trailing dashes
+  });
+}
+
+export default fp(xSlugify, {
+  name: "xSlugify",
+});

package/src/utils/xUUID.js

@@ -0,0 +1,14 @@
+import fp from "fastify-plugin";
+import { randomUUID } from "uncrypto";
+
+async function xUUID(fastify, options) {
+  fastify.decorate("generateUUID", randomUUID);
+
+  fastify.decorate('randomUUID', () => {
+    return randomUUID(); // Generate a UUID using uncrypto's randomUUID
+  });
+}
+
+export default fp(xUUID, {
+  name: "xUUID",
+});

package/src/xConfig.js

@@ -0,0 +1,117 @@
+// src/xConfig.js
+import fp from "fastify-plugin";
+const isProduction = process.env.NODE_ENV === 'production';
+/*
+* Auth
+*/
+import { setupAdminAuth } from "./auth/admin.js";
+import { setupAuth } from "./auth/portal.js";
+
+
+/*
+* Integrations
+*/
+import { setupPrisma } from "./integrations/prisma.js";
+import { setupSendgrid } from "./integrations/sendgrid.js";
+import { setupTwilio } from "./integrations/twilio.js";
+import { setupCloudinary } from "./integrations/cloudinary.js";
+import { setupGeocode } from "./integrations/geocode.js";
+
+/*
+* Lifecycle
+*/
+import { xFastifyAfter } from "./lifecycle/xFastifyAfter.js";
+
+
+/*
+* Middleware
+*/
+import { setupCors } from './middleware/cors.js';
+import { setupUnderPressure } from './middleware/underPressure.js';
+import { setupRateLimit } from './middleware/rateLimit.js';
+import { setupMultipart } from './middleware/multipart.js';
+import { setupBugsnag } from './middleware/bugsnag.js';
+import { setupFancyErrors } from './middleware/fancyErrors.js'
+
+/*
+* Utils
+*/
+import xEcho from "./utils/xEcho.js";
+import { setupHealth } from "./utils/health.js";
+import xSlugify from "./utils/xSlugify.js";
+import xUUID from "./utils/xUUID.js";
+import { setupCookie } from "./utils/cookie.js";
+
+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;
+
+  // add starting console with emoji
+  console.info("\n 🌮 Starting xConfig...\n");
+
+  /*
+    ===== LIST ROUTES =====
+    Moved the onRoute hook to the top to capture all routes.
+  */
+  const routes = [];
+  fastify.addHook("onRoute", (r) => routes.push(r));
+
+  /*
+  * Integrations
+  */
+  await setupPrisma(fastify, prismaOptions);
+  await setupSendgrid(fastify, sendGridOptions);
+  await setupTwilio(fastify, twilioOptions);
+  await setupCloudinary(fastify, cloudinaryOptions);
+  await setupGeocode(fastify, geocodeOptions);
+
+  /*
+  * Middleware
+  */
+  await setupCors(fastify, corsOptions);
+  await setupUnderPressure(fastify, underPressureOptions);
+  await setupRateLimit(fastify, rateLimitOptions);
+  await setupMultipart(fastify, multipartOptions);
+  await setupBugsnag(fastify, bugsnagOptions);
+  await setupFancyErrors(fastify, fancyErrors);
+  fastify.register(import('@fastify/sensible'))
+
+  /*
+  * Utils
+  */
+
+  fastify.register(xEcho);
+  fastify.register(xSlugify);
+  fastify.register(xUUID);
+  await setupHealth(fastify);
+  await setupCookie(fastify, authOptions);
+
+  /*
+  * Auth
+  */
+  await setupAuth(fastify, authOptions);
+  await setupAdminAuth(fastify, authOptions);
+
+
+  //.after() method to ensure this runs after all plugins are registered.
+  await xFastifyAfter(fastify, { professional, routes });
+
+}
+
+export default fp(xConfig, {
+  name: "xConfig",
+});

package/test/index.js

@@ -0,0 +1,17 @@
+// test.js
+const fastify = require('fastify')();
+const myPlugin = require('../src/xConfig');
+
+fastify.register(myPlugin);
+
+fastify.get('/', async (request, reply) => {
+  return { message: fastify.myPluginMethod() };
+});
+
+fastify.listen(3000, (err, address) => {
+  if (err) {
+    console.error(err);
+    process.exit(1);
+  }
+  console.log(`Server running at ${address}`);
+});