Merge pull request #10 from foyzulkarim/feature/05-configuration-management

Implement environment-based config loading with Joi validation

Author: foyzulkarim

.gitignore

@@ -72,13 +72,6 @@ web_modules/
 # Yarn Integrity file
 .yarn-integrity
 
-# dotenv environment variable files
-.env
-.env.development.local
-.env.test.local
-.env.production.local
-.env.local
-
 # parcel-bundler cache (https://parceljs.org/)
 .cache
 .parcel-cache
@@ -128,3 +121,11 @@ dist
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+# ignore .env and config.{}.json files
+.env.development
+.env.production
+.env.test
+config.development.json
+config.production.json
+config.test.json

src/.env.example

@@ -0,0 +1 @@
+MONGODB_URI=mongodb://localhost:27017/your-database-name

src/.env.test

@@ -0,0 +1 @@
+MONGODB_URI=mongodb://localhost:27018/testdb

src/configs/config.example.json

@@ -0,0 +1,6 @@
+{
+  "NODE_ENV": "development",
+  "MONGODB_URI": "mongodb://localhost:27017/mydatabase",
+  "RATE": 40,
+  "PORT": 4000
+}

src/configs/config.schema.js

@@ -0,0 +1,12 @@
+const Joi = require("joi");
+
+const schema = Joi.object({
+  NODE_ENV: Joi.string()
+    .valid("development", "production", "test")
+    .default("development"),
+  MONGODB_URI: Joi.string().required(),
+  RATE: Joi.number().min(0).required(),
+  PORT: Joi.number().min(1000).default(4000),
+});
+
+module.exports = schema;

src/configs/config.shared.json

@@ -0,0 +1,3 @@
+{
+  "RATE": 100
+}

src/configs/config.test.json

@@ -0,0 +1 @@
+{}

src/configs/index.js

@@ -0,0 +1,80 @@
+const dotenv = require("dotenv");
+const fs = require("fs");
+const path = require("path");
+
+const logger = require("../libraries/log/logger");
+const schema = require("./config.schema");
+
+class Config {
+  constructor() {
+    if (!Config.instance) {
+      logger.info("Loading and validating config for the first time...");
+      this.config = this.loadAndValidateConfig();
+      Config.instance = this;
+      logger.info("Config loaded and validated");
+    }
+
+    return Config.instance;
+  }
+
+  loadAndValidateConfig() {
+    const environment = process.env.NODE_ENV || "development";
+
+    // 1. Load environment file from one level up and using __dirname
+    const envFile = `.env.${environment}`;
+    const envPath = path.join(__dirname, "..", envFile);
+    if (!fs.existsSync(envPath)) {
+      throw new Error(`Environment file not found: ${envPath}`);
+    }
+    dotenv.config({ path: envPath });
+
+    // 2. Load config file based on environment
+    // Construct the path to the config file
+    const configFile = path.join(__dirname, `config.${environment}.json`);
+
+    // Check if the file exists before trying to read it
+    if (!fs.existsSync(configFile)) {
+      throw new Error(`Config file not found: ${configFile}`);
+    }
+
+    let config = JSON.parse(fs.readFileSync(configFile));
+
+    const sharedConfigFile = path.join(__dirname, "config.shared.json");
+    if (fs.existsSync(sharedConfigFile)) {
+      const sharedConfig = JSON.parse(fs.readFileSync(sharedConfigFile));
+      config = { ...sharedConfig, ...config };
+    }
+
+    const finalConfig = {};
+    for (const key in schema.describe().keys) {
+      if (process.env.hasOwnProperty(key)) {
+        finalConfig[key] = process.env[key]; // Prioritize environment variables
+      } else if (config.hasOwnProperty(key)) {
+        finalConfig[key] = config[key]; // Fallback to config file value
+      }
+    }
+
+    // 4. load the schema file
+    if (!schema) {
+      throw new Error(`Schema file not found`);
+    }
+
+    const { error, value: validatedConfig } = schema.validate(finalConfig);
+    if (error) {
+      const missingProperties = error.details.map((detail) => detail.path[0]);
+      throw new Error(
+        `Config validation error: missing properties ${missingProperties}`,
+      );
+    }
+    return validatedConfig;
+  }
+
+  static getInstance() {
+    if (!Config.instance) {
+      new Config();
+    }
+    return Config.instance;
+  }
+}
+
+module.exports = Config.getInstance().config;

src/domains/product/request.js

@@ -3,12 +3,16 @@ const mongoose = require('mongoose');
 
 const createSchema = Joi.object().keys({
   name: Joi.string().required(),
-  // other properties
+  description: Joi.string().required(),
+  price: Joi.number().required(),
+  inStock: Joi.boolean().optional(),
 });
 
 const updateSchema = Joi.object().keys({
   name: Joi.string(),
-  // other properties
+  description: Joi.string(),
+  price: Joi.number(),
+  inStock: Joi.boolean(),
 });
 
 const idSchema = Joi.object().keys({

src/libraries/db/index.js

@@ -0,0 +1,30 @@
+const mongoose = require("mongoose");
+const logger = require("../log/logger");
+
+const config = require("../../configs");
+
+const connectWithMongoDb = async () => {
+  const MONGODB_URI = config.MONGODB_URI;
+
+  logger.info("Connecting to MongoDB...");
+  mongoose.connection.once("open", () => {
+    logger.info("MongoDB connection is open");
+  });
+  mongoose.connection.on("error", (error) => {
+    logger.error("MongoDB connection error", error);
+  });
+
+  await mongoose.connect(MONGODB_URI, {
+    autoIndex: true,
+    autoCreate: true,
+  });
+  logger.info("Connected to MongoDB");
+};
+
+const disconnectWithMongoDb = async () => {
+  logger.info("Disconnecting from MongoDB...");
+  await mongoose.disconnect();
+  logger.info("Disconnected from MongoDB");
+};
+
+module.exports = { connectWithMongoDb, disconnectWithMongoDb };

src/server.js

@@ -1,13 +1,12 @@
-const mongoose = require('mongoose');
-const http = require('http');
-const net = require('net');
-const express = require('express');
-const helmet = require('helmet');
-const defineRoutes = require('./app');
+const config = require("./configs");
+const express = require("express");
+const helmet = require("helmet");
 
-const { errorHandler } = require('./libraries/error-handling');
-const logger = require('./libraries/log/logger');
-const { addRequestIdMiddleware } = require('./middlewares/request-context');
+const defineRoutes = require("./app");
+const { errorHandler } = require("./libraries/error-handling");
+const logger = require("./libraries/log/logger");
+const { addRequestIdMiddleware } = require("./middlewares/request-context");
+const { connectWithMongoDb } = require("./libraries/db");
 
 let connection;
 
@@ -24,14 +23,14 @@ const createExpressApp = () => {
     next();
   });
 
-  logger.info('Express middlewares are set up');
+  logger.info("Express middlewares are set up");
   defineRoutes(expressApp);
   defineErrorHandlingMiddleware(expressApp);
   return expressApp;
 };
 
 async function startWebServer() {
-  logger.info('Starting web server...');
+  logger.info("Starting web server...");
   const expressApp = createExpressApp();
   const APIAddress = await openConnection(expressApp);
   logger.info(`Server is running on ${APIAddress.address}:${APIAddress.port}`);
@@ -51,7 +50,7 @@ async function stopWebServer() {
 
 async function openConnection(expressApp) {
   return new Promise((resolve) => {
-    const webServerPort = process.env.PORT || 4000;
+    const webServerPort = config.PORT;
     logger.info(`Server is about to listen to port ${webServerPort}`);
 
     connection = expressApp.listen(webServerPort, () => {
@@ -64,34 +63,15 @@ async function openConnection(expressApp) {
 function defineErrorHandlingMiddleware(expressApp) {
   expressApp.use(async (error, req, res, next) => {
     // Note: next is required for Express error handlers
-    if (error && typeof error === 'object') {
+    if (error && typeof error === "object") {
       if (error.isTrusted === undefined || error.isTrusted === null) {
         error.isTrusted = true;
       }
     }
-    
+
     errorHandler.handleError(error);
     res.status(error?.HTTPStatus || 500).end();
   });
 }
 
-const connectWithMongoDb = async () => {
-  const MONGODB_URI =
-    process.env.MONGODB_URI || 'mongodb://localhost:27017/express-mongoose';
-
-  logger.info('Connecting to MongoDB...');
-  mongoose.connection.once('open', () => {
-    logger.info('MongoDB connection is open');
-  });
-  mongoose.connection.on('error', (error) => {
-    logger.error('MongoDB connection error', error);
-  });
-
-  await mongoose.connect(MONGODB_URI, {
-    autoIndex: true,
-    autoCreate: true,
-  });
-  logger.info('Connected to MongoDB');
-};
-
 module.exports = { createExpressApp, startWebServer, stopWebServer };

src/start.js

@@ -1,7 +1,6 @@
 const { startWebServer } = require('./server');
 
 const start = async () => {
-  console.log('Hello World');
   await startWebServer();
 };
 

test/globalSetup.js

@@ -5,9 +5,8 @@ module.exports = async function globalSetup() {
   const instance = await MongoMemoryServer.create({
     instance: {
       dbName: 'testdb',
+      port: 27018,
     },
   });
-  const uri = instance.getUri();
   global.__MONGOINSTANCE = instance;
-  process.env.MONGODB_URL = uri.slice(0, uri.lastIndexOf('/'));
 };

test/setupFile.js

@@ -1,21 +1,19 @@
-const { beforeAll, afterAll } = require('@jest/globals');
-const mongoose = require('mongoose');
+const { beforeAll, afterAll } = require("@jest/globals");
+const mongoose = require("mongoose");
+const { connectWithMongoDb, disconnectWithMongoDb } = require("../src/libraries/db");
 
 beforeAll(async () => {
-  await mongoose.connect(process.env.MONGODB_URL, {
-    autoIndex: true,
-    autoCreate: true,
-  });
+  await connectWithMongoDb();
 });
 
 afterAll(async () => {
-  await mongoose.connection.close();
+  await disconnectWithMongoDb();
 });
 
 // test mongoose connection is open
 
-describe('Mongoose connection', () => {
-  it('should be open', () => {
+describe("Mongoose connection", () => {
+  it("should be open", () => {
     expect(mongoose.connection.readyState).toBe(1);
   });
 });