Build aws cloud infra by setting up terraform

.gitignore

@@ -6,4 +6,4 @@ node_modules
 **.pem
 .vscode
 .terraform
-*.tfvars
+*.tfvars

auth-service/db/connect.js

@@ -2,7 +2,7 @@ import mongoose from "mongoose"
 import { InternalServerError } from "#shared/errors/errors.js";
 import { SecretService } from "#shared/utils/index.js"
 
-const secret = await SecretService.getSecret("prod/cr-user-sv");
+const secret = await SecretService.getSecret(process.env.SERVICE_SECRET_NAME);
 
 const MONGO_USERNAME = secret.MONGO_USERNAME || process.env.MONGO_USERNAME;
 const MONGO_PASSWORD = secret.MONGO_PASSWORD || process.env.MONGO_PASSWORD;

auth-service/package.json

@@ -19,7 +19,6 @@
     "@aws-sdk/client-secrets-manager": "^3.908.0",
     "bcrypt": "^6.0.0",
     "cookie-parser": "^1.4.7",
-    "dotenv": "^17.2.1",
     "express": "^5.1.0",
     "fs": "^0.0.1-security",
     "ioredis": "^5.7.0",

auth-service/utils/jwt.js

@@ -2,7 +2,7 @@ import jwt from "jsonwebtoken"
 import fs from 'fs'
 import { SecretService } from "#shared/utils/index.js"
 
-const secret = await SecretService.getSecret("prod/cr-user-sv");
+const secret = await SecretService.getSecret(process.env.SERVICE_SECRET_NAME);
 
 export default class JwtFacade {
   static ACCESS_TOKEN_SECRET = secret.PRIVATE_KEY || fs.readFileSync("private.pem", "utf8");

class-service/api/studentServiceApi.js

@@ -1,45 +1,56 @@
 import axios from "axios";
-import { InternalServerError } from "#shared/errors/errors.js";
+import { LambdaInvoker } from "../utils/index.js";
 
-const URL = process.env.STUDENT_SERVICE_URL;
+const STUDENT_SERVICE = process.env.STUDENT_SERVICE_API; // Development: localhost URL, Production: Lambda function name
 
 class StudentServiceClient {
-  constructor(baseURL) {
-    this.api = axios.create({ baseURL });
-  }
+  constructor() {
+    this.isProd = process.env.NODE_ENV === "production";
 
-  async getStudentByIds(ids, accessToken) {
-    try {
-      const res = await this.api.get(`/by-ids?ids=${ids}`, {
-        headers: { Authorization: `Bearer ${accessToken}` },
-      });
-      return res.data;
-    } catch (err) {
-      throw new InternalServerError(`Student API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+    if (!this.isProd) {
+      this.api = axios.create({ baseURL: STUDENT_SERVICE });
+    } else {
+      this.lambda = new LambdaInvoker();
     }
   }
 
-  async getStudentById(id, accessToken) {
+  async getStudentByIds(ids, accessToken) {
+    const route = `/by-ids?ids=${ids}`;
     try {
-      const res = await this.api.get(`/${id}`, {
-        headers: { Authorization: `Bearer ${accessToken}` },
-      });
-      return res.data;
+      if (!this.isProd) {
+        const res = await this.api.get(route, {
+          headers: { Authorization: `Bearer ${accessToken}` },
+        });
+        return res.data;
+      }
+      return await this.lambda.invoke("GET", route, accessToken, STUDENT_SERVICE);
     } catch (err) {
-      throw new InternalServerError(`Student API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+      if (!this.isProd) {
+        logger.error(`Student API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+      } else {
+        logger.error("StudentService error:", err);
+      }
     }
   }
 
-  async deleteStudentById(id, accessToken) {
+  async getStudentById(id, accessToken) {
+    const route = `/${id}`;
     try {
-      const res = await this.api.delete(`/${id}`, {
-        headers: { Authorization: `Bearer ${accessToken}` },
-      });
-      return res.data;
+      if (!this.isProd) {
+        const res = await this.api.get(route, {
+          headers: { Authorization: `Bearer ${accessToken}` },
+        });
+        return res.data;
+      }
+      return await this.lambda.invoke("GET", route, accessToken, STUDENT_SERVICE);
     } catch (err) {
-      throw new InternalServerError(`Student API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+      if (!this.isProd) {
+        logger.error(`Student API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+      } else {
+        logger.error("StudentService error:", err);
+      }
     }
   }
 }
 
-export default new StudentServiceClient(URL);
+export default new StudentServiceClient();

class-service/api/teacherServiceApi.js

@@ -1,23 +1,37 @@
 import axios from "axios";
-import { InternalServerError } from "#shared/errors/errors.js";
+import { LambdaInvoker } from "../utils/index.js";
 
-const URL = process.env.TEACHER_SERVICE_URL;
+const TEACHER_SERVICE = process.env.TEACHER_SERVICE_API; // Development: localhost URL, Production: Lambda function name
 
 class TeacherServiceClient {
-  constructor(baseURL) {
-    this.api = axios.create({ baseURL });
+  constructor() {
+    this.isProd = process.env.NODE_ENV === "production";
+
+    if (!this.isProd) {
+      this.api = axios.create({ baseURL: TEACHER_SERVICE });
+    } else {
+      this.lambda = new LambdaInvoker();
+    }
   }
 
   async getTeacherById(id, accessToken) {
+    const route = `/${id}`;
     try {
-      const res = await this.api.get(`/${id}`, {
-        headers: { Authorization: `Bearer ${accessToken}` },
-      });
-      return res.data;
+      if (!this.isProd) {
+        const res = await this.api.get(route, {
+          headers: { Authorization: `Bearer ${accessToken}` },
+        });
+        return res.data;
+      }
+      return await this.lambda.invoke("GET", route, accessToken, TEACHER_SERVICE);
     } catch (err) {
-      throw new InternalServerError(`Teacher API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+      if (!this.isProd) {
+        logger.error(`Student API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+      } else {
+        logger.error("StudentService error:", err);
+      }
     }
   }
 }
 
-export default new TeacherServiceClient(URL);
+export default new TeacherServiceClient();

class-service/api/userServiceApi.js

@@ -1,23 +1,37 @@
 import axios from "axios";
-import { InternalServerError } from "#shared/errors/errors.js";
+import { LambdaInvoker } from "../utils/index.js";
 
-const URL = process.env.USER_SERVICE_URL;
+const USER_SERVICE = process.env.USER_SERVICE_API; // Development: localhost URL, Production: Lambda function name
 
 class UserServiceClient {
-  constructor(baseURL) {
-    this.api = axios.create({ baseURL });
+  constructor() {
+    this.isProd = process.env.NODE_ENV === "production";
+
+    if (!this.isProd) {
+      this.api = axios.create({ baseURL: USER_SERVICE });
+    } else {
+      this.lambda = new LambdaInvoker();
+    }
   }
 
   async getUserByIds(ids, accessToken) {
+    const route = `/by-ids?ids=${ids}`;
     try {
-      const res = await this.api.get(`/by-ids?ids=${ids}`, {
-        headers: { Authorization: `Bearer ${accessToken}` },
-      });
-      return res.data;
+      if (!this.isProd) {
+        const res = await this.api.get(route, {
+          headers: { Authorization: `Bearer ${accessToken}` },
+        });
+        return res.data;
+      }
+      return await this.lambda.invoke("GET", route, accessToken, USER_SERVICE);
     } catch (err) {
-      throw new InternalServerError(`Auth API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+      if (!this.isProd) {
+        logger.error(`Student API returned ${err.response.status}: ${err.response.data?.msg || err.message}`);
+      } else {
+        logger.error("StudentService error:", err);
+      }
     }
   }
 }
 
-export default new UserServiceClient(URL);
+export default new UserServiceClient();