@xenterprises/fastify-xconfig 1.1.8 → 2.0.1

package/src/utils/health.js

@@ -103,17 +103,16 @@ export async function setupHealth(fastify, options) {
     }
 
     // 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;
+    // Only check required env vars if Prisma is enabled
+    if (fastify.prisma) {
+      const requiredEnvVars = ["DATABASE_URL"];
+      const missingEnvVars = requiredEnvVars.filter(
+        (varName) => !process.env[varName]
+      );
+      if (missingEnvVars.length > 0) {
+        status.status = "degraded";
+        status.details.missingEnvVars = missingEnvVars;
+      }
     }
 
     // Determine overall health

package/src/xConfig.js

@@ -1,28 +1,17 @@
 // 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
 */
@@ -47,16 +36,10 @@ async function xConfig(fastify, options) {
     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
@@ -73,10 +56,6 @@ async function xConfig(fastify, options) {
   * Integrations
   */
   await setupPrisma(fastify, prismaOptions);
-  await setupSendgrid(fastify, sendGridOptions);
-  await setupTwilio(fastify, twilioOptions);
-  await setupCloudinary(fastify, cloudinaryOptions);
-  await setupGeocode(fastify, geocodeOptions);
 
   /*
   * Middleware
@@ -98,13 +77,6 @@ async function xConfig(fastify, options) {
   fastify.register(xUUID);
   await setupHealth(fastify);
 
-  /*
-  * 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 });
 
@@ -112,4 +84,4 @@ async function xConfig(fastify, options) {
 
 export default fp(xConfig, {
   name: "xConfig",
-});
+});

package/test/index.js

@@ -8,10 +8,10 @@ fastify.get('/', async (request, reply) => {
   return { message: fastify.myPluginMethod() };
 });
 
-fastify.listen(3000, (err, address) => {
-  if (err) {
-    console.error(err);
-    process.exit(1);
-  }
+try {
+  const address = await fastify.listen({ port: 3000 });
   console.log(`Server running at ${address}`);
-});
+} catch (err) {
+  console.error(err);
+  process.exit(1);
+}

package/test/xConfig.test.js

@@ -0,0 +1,278 @@
+// test/xConfig.test.js
+import { test } from "node:test";
+import assert from "node:assert";
+import Fastify from "fastify";
+import xConfig from "../src/xConfig.js";
+
+// Minimal config for testing
+const minimalConfig = {
+  prisma: { active: false },
+  bugsnag: { active: false },
+};
+
+test("xConfig Plugin - registers successfully", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xConfig, minimalConfig);
+    assert.ok(true, "Plugin registered successfully");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Plugin - provides utility decorators", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xConfig, minimalConfig);
+    // At least one utility decorator should be available
+    const hasUtilityDecorators =
+      fastify.xEcho !== undefined ||
+      fastify.xUUID !== undefined;
+    assert.ok(hasUtilityDecorators, "At least one utility decorator is available");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Plugin - has health route registered", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    const routes = [];
+    fastify.addHook("onRoute", (r) => routes.push(r));
+    await fastify.register(xConfig, minimalConfig);
+
+    // Check that health route is present
+    const hasHealthRoute = routes.some((r) => r.url === "/health");
+    assert.ok(hasHealthRoute, "Health endpoint route is registered");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Plugin - accepts custom CORS config", async () => {
+  const fastify = Fastify({ logger: false });
+  const customConfig = {
+    ...minimalConfig,
+    cors: { origin: "http://example.com" },
+  };
+  try {
+    await fastify.register(xConfig, customConfig);
+    assert.ok(true, "Custom CORS config accepted");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Plugin - accepts custom rate limit config", async () => {
+  const fastify = Fastify({ logger: false });
+  const customConfig = {
+    ...minimalConfig,
+    rateLimit: { max: 50, timeWindow: "1 minute" },
+  };
+  try {
+    await fastify.register(xConfig, customConfig);
+    assert.ok(true, "Custom rate limit config accepted");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Plugin - under pressure monitoring available", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    const customConfig = {
+      ...minimalConfig,
+      underPressure: {
+        maxEventLoopDelay: 1000,
+        maxHeapUsedBytes: 1000000000,
+        maxRssBytes: 1000000000
+      }
+    };
+    await fastify.register(xConfig, customConfig);
+    assert.ok(true, "Under pressure config accepted");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Plugin - multipart handling available", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    const customConfig = {
+      ...minimalConfig,
+      multipart: { limits: { fileSize: 52428800 } }
+    };
+    await fastify.register(xConfig, customConfig);
+    assert.ok(true, "Multipart config accepted");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Plugin - health check endpoint responds", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    const routes = [];
+    fastify.addHook("onRoute", (r) => routes.push(r));
+    await fastify.register(xConfig, minimalConfig);
+
+    const response = await fastify.inject({
+      method: "GET",
+      url: "/health"
+    });
+    assert.equal(response.statusCode, 200, "Health endpoint returns 200");
+    const body = JSON.parse(response.body);
+    assert.ok(body.status, "Health response includes status field");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Utilities - xUUID generates valid UUIDs", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xConfig, minimalConfig);
+
+    const uuid1 = fastify.randomUUID();
+    const uuid2 = fastify.randomUUID();
+
+    // Check that randomUUID is a function
+    assert.equal(typeof fastify.randomUUID, "function", "randomUUID is a function");
+
+    // Check that UUIDs are generated
+    assert.ok(uuid1, "UUID is generated");
+    assert.ok(uuid2, "Second UUID is generated");
+
+    // Check that UUIDs are different
+    assert.notEqual(uuid1, uuid2, "UUIDs are unique");
+
+    // Check UUID format (36 chars, with dashes at positions 8, 13, 18, 23)
+    assert.match(uuid1, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "UUID matches format");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Utilities - xSlugify handles various inputs", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xConfig, minimalConfig);
+
+    // Test basic slugification
+    assert.equal(fastify.slugify("Hello World"), "hello-world", "Converts to lowercase and replaces spaces");
+    assert.equal(fastify.slugify("UPPERCASE"), "uppercase", "Converts uppercase to lowercase");
+    assert.equal(fastify.slugify("Multiple   Spaces"), "multiple-spaces", "Collapses multiple spaces");
+
+    // Test special character removal
+    assert.equal(fastify.slugify("Hello@World!"), "helloworld", "Removes special characters");
+    assert.equal(fastify.slugify("Test-String"), "test-string", "Preserves dashes");
+
+    // Test edge cases
+    assert.equal(fastify.slugify("  Trim  "), "trim", "Trims leading and trailing spaces");
+    assert.equal(fastify.slugify("---multiple-dashes---"), "multiple-dashes", "Collapses multiple dashes");
+    assert.equal(fastify.slugify(""), "", "Handles empty string");
+
+    // Test with numbers
+    assert.equal(fastify.slugify("Test123"), "test123", "Preserves numbers");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Utilities - xEcho returns status message", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xConfig, minimalConfig);
+
+    const echo = fastify.xEcho();
+    assert.ok(echo, "xEcho returns a value");
+    assert.equal(typeof echo, "string", "xEcho returns a string");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Health Endpoint - response structure validation", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xConfig, minimalConfig);
+
+    const response = await fastify.inject({
+      method: "GET",
+      url: "/health"
+    });
+
+    assert.equal(response.statusCode, 200, "Returns 200 status");
+
+    const body = JSON.parse(response.body);
+    assert.ok(body.status, "Has status field");
+    assert.ok(body.timestamp, "Has timestamp field");
+    assert.ok(body.details, "Has details object");
+    assert.ok(typeof body.details === "object", "Details is an object");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Configuration - CORS disabled when active is false", async () => {
+  const fastify = Fastify({ logger: false });
+  const customConfig = {
+    ...minimalConfig,
+    cors: { active: false },
+  };
+  try {
+    await fastify.register(xConfig, customConfig);
+    assert.ok(true, "Plugin accepts cors.active: false");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Configuration - rate limit disabled when active is false", async () => {
+  const fastify = Fastify({ logger: false });
+  const customConfig = {
+    ...minimalConfig,
+    rateLimit: { active: false },
+  };
+  try {
+    await fastify.register(xConfig, customConfig);
+    assert.ok(true, "Plugin accepts rateLimit.active: false");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Configuration - fancy errors can be disabled", async () => {
+  const fastify = Fastify({ logger: false });
+  const customConfig = {
+    ...minimalConfig,
+    fancyErrors: false,
+  };
+  try {
+    await fastify.register(xConfig, customConfig);
+    assert.ok(true, "Plugin accepts fancyErrors: false");
+  } finally {
+    await fastify.close();
+  }
+});
+
+test("xConfig Integration - all decorators available together", async () => {
+  const fastify = Fastify({ logger: false });
+  try {
+    await fastify.register(xConfig, minimalConfig);
+
+    // Verify all expected decorators exist
+    assert.ok(fastify.xEcho, "xEcho decorator available");
+    assert.ok(fastify.randomUUID, "randomUUID decorator available");
+    assert.ok(fastify.generateUUID, "generateUUID decorator available");
+    assert.ok(fastify.slugify, "slugify decorator available");
+
+    // Verify they're functions
+    assert.equal(typeof fastify.xEcho, "function", "xEcho is a function");
+    assert.equal(typeof fastify.randomUUID, "function", "randomUUID is a function");
+    assert.equal(typeof fastify.generateUUID, "function", "generateUUID is a function");
+    assert.equal(typeof fastify.slugify, "function", "slugify is a function");
+  } finally {
+    await fastify.close();
+  }
+});