@xenterprises/fastify-xconfig 0.0.1 → 0.0.3

package/ts-reference/integrations/cloudinary.ts

@@ -0,0 +1,26 @@
+import { v2 as Cloudinary } from "cloudinary";
+
+export async function setupCloudinary(fastify: any, cloudinaryOptions: any) {
+  if (cloudinaryOptions.active !== false) {
+    Cloudinary.config({
+      cloud_name: cloudinaryOptions.cloudName,
+      api_key: cloudinaryOptions.apiKey,
+      api_secret: cloudinaryOptions.apiSecret,
+    });
+    fastify.decorate("cloudinary", {
+      async upload(fileStream: any, options = {}) {
+        return new Promise((resolve, reject) => {
+          const uploadStream = Cloudinary.uploader.upload_stream(
+            options,
+            (error, result) => {
+              if (error) reject(error);
+              else resolve(result);
+            }
+          );
+          fileStream.pipe(uploadStream);
+        });
+      },
+    });
+    console.info("   ✅ Cloudinary Enabled");
+  }
+}

package/ts-reference/integrations/prisma.ts

@@ -0,0 +1,13 @@
+import { PrismaClient } from "@prisma/client";
+
+export async function setupPrisma(fastify: any, prismaOptions: any) {
+  if (prismaOptions.active !== false) {
+    const prisma = new PrismaClient(prismaOptions);
+    await prisma.$connect();
+    fastify.decorate("prisma", prisma);
+    fastify.addHook("onClose", async () => {
+      await fastify.prisma.$disconnect();
+    });
+    console.info("   ✅ Prisma Enabled");
+  }
+}

package/ts-reference/integrations/sendgrid.ts

@@ -0,0 +1,27 @@
+import Sendgrid from "@sendgrid/mail";
+
+export async function setupSendGrid(fastify: any, sendGridOptions: any) {
+  if (sendGridOptions.active !== false) {
+    if (!sendGridOptions.apiKey)
+      throw new Error("SendGrid API key must be provided.");
+    Sendgrid.setApiKey(sendGridOptions.apiKey);
+    fastify.decorate("sendgrid", {
+      async sendEmail(
+        to: string,
+        subject: string,
+        templateId: string,
+        dynamicTemplateData: any
+      ) {
+        const msg = {
+          to,
+          from: sendGridOptions.fromEmail,
+          subject,
+          templateId,
+          dynamicTemplateData,
+        };
+        await Sendgrid.send(msg);
+      },
+    });
+    console.info("   ✅ SendGrid Enabled");
+  }
+}

package/ts-reference/integrations/stripe.ts

@@ -0,0 +1,15 @@
+import Stripe from "stripe";
+
+export async function setupStripe(fastify: any, stripeOptions: any) {
+  if (stripeOptions.active !== false) {
+    const stripeClient = new Stripe(stripeOptions.apiKey, {
+      apiVersion: "2024-06-20",
+    });
+    fastify.decorate("stripe", {
+      async createPaymentIntent(amount: number, currency = "usd") {
+        return await stripeClient.paymentIntents.create({ amount, currency });
+      },
+    });
+    console.info("   ✅ Stripe Enabled");
+  }
+}

package/ts-reference/integrations/twilio.ts

@@ -0,0 +1,20 @@
+import Twilio from "twilio";
+
+export async function setupTwilio(fastify: any, twilioOptions: any) {
+  if (twilioOptions.active !== false) {
+    const twilioClient = Twilio(
+      twilioOptions.accountSid,
+      twilioOptions.authToken
+    );
+    fastify.decorate("twilio", {
+      async sendSMS(to: string, body: string) {
+        return await twilioClient.messages.create({
+          body,
+          to,
+          from: twilioOptions.phoneNumber,
+        });
+      },
+    });
+    console.info("   ✅ Twilio Enabled");
+  }
+}

package/ts-reference/middleware/bugsnag.ts

@@ -0,0 +1,10 @@
+import { FastifyInstance } from "fastify";
+
+export async function setupBugsnag(fastify: FastifyInstance, options: any) {
+  if (options.active !== false && options.apiKey) {
+    await fastify.register(import("fastify-bugsnag"), {
+      apiKey: options.apiKey,
+    });
+    console.info("   ✅ Bugsnag Enabled");
+  }
+}

package/ts-reference/middleware/cors.ts

@@ -0,0 +1,13 @@
+import { FastifyInstance } from "fastify";
+
+export async function setupCors(fastify: FastifyInstance, options: any) {
+  if (options.active !== false) {
+    await fastify.register(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/ts-reference/middleware/errorHandler.ts

@@ -0,0 +1,24 @@
+import { FastifyInstance } from "fastify";
+
+export async function setupErrorHandler(
+  fastify: FastifyInstance,
+  fancyErrors: boolean
+) {
+  if (fancyErrors !== false) {
+    fastify.setErrorHandler((error, request, reply) => {
+      const statusCode = error.statusCode || 500;
+      const response = {
+        status: statusCode,
+        message: error.message || "Internal Server Error",
+        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/ts-reference/middleware/multipart.ts

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

package/ts-reference/middleware/rateLimit.ts

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

package/ts-reference/middleware/underPressure.ts

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

package/ts-reference/utils/colorize.ts

@@ -0,0 +1,45 @@
+import type { FastifyInstance, RouteOptions } from "fastify";
+
+type HttpMethod = "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "clear";
+
+const COLORS: Record<HttpMethod, number> = {
+  POST: 33,
+  GET: 32,
+  PUT: 34,
+  DELETE: 31,
+  PATCH: 90,
+  clear: 39,
+};
+
+// Function to colorize method and path names
+export function colorize(method: string, text: string) {
+  const colorCode = COLORS[method as HttpMethod] || COLORS.clear;
+  return `\u001b[${colorCode}m${text}\u001b[${COLORS.clear}m`;
+}
+
+// Function to print the collected routes
+export function printRoutes(routes: RouteOptions[], colors = true): void {
+  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}`
+          )
+        );
+    });
+}
+
+// Helper function to capture all registered routes
+export function captureRoutes(fastify: FastifyInstance): RouteOptions[] {
+  const routes: RouteOptions[] = [];
+
+  fastify.addHook("onRoute", (routeOptions) => {
+    routes.push(routeOptions);
+  });
+
+  return routes;
+}

package/ts-reference/utils/formatBytes.ts

@@ -0,0 +1,8 @@
+export function formatBytes(bytes: number, decimals = 2): string {
+  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]}`;
+}

package/ts-reference/utils/randomUUID.ts

@@ -0,0 +1,3 @@
+import { randomUUID } from "uncrypto";
+
+export const generateUUID = randomUUID;

package/ts-reference/utils/statAsync.ts

@@ -0,0 +1,4 @@
+import fs from "fs";
+import util from "util";
+
+export const statAsync = util.promisify(fs.stat);