refactor(infra): 🔨 revamped infra removed mongodb, supabase, redis

Author: Anmol Gangwar

.env.example

@@ -50,16 +50,12 @@
   "dependencies": {
     "@hono/node-server": "^1.12.1",
     "@hono/zod-openapi": "^0.15.3",
-    "@scalar/hono-api-reference": "^0.5.142",
-    "@supabase/supabase-js": "^2.45.2",
+    "@scalar/hono-api-reference": "^0.9.5",
     "@typescript-eslint/eslint-plugin": "^8.2.0",
     "axios": "^1.7.5",
     "form-data": "^4.0.0",
+    "fuse.js": "^7.1.0",
     "hono": "^4.5.8",
-    "ioredis": "^5.4.1",
-    "jsonwebtoken": "^9.0.2",
-    "mongoose": "^8.5.3",
-    "otplib": "^12.0.1",
     "zod": "^3.23.8"
   },
   "devDependencies": {

bun.lockb

@@ -1,12 +1,11 @@
 import { OpenAPIHono } from '@hono/zod-openapi'
-import { apiReference } from '@scalar/hono-api-reference'
+import { Scalar } from '@scalar/hono-api-reference'
 import { logger } from 'hono/logger'
 import { prettyJSON } from 'hono/pretty-json'
 import { Home } from './pages/home'
 import { Routes } from '#common/types'
 import type { HTTPException } from 'hono/http-exception'
 import { cors } from 'hono/cors'
-import { authMiddleware } from './middleware/auth'
 export class App {
   private app: OpenAPIHono
   constructor(routes: Routes[]) {
@@ -35,16 +34,6 @@ export class App {
   }
 
   private initializeGlobalMiddleware() {
-    this.app.use(async (c, next) => {
-      try {
-        await next()
-      } catch (error) {
-        console.error('Database connection error:', error)
-        return c.json({ error: 'Internal Server Error' }, 500)
-      } finally {
-        // await this.dalService.cleanup()
-      }
-    })
     this.app.use(
       cors({
         origin: '*',
@@ -61,7 +50,7 @@ export class App {
       c.res.headers.set('X-Response-Time', `${end - start}ms`)
     })
 
-    this.app.use(authMiddleware)
+    // this.app.use(authMiddleware)
   }
 
   private initializeSwaggerUI() {
@@ -90,12 +79,14 @@ export class App {
 
     this.app.get(
       '/docs',
-      apiReference({
+      Scalar({
         pageTitle: 'ExerciseDB API Documentation',
         theme: 'bluePlanet',
         isEditable: false,
         layout: 'modern',
         darkMode: true,
+        url: '/swagger',
+        favicon: 'https://cdn.exercisedb.dev/exercisedb/favicon.ico',
         metaData: {
           applicationName: 'ExerciseDB API',
           author: 'ExerciseDB API',
@@ -104,10 +95,6 @@ export class App {
           robots: 'index follow',
           description:
             'Access detailed data on over 1300+ exercises with the ExerciseDB API. This API offers extensive information on each exercise, including target body parts, equipment needed, GIFs for visual guidance, and step-by-step instructions.'
-        },
-
-        spec: {
-          url: '/swagger'
         }
       })
     )
@@ -118,7 +105,7 @@ export class App {
       return c.json(
         {
           success: false,
-          message: 'oops route not found!!. check docs at https://v1.exercisedb.dev/docs'
+          message: 'route not found!!. check docs at https://v1.exercisedb.dev/docs'
         },
         404
       )

package.json

@@ -4,7 +4,7 @@
     "name": "band shrug",
     "gifUrl": "https://v1.cdn.exercisedb.dev/media/trmte8s.gif",
     "targetMuscles": ["traps"],
-    "bodyParts": ["back"],
+    "bodyParts": ["neck"],
     "equipments": ["band"],
     "secondaryMuscles": ["shoulders"],
     "instructions": [

src/app.ts

@@ -0,0 +1,44 @@
+import { promises as fs } from 'fs'
+import path from 'path'
+import { Equipment, Exercise, Muscle, BodyPart } from './types'
+import { HTTPException } from 'hono/http-exception'
+
+export class FileLoader {
+  private static dataPath = path.resolve(process.cwd(), 'src', 'data')
+
+  private static cache = new Map<string, unknown>()
+
+  private static async loadJSON<T>(filename: string): Promise<T> {
+    const filePath = path.resolve(this.dataPath, filename)
+
+    if (this.cache.has(filePath)) {
+      return this.cache.get(filePath) as T
+    }
+
+    try {
+      const fileContent = await fs.readFile(filePath, 'utf-8')
+      const data = JSON.parse(fileContent) as T
+      this.cache.set(filePath, data)
+      return data
+    } catch (error) {
+      console.error(`❌ Error loading JSON file [${filename}]:`, error)
+      throw new HTTPException(500, { message: `database not working` })
+    }
+  }
+
+  public static loadExercises(): Promise<Exercise[]> {
+    return this.loadJSON<Exercise[]>(`exercises.json`)
+  }
+
+  public static loadEquipments(): Promise<Equipment[]> {
+    return this.loadJSON<Equipment[]>('equipments.json')
+  }
+
+  public static loadBodyParts(): Promise<BodyPart[]> {
+    return this.loadJSON<BodyPart[]>('bodyparts.json')
+  }
+
+  public static loadMuscles(): Promise<Muscle[]> {
+    return this.loadJSON<Muscle[]>('muscles.json')
+  }
+}

src/common/helpers/crypto.service.ts

@@ -0,0 +1,22 @@
+export interface Equipment {
+  name: string
+}
+
+export interface Exercise {
+  exerciseId: string
+  name: string
+  gifUrl: string
+  equipments: string[]
+  bodyParts: string[]
+  targetMuscles: string[]
+  secondaryMuscles: string[]
+  instructions: string[]
+}
+
+export interface BodyPart {
+  name: string
+}
+
+export interface Muscle {
+  name: string
+}

src/data/exercises.json

@@ -1,82 +1,79 @@
-import { CryptoService } from '#common/helpers/crypto.service.js'
-import { Context, Next } from 'hono'
+// import { Context, Next } from 'hono'
 
-type Role = 'member' | 'moderator' | 'admin'
+// type Role = 'member' | 'moderator' | 'admin'
 
-const ROLE_PERMISSIONS: Record<Role, Set<string>> = {
-  member: new Set(['GET']),
-  moderator: new Set(['GET', 'POST', 'PUT', 'PATCH']),
-  admin: new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE'])
-}
+// const ROLE_PERMISSIONS: Record<Role, Set<string>> = {
+//   member: new Set(['GET']),
+//   moderator: new Set(['GET', 'POST', 'PUT', 'PATCH']),
+//   admin: new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE'])
+// }
 
-const RESTRICTED_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE'])
-const VALID_ROLES = new Set(['member', 'moderator', 'admin'])
+// const RESTRICTED_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE'])
+// const VALID_ROLES = new Set(['member', 'moderator', 'admin'])
 
-const cryptoService = new CryptoService()
 
-interface RouteConfig {
-  path: string
-  allowedEnvs: Set<string>
-  skipAuth?: boolean
-  message?: string
-}
+// interface RouteConfig {
+//   path: string
+//   allowedEnvs: Set<string>
+//   skipAuth?: boolean
+//   message?: string
+// }
 
-const ROUTE_CONFIG: RouteConfig[] = [
-  {
-    path: '/api/v1/register',
-    allowedEnvs: new Set(['development', 'staging']),
-    skipAuth: true,
-    message: 'signup is not allowed in production'
-  },
-  { path: '/api/v1/authenticate', allowedEnvs: new Set(['development', 'staging', 'production']), skipAuth: true }
-]
+// const ROUTE_CONFIG: RouteConfig[] = [
+//   {
+//     path: '/api/v1/register',
+//     allowedEnvs: new Set(['development', 'staging']),
+//     skipAuth: true,
+//     message: 'signup is not allowed in production'
+//   },
+//   { path: '/api/v1/authenticate', allowedEnvs: new Set(['development', 'staging', 'production']), skipAuth: true }
+// ]
 
-export async function authMiddleware(c: Context, next: Next) {
-  const { method, path } = c.req
-  const currentEnv = process.env.NODE_ENV || 'development'
+// export async function authMiddleware(c: Context, next: Next) {
+//   const { method, path } = c.req
+//   const currentEnv = process.env.NODE_ENV || 'development'
 
-  const routeConfig = ROUTE_CONFIG.find((route) => route.path === path)
+//   const routeConfig = ROUTE_CONFIG.find((route) => route.path === path)
 
-  if (routeConfig) {
-    if (!routeConfig.allowedEnvs.has(currentEnv)) {
-      return c.json(
-        {
-          success: false,
-          error: routeConfig.message
-            ? routeConfig.message
-            : `This route is not available in the ${currentEnv} environment.`
-        },
-        403
-      )
-    }
-    if (routeConfig.skipAuth) {
-      return next()
-    }
-  }
+//   if (routeConfig) {
+//     if (!routeConfig.allowedEnvs.has(currentEnv)) {
+//       return c.json(
+//         {
+//           success: false,
+//           error: routeConfig.message
+//             ? routeConfig.message
+//             : `This route is not available in the ${currentEnv} environment.`
+//         },
+//         403
+//       )
+//     }
+//     if (routeConfig.skipAuth) {
+//       return next()
+//     }
+//   }
 
-  if (!RESTRICTED_METHODS.has(method)) return next()
+//   if (!RESTRICTED_METHODS.has(method)) return next()
 
-  const authorization = c.req.header('Authorization')
+//   const authorization = c.req.header('Authorization')
 
-  if (!authorization) {
-    return c.json({ success: false, error: 'No authorization header | unauthorized request' }, 401)
-  }
-  const token = authorization.split(' ')[1]
+//   if (!authorization) {
+//     return c.json({ success: false, error: 'No authorization header | unauthorized request' }, 401)
+//   }
+//   const token = authorization.split(' ')[1]
 
-  if (!authorization.startsWith('Bearer')) {
-    return c.json({ success: false, error: 'Invalid authorization header format. Format is "Bearer <token>".' }, 401)
-  }
+//   if (!authorization.startsWith('Bearer')) {
+//     return c.json({ success: false, error: 'Invalid authorization header format. Format is "Bearer <token>".' }, 401)
+//   }
 
-  try {
-    const userPayload = cryptoService.verifyAccessToken(token)
-    if (!VALID_ROLES.has(userPayload.role) || !ROLE_PERMISSIONS[userPayload.role as Role].has(method)) {
-      return c.json({ success: false, error: 'Forbidden' }, 403)
-    }
+//   try {
+//     if (!VALID_ROLES.has(userPayload.role) || !ROLE_PERMISSIONS[userPayload.role as Role].has(method)) {
+//       return c.json({ success: false, error: 'Forbidden' }, 403)
+//     }
 
-    c.set('user', userPayload)
-    await next()
-  } catch (error) {
-    console.error(error)
-    return c.json({ success: false, error: 'Invalid token' }, 401)
-  }
-}
+//     c.set('user', userPayload)
+//     await next()
+//   } catch (error) {
+//     console.error(error)
+//     return c.json({ success: false, error: 'Invalid token' }, 401)
+//   }
+// }