@xenterprises/fastify-xconfig 1.0.2 → 1.1.1

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

package/tsconfig.json

@@ -1,16 +1,14 @@
 {
+  "extends": "fastify-tsconfig",
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "declaration": true,              // Generates .d.ts files for types
-    "outDir": "./dist",               // Output directory for compiled files
-    "strict": true,                   // Enable all strict type-checking options
-    "moduleResolution": "node",       // Proper module resolution
-    "esModuleInterop": true,          // Allows default imports from CJS modules
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "sourceMap": true
+    "outDir": "dist",
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "module": "NodeNext",
+    "target": "ES2022",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true
   },
-  "include": ["src/**/*"],            // Specifies files to include for compilation
+  "include": ["src/**/*.ts", "ts-reference/**/*.ts"],
   "exclude": ["node_modules", "dist"]
 }